[codeview] Begin to add support for inlined call sites

[rnk]

Summary

There are three parts to inlined call frames:

1. The inlinee line subsection
2. The inline site symbol record
3. The function ids referenced by both

This change starts by emitting function ids (3) for all subprograms and
emitting the base inline site symbol record (2). The actual line numbers
in (2) use an encoded format that will come next, along with the inlinee
line subsection.

include/llvm/DebugInfo/CodeView/TypeRecord.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include <cinttypes>
 
 namespace llvm {
 namespace codeview {
 
+using llvm::support::little32_t;
+using llvm::support::ulittle16_t;
+using llvm::support::ulittle32_t;
+
 class TypeRecord {
 protected:
   explicit TypeRecord(TypeRecordKind Kind) : Kind(Kind) {}
 
 public:
   TypeRecordKind getKind() const { return Kind; }
 
 private:
public:
   explicit VirtualTableShapeRecord(ArrayRef<VirtualTableSlotKind> Slots)
       : TypeRecord(TypeRecordKind::VirtualTableShape), Slots(Slots) {}
 
   ArrayRef<VirtualTableSlotKind> getSlots() const { return Slots; }
 
 private:
   ArrayRef<VirtualTableSlotKind> Slots;
 };
+
+//===----------------------------------------------------------------------===//
+// On-disk representation of type information
+
+// A CodeView type stream is a sequence of TypeRecords. Records larger than
+// 65536 must chain on to a second record. Each TypeRecord is followed by one of
+// the leaf types described below.
+struct TypeRecordPrefix {
+  ulittle16_t Len;  // Type record length, starting from &Leaf.
+  ulittle16_t Leaf; // Type record kind (TypeLeafKind)
+};
+
+// LF_TYPESERVER2
+struct TypeServer2 {
+  char Signature[16];  // GUID
+  ulittle32_t Age;
+  // Name: Name of the PDB as a null-terminated string
+};
+
+// LF_STRING_ID
+struct StringId {
+  TypeIndex id;
+};
+
+// LF_FUNC_ID
+struct FuncId {
+  TypeIndex ParentScope;
+  TypeIndex FunctionType;
+  // Name: The null-terminated name follows.
+};
+
+// LF_CLASS, LF_STRUCT, LF_INTERFACE
+struct ClassType {
+  ulittle16_t MemberCount; // Number of members in FieldList.
+  ulittle16_t Properties;  // ClassOptions bitset
+  TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
+  TypeIndex DerivedFrom;   // LF_DERIVED: List of known derived classes
+  TypeIndex VShape;        // LF_VTSHAPE: Shape of the vftable
+  // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
+  // Name: The null-terminated name follows.
+};
+
+// LF_UNION
+struct UnionType {
+  ulittle16_t MemberCount; // Number of members in FieldList.
+  ulittle16_t Properties;  // ClassOptions bitset
+  TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
+  // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
+  // Name: The null-terminated name follows.
+};
+
+// LF_POINTER
+struct PointerType {
+  TypeIndex PointeeType;
+  ulittle32_t Attrs; // pointer attributes
+  // if pointer to member:
+  //   PointerToMemberTail
+
+  PointerKind getPtrKind() const { return PointerKind(Attrs & 0x1f); }
+  PointerMode getPtrMode() const { return PointerMode((Attrs >> 5) & 0x07); }
+  bool isFlat() const { return Attrs & (1 << 8); }
+  bool isVolatile() const { return Attrs & (1 << 9); }
+  bool isConst() const { return Attrs & (1 << 10); }
+  bool isUnaligned() const { return Attrs & (1 << 11); }
+
+  bool isPointerToDataMember() const {
+    return getPtrMode() == PointerMode::PointerToDataMember;
+  }
+  bool isPointerToMemberFunction() const {
+    return getPtrMode() == PointerMode::PointerToMemberFunction;
+  }
+  bool isPointerToMember() const {
+    return isPointerToMemberFunction() || isPointerToDataMember();
+  }
+};
+
+struct PointerToMemberTail {
+  TypeIndex ClassType;
+  ulittle16_t Representation; // PointerToMemberRepresentation
+};
+
+/// In Clang parlance, these are "qualifiers".  LF_MODIFIER
+struct TypeModifier {
+  TypeIndex ModifiedType;
+  ulittle16_t Modifiers; // ModifierOptions
+};
+
+// LF_VTSHAPE
+struct VTableShape {
+  // Number of vftable entries. Each method may have more than one entry due to
+  // things like covariant return types.
+  ulittle16_t VFEntryCount;
+  // Descriptors[]: 4-bit virtual method descriptors of type CV_VTS_desc_e.
+};
+
+// LF_UDT_SRC_LINE
+struct UDTSrcLine {
+  TypeIndex UDT;        // The user-defined type
+  TypeIndex SourceFile; // StringID containing the source filename
+  ulittle32_t LineNumber;
+};
+
+// LF_ARGLIST, LF_SUBSTR_LIST
+struct ArgList {
+  ulittle32_t NumArgs; // Number of arguments
+  // ArgTypes[]: Type indicies of arguments
+};
+
+// LF_BUILDINFO
+struct BuildInfo {
+  ulittle16_t NumArgs; // Number of arguments
+  // ArgTypes[]: Type indicies of arguments
+};
+
+// LF_ENUM
+struct EnumType {
+  ulittle16_t NumEnumerators; // Number of enumerators
+  ulittle16_t Properties;
+  TypeIndex UnderlyingType;
+  TypeIndex FieldListType;
+  // Name: The null-terminated name follows.
+};
+
+// LF_ARRAY
+struct ArrayType {
+  TypeIndex ElementType;
+  TypeIndex IndexType;
+  // SizeOf: LF_NUMERIC encoded size in bytes. Not element count!
+  // Name: The null-terminated name follows.
+};
+
+// LF_VFTABLE
+struct VFTableType {
+  TypeIndex CompleteClass;     // Class that owns this vftable.
+  TypeIndex OverriddenVFTable; // VFTable that this overrides.
+  ulittle32_t VFPtrOffset;     // VFPtr offset in CompleteClass
+  ulittle32_t NamesLen;        // Length of subsequent names array in bytes.
+  // Names: A sequence of null-terminated strings. First string is vftable
+  // names.
+};
+
+// LF_MFUNC_ID
+struct MemberFuncId {
+  TypeIndex ClassType;
+  TypeIndex FunctionType;
+  // Name: The null-terminated name follows.
+};
+
+// LF_PROCEDURE
+struct ProcedureType {
+  TypeIndex ReturnType;
+  CallingConvention CallConv;
+  FunctionOptions Options;
+  ulittle16_t NumParameters;
+  TypeIndex ArgListType;
+};
+
+// LF_MFUNCTION
+struct MemberFunctionType {
+  TypeIndex ReturnType;
+  TypeIndex ClassType;
+  TypeIndex ThisType;
+  CallingConvention CallConv;
+  FunctionOptions Options;
+  ulittle16_t NumParameters;
+  TypeIndex ArgListType;
+  little32_t ThisAdjustment;
+};
+
+//===----------------------------------------------------------------------===//
+// Field list records, which do not include leafs or sizes
+
+/// Equvalent to CV_fldattr_t in cvinfo.h.
+struct MemberAttributes {
+  ulittle16_t Attrs;
+
+  /// Get the access specifier. Valid for any kind of member.
+  MemberAccess getAccess() const {
+    return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
+  }
+
+  /// Indicates if a method is defined with friend, virtual, static, etc.
+  MethodKind getMethodKind() const {
+    return MethodKind(
+        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >> 2);
+  }
+
+  /// Get the flags that are not included in access control or method
+  /// properties.
+  MethodOptions getFlags() const {
+    return MethodOptions(
+        unsigned(Attrs) &
+        ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
+  }
+
+  /// Is this method virtual.
+  bool isVirtual() const {
+    auto MP = getMethodKind();
+    return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
+           MP != MethodKind::Static;
+  }
+
+  /// Does this member introduce a new virtual method.
+  bool isIntroducedVirtual() const {
+    auto MP = getMethodKind();
+    return MP == MethodKind::IntroducingVirtual ||
+           MP == MethodKind::PureIntroducingVirtual;
+  }
+};
+
+// LF_NESTTYPE
+struct NestedType {
+  ulittle16_t Pad0; // Should be zero
+  TypeIndex Type;   // Type index of nested type
+  // Name: Null-terminated string
+};
+
+// LF_ONEMETHOD
+struct OneMethod {
+  MemberAttributes Attrs;
+  TypeIndex Type;
+  // If is introduced virtual method:
+  //   VFTableOffset: int32_t offset in vftable
+  // Name: Null-terminated string
+
+  MethodKind getMethodKind() const {
+    return Attrs.getMethodKind();
+  }
+
+  bool isVirtual() const { return Attrs.isVirtual(); }
+  bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
+};
+
+struct MethodListEntry {
+  MemberAttributes Attrs;
+  ulittle16_t Padding;
+
+  TypeIndex Type;
+  // If is introduced virtual method:
+  //   VFTableOffset: int32_t offset in vftable
+
+  MethodKind getMethodKind() const {
+    return Attrs.getMethodKind();
+  }
+
+  bool isVirtual() const { return Attrs.isVirtual(); }
+  bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
+};
+
+/// For method overload sets.  LF_METHOD
+struct OverloadedMethod {
+  ulittle16_t MethodCount; // Size of overload set
+  TypeIndex MethList;      // Type index of methods in overload set
+  // Name: Null-terminated string
+};
+
+// LF_VFUNCTAB
+struct VirtualFunctionPointer {
+  ulittle16_t Pad0;
+  TypeIndex Type;   // Type of vfptr
+};
+
+// LF_MEMBER
+struct DataMember {
+  MemberAttributes Attrs; // Access control attributes, etc
+  TypeIndex Type;
+  // FieldOffset: LF_NUMERIC encoded byte offset
+  // Name: Null-terminated string
+};
+
+// LF_STMEMBER
+struct StaticDataMember {
+  MemberAttributes Attrs; // Access control attributes, etc
+  TypeIndex Type;
+  // Name: Null-terminated string
+};
+
+// LF_ENUMERATE
+struct Enumerator {
+  MemberAttributes Attrs; // Access control attributes, etc
+  // EnumValue: LF_NUMERIC encoded enumerator value
+  // Name: Null-terminated string
+};
+
+// LF_BCLASS, LF_BINTERFACE
+struct BaseClass {
+  MemberAttributes Attrs; // Access control attributes, etc
+  TypeIndex BaseType;     // Base class type
+  // BaseOffset: LF_NUMERIC encoded byte offset of base from derived.
+};
+
+// LF_VBCLASS | LV_IVBCLASS
+struct VirtualBaseClass {
+  MemberAttributes Attrs; // Access control attributes, etc.
+  TypeIndex BaseType;     // Base class type
+  TypeIndex VBPtrType;    // Virtual base pointer type
+  // VBPtrOffset: Offset of vbptr from vfptr encoded as LF_NUMERIC.
+  // VBTableIndex: Index of vbase within vbtable encoded as LF_NUMERIC.
+};
 }
 }
 
 #endif

include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *DwarfTUIndexSection;
 
   /// Section for newer gnu pubnames.
   MCSection *DwarfGnuPubNamesSection;
   /// Section for newer gnu pubtypes.
   MCSection *DwarfGnuPubTypesSection;
 
   MCSection *COFFDebugSymbolsSection;
+  MCSection *COFFDebugTypesSection;
 
   /// Extra TLS Variable Data section.
   ///
   /// If the target needs to put additional information for a TLS variable,
   /// it'll go here.
   MCSection *TLSExtraDataSection;
 
   /// Section directive for Thread Local data. ELF, MachO and COFF.
public:
   MCSection *getDwarfStrOffDWOSection() const { return DwarfStrOffDWOSection; }
   MCSection *getDwarfAddrSection() const { return DwarfAddrSection; }
   MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
   MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
 
   MCSection *getCOFFDebugSymbolsSection() const {
     return COFFDebugSymbolsSection;
   }
+  MCSection *getCOFFDebugTypesSection() const {
+    return COFFDebugTypesSection;
+  }
+
 
   MCSection *getTLSExtraDataSection() const { return TLSExtraDataSection; }
   const MCSection *getTLSDataSection() const { return TLSDataSection; }
   MCSection *getTLSBSSSection() const { return TLSBSSSection; }
 
   MCSection *getStackMapSection() const { return StackMapSection; }
   MCSection *getFaultMapSection() const { return FaultMapSection; }
 

lib/CodeGen/AsmPrinter/CodeViewDebug.h

 #include "AsmPrinterHandler.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 /// \brief Collects and handles line tables information in a CodeView format.
 class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public AsmPrinterHandler {
   AsmPrinter *Asm;
   DebugLoc PrevInstLoc;
 
+  struct InlineInfo {
+    TinyPtrVector<const DILocation *> ChildSites;
+    TinyPtrVector<MCSymbol *> Instrs;
+  };
+
   // For each function, store a vector of labels to its instructions, as well as
   // to the end of the function.
   struct FunctionInfo {
     DebugLoc LastLoc;
     SmallVector<MCSymbol *, 10> Instrs;
+
+    /// Map from inlined call site to inlined instructions and child inlined
+    /// call sites. Listed in program order.
+    MapVector<const DILocation *, InlineInfo> InlineSites;
+
     MCSymbol *End;
     FunctionInfo() : End(nullptr) {}
   };
   FunctionInfo *CurFn;
 
+  DenseMap<const DISubprogram *, codeview::TypeIndex> SubprogramToFuncId;
+
+  unsigned TypeCount = 0;
+
+  /// Gets the next type index and increments the count of types streamed so
+  /// far.
+  codeview::TypeIndex getNextTypeIndex() {
+    return codeview::TypeIndex(codeview::TypeIndex::FirstNonSimpleIndex + TypeCount++);
+  }
+
   typedef DenseMap<const Function *, FunctionInfo> FnDebugInfoTy;
   FnDebugInfoTy FnDebugInfo;
   // Store the functions we've visited in a vector so we can maintain a stable
   // order while emitting subsections.
   SmallVector<const Function *, 10> VisitedFunctions;
 
   DenseMap<MCSymbol *, DebugLoc> LabelsAndLocs;
 
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public AsmPrinterHandler {
   void maybeRecordLocation(DebugLoc DL, const MachineFunction *MF);
 
   void clear() {
     assert(CurFn == nullptr);
     FileNameRegistry.clear();
     LabelsAndLocs.clear();
   }
 
+  void emitTypeInformation();
+
   void emitDebugInfoForFunction(const Function *GV);
 
+  void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
+                           const InlineInfo &Site);
+
 public:
   CodeViewDebug(AsmPrinter *Asm);
 
   void setSymbolSize(const llvm::MCSymbol *, uint64_t) override {}
 
   /// \brief Emit the COFF section that holds the line table information.
   void endModule() override;
 

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 //===-- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp --*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing Microsoft CodeView debug info.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeViewDebug.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+#include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 
 using namespace llvm::codeview;
 
 namespace llvm {
 
void CodeViewDebug::maybeRecordLocation(DebugLoc DL,
   // Skip this line if it is longer than the maximum we can record.
   if (DL.getLine() > COFF::CVL_MaxLineNumber)
     return;
 
   CurFn->LastLoc = DL;
 
   MCSymbol *MCL = Asm->MMI->getContext().createTempSymbol();
   Asm->OutStreamer->EmitLabel(MCL);
+  if (const DILocation *Loc = DL->getInlinedAt()) {
+    CurFn->InlineSites[Loc].Instrs.push_back(MCL);
+    // Invert the IR child-to-parent links.
+    while (const DILocation *ParentLoc = Loc->getInlinedAt()) {
+      InlineInfo &ParentSite = CurFn->InlineSites[ParentLoc];
+      auto B = ParentSite.ChildSites.begin(), E = ParentSite.ChildSites.end();
+      // Stop inserting links if we've already inserted this one.
+      if (std::find(B, E, Loc) != E)
+        break;
+      ParentSite.ChildSites.push_back(Loc);
+      Loc = ParentLoc;
+    }
+  } else {
     CurFn->Instrs.push_back(MCL);
+  }
   LabelsAndLocs[MCL] = DL;
 }
 
 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
     : Asm(nullptr), CurFn(nullptr) {
   MachineModuleInfo *MMI = AP->MMI;
 
   // If module doesn't have named metadata anchors or COFF debug section
   // is not available, skip any debug info related stuff.
   if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
       !AP->getObjFileLowering().getCOFFDebugSymbolsSection())
     return;
 
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
   Asm = AP;
 }
 
 void CodeViewDebug::endModule() {
   if (FnDebugInfo.empty())
     return;
 
+  emitTypeInformation();
+
   // FIXME: For functions that are comdat, we should emit separate .debug$S
   // sections that are comdat associative with the main function instead of
   // having one big .debug$S section.
   assert(Asm != nullptr);
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getCOFFDebugSymbolsSection());
   Asm->EmitInt32(COFF::DEBUG_SECTION_MAGIC);
 
void CodeViewDebug::endModule() {
   }
 
   // No more subsections. Fill with zeros to align the end of the section by 4.
   Asm->OutStreamer->EmitFill((-FileNameRegistry.LastOffset) % 4, 0);
 
   clear();
 }
 
+void CodeViewDebug::emitTypeInformation() {
+  // Start the .debug$T section with 0x4.
+  Asm->OutStreamer->SwitchSection(
+      Asm->getObjFileLowering().getCOFFDebugTypesSection());
+  Asm->EmitInt32(COFF::DEBUG_SECTION_MAGIC);
+
+  NamedMDNode *CU_Nodes =
+      Asm->MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
+  if (!CU_Nodes)
+    return;
+
+  // This type info currently only holds function ids for use with inline call
+  // frame info. All functions are assigned a simple 'void ()' type. Emit that
+  // type here.
+  TypeIndex ArgListIdx = getNextTypeIndex();
+  Asm->EmitInt16(2 + sizeof(ArgList));
+  Asm->EmitInt16(LF_ARGLIST);
+  Asm->EmitInt32(0);
+
+  TypeIndex VoidProcIdx = getNextTypeIndex();
+  Asm->EmitInt16(2 + sizeof(ProcedureType));
+  Asm->EmitInt16(LF_PROCEDURE);
+  ProcedureType Proc {};
+  Proc.ReturnType = TypeIndex::Void();
+  Proc.CallConv = CallingConvention::NearC;
+  Proc.Options = FunctionOptions::None;
+  Proc.NumParameters = 0;
+  Proc.ArgListType = ArgListIdx;
+  Asm->OutStreamer->EmitBytes(
+      StringRef(reinterpret_cast<const char *>(&Proc), sizeof(Proc)));
+
+  for (MDNode *N : CU_Nodes->operands()) {
+    auto *CUNode = cast<DICompileUnit>(N);
+    for (auto *SP : CUNode->getSubprograms()) {
+      StringRef DisplayName = SP->getDisplayName();
+      Asm->EmitInt16(2 + sizeof(FuncId) + DisplayName.size() + 1);
+      Asm->EmitInt16(LF_FUNC_ID);
+
+      FuncId Func{};
+      // FIXME: Should be full namespace scope as a string id.
+      Func.ParentScope = TypeIndex();
+      Func.FunctionType = VoidProcIdx;
+      Asm->OutStreamer->EmitBytes(
+          StringRef(reinterpret_cast<const char *>(&Func), sizeof(Func)));
+      Asm->OutStreamer->EmitBytes(DisplayName);
+      Asm->EmitInt8(0);
+
+      TypeIndex FuncIdIdx = getNextTypeIndex();
+      SubprogramToFuncId.insert(std::make_pair(SP, FuncIdIdx));
+    }
+  }
+}
+
 static void EmitLabelDiff(MCStreamer &Streamer,
                           const MCSymbol *From, const MCSymbol *To,
                           unsigned int Size = 4) {
   MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None;
   MCContext &Context = Streamer.getContext();
   const MCExpr *FromRef = MCSymbolRefExpr::create(From, Variant, Context),
                *ToRef   = MCSymbolRefExpr::create(To, Variant, Context);
   const MCExpr *AddrDelta =
       MCBinaryExpr::create(MCBinaryExpr::Sub, ToRef, FromRef, Context);
   Streamer.EmitValue(AddrDelta, Size);
 }
 
 static const DIFile *getFileFromLoc(DebugLoc DL) {
   return DL.get()->getScope()->getFile();
 }
 
+void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
+                                        const DILocation *InlinedAt,
+                                        const InlineInfo &Site) {
+  MCStreamer &OS = *Asm->OutStreamer;
+
+  MCSymbol *InlineBegin = Asm->MMI->getContext().createTempSymbol(),
+           *InlineEnd = Asm->MMI->getContext().createTempSymbol();
+
+  // Find the inlinee by looking for inlined instructions or an inlined call
+  // site if there are none.
+  const DILocation *DL;
+  if (!Site.ChildSites.empty())
+    DL = Site.ChildSites.front();
+  else
+    DL = LabelsAndLocs[Site.Instrs.front()].get();
+  const DISubprogram *Inlinee = DL->getScope()->getSubprogram();
+  assert(SubprogramToFuncId.count(Inlinee));
+  TypeIndex InlineeIdx = SubprogramToFuncId[Inlinee];
+
+  // SymbolRecord
+  EmitLabelDiff(OS, InlineBegin, InlineEnd, 2);   // RecordLength
+  OS.EmitLabel(InlineBegin);
+  Asm->EmitInt16(SymbolRecordKind::S_INLINESITE); // RecordKind
+
+  InlineSiteSym SiteBytes{};
+  SiteBytes.Inlinee = InlineeIdx;
+  Asm->OutStreamer->EmitBytes(
+      StringRef(reinterpret_cast<const char *>(&SiteBytes), sizeof(SiteBytes)));
+
+  // FIXME: annotations
+
+  OS.EmitLabel(InlineEnd);
+
+  // Recurse on child inlined call sites before closing the scope.
+  for (const DILocation *ChildSite : Site.ChildSites) {
+    auto I = FI.InlineSites.find(ChildSite);
+    assert(I != FI.InlineSites.end() &&
+           "child site not in function inline site map");
+    emitInlinedCallSite(FI, ChildSite, I->second);
+  }
+
+  // Close the scope.
+  Asm->EmitInt16(2);                                  // RecordLength
+  Asm->EmitInt16(SymbolRecordKind::S_INLINESITE_END); // RecordKind
+}
+
 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV) {
   // For each function there is a separate subsection
   // which holds the PC to file:line table.
   const MCSymbol *Fn = Asm->getSymbol(GV);
   assert(Fn);
 
   const FunctionInfo &FI = FnDebugInfo[GV];
-  if (FI.Instrs.empty())
+  if (FI.Instrs.empty() && FI.InlineSites.empty())
     return;
   assert(FI.End && "Don't know where the function ends?");
 
   StringRef FuncName;
   if (auto *SP = getDISubprogram(GV))
     FuncName = SP->getDisplayName();
 
   // If our DISubprogram name is empty, use the mangled name.
Asm->OutStreamer->EmitLabel(SymbolsBegin);
     Asm->OutStreamer->EmitCOFFSecRel32(Fn);
     Asm->OutStreamer->EmitCOFFSectionIndex(Fn);
     Asm->EmitInt8(0);
     // Emit the function display name as a null-terminated string.
     Asm->OutStreamer->EmitBytes(FuncName);
     Asm->EmitInt8(0);
     Asm->OutStreamer->EmitLabel(ProcSegmentEnd);
 
+    // Emit inlined call site information. Only emit functions inlined directly
+    // into the parent function. We'll emit the other sites recursively as part
+    // of their parent inline site.
+    for (auto &KV : FI.InlineSites) {
+      const DILocation *InlinedAt = KV.first;
+      if (!InlinedAt->getInlinedAt())
+        emitInlinedCallSite(FI, InlinedAt, KV.second);
+    }
+
     // We're done with this function.
     Asm->EmitInt16(0x0002);
     Asm->EmitInt16(unsigned(SymbolRecordKind::S_PROC_ID_END));
   }
   Asm->OutStreamer->EmitLabel(SymbolsEnd);
   // Every subsection must be aligned to a 4-byte boundary.
   Asm->OutStreamer->EmitFill((-FuncName.size()) % 4, 0);
 

lib/MC/MCObjectFileInfo.cpp

StaticDtorSection = Ctx->getMachOSection("__DATA", "__mod_term_func",
                                              SectionKind::getData());
   }
 
   // Exception Handling.
   LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
                                      SectionKind::getReadOnlyWithRel());
 
   COFFDebugSymbolsSection = nullptr;
+  COFFDebugTypesSection = nullptr;
 
   if (useCompactUnwind(T)) {
     CompactUnwindSection =
         Ctx->getMachOSection("__LD", "__compact_unwind", MachO::S_ATTR_DEBUG,
                              SectionKind::getReadOnly());
 
     if (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86)
       CompactUnwindDwarfEHFrameOnly = 0x04000000;  // UNWIND_X86_64_MODE_DWARF
void MCObjectFileInfo::initELFMCObjectFileInfo(Triple T) {
   // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
   // it contains relocatable pointers.  In PIC mode, this is probably a big
   // runtime hit for C++ apps.  Either the contents of the LSDA need to be
   // adjusted or this should be a data section.
   LSDASection = Ctx->getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
                                    ELF::SHF_ALLOC);
 
   COFFDebugSymbolsSection = nullptr;
+  COFFDebugTypesSection = nullptr;
 
   // Debug Info Sections.
   DwarfAbbrevSection = Ctx->getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0,
                                           "section_abbrev");
   DwarfInfoSection =
       Ctx->getELFSection(".debug_info", ELF::SHT_PROGBITS, 0, "section_info");
   DwarfLineSection = Ctx->getELFSection(".debug_line", ELF::SHT_PROGBITS, 0);
   DwarfFrameSection = Ctx->getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0);
if (T.getArch() == Triple::x86_64) {
     LSDASection = Ctx->getCOFFSection(".gcc_except_table",
                                       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                                           COFF::IMAGE_SCN_MEM_READ,
                                       SectionKind::getReadOnly());
   }
 
   // Debug info.
   COFFDebugSymbolsSection =
-      Ctx->getCOFFSection(".debug$S", COFF::IMAGE_SCN_MEM_DISCARDABLE |
-                                          COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
-                                          COFF::IMAGE_SCN_MEM_READ,
+      Ctx->getCOFFSection(".debug$S", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
+                                       COFF::IMAGE_SCN_MEM_READ),
+                          SectionKind::getMetadata());
+  COFFDebugTypesSection =
+      Ctx->getCOFFSection(".debug$T", (COFF::IMAGE_SCN_MEM_DISCARDABLE |
+                                       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+                                       COFF::IMAGE_SCN_MEM_READ),
                           SectionKind::getMetadata());
 
   DwarfAbbrevSection = Ctx->getCOFFSection(
       ".debug_abbrev",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "section_abbrev");
   DwarfInfoSection = Ctx->getCOFFSection(

test/DebugInfo/COFF/inlining.ll

+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj -codeview | FileCheck %s
+
+; This LL file was generated by running clang on the following code:
+; extern volatile int x;
+; static inline void foo() {
+;   int y = 1;
+;   x += (int)&y;
+;   x += 2;
+;   x += 3;
+; }
+; static inline void bar() {
+;   x += 4;
+;   foo();
+;   x += 5;
+; }
+; void baz() {
+;   x += 6;
+;   bar();
+;   x += 7;
+; }
+
+; CHECK: InlineSite {
+; CHECK: Inlinee: bar
+; CHECK: }
+; CHECK: InlineSite {
+; CHECK: Inlinee: foo
+; CHECK: }
+; CHECK: InlineSiteEnd
+; CHECK: InlineSiteEnd
+
+; ModuleID = 't.cpp'
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc18.0.0"
+
+@"\01?x@@3HC" = external global i32, align 4
+
+; Function Attrs: norecurse nounwind uwtable
+define void @"\01?baz@@YAXXZ"() #0 !dbg !4 {
+entry:
+  %y.i.i = alloca i32, align 4
+  %0 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !12, !tbaa !13
+  %add = add nsw i32 %0, 6, !dbg !12
+  store volatile i32 %add, i32* @"\01?x@@3HC", align 4, !dbg !12, !tbaa !13
+  %1 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !17, !tbaa !13
+  %add.i = add nsw i32 %1, 4, !dbg !17
+  store volatile i32 %add.i, i32* @"\01?x@@3HC", align 4, !dbg !17, !tbaa !13
+  %2 = bitcast i32* %y.i.i to i8*, !dbg !19
+  call void @llvm.lifetime.start(i64 4, i8* %2) #2, !dbg !19
+  store i32 1, i32* %y.i.i, align 4, !dbg !21, !tbaa !13
+  %3 = ptrtoint i32* %y.i.i to i64, !dbg !22
+  %4 = trunc i64 %3 to i32, !dbg !22
+  %5 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !23, !tbaa !13
+  %add.i.i = add nsw i32 %5, %4, !dbg !23
+  store volatile i32 %add.i.i, i32* @"\01?x@@3HC", align 4, !dbg !23, !tbaa !13
+  %6 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !24, !tbaa !13
+  %add1.i.i = add nsw i32 %6, 2, !dbg !24
+  store volatile i32 %add1.i.i, i32* @"\01?x@@3HC", align 4, !dbg !24, !tbaa !13
+  %7 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !25, !tbaa !13
+  %add2.i.i = add nsw i32 %7, 3, !dbg !25
+  store volatile i32 %add2.i.i, i32* @"\01?x@@3HC", align 4, !dbg !25, !tbaa !13
+  call void @llvm.lifetime.end(i64 4, i8* %2) #2, !dbg !26
+  %8 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !27, !tbaa !13
+  %add1.i = add nsw i32 %8, 5, !dbg !27
+  store volatile i32 %add1.i, i32* @"\01?x@@3HC", align 4, !dbg !27, !tbaa !13
+  %9 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !28, !tbaa !13
+  %add1 = add nsw i32 %9, 7, !dbg !28
+  store volatile i32 %add1, i32* @"\01?x@@3HC", align 4, !dbg !28, !tbaa !13
+  ret void, !dbg !29
+}
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.start(i64, i8* nocapture) #1
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.lifetime.end(i64, i8* nocapture) #1
+
+attributes #0 = { norecurse nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { argmemonly nounwind }
+attributes #2 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: 2, enums: !2, subprograms: !3)
+!1 = !DIFile(filename: "t.cpp", directory: "D:\5Csrc\5Cllvm\5Cbuild")
+!2 = !{}
+!3 = !{!4, !6, !7}
+!4 = distinct !DISubprogram(name: "baz", scope: !1, file: !1, line: 13, type: !5, isLocal: false, isDefinition: true, scopeLine: 13, flags: DIFlagPrototyped, isOptimized: true, variables: !2)
+!5 = !DISubroutineType(types: !2)
+!6 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 8, type: !5, isLocal: true, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: true, variables: !2)
+!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 2, type: !5, isLocal: true, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: true, variables: !2)
+!8 = !{i32 2, !"CodeView", i32 1}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"PIC Level", i32 2}
+!11 = !{!"clang version 3.9.0 "}
+!12 = !DILocation(line: 14, column: 5, scope: !4)
+!13 = !{!14, !14, i64 0}
+!14 = !{!"int", !15, i64 0}
+!15 = !{!"omnipotent char", !16, i64 0}
+!16 = !{!"Simple C/C++ TBAA"}
+!17 = !DILocation(line: 9, column: 5, scope: !6, inlinedAt: !18)
+!18 = distinct !DILocation(line: 15, column: 3, scope: !4)
+!19 = !DILocation(line: 3, column: 3, scope: !7, inlinedAt: !20)
+!20 = distinct !DILocation(line: 10, column: 3, scope: !6, inlinedAt: !18)
+!21 = !DILocation(line: 3, column: 7, scope: !7, inlinedAt: !20)
+!22 = !DILocation(line: 4, column: 8, scope: !7, inlinedAt: !20)
+!23 = !DILocation(line: 4, column: 5, scope: !7, inlinedAt: !20)
+!24 = !DILocation(line: 5, column: 5, scope: !7, inlinedAt: !20)
+!25 = !DILocation(line: 6, column: 5, scope: !7, inlinedAt: !20)
+!26 = !DILocation(line: 7, column: 1, scope: !7, inlinedAt: !20)
+!27 = !DILocation(line: 11, column: 5, scope: !6, inlinedAt: !18)
+!28 = !DILocation(line: 16, column: 5, scope: !4)
+!29 = !DILocation(line: 17, column: 1, scope: !4)

tools/llvm-readobj/CodeView.h

 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Endian.h"
 
 namespace llvm {
 namespace codeview {
 
-using llvm::support::little32_t;
 using llvm::support::ulittle16_t;
 using llvm::support::ulittle32_t;
 
 /// Data in the the SUBSEC_FRAMEDATA subection.
 struct FrameData {
   ulittle32_t RvaStart;
   ulittle32_t CodeSize;
   ulittle32_t LocalSize;
   ulittle32_t ParamsSize;
   ulittle32_t MaxStackSize;
   ulittle32_t FrameFunc;
   ulittle16_t PrologSize;
   ulittle16_t SavedRegsSize;
   ulittle32_t Flags;
   enum : uint32_t {
     HasSEH = 1 << 0,
     HasEH = 1 << 1,
     IsFunctionStart = 1 << 2,
   };
 };
 
-//===----------------------------------------------------------------------===//
-// On-disk representation of type information
-
-// A CodeView type stream is a sequence of TypeRecords. Records larger than
-// 65536 must chain on to a second record. Each TypeRecord is followed by one of
-// the leaf types described below.
-struct TypeRecordPrefix {
-  ulittle16_t Len;  // Type record length, starting from &Leaf.
-  ulittle16_t Leaf; // Type record kind (TypeLeafKind)
-};
-
-// LF_TYPESERVER2
-struct TypeServer2 {
-  char Signature[16];  // GUID
-  ulittle32_t Age;
-  // Name: Name of the PDB as a null-terminated string
-};
-
-// LF_STRING_ID
-struct StringId {
-  TypeIndex id;
-};
-
-// LF_FUNC_ID
-struct FuncId {
-  TypeIndex ParentScope;
-  TypeIndex FunctionType;
-  // Name: The null-terminated name follows.
-};
-
-// LF_CLASS, LF_STRUCT, LF_INTERFACE
-struct ClassType {
-  ulittle16_t MemberCount; // Number of members in FieldList.
-  ulittle16_t Properties;  // ClassOptions bitset
-  TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
-  TypeIndex DerivedFrom;   // LF_DERIVED: List of known derived classes
-  TypeIndex VShape;        // LF_VTSHAPE: Shape of the vftable
-  // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
-  // Name: The null-terminated name follows.
-};
-
-// LF_UNION
-struct UnionType {
-  ulittle16_t MemberCount; // Number of members in FieldList.
-  ulittle16_t Properties;  // ClassOptions bitset
-  TypeIndex FieldList;     // LF_FIELDLIST: List of all kinds of members
-  // SizeOf: The 'sizeof' the UDT in bytes is encoded as an LF_NUMERIC integer.
-  // Name: The null-terminated name follows.
-};
-
-// LF_POINTER
-struct PointerType {
-  TypeIndex PointeeType;
-  ulittle32_t Attrs; // pointer attributes
-  // if pointer to member:
-  //   PointerToMemberTail
-
-  PointerKind getPtrKind() const { return PointerKind(Attrs & 0x1f); }
-  PointerMode getPtrMode() const { return PointerMode((Attrs >> 5) & 0x07); }
-  bool isFlat() const { return Attrs & (1 << 8); }
-  bool isVolatile() const { return Attrs & (1 << 9); }
-  bool isConst() const { return Attrs & (1 << 10); }
-  bool isUnaligned() const { return Attrs & (1 << 11); }
-
-  bool isPointerToDataMember() const {
-    return getPtrMode() == PointerMode::PointerToDataMember;
-  }
-  bool isPointerToMemberFunction() const {
-    return getPtrMode() == PointerMode::PointerToMemberFunction;
-  }
-  bool isPointerToMember() const {
-    return isPointerToMemberFunction() || isPointerToDataMember();
-  }
-};
-
-struct PointerToMemberTail {
-  TypeIndex ClassType;
-  ulittle16_t Representation; // PointerToMemberRepresentation
-};
-
-/// In Clang parlance, these are "qualifiers".  LF_MODIFIER
-struct TypeModifier {
-  TypeIndex ModifiedType;
-  ulittle16_t Modifiers; // ModifierOptions
-};
-
-// LF_VTSHAPE
-struct VTableShape {
-  // Number of vftable entries. Each method may have more than one entry due to
-  // things like covariant return types.
-  ulittle16_t VFEntryCount;
-  // Descriptors[]: 4-bit virtual method descriptors of type CV_VTS_desc_e.
-};
-
-// LF_UDT_SRC_LINE
-struct UDTSrcLine {
-  TypeIndex UDT;        // The user-defined type
-  TypeIndex SourceFile; // StringID containing the source filename
-  ulittle32_t LineNumber;
-};
-
-// LF_ARGLIST, LF_SUBSTR_LIST
-struct ArgList {
-  ulittle32_t NumArgs; // Number of arguments
-  // ArgTypes[]: Type indicies of arguments
-};
-
-// LF_BUILDINFO
-struct BuildInfo {
-  ulittle16_t NumArgs; // Number of arguments
-  // ArgTypes[]: Type indicies of arguments
-};
-
-// LF_ENUM
-struct EnumType {
-  ulittle16_t NumEnumerators; // Number of enumerators
-  ulittle16_t Properties;
-  TypeIndex UnderlyingType;
-  TypeIndex FieldListType;
-  // Name: The null-terminated name follows.
-};
-
-// LF_ARRAY
-struct ArrayType {
-  TypeIndex ElementType;
-  TypeIndex IndexType;
-  // SizeOf: LF_NUMERIC encoded size in bytes. Not element count!
-  // Name: The null-terminated name follows.
-};
-
-// LF_VFTABLE
-struct VFTableType {
-  TypeIndex CompleteClass;     // Class that owns this vftable.
-  TypeIndex OverriddenVFTable; // VFTable that this overrides.
-  ulittle32_t VFPtrOffset;     // VFPtr offset in CompleteClass
-  ulittle32_t NamesLen;        // Length of subsequent names array in bytes.
-  // Names: A sequence of null-terminated strings. First string is vftable
-  // names.
-};
-
-// LF_MFUNC_ID
-struct MemberFuncId {
-  TypeIndex ClassType;
-  TypeIndex FunctionType;
-  // Name: The null-terminated name follows.
-};
-
-// LF_PROCEDURE
-struct ProcedureType {
-  TypeIndex ReturnType;
-  CallingConvention CallConv;
-  FunctionOptions Options;
-  ulittle16_t NumParameters;
-  TypeIndex ArgListType;
-};
-
-// LF_MFUNCTION
-struct MemberFunctionType {
-  TypeIndex ReturnType;
-  TypeIndex ClassType;
-  TypeIndex ThisType;
-  CallingConvention CallConv;
-  FunctionOptions Options;
-  ulittle16_t NumParameters;
-  TypeIndex ArgListType;
-  little32_t ThisAdjustment;
-};
-
-//===----------------------------------------------------------------------===//
-// Field list records, which do not include leafs or sizes
-
-/// Equvalent to CV_fldattr_t in cvinfo.h.
-struct MemberAttributes {
-  ulittle16_t Attrs;
-
-  /// Get the access specifier. Valid for any kind of member.
-  MemberAccess getAccess() const {
-    return MemberAccess(unsigned(Attrs) & unsigned(MethodOptions::AccessMask));
-  }
-
-  /// Indicates if a method is defined with friend, virtual, static, etc.
-  MethodKind getMethodKind() const {
-    return MethodKind(
-        (unsigned(Attrs) & unsigned(MethodOptions::MethodKindMask)) >> 2);
-  }
-
-  /// Get the flags that are not included in access control or method
-  /// properties.
-  MethodOptions getFlags() const {
-    return MethodOptions(
-        unsigned(Attrs) &
-        ~unsigned(MethodOptions::AccessMask | MethodOptions::MethodKindMask));
-  }
-
-  /// Is this method virtual.
-  bool isVirtual() const {
-    auto MP = getMethodKind();
-    return MP != MethodKind::Vanilla && MP != MethodKind::Friend &&
-           MP != MethodKind::Static;
-  }
-
-  /// Does this member introduce a new virtual method.
-  bool isIntroducedVirtual() const {
-    auto MP = getMethodKind();
-    return MP == MethodKind::IntroducingVirtual ||
-           MP == MethodKind::PureIntroducingVirtual;
-  }
-};
-
-// LF_NESTTYPE
-struct NestedType {
-  ulittle16_t Pad0; // Should be zero
-  TypeIndex Type;   // Type index of nested type
-  // Name: Null-terminated string
-};
-
-// LF_ONEMETHOD
-struct OneMethod {
-  MemberAttributes Attrs;
-  TypeIndex Type;
-  // If is introduced virtual method:
-  //   VFTableOffset: int32_t offset in vftable
-  // Name: Null-terminated string
-
-  MethodKind getMethodKind() const {
-    return Attrs.getMethodKind();
-  }
-
-  bool isVirtual() const { return Attrs.isVirtual(); }
-  bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
-};
-
-struct MethodListEntry {
-  MemberAttributes Attrs;
-  ulittle16_t Padding;
-
-  TypeIndex Type;
-  // If is introduced virtual method:
-  //   VFTableOffset: int32_t offset in vftable
-
-  MethodKind getMethodKind() const {
-    return Attrs.getMethodKind();
-  }
-
-  bool isVirtual() const { return Attrs.isVirtual(); }
-  bool isIntroducedVirtual() const { return Attrs.isIntroducedVirtual(); }
-};
-
-/// For method overload sets.  LF_METHOD
-struct OverloadedMethod {
-  ulittle16_t MethodCount; // Size of overload set
-  TypeIndex MethList;      // Type index of methods in overload set
-  // Name: Null-terminated string
-};
-
-// LF_VFUNCTAB
-struct VirtualFunctionPointer {
-  ulittle16_t Pad0;
-  TypeIndex Type;   // Type of vfptr
-};
-
-// LF_MEMBER
-struct DataMember {
-  MemberAttributes Attrs; // Access control attributes, etc
-  TypeIndex Type;
-  // FieldOffset: LF_NUMERIC encoded byte offset
-  // Name: Null-terminated string
-};
-
-// LF_STMEMBER
-struct StaticDataMember {
-  MemberAttributes Attrs; // Access control attributes, etc
-  TypeIndex Type;
-  // Name: Null-terminated string
-};
-
-// LF_ENUMERATE
-struct Enumerator {
-  MemberAttributes Attrs; // Access control attributes, etc
-  // EnumValue: LF_NUMERIC encoded enumerator value
-  // Name: Null-terminated string
-};
-
-// LF_BCLASS, LF_BINTERFACE
-struct BaseClass {
-  MemberAttributes Attrs; // Access control attributes, etc
-  TypeIndex BaseType;     // Base class type
-  // BaseOffset: LF_NUMERIC encoded byte offset of base from derived.
-};
-
-// LF_VBCLASS | LV_IVBCLASS
-struct VirtualBaseClass {
-  MemberAttributes Attrs; // Access control attributes, etc.
-  TypeIndex BaseType;     // Base class type
-  TypeIndex VBPtrType;    // Virtual base pointer type
-  // VBPtrOffset: Offset of vbptr from vfptr encoded as LF_NUMERIC.
-  // VBTableIndex: Index of vbase within vbtable encoded as LF_NUMERIC.
-};
 
 } // namespace codeview
 } // namespace llvm
 
 #endif // LLVM_READOBJ_CODEVIEW_H