maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/DebugInfo/CodeView/EnumTables.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

560 lines
21 KiB
C++
Raw Normal View History

[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
//===- EnumTables.cpp - Enum to string conversion tables ------------------===//
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/CodeView/EnumTables.h"
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
#include "llvm/Support/ScopedPrinter.h"
#include <type_traits>
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
using namespace llvm;
using namespace codeview;
#define CV_ENUM_CLASS_ENT(enum_class, enum) \
{ #enum, std::underlying_type < enum_class > ::type(enum_class::enum) }
#define CV_ENUM_ENT(ns, enum) \
{ #enum, ns::enum }
static const EnumEntry<SymbolKind> SymbolTypeNames[] = {
#define CV_SYMBOL(enum, val) {#enum, enum},
[CodeView] Move CodeView YAML code to ObjectYAML. This is the beginning of an effort to move the codeview yaml reader / writer into ObjectYAML so that it can be shared. Currently the only consumer / producer of CodeView YAML is llvm-pdbdump, but CodeView can exist outside of PDB files, and indeed is put into object files and passed to the linker to produce PDB files. Furthermore, there are subtle differences in the types of records that show up in object file CodeView vs PDB file CodeView, but they are otherwise 99% the same. By having this code in ObjectYAML, we can have llvm-pdbdump reuse this code, while teaching obj2yaml and yaml2obj to use this syntax for dealing with object files that can contain CodeView. This patch only adds support for CodeView type information to ObjectYAML. Subsequent patches will add support for CodeView symbol information. llvm-svn: 304248
2017-05-31 05:53:05 +08:00
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
#undef CV_SYMBOL
};
Resubmit "Write the TPI stream from a PDB to Yaml." The original patch was breaking some buildbots due to an incorrect ordering of function definitions which caused some compilers to recognize a definition but others to not. llvm-svn: 279089
2016-08-19 00:49:29 +08:00
static const EnumEntry<TypeLeafKind> TypeLeafNames[] = {
#define CV_TYPE(name, val) {#name, name},
[CodeView] Move CodeView YAML code to ObjectYAML. This is the beginning of an effort to move the codeview yaml reader / writer into ObjectYAML so that it can be shared. Currently the only consumer / producer of CodeView YAML is llvm-pdbdump, but CodeView can exist outside of PDB files, and indeed is put into object files and passed to the linker to produce PDB files. Furthermore, there are subtle differences in the types of records that show up in object file CodeView vs PDB file CodeView, but they are otherwise 99% the same. By having this code in ObjectYAML, we can have llvm-pdbdump reuse this code, while teaching obj2yaml and yaml2obj to use this syntax for dealing with object files that can contain CodeView. This patch only adds support for CodeView type information to ObjectYAML. Subsequent patches will add support for CodeView symbol information. llvm-svn: 304248
2017-05-31 05:53:05 +08:00
#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
Resubmit "Write the TPI stream from a PDB to Yaml." The original patch was breaking some buildbots due to an incorrect ordering of function definitions which caused some compilers to recognize a definition but others to not. llvm-svn: 279089
2016-08-19 00:49:29 +08:00
#undef CV_TYPE
};
[COFF, ARM64] Add CodeView register mapping CodeView has its own register map which is defined in cvconst.h. Missing this mapping before saving register to CodeView causes debugger to show incorrect value for all register based variables, like variables in register and local variables addressed by register (stack pointer + offset). This change added mapping between LLVM register and CodeView register so the correct register number will be stored to CodeView/PDB, it aso fixed the mapping from CodeView register number to register name based on current CPUType but print PDB to yaml still assumes X86 CPU and needs to be fixed. Differential Revision: https://reviews.llvm.org/D62608 llvm-svn: 362280
2019-06-01 07:43:31 +08:00
static const EnumEntry<uint16_t> RegisterNames_X86[] = {
#define CV_REGISTERS_X86
CodeView: Provide a .def file with the register ids The list of register ids was previously written out in a couple of dirrent places. This puts it in a .def file and also adds a few more registers (e.g. the x87 regs) which should lead to more readable dumps, but I didn't include the whole list since that seems unnecessary. X86_MC::initLLVMToSEHAndCVRegMapping is pretty ugly, but at least it's not relying on magic constants anymore. The TODO of using tablegen still stands. Differential revision: https://reviews.llvm.org/D38480 llvm-svn: 314821
2017-10-04 02:27:22 +08:00
#define CV_REGISTER(name, val) CV_ENUM_CLASS_ENT(RegisterId, name),
#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
#undef CV_REGISTER
[COFF, ARM64] Add CodeView register mapping CodeView has its own register map which is defined in cvconst.h. Missing this mapping before saving register to CodeView causes debugger to show incorrect value for all register based variables, like variables in register and local variables addressed by register (stack pointer + offset). This change added mapping between LLVM register and CodeView register so the correct register number will be stored to CodeView/PDB, it aso fixed the mapping from CodeView register number to register name based on current CPUType but print PDB to yaml still assumes X86 CPU and needs to be fixed. Differential Revision: https://reviews.llvm.org/D62608 llvm-svn: 362280
2019-06-01 07:43:31 +08:00
#undef CV_REGISTERS_X86
};
[COFF][ARM] Fix CodeView for Windows on 32bit ARM targets. Create the LLVM / CodeView register mappings for the 32-bit ARM Window targets. Reviewed By: compnerd Differential Revision: https://reviews.llvm.org/D89622
2020-10-20 13:10:27 +08:00
static const EnumEntry<uint16_t> RegisterNames_ARM[] = {
#define CV_REGISTERS_ARM
#define CV_REGISTER(name, val) CV_ENUM_CLASS_ENT(RegisterId, name),
#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
#undef CV_REGISTER
#undef CV_REGISTERS_ARM
};
[COFF, ARM64] Add CodeView register mapping CodeView has its own register map which is defined in cvconst.h. Missing this mapping before saving register to CodeView causes debugger to show incorrect value for all register based variables, like variables in register and local variables addressed by register (stack pointer + offset). This change added mapping between LLVM register and CodeView register so the correct register number will be stored to CodeView/PDB, it aso fixed the mapping from CodeView register number to register name based on current CPUType but print PDB to yaml still assumes X86 CPU and needs to be fixed. Differential Revision: https://reviews.llvm.org/D62608 llvm-svn: 362280
2019-06-01 07:43:31 +08:00
static const EnumEntry<uint16_t> RegisterNames_ARM64[] = {
#define CV_REGISTERS_ARM64
#define CV_REGISTER(name, val) CV_ENUM_CLASS_ENT(RegisterId, name),
#include "llvm/DebugInfo/CodeView/CodeViewRegisters.def"
#undef CV_REGISTER
#undef CV_REGISTERS_ARM64
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
};
[CodeView] Fix dumping of public symbol record flags I noticed nonsensical type information while dumping PDBs produced by MSVC. llvm-svn: 305708
2017-06-20 00:54:51 +08:00
static const EnumEntry<uint32_t> PublicSymFlagNames[] = {
CV_ENUM_CLASS_ENT(PublicSymFlags, Code),
CV_ENUM_CLASS_ENT(PublicSymFlags, Function),
CV_ENUM_CLASS_ENT(PublicSymFlags, Managed),
CV_ENUM_CLASS_ENT(PublicSymFlags, MSIL),
};
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
static const EnumEntry<uint8_t> ProcSymFlagNames[] = {
CV_ENUM_CLASS_ENT(ProcSymFlags, HasFP),
CV_ENUM_CLASS_ENT(ProcSymFlags, HasIRET),
CV_ENUM_CLASS_ENT(ProcSymFlags, HasFRET),
CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoReturn),
CV_ENUM_CLASS_ENT(ProcSymFlags, IsUnreachable),
CV_ENUM_CLASS_ENT(ProcSymFlags, HasCustomCallingConv),
CV_ENUM_CLASS_ENT(ProcSymFlags, IsNoInline),
CV_ENUM_CLASS_ENT(ProcSymFlags, HasOptimizedDebugInfo),
};
static const EnumEntry<uint16_t> LocalFlags[] = {
CV_ENUM_CLASS_ENT(LocalSymFlags, IsParameter),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsAddressTaken),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsCompilerGenerated),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregate),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsAggregated),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsAliased),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsAlias),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsReturnValue),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsOptimizedOut),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredGlobal),
CV_ENUM_CLASS_ENT(LocalSymFlags, IsEnregisteredStatic),
};
[codeview] Use one byte for S_FRAMECOOKIE CookieKind and add flags byte We bailed out while printing codeview for an MSVC compiled SemaExprCXX.cpp that used this record. The MS reference headers look incorrect here, which is probably why we had this bug. They use a 32-bit enum as the field type, but the actual record appears to use one byte for the cookie kind followed by a flags byte. llvm-svn: 273691
2016-06-25 01:23:49 +08:00
static const EnumEntry<uint8_t> FrameCookieKinds[] = {
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
CV_ENUM_CLASS_ENT(FrameCookieKind, Copy),
CV_ENUM_CLASS_ENT(FrameCookieKind, XorStackPointer),
CV_ENUM_CLASS_ENT(FrameCookieKind, XorFramePointer),
CV_ENUM_CLASS_ENT(FrameCookieKind, XorR13),
};
static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
CV_ENUM_ENT(SourceLanguage, C), CV_ENUM_ENT(SourceLanguage, Cpp),
CV_ENUM_ENT(SourceLanguage, Fortran), CV_ENUM_ENT(SourceLanguage, Masm),
CV_ENUM_ENT(SourceLanguage, Pascal), CV_ENUM_ENT(SourceLanguage, Basic),
CV_ENUM_ENT(SourceLanguage, Cobol), CV_ENUM_ENT(SourceLanguage, Link),
CV_ENUM_ENT(SourceLanguage, Cvtres), CV_ENUM_ENT(SourceLanguage, Cvtpgd),
CV_ENUM_ENT(SourceLanguage, CSharp), CV_ENUM_ENT(SourceLanguage, VB),
CV_ENUM_ENT(SourceLanguage, ILAsm), CV_ENUM_ENT(SourceLanguage, Java),
CV_ENUM_ENT(SourceLanguage, JScript), CV_ENUM_ENT(SourceLanguage, MSIL),
[codeview] Emit 'D' as the cv source language for D code This matches DMD: https://github.com/dlang/dmd/blob/522263965cf3a27ed16b31f3c3562db86cdeabec/src/ddmd/backend/cv8.c#L199 Fixes PR33899. llvm-svn: 308890
2017-07-25 00:16:42 +08:00
CV_ENUM_ENT(SourceLanguage, HLSL), CV_ENUM_ENT(SourceLanguage, D),
Add Swift enumerator value for CodeView::SourceLanguage Summary: Swift now generates PDBs for debugging on Windows. llvm and lldb need a language enumerator value too properly handle the output emitted by swiftc. Subscribers: jdoerfert, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D59231 llvm-svn: 355882
2019-03-12 07:27:59 +08:00
CV_ENUM_ENT(SourceLanguage, Swift),
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
};
static const EnumEntry<uint32_t> CompileSym2FlagNames[] = {
CV_ENUM_CLASS_ENT(CompileSym2Flags, EC),
CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDbgInfo),
CV_ENUM_CLASS_ENT(CompileSym2Flags, LTCG),
CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDataAlign),
CV_ENUM_CLASS_ENT(CompileSym2Flags, ManagedPresent),
CV_ENUM_CLASS_ENT(CompileSym2Flags, SecurityChecks),
CV_ENUM_CLASS_ENT(CompileSym2Flags, HotPatch),
CV_ENUM_CLASS_ENT(CompileSym2Flags, CVTCIL),
CV_ENUM_CLASS_ENT(CompileSym2Flags, MSILModule),
};
static const EnumEntry<uint32_t> CompileSym3FlagNames[] = {
CV_ENUM_CLASS_ENT(CompileSym3Flags, EC),
CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDbgInfo),
CV_ENUM_CLASS_ENT(CompileSym3Flags, LTCG),
CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDataAlign),
CV_ENUM_CLASS_ENT(CompileSym3Flags, ManagedPresent),
CV_ENUM_CLASS_ENT(CompileSym3Flags, SecurityChecks),
CV_ENUM_CLASS_ENT(CompileSym3Flags, HotPatch),
CV_ENUM_CLASS_ENT(CompileSym3Flags, CVTCIL),
CV_ENUM_CLASS_ENT(CompileSym3Flags, MSILModule),
CV_ENUM_CLASS_ENT(CompileSym3Flags, Sdl),
CV_ENUM_CLASS_ENT(CompileSym3Flags, PGO),
CV_ENUM_CLASS_ENT(CompileSym3Flags, Exp),
};
[pdb] Dump file checksums from pdb codeview line info. llvm-svn: 271622
2016-06-03 12:01:48 +08:00
static const EnumEntry<uint32_t> FileChecksumNames[] = {
CV_ENUM_CLASS_ENT(FileChecksumKind, None),
CV_ENUM_CLASS_ENT(FileChecksumKind, MD5),
CV_ENUM_CLASS_ENT(FileChecksumKind, SHA1),
CV_ENUM_CLASS_ENT(FileChecksumKind, SHA256),
};
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
static const EnumEntry<unsigned> CPUTypeNames[] = {
CV_ENUM_CLASS_ENT(CPUType, Intel8080),
CV_ENUM_CLASS_ENT(CPUType, Intel8086),
CV_ENUM_CLASS_ENT(CPUType, Intel80286),
CV_ENUM_CLASS_ENT(CPUType, Intel80386),
CV_ENUM_CLASS_ENT(CPUType, Intel80486),
CV_ENUM_CLASS_ENT(CPUType, Pentium),
CV_ENUM_CLASS_ENT(CPUType, PentiumPro),
CV_ENUM_CLASS_ENT(CPUType, Pentium3),
CV_ENUM_CLASS_ENT(CPUType, MIPS),
CV_ENUM_CLASS_ENT(CPUType, MIPS16),
CV_ENUM_CLASS_ENT(CPUType, MIPS32),
CV_ENUM_CLASS_ENT(CPUType, MIPS64),
CV_ENUM_CLASS_ENT(CPUType, MIPSI),
CV_ENUM_CLASS_ENT(CPUType, MIPSII),
CV_ENUM_CLASS_ENT(CPUType, MIPSIII),
CV_ENUM_CLASS_ENT(CPUType, MIPSIV),
CV_ENUM_CLASS_ENT(CPUType, MIPSV),
CV_ENUM_CLASS_ENT(CPUType, M68000),
CV_ENUM_CLASS_ENT(CPUType, M68010),
CV_ENUM_CLASS_ENT(CPUType, M68020),
CV_ENUM_CLASS_ENT(CPUType, M68030),
CV_ENUM_CLASS_ENT(CPUType, M68040),
CV_ENUM_CLASS_ENT(CPUType, Alpha),
CV_ENUM_CLASS_ENT(CPUType, Alpha21164),
CV_ENUM_CLASS_ENT(CPUType, Alpha21164A),
CV_ENUM_CLASS_ENT(CPUType, Alpha21264),
CV_ENUM_CLASS_ENT(CPUType, Alpha21364),
CV_ENUM_CLASS_ENT(CPUType, PPC601),
CV_ENUM_CLASS_ENT(CPUType, PPC603),
CV_ENUM_CLASS_ENT(CPUType, PPC604),
CV_ENUM_CLASS_ENT(CPUType, PPC620),
CV_ENUM_CLASS_ENT(CPUType, PPCFP),
CV_ENUM_CLASS_ENT(CPUType, PPCBE),
CV_ENUM_CLASS_ENT(CPUType, SH3),
CV_ENUM_CLASS_ENT(CPUType, SH3E),
CV_ENUM_CLASS_ENT(CPUType, SH3DSP),
CV_ENUM_CLASS_ENT(CPUType, SH4),
CV_ENUM_CLASS_ENT(CPUType, SHMedia),
CV_ENUM_CLASS_ENT(CPUType, ARM3),
CV_ENUM_CLASS_ENT(CPUType, ARM4),
CV_ENUM_CLASS_ENT(CPUType, ARM4T),
CV_ENUM_CLASS_ENT(CPUType, ARM5),
CV_ENUM_CLASS_ENT(CPUType, ARM5T),
CV_ENUM_CLASS_ENT(CPUType, ARM6),
CV_ENUM_CLASS_ENT(CPUType, ARM_XMAC),
CV_ENUM_CLASS_ENT(CPUType, ARM_WMMX),
CV_ENUM_CLASS_ENT(CPUType, ARM7),
CV_ENUM_CLASS_ENT(CPUType, Omni),
CV_ENUM_CLASS_ENT(CPUType, Ia64),
CV_ENUM_CLASS_ENT(CPUType, Ia64_2),
CV_ENUM_CLASS_ENT(CPUType, CEE),
CV_ENUM_CLASS_ENT(CPUType, AM33),
CV_ENUM_CLASS_ENT(CPUType, M32R),
CV_ENUM_CLASS_ENT(CPUType, TriCore),
CV_ENUM_CLASS_ENT(CPUType, X64),
CV_ENUM_CLASS_ENT(CPUType, EBC),
CV_ENUM_CLASS_ENT(CPUType, Thumb),
CV_ENUM_CLASS_ENT(CPUType, ARMNT),
[CodeView] Fix the ARM64 CPUType enum The old, incorrect one seems to have been added in d41ac895bb810d0b15844773cbecbf394d914010, with a similarly placed entry added in EnumTables.cpp in eb4d6142dcd53d79d8f8a86908a035582965fc52. This matches the value documented at https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/cv-cpu-type-e?view=vs-2019. This fixes running obj2yaml on an object file generated by MSVC. Differential Revision: https://reviews.llvm.org/D100306
2021-04-12 19:46:36 +08:00
CV_ENUM_CLASS_ENT(CPUType, ARM64),
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
CV_ENUM_CLASS_ENT(CPUType, D3D11_Shader),
};
static const EnumEntry<uint32_t> FrameProcSymFlagNames[] = {
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasInlineAssembly),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasExceptionHandling),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, MarkedInline),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, HasStructuredExceptionHandling),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, Naked),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, SecurityChecks),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, AsynchronousExceptionHandling),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, NoStackOrderingForSecurityChecks),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, Inlined),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, StrictSecurityChecks),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, SafeBuffers),
[codeview] Decode and dump FP regs from S_FRAMEPROC records Summary: There are two registers encoded in the S_FRAMEPROC flags: one for locals and one for parameters. The encoding is described by the ExpandEncodedBasePointerReg function in cvinfo.h. Two bits are used to indicate one of four possible values: 0: no register - Used when there are no variables. 1: SP / standard - Variables are stored relative to the standard SP for the ISA. 2: FP - Variables are addressed relative to the ISA frame pointer, i.e. EBP on x86. If realignment is required, parameters use this. If a dynamic alloca is used, locals will be EBP relative. 3: Alternative - Variables are stored relative to some alternative third callee-saved register. This is required to address highly aligned locals when there are dynamic stack adjustments. In this case, both the incoming SP saved in the standard FP and the current SP are at some dynamic offset from the locals. LLVM uses ESI in this case, MSVC uses EBX. Most of the changes in this patch are to pass around the CPU so that we can decode these into real, named architectural registers. Subscribers: hiraditya Differential Revision: https://reviews.llvm.org/D51894 llvm-svn: 341999
2018-09-12 06:00:50 +08:00
CV_ENUM_CLASS_ENT(FrameProcedureOptions, EncodedLocalBasePointerMask),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, EncodedParamBasePointerMask),
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
CV_ENUM_CLASS_ENT(FrameProcedureOptions, ProfileGuidedOptimization),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, ValidProfileCounts),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, OptimizedForSpeed),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfg),
CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
};
[llvm-pdbdump] Dump CodeView line information. This first pass only splits apart the records and dumps the line info kinds and binary data. Subsequent patches will parse out the binary data into more useful information and dump it in detail. llvm-svn: 271576
2016-06-03 04:11:22 +08:00
static const EnumEntry<uint32_t> ModuleSubstreamKindNames[] = {
[CodeView] Rename ModuleDebugFragment -> DebugSubsection. This is more concise, and matches the terminology used in other parts of the codebase more closely. llvm-svn: 304218
2017-05-31 00:36:15 +08:00
CV_ENUM_CLASS_ENT(DebugSubsectionKind, None),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, Symbols),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, Lines),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, StringTable),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, FileChecksums),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, FrameData),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, InlineeLines),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeImports),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, CrossScopeExports),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, ILLines),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, FuncMDTokenMap),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, TypeMDTokenMap),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, MergedAssemblyInput),
CV_ENUM_CLASS_ENT(DebugSubsectionKind, CoffSymbolRVA),
[llvm-pdbdump] Dump CodeView line information. This first pass only splits apart the records and dumps the line info kinds and binary data. Subsequent patches will parse out the binary data into more useful information and dump it in detail. llvm-svn: 271576
2016-06-03 04:11:22 +08:00
};
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
static const EnumEntry<uint16_t> ExportSymFlagNames[] = {
CV_ENUM_CLASS_ENT(ExportFlags, IsConstant),
CV_ENUM_CLASS_ENT(ExportFlags, IsData),
CV_ENUM_CLASS_ENT(ExportFlags, IsPrivate),
CV_ENUM_CLASS_ENT(ExportFlags, HasNoName),
CV_ENUM_CLASS_ENT(ExportFlags, HasExplicitOrdinal),
CV_ENUM_CLASS_ENT(ExportFlags, IsForwarder),
};
static const EnumEntry<uint8_t> ThunkOrdinalNames[] = {
CV_ENUM_CLASS_ENT(ThunkOrdinal, Standard),
CV_ENUM_CLASS_ENT(ThunkOrdinal, ThisAdjustor),
CV_ENUM_CLASS_ENT(ThunkOrdinal, Vcall),
CV_ENUM_CLASS_ENT(ThunkOrdinal, Pcode),
CV_ENUM_CLASS_ENT(ThunkOrdinal, UnknownLoad),
CV_ENUM_CLASS_ENT(ThunkOrdinal, TrampIncremental),
CV_ENUM_CLASS_ENT(ThunkOrdinal, BranchIsland),
};
static const EnumEntry<uint16_t> TrampolineNames[] = {
CV_ENUM_CLASS_ENT(TrampolineType, TrampIncremental),
CV_ENUM_CLASS_ENT(TrampolineType, BranchIsland),
};
static const EnumEntry<COFF::SectionCharacteristics>
ImageSectionCharacteristicNames[] = {
CV_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD),
CV_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD),
CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE),
CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA),
CV_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER),
CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO),
CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_REMOVE),
CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_COMDAT),
CV_ENUM_ENT(COFF, IMAGE_SCN_GPREL),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_PURGEABLE),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_16BIT),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_LOCKED),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_PRELOAD),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_16BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_32BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_64BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_128BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_256BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_512BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_1024BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_2048BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_4096BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_ALIGN_8192BYTES),
CV_ENUM_ENT(COFF, IMAGE_SCN_LNK_NRELOC_OVFL),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_DISCARDABLE),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ),
CV_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE)};
Improving CodeView debug info type record's inline comments llvm-svn: 369533
2019-08-21 23:19:58 +08:00
static const EnumEntry<uint16_t> ClassOptionNames[] = {
CV_ENUM_CLASS_ENT(ClassOptions, Packed),
CV_ENUM_CLASS_ENT(ClassOptions, HasConstructorOrDestructor),
CV_ENUM_CLASS_ENT(ClassOptions, HasOverloadedOperator),
CV_ENUM_CLASS_ENT(ClassOptions, Nested),
CV_ENUM_CLASS_ENT(ClassOptions, ContainsNestedClass),
CV_ENUM_CLASS_ENT(ClassOptions, HasOverloadedAssignmentOperator),
CV_ENUM_CLASS_ENT(ClassOptions, HasConversionOperator),
CV_ENUM_CLASS_ENT(ClassOptions, ForwardReference),
CV_ENUM_CLASS_ENT(ClassOptions, Scoped),
CV_ENUM_CLASS_ENT(ClassOptions, HasUniqueName),
CV_ENUM_CLASS_ENT(ClassOptions, Sealed),
CV_ENUM_CLASS_ENT(ClassOptions, Intrinsic),
};
static const EnumEntry<uint8_t> MemberAccessNames[] = {
CV_ENUM_CLASS_ENT(MemberAccess, None),
CV_ENUM_CLASS_ENT(MemberAccess, Private),
CV_ENUM_CLASS_ENT(MemberAccess, Protected),
CV_ENUM_CLASS_ENT(MemberAccess, Public),
};
static const EnumEntry<uint16_t> MethodOptionNames[] = {
CV_ENUM_CLASS_ENT(MethodOptions, Pseudo),
CV_ENUM_CLASS_ENT(MethodOptions, NoInherit),
CV_ENUM_CLASS_ENT(MethodOptions, NoConstruct),
CV_ENUM_CLASS_ENT(MethodOptions, CompilerGenerated),
CV_ENUM_CLASS_ENT(MethodOptions, Sealed),
};
static const EnumEntry<uint16_t> MemberKindNames[] = {
CV_ENUM_CLASS_ENT(MethodKind, Vanilla),
CV_ENUM_CLASS_ENT(MethodKind, Virtual),
CV_ENUM_CLASS_ENT(MethodKind, Static),
CV_ENUM_CLASS_ENT(MethodKind, Friend),
CV_ENUM_CLASS_ENT(MethodKind, IntroducingVirtual),
CV_ENUM_CLASS_ENT(MethodKind, PureVirtual),
CV_ENUM_CLASS_ENT(MethodKind, PureIntroducingVirtual),
};
static const EnumEntry<uint8_t> PtrKindNames[] = {
CV_ENUM_CLASS_ENT(PointerKind, Near16),
CV_ENUM_CLASS_ENT(PointerKind, Far16),
CV_ENUM_CLASS_ENT(PointerKind, Huge16),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnSegment),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnValue),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentValue),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnAddress),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentAddress),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnType),
CV_ENUM_CLASS_ENT(PointerKind, BasedOnSelf),
CV_ENUM_CLASS_ENT(PointerKind, Near32),
CV_ENUM_CLASS_ENT(PointerKind, Far32),
CV_ENUM_CLASS_ENT(PointerKind, Near64),
};
static const EnumEntry<uint8_t> PtrModeNames[] = {
CV_ENUM_CLASS_ENT(PointerMode, Pointer),
CV_ENUM_CLASS_ENT(PointerMode, LValueReference),
CV_ENUM_CLASS_ENT(PointerMode, PointerToDataMember),
CV_ENUM_CLASS_ENT(PointerMode, PointerToMemberFunction),
CV_ENUM_CLASS_ENT(PointerMode, RValueReference),
};
static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, Unknown),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, SingleInheritanceData),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, MultipleInheritanceData),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, VirtualInheritanceData),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralData),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, SingleInheritanceFunction),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation,
MultipleInheritanceFunction),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation,
VirtualInheritanceFunction),
CV_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralFunction),
};
static const EnumEntry<uint16_t> TypeModifierNames[] = {
CV_ENUM_CLASS_ENT(ModifierOptions, Const),
CV_ENUM_CLASS_ENT(ModifierOptions, Volatile),
CV_ENUM_CLASS_ENT(ModifierOptions, Unaligned),
};
static const EnumEntry<uint8_t> CallingConventions[] = {
CV_ENUM_CLASS_ENT(CallingConvention, NearC),
CV_ENUM_CLASS_ENT(CallingConvention, FarC),
CV_ENUM_CLASS_ENT(CallingConvention, NearPascal),
CV_ENUM_CLASS_ENT(CallingConvention, FarPascal),
CV_ENUM_CLASS_ENT(CallingConvention, NearFast),
CV_ENUM_CLASS_ENT(CallingConvention, FarFast),
CV_ENUM_CLASS_ENT(CallingConvention, NearStdCall),
CV_ENUM_CLASS_ENT(CallingConvention, FarStdCall),
CV_ENUM_CLASS_ENT(CallingConvention, NearSysCall),
CV_ENUM_CLASS_ENT(CallingConvention, FarSysCall),
CV_ENUM_CLASS_ENT(CallingConvention, ThisCall),
CV_ENUM_CLASS_ENT(CallingConvention, MipsCall),
CV_ENUM_CLASS_ENT(CallingConvention, Generic),
CV_ENUM_CLASS_ENT(CallingConvention, AlphaCall),
CV_ENUM_CLASS_ENT(CallingConvention, PpcCall),
CV_ENUM_CLASS_ENT(CallingConvention, SHCall),
CV_ENUM_CLASS_ENT(CallingConvention, ArmCall),
CV_ENUM_CLASS_ENT(CallingConvention, AM33Call),
CV_ENUM_CLASS_ENT(CallingConvention, TriCall),
CV_ENUM_CLASS_ENT(CallingConvention, SH5Call),
CV_ENUM_CLASS_ENT(CallingConvention, M32RCall),
CV_ENUM_CLASS_ENT(CallingConvention, ClrCall),
CV_ENUM_CLASS_ENT(CallingConvention, Inline),
CV_ENUM_CLASS_ENT(CallingConvention, NearVector),
};
static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
CV_ENUM_CLASS_ENT(FunctionOptions, CxxReturnUdt),
CV_ENUM_CLASS_ENT(FunctionOptions, Constructor),
CV_ENUM_CLASS_ENT(FunctionOptions, ConstructorWithVirtualBases),
};
static const EnumEntry<uint16_t> LabelTypeEnum[] = {
CV_ENUM_CLASS_ENT(LabelType, Near),
CV_ENUM_CLASS_ENT(LabelType, Far),
};
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
namespace llvm {
namespace codeview {
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<SymbolKind>> getSymbolTypeNames() {
return makeArrayRef(SymbolTypeNames);
}
Resubmit "Write the TPI stream from a PDB to Yaml." The original patch was breaking some buildbots due to an incorrect ordering of function definitions which caused some compilers to recognize a definition but others to not. llvm-svn: 279089
2016-08-19 00:49:29 +08:00
ArrayRef<EnumEntry<TypeLeafKind>> getTypeLeafNames() {
return makeArrayRef(TypeLeafNames);
}
[COFF, ARM64] Add CodeView register mapping CodeView has its own register map which is defined in cvconst.h. Missing this mapping before saving register to CodeView causes debugger to show incorrect value for all register based variables, like variables in register and local variables addressed by register (stack pointer + offset). This change added mapping between LLVM register and CodeView register so the correct register number will be stored to CodeView/PDB, it aso fixed the mapping from CodeView register number to register name based on current CPUType but print PDB to yaml still assumes X86 CPU and needs to be fixed. Differential Revision: https://reviews.llvm.org/D62608 llvm-svn: 362280
2019-06-01 07:43:31 +08:00
ArrayRef<EnumEntry<uint16_t>> getRegisterNames(CPUType Cpu) {
[COFF][ARM] Fix CodeView for Windows on 32bit ARM targets. Create the LLVM / CodeView register mappings for the 32-bit ARM Window targets. Reviewed By: compnerd Differential Revision: https://reviews.llvm.org/D89622
2020-10-20 13:10:27 +08:00
if (Cpu == CPUType::ARMNT) {
return makeArrayRef(RegisterNames_ARM);
} else if (Cpu == CPUType::ARM64) {
[COFF, ARM64] Add CodeView register mapping CodeView has its own register map which is defined in cvconst.h. Missing this mapping before saving register to CodeView causes debugger to show incorrect value for all register based variables, like variables in register and local variables addressed by register (stack pointer + offset). This change added mapping between LLVM register and CodeView register so the correct register number will be stored to CodeView/PDB, it aso fixed the mapping from CodeView register number to register name based on current CPUType but print PDB to yaml still assumes X86 CPU and needs to be fixed. Differential Revision: https://reviews.llvm.org/D62608 llvm-svn: 362280
2019-06-01 07:43:31 +08:00
return makeArrayRef(RegisterNames_ARM64);
}
return makeArrayRef(RegisterNames_X86);
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
}
[CodeView] Fix dumping of public symbol record flags I noticed nonsensical type information while dumping PDBs produced by MSVC. llvm-svn: 305708
2017-06-20 00:54:51 +08:00
ArrayRef<EnumEntry<uint32_t>> getPublicSymFlagNames() {
return makeArrayRef(PublicSymFlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint8_t>> getProcSymFlagNames() {
return makeArrayRef(ProcSymFlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint16_t>> getLocalFlagNames() {
return makeArrayRef(LocalFlags);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[codeview] Use one byte for S_FRAMECOOKIE CookieKind and add flags byte We bailed out while printing codeview for an MSVC compiled SemaExprCXX.cpp that used this record. The MS reference headers look incorrect here, which is probably why we had this bug. They use a 32-bit enum as the field type, but the actual record appears to use one byte for the cookie kind followed by a flags byte. llvm-svn: 273691
2016-06-25 01:23:49 +08:00
ArrayRef<EnumEntry<uint8_t>> getFrameCookieKindNames() {
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
return makeArrayRef(FrameCookieKinds);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<SourceLanguage>> getSourceLanguageNames() {
return makeArrayRef(SourceLanguages);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint32_t>> getCompileSym2FlagNames() {
return makeArrayRef(CompileSym2FlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint32_t>> getCompileSym3FlagNames() {
return makeArrayRef(CompileSym3FlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Dump file checksums from pdb codeview line info. llvm-svn: 271622
2016-06-03 12:01:48 +08:00
ArrayRef<EnumEntry<uint32_t>> getFileChecksumNames() {
return makeArrayRef(FileChecksumNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<unsigned>> getCPUTypeNames() {
return makeArrayRef(CPUTypeNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint32_t>> getFrameProcSymFlagNames() {
return makeArrayRef(FrameProcSymFlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint16_t>> getExportSymFlagNames() {
return makeArrayRef(ExportSymFlagNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[llvm-pdbdump] Dump CodeView line information. This first pass only splits apart the records and dumps the line info kinds and binary data. Subsequent patches will parse out the binary data into more useful information and dump it in detail. llvm-svn: 271576
2016-06-03 04:11:22 +08:00
ArrayRef<EnumEntry<uint32_t>> getModuleSubstreamKindNames() {
return makeArrayRef(ModuleSubstreamKindNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint8_t>> getThunkOrdinalNames() {
return makeArrayRef(ThunkOrdinalNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<uint16_t>> getTrampolineNames() {
return makeArrayRef(TrampolineNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 13:07:49 +08:00
ArrayRef<EnumEntry<COFF::SectionCharacteristics>>
getImageSectionCharacteristicNames() {
return makeArrayRef(ImageSectionCharacteristicNames);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
Improving CodeView debug info type record's inline comments llvm-svn: 369533
2019-08-21 23:19:58 +08:00
ArrayRef<EnumEntry<uint16_t>> getClassOptionNames() {
return makeArrayRef(ClassOptionNames);
}
ArrayRef<EnumEntry<uint8_t>> getMemberAccessNames() {
return makeArrayRef(MemberAccessNames);
}
ArrayRef<EnumEntry<uint16_t>> getMethodOptionNames() {
return makeArrayRef(MethodOptionNames);
}
ArrayRef<EnumEntry<uint16_t>> getMemberKindNames() {
return makeArrayRef(MemberKindNames);
}
ArrayRef<EnumEntry<uint8_t>> getPtrKindNames() {
return makeArrayRef(PtrKindNames);
}
ArrayRef<EnumEntry<uint8_t>> getPtrModeNames() {
return makeArrayRef(PtrModeNames);
}
ArrayRef<EnumEntry<uint16_t>> getPtrMemberRepNames() {
return makeArrayRef(PtrMemberRepNames);
}
ArrayRef<EnumEntry<uint16_t>> getTypeModifierNames() {
return makeArrayRef(TypeModifierNames);
}
ArrayRef<EnumEntry<uint8_t>> getCallingConventions() {
return makeArrayRef(CallingConventions);
}
ArrayRef<EnumEntry<uint8_t>> getFunctionOptionEnum() {
return makeArrayRef(FunctionOptionEnum);
}
ArrayRef<EnumEntry<uint16_t>> getLabelTypeEnum() {
return makeArrayRef(LabelTypeEnum);
}
[CodeView] Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306616
2017-06-29 08:05:44 +08:00
} // end namespace codeview
} // end namespace llvm