EIC code displayed by LXR master/​include/​llvm/​DebugInfo/​CodeView/​SymbolRecord.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:40

 //===- SymbolRecord.h -------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H
 #define LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/RecordSerialization.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/Endian.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 namespace codeview {
 
 class SymbolRecord {
 protected:
   explicit SymbolRecord(SymbolRecordKind Kind) : Kind(Kind) {}
 
 public:
   SymbolRecordKind getKind() const { return Kind; }
 
   SymbolRecordKind Kind;
 };
 
 // S_GPROC32, S_LPROC32, S_GPROC32_ID, S_LPROC32_ID, S_LPROC32_DPC or
 // S_LPROC32_DPC_ID
 class ProcSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 32;
 
 public:
   explicit ProcSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ProcSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t Parent = 0;
   uint32_t End = 0;
   uint32_t Next = 0;
   uint32_t CodeSize = 0;
   uint32_t DbgStart = 0;
   uint32_t DbgEnd = 0;
   TypeIndex FunctionType;
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   ProcSymFlags Flags = ProcSymFlags::None;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_THUNK32
 class Thunk32Sym : public SymbolRecord {
 public:
   explicit Thunk32Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   Thunk32Sym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   uint32_t Parent = 0;
   uint32_t End = 0;
   uint32_t Next = 0;
   uint32_t Offset = 0;
   uint16_t Segment = 0;
   uint16_t Length = 0;
   ThunkOrdinal Thunk = ThunkOrdinal::Standard;
   StringRef Name;
   ArrayRef<uint8_t> VariantData;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_TRAMPOLINE
 class TrampolineSym : public SymbolRecord {
 public:
   explicit TrampolineSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   TrampolineSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   TrampolineType Type;
   uint16_t Size = 0;
   uint32_t ThunkOffset = 0;
   uint32_t TargetOffset = 0;
   uint16_t ThunkSection = 0;
   uint16_t TargetSection = 0;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_SECTION
 class SectionSym : public SymbolRecord {
 public:
   explicit SectionSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   SectionSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   uint16_t SectionNumber = 0;
   uint8_t Alignment = 0;
   uint32_t Rva = 0;
   uint32_t Length = 0;
   uint32_t Characteristics = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_COFFGROUP
 class CoffGroupSym : public SymbolRecord {
 public:
   explicit CoffGroupSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   CoffGroupSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   uint32_t Size = 0;
   uint32_t Characteristics = 0;
   uint32_t Offset = 0;
   uint16_t Segment = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 class ScopeEndSym : public SymbolRecord {
 public:
   explicit ScopeEndSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   ScopeEndSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   uint32_t RecordOffset = 0;
 };
 
 class JumpTableSym : public SymbolRecord {
 public:
   explicit JumpTableSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   JumpTableSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::JumpTableSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t BaseOffset = 0;
   uint16_t BaseSegment = 0;
 
   JumpTableEntrySize SwitchType;
   uint32_t BranchOffset = 0;
   uint32_t TableOffset = 0;
   uint16_t BranchSegment = 0;
   uint16_t TableSegment = 0;
 
   uint32_t EntriesCount = 0;
 
   uint32_t RecordOffset = 0;
 };
 
 class CallerSym : public SymbolRecord {
 public:
   explicit CallerSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   CallerSym(SymbolRecordKind Kind, uint32_t RecordOffset)
       : SymbolRecord(Kind), RecordOffset(RecordOffset) {}
 
   std::vector<TypeIndex> Indices;
 
   uint32_t RecordOffset = 0;
 };
 
 struct DecodedAnnotation {
   StringRef Name;
   ArrayRef<uint8_t> Bytes;
   BinaryAnnotationsOpCode OpCode = BinaryAnnotationsOpCode::Invalid;
   uint32_t U1 = 0;
   uint32_t U2 = 0;
   int32_t S1 = 0;
 };
 
 struct BinaryAnnotationIterator
     : public iterator_facade_base<BinaryAnnotationIterator,
                                   std::forward_iterator_tag,
                                   DecodedAnnotation> {
   BinaryAnnotationIterator() = default;
   BinaryAnnotationIterator(ArrayRef<uint8_t> Annotations) : Data(Annotations) {}
   BinaryAnnotationIterator(const BinaryAnnotationIterator &Other)
       : Data(Other.Data) {}
 
   bool operator==(BinaryAnnotationIterator Other) const {
     return Data == Other.Data;
   }
 
   BinaryAnnotationIterator &operator=(const BinaryAnnotationIterator Other) {
     Data = Other.Data;
     return *this;
   }
 
   BinaryAnnotationIterator &operator++() {
     if (!ParseCurrentAnnotation()) {
       *this = BinaryAnnotationIterator();
       return *this;
     }
     Data = Next;
     Next = ArrayRef<uint8_t>();
     Current.reset();
     return *this;
   }
 
   const DecodedAnnotation &operator*() {
     ParseCurrentAnnotation();
     return *Current;
   }
 
 private:
   static uint32_t GetCompressedAnnotation(ArrayRef<uint8_t> &Annotations) {
     if (Annotations.empty())
       return -1;
 
     uint8_t FirstByte = Annotations.front();
     Annotations = Annotations.drop_front();
 
     if ((FirstByte & 0x80) == 0x00)
       return FirstByte;
 
     if (Annotations.empty())
       return -1;
 
     uint8_t SecondByte = Annotations.front();
     Annotations = Annotations.drop_front();
 
     if ((FirstByte & 0xC0) == 0x80)
       return ((FirstByte & 0x3F) << 8) | SecondByte;
 
     if (Annotations.empty())
       return -1;
 
     uint8_t ThirdByte = Annotations.front();
     Annotations = Annotations.drop_front();
 
     if (Annotations.empty())
       return -1;
 
     uint8_t FourthByte = Annotations.front();
     Annotations = Annotations.drop_front();
 
     if ((FirstByte & 0xE0) == 0xC0)
       return ((FirstByte & 0x1F) << 24) | (SecondByte << 16) |
              (ThirdByte << 8) | FourthByte;
 
     return -1;
   }
 
   static int32_t DecodeSignedOperand(uint32_t Operand) {
     if (Operand & 1)
       return -(Operand >> 1);
     return Operand >> 1;
   }
 
   static int32_t DecodeSignedOperand(ArrayRef<uint8_t> &Annotations) {
     return DecodeSignedOperand(GetCompressedAnnotation(Annotations));
   }
 
   bool ParseCurrentAnnotation() {
     if (Current)
       return true;
 
     Next = Data;
     uint32_t Op = GetCompressedAnnotation(Next);
     DecodedAnnotation Result;
     Result.OpCode = static_cast<BinaryAnnotationsOpCode>(Op);
     switch (Result.OpCode) {
     case BinaryAnnotationsOpCode::Invalid:
       Result.Name = "Invalid";
       Next = ArrayRef<uint8_t>();
       break;
     case BinaryAnnotationsOpCode::CodeOffset:
       Result.Name = "CodeOffset";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
       Result.Name = "ChangeCodeOffsetBase";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeCodeOffset:
       Result.Name = "ChangeCodeOffset";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeCodeLength:
       Result.Name = "ChangeCodeLength";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeFile:
       Result.Name = "ChangeFile";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeLineEndDelta:
       Result.Name = "ChangeLineEndDelta";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeRangeKind:
       Result.Name = "ChangeRangeKind";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeColumnStart:
       Result.Name = "ChangeColumnStart";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeColumnEnd:
       Result.Name = "ChangeColumnEnd";
       Result.U1 = GetCompressedAnnotation(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeLineOffset:
       Result.Name = "ChangeLineOffset";
       Result.S1 = DecodeSignedOperand(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
       Result.Name = "ChangeColumnEndDelta";
       Result.S1 = DecodeSignedOperand(Next);
       break;
     case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset: {
       Result.Name = "ChangeCodeOffsetAndLineOffset";
       uint32_t Annotation = GetCompressedAnnotation(Next);
       Result.S1 = DecodeSignedOperand(Annotation >> 4);
       Result.U1 = Annotation & 0xf;
       break;
     }
     case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset: {
       Result.Name = "ChangeCodeLengthAndCodeOffset";
       Result.U1 = GetCompressedAnnotation(Next);
       Result.U2 = GetCompressedAnnotation(Next);
       break;
     }
     }
     Result.Bytes = Data.take_front(Data.size() - Next.size());
     Current = Result;
     return true;
   }
 
   std::optional<DecodedAnnotation> Current;
   ArrayRef<uint8_t> Data;
   ArrayRef<uint8_t> Next;
 };
 
 // S_INLINESITE
 class InlineSiteSym : public SymbolRecord {
 public:
   explicit InlineSiteSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit InlineSiteSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::InlineSiteSym),
         RecordOffset(RecordOffset) {}
 
   iterator_range<BinaryAnnotationIterator> annotations() const {
     return make_range(BinaryAnnotationIterator(AnnotationData),
                       BinaryAnnotationIterator());
   }
 
   uint32_t Parent = 0;
   uint32_t End = 0;
   TypeIndex Inlinee;
   std::vector<uint8_t> AnnotationData;
 
   uint32_t RecordOffset = 0;
 };
 
 struct PublicSym32Header {
   ulittle32_t Flags;
   ulittle32_t Offset;
   ulittle16_t Segment;
   // char Name[];
 };
 
 // S_PUB32
 class PublicSym32 : public SymbolRecord {
 public:
   PublicSym32() : SymbolRecord(SymbolRecordKind::PublicSym32) {}
   explicit PublicSym32(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit PublicSym32(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::PublicSym32),
         RecordOffset(RecordOffset) {}
 
   PublicSymFlags Flags = PublicSymFlags::None;
   uint32_t Offset = 0;
   uint16_t Segment = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_REGISTER
 class RegisterSym : public SymbolRecord {
 public:
   explicit RegisterSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit RegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::RegisterSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex Index;
   RegisterId Register;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_PROCREF, S_LPROCREF
 class ProcRefSym : public SymbolRecord {
 public:
   explicit ProcRefSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit ProcRefSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ProcRefSym), RecordOffset(RecordOffset) {
   }
 
   uint32_t SumName = 0;
   uint32_t SymOffset = 0;
   uint16_t Module = 0;
   StringRef Name;
 
   uint16_t modi() const { return Module - 1; }
   uint32_t RecordOffset = 0;
 };
 
 // S_LOCAL
 class LocalSym : public SymbolRecord {
 public:
   explicit LocalSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit LocalSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::LocalSym), RecordOffset(RecordOffset) {}
 
   TypeIndex Type;
   LocalSymFlags Flags = LocalSymFlags::None;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 struct LocalVariableAddrRange {
   uint32_t OffsetStart = 0;
   uint16_t ISectStart = 0;
   uint16_t Range = 0;
 };
 
 struct LocalVariableAddrGap {
   uint16_t GapStartOffset = 0;
   uint16_t Range = 0;
 };
 
 enum : uint16_t { MaxDefRange = 0xf000 };
 
 // S_DEFRANGE
 class DefRangeSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 8;
 
 public:
   explicit DefRangeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DefRangeSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t Program = 0;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_DEFRANGE_SUBFIELD
 class DefRangeSubfieldSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 12;
 
 public:
   explicit DefRangeSubfieldSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DefRangeSubfieldSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeSubfieldSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t Program = 0;
   uint16_t OffsetInParent = 0;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 struct DefRangeRegisterHeader {
   ulittle16_t Register;
   ulittle16_t MayHaveNoName;
 };
 
 // S_DEFRANGE_REGISTER
 class DefRangeRegisterSym : public SymbolRecord {
 public:
   explicit DefRangeRegisterSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DefRangeRegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeRegisterSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeRegisterHeader); }
 
   DefRangeRegisterHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 struct DefRangeSubfieldRegisterHeader {
   ulittle16_t Register;
   ulittle16_t MayHaveNoName;
   ulittle32_t OffsetInParent;
 };
 
 // S_DEFRANGE_SUBFIELD_REGISTER
 class DefRangeSubfieldRegisterSym : public SymbolRecord {
 public:
   explicit DefRangeSubfieldRegisterSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   explicit DefRangeSubfieldRegisterSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeSubfieldRegisterSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeSubfieldRegisterHeader); }
 
   DefRangeSubfieldRegisterHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 struct DefRangeFramePointerRelHeader {
   little32_t Offset;
 };
 
 // S_DEFRANGE_FRAMEPOINTER_REL
 class DefRangeFramePointerRelSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 8;
 
 public:
   explicit DefRangeFramePointerRelSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   explicit DefRangeFramePointerRelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   DefRangeFramePointerRelHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 struct DefRangeRegisterRelHeader {
   ulittle16_t Register;
   ulittle16_t Flags;
   little32_t BasePointerOffset;
 };
 
 // S_DEFRANGE_REGISTER_REL
 class DefRangeRegisterRelSym : public SymbolRecord {
 public:
   explicit DefRangeRegisterRelSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DefRangeRegisterRelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeRegisterRelSym),
         RecordOffset(RecordOffset) {}
 
   // The flags implement this notional bitfield:
   //   uint16_t IsSubfield : 1;
   //   uint16_t Padding : 3;
   //   uint16_t OffsetInParent : 12;
   enum : uint16_t {
     IsSubfieldFlag = 1,
     OffsetInParentShift = 4,
   };
 
   bool hasSpilledUDTMember() const { return Hdr.Flags & IsSubfieldFlag; }
   uint16_t offsetInParent() const { return Hdr.Flags >> OffsetInParentShift; }
 
   uint32_t getRelocationOffset() const { return RecordOffset + sizeof(DefRangeRegisterRelHeader); }
 
   DefRangeRegisterRelHeader Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE
 class DefRangeFramePointerRelFullScopeSym : public SymbolRecord {
 public:
   explicit DefRangeFramePointerRelFullScopeSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   explicit DefRangeFramePointerRelFullScopeSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelFullScopeSym),
         RecordOffset(RecordOffset) {}
 
   int32_t Offset = 0;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_BLOCK32
 class BlockSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 16;
 
 public:
   explicit BlockSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit BlockSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::BlockSym), RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t Parent = 0;
   uint32_t End = 0;
   uint32_t CodeSize = 0;
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_LABEL32
 class LabelSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit LabelSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit LabelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::LabelSym), RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   ProcSymFlags Flags = ProcSymFlags::None;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_OBJNAME
 class ObjNameSym : public SymbolRecord {
 public:
   explicit ObjNameSym() : SymbolRecord(SymbolRecordKind::ObjNameSym) {}
   explicit ObjNameSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit ObjNameSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ObjNameSym), RecordOffset(RecordOffset) {
   }
 
   uint32_t Signature = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_ENVBLOCK
 class EnvBlockSym : public SymbolRecord {
 public:
   explicit EnvBlockSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit EnvBlockSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::EnvBlockSym),
         RecordOffset(RecordOffset) {}
 
   std::vector<StringRef> Fields;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_EXPORT
 class ExportSym : public SymbolRecord {
 public:
   explicit ExportSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit ExportSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ExportSym), RecordOffset(RecordOffset) {}
 
   uint16_t Ordinal = 0;
   ExportFlags Flags = ExportFlags::None;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_FILESTATIC
 class FileStaticSym : public SymbolRecord {
 public:
   explicit FileStaticSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit FileStaticSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::FileStaticSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex Index;
   uint32_t ModFilenameOffset = 0;
   LocalSymFlags Flags = LocalSymFlags::None;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_COMPILE2
 class Compile2Sym : public SymbolRecord {
 public:
   explicit Compile2Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit Compile2Sym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::Compile2Sym),
         RecordOffset(RecordOffset) {}
 
   CompileSym2Flags Flags = CompileSym2Flags::None;
   CPUType Machine;
   uint16_t VersionFrontendMajor = 0;
   uint16_t VersionFrontendMinor = 0;
   uint16_t VersionFrontendBuild = 0;
   uint16_t VersionBackendMajor = 0;
   uint16_t VersionBackendMinor = 0;
   uint16_t VersionBackendBuild = 0;
   StringRef Version;
   std::vector<StringRef> ExtraStrings;
 
   uint8_t getLanguage() const { return static_cast<uint32_t>(Flags) & 0xFF; }
   uint32_t getFlags() const { return static_cast<uint32_t>(Flags) & ~0xFF; }
 
   uint32_t RecordOffset = 0;
 };
 
 // S_COMPILE3
 class Compile3Sym : public SymbolRecord {
 public:
   Compile3Sym() : SymbolRecord(SymbolRecordKind::Compile3Sym) {}
   explicit Compile3Sym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit Compile3Sym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::Compile3Sym),
         RecordOffset(RecordOffset) {}
 
   CompileSym3Flags Flags = CompileSym3Flags::None;
   CPUType Machine;
   uint16_t VersionFrontendMajor = 0;
   uint16_t VersionFrontendMinor = 0;
   uint16_t VersionFrontendBuild = 0;
   uint16_t VersionFrontendQFE = 0;
   uint16_t VersionBackendMajor = 0;
   uint16_t VersionBackendMinor = 0;
   uint16_t VersionBackendBuild = 0;
   uint16_t VersionBackendQFE = 0;
   StringRef Version;
 
   void setLanguage(SourceLanguage Lang) {
     Flags = CompileSym3Flags((uint32_t(Flags) & 0xFFFFFF00) | uint32_t(Lang));
   }
 
   SourceLanguage getLanguage() const {
     return static_cast<SourceLanguage>(static_cast<uint32_t>(Flags) & 0xFF);
   }
   CompileSym3Flags getFlags() const {
     return static_cast<CompileSym3Flags>(static_cast<uint32_t>(Flags) & ~0xFF);
   }
 
   bool hasOptimizations() const {
     return CompileSym3Flags::None !=
            (getFlags() & (CompileSym3Flags::PGO | CompileSym3Flags::LTCG));
   }
 
   uint32_t RecordOffset = 0;
 };
 
 // S_FRAMEPROC
 class FrameProcSym : public SymbolRecord {
 public:
   explicit FrameProcSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit FrameProcSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::FrameProcSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t TotalFrameBytes = 0;
   uint32_t PaddingFrameBytes = 0;
   uint32_t OffsetToPadding = 0;
   uint32_t BytesOfCalleeSavedRegisters = 0;
   uint32_t OffsetOfExceptionHandler = 0;
   uint16_t SectionIdOfExceptionHandler = 0;
   FrameProcedureOptions Flags = FrameProcedureOptions::None;
 
   /// Extract the register this frame uses to refer to local variables.
   RegisterId getLocalFramePtrReg(CPUType CPU) const {
     return decodeFramePtrReg(
         EncodedFramePtrReg((uint32_t(Flags) >> 14U) & 0x3U), CPU);
   }
 
   /// Extract the register this frame uses to refer to parameters.
   RegisterId getParamFramePtrReg(CPUType CPU) const {
     return decodeFramePtrReg(
         EncodedFramePtrReg((uint32_t(Flags) >> 16U) & 0x3U), CPU);
   }
 
   uint32_t RecordOffset = 0;
 
 private:
 };
 
 // S_CALLSITEINFO
 class CallSiteInfoSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit CallSiteInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit CallSiteInfoSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::CallSiteInfoSym) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   TypeIndex Type;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_HEAPALLOCSITE
 class HeapAllocationSiteSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit HeapAllocationSiteSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit HeapAllocationSiteSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::HeapAllocationSiteSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   uint16_t CallInstructionSize = 0;
   TypeIndex Type;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_FRAMECOOKIE
 class FrameCookieSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 4;
 
 public:
   explicit FrameCookieSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit FrameCookieSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::FrameCookieSym) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   uint32_t CodeOffset = 0;
   uint16_t Register = 0;
   FrameCookieKind CookieKind;
   uint8_t Flags = 0;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_UDT, S_COBOLUDT
 class UDTSym : public SymbolRecord {
 public:
   explicit UDTSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit UDTSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::UDTSym) {}
 
   TypeIndex Type;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_BUILDINFO
 class BuildInfoSym : public SymbolRecord {
 public:
   explicit BuildInfoSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit BuildInfoSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::BuildInfoSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex BuildId;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_BPREL32
 class BPRelativeSym : public SymbolRecord {
 public:
   explicit BPRelativeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit BPRelativeSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::BPRelativeSym),
         RecordOffset(RecordOffset) {}
 
   int32_t Offset = 0;
   TypeIndex Type;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_REGREL32
 class RegRelativeSym : public SymbolRecord {
 public:
   explicit RegRelativeSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit RegRelativeSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::RegRelativeSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t Offset = 0;
   TypeIndex Type;
   RegisterId Register;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_CONSTANT, S_MANCONSTANT
 class ConstantSym : public SymbolRecord {
 public:
   explicit ConstantSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit ConstantSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ConstantSym),
         RecordOffset(RecordOffset) {}
 
   TypeIndex Type;
   APSInt Value;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_LDATA32, S_GDATA32, S_LMANDATA, S_GMANDATA
 class DataSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 8;
 
 public:
   explicit DataSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit DataSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DataSym), RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   TypeIndex Type;
   uint32_t DataOffset = 0;
   uint16_t Segment = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_LTHREAD32, S_GTHREAD32
 class ThreadLocalDataSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 8;
 
 public:
   explicit ThreadLocalDataSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit ThreadLocalDataSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::ThreadLocalDataSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
   TypeIndex Type;
   uint32_t DataOffset = 0;
   uint16_t Segment = 0;
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_UNAMESPACE
 class UsingNamespaceSym : public SymbolRecord {
 public:
   explicit UsingNamespaceSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit UsingNamespaceSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::UsingNamespaceSym),
         RecordOffset(RecordOffset) {}
 
   StringRef Name;
 
   uint32_t RecordOffset = 0;
 };
 
 // S_ANNOTATION
 class AnnotationSym : public SymbolRecord {
 public:
   explicit AnnotationSym(SymbolRecordKind Kind) : SymbolRecord(Kind) {}
   explicit AnnotationSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::AnnotationSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t CodeOffset = 0;
   uint16_t Segment = 0;
   std::vector<StringRef> Strings;
 
   uint32_t RecordOffset = 0;
 };
 
 Expected<CVSymbol> readSymbolFromStream(BinaryStreamRef Stream,
                                         uint32_t Offset);
 
 } // end namespace codeview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_CODEVIEW_SYMBOLRECORD_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team