[codeview] Add complex record type translation

[aaboud]

Summary

Improved the support of records (classes and structures) to include virtual and non-virtual methods, virtual and non-virtual inheritance, bitfield members.

Major changes included in the patch

1. Introduced "ClassInfo" container that is used to collect record info from current debug info metadata that is needed to emit CodeView records.
2. Extended the TypeIndices map to have another dimension, i.e. from {DINode -> TypeIndex} to {DIType -> {DINode -> TypeIndex} }.
   • This is needed as DISubroutine might be shared for static methods from different classes as well as regular functions, e.g. all three functions bellow (f1, f2, and f3) will have same DISubroutine.

void f1() {}
class A {
  static void f2() {}
};
class B {
  static void f3() {}
};

[aaboud]

Fixed some comments.

[rnk]

Can we separate the instance member function type changes from the class info changes? We should already get method types from member functions.

include/llvm/DebugInfo/CodeView/TypeRecord.h

1362

It would be more consistent to directly take the TypeRecordKind as a parameter here.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

879–881

We should assert if this happens. I'd be interested in a test case that triggered this scenario.

932

I would really prefer it if we formed a new key into our type index map and called the generic getTypeIndex method here. Calling 'lowerTypeMemberFunction' unconditionally is a good way to end up lowering a type twice by accident.

960–962

Ditto, this is bad.

1197

Ah, yeah, OK, when generating complete type info we will need to recurse onto base types. Your comment from before about not caching the hash table lookup makes sense now.

1278

Please don't commit this code if we can just fix it in clang. It's really easy to change our name printing code, we have a printing option that detects if codeview is enabled.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

143–151

Having DenseMaps inside DenseMaps will be terribly inefficient. A better way to do this would be to extend the key to have more data, perhaps with a PointerUnion between DINode* and MyCustomSubroutineKey.

Actually, I think it might be better to change DISubroutineType to have a scope operand. We're going to need to add a callingconv field anyway, might as well go all the way so we can simplify this. I need to look at Duncan's recent ODR changes to understand if it's OK to have this cycle in the metadata.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1216–1220

Please use / 8 here and elsewhere.

1232

Please use the LLVM naming convention.

1543

Please parenthesize the subexpression.

[aaboud]

Thanks for the feedback, I will apply fixes in next patch.
Please see my response on some comments below.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

879–881

No need to add assertion, here is an example:

struct A {
  A* next;
};

void foo() {
 A *p;
 A a;
}

960–962

And once again, an example :)

struct A {
  const A* next;
  A();
};

void foo() {
 const A a;
}

1278

Actually, I think we can change the way clang generate DISubprogram names: http://reviews.llvm.org/rL255744
This commit was not the right thing to do, because when generating function inside FieldList we need to give it the naked name (without scoping), however in all other places we will need the full name with the scope.

If you ask me, I prefer that Clang do not add the scope name prefix to the function name, and lit this to the be done by the CodeViewDebug component in the Backend.

[aaboud]

Updated patch according to comments from Reid and David.

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

879–881

This example works fine today without this extra lookup, though. The only way I could imagine this happening is if translating 'A*' triggers translation of the complete A type, and we can avoid that. The graph of types should be acyclic if you don't follow edges through record types, which is what I was trying to do.

Instead, I think we should queue all complete record types that we've seen during type translation in a separate list, and lower them later. We'll need this anyway to implement S_UDT.

1064

Hm, maybe this thing should just take (unsigned RecordTag, unsigned Flags) so we can avoid the duplication.

1278

Sure, we can do that. Just modify the metadata in your test case to have the names you expect and we'll fix clang later.

[aaboud]

Thanks Reid for the comments.
Please just let me know what you think about the double check for Modifier and Pointer record generation (see my comment below).
I will upload a new patch with all the fixes accordingly.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

879–881

The only reason why this is working today without this check, is that we have another check in MemoryTypeTableBuilder for the hashed record.
But this is still inefficient as we are creating the Record and building the String using the TypeRecordBuilder, just to find out that we already have the record hashed!

If you think this is good enough, I do not mind removing all these checks (we can add them later anyway).

1064

Will fix in next uploaded patch.

1278

Will do that in next uploaded patch.

[aaboud]

Addressing two of Reid comments.

[rnk]

I still feel like this patch is too large and is trying to do too much. Can we limit it to just handling non-virtual methods and their overloads? I don't want to review the VBPtr offset computation code at the same time as bitfields and virtual bases and etc etc. Each of those things requires a certain amount of care.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1029

You should rebase your patch to pick up the calling convention changes, this TODO should be done.

1132–1137

You should be able to key these on MDString* instead of StringRef, because MDStrings are uniqued. That will be more efficient.

1209

All this code below here scares me. It feels like an ad-hoc reimplementation of inheritance logic that should really be in clang. I think it would really simplify things if we ignored virtual base classes for now, and didn't try to emit them just yet. It would make it easier to review this patch.

1323

This patch uses too much auto in for loops. The LLVM guidelines say to use it in "places where the type is already obvious from the context". As a reader, Methods is some other data structure that I don't know much about, so it would help me to have the type here.

[aaboud]

In D21011#453066, @rnk wrote:

I still feel like this patch is too large and is trying to do too much. Can we limit it to just handling non-virtual methods and their overloads? I don't want to review the VBPtr offset computation code at the same time as bitfields and virtual bases and etc etc. Each of those things requires a certain amount of care.

OK, this is what I am going to do:

1. Update (rebase) this patch to top of trunk (no other changes will be made) and will upload the patch.
2. I will remove remove from the patch the handling of bitfield, VBPtr, virtual inheritance, etc. and will apply relevant comments.

I am doing (1) so we still have a reference for this code (updated to top of trunk).
I will upload these patches soon today.

[aaboud]

Updated patch to top of trunk.
Next will split patch into small patches.

[aaboud]

Reduced the support to only methods.

[rnk]

This needs some test, I'd add something like types-method-overloads.ll, and keep it focused to non-virtual methods so that we don't have to update it too much as we handle more complex virtual inheritance cases.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1166–1173

This does 3 lookups, it only needs to do one, something like this:

auto Insertion = ClassInfoMap.insert({Ty, std::unique_ptr<ClassInfo>()});
std::unique_ptr<ClassInfo> &Info = *Insertion.first->second;
if (!Insertion.second)
  return Info;
Info.reset(new ClassInfo());
...

1183

Should we claim that all methods are introduced virtual methods, or just the virtual ones?

[aaboud]

Thanks Reid for the comments, I will upload a new version with a LIT tests and some fixes.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1183

Introduce is only for virtual methods, however the "Methods" container holds all methods of the class (virtual and non-virtual).
I am using the same container to be able to output the methods in the right order, though I am not sure if the order is important!

See "translateMethodKindFlags" at line 1091, where it consider the "Introduced" variable only for virtual functions.

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1183

I guess I'm questioning the usefulness of MethodInfo. The 'Introduced' boolean is always set to true in this code.

How do you propose to calculate whether a method was introduced? Remember, we can't actually walk the class hierarchy because the frontend may not emit complete debug information about base classes, unless -fstandalone-debug-info is on. I think this is something that we will need the frontend to tell us directly, see https://llvm.org/bugs/show_bug.cgi?id=28150.

Anyway, this doesn't need to hold up the patch. With tests I think this is ready and we can iterate on it from there.

[aaboud]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1183

Actually, I planed to travel the hierarchy, though you might have a point with clang not emitting the complete debug info (but need to produce an example for that first).

Anyway, I added a comment and switched the value to false, as we are handling non-virtual methods for now, and they should not be marked as introduced.

[aaboud]

Added LIT test, and applied some minor changes to the code according to Reid comments.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

759–760

else after return is discouraged by the coding standards: http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

1113

Does this need to be in the LLVM namespace? Why not stick it in an anonymous namespace?

1408

Why not use std::ignore instead?

1452

Comments should end in a period.

1504

Please clang-format this.

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1031–1032

The TODO is done, you can delete the comment.

1113

It does, it's forward declared and used as an incomplete type in the header.

[aaboud]

Applied changes according to comments from David and Reid.

[rnk]

lgtm, thanks!

include/llvm/DebugInfo/CodeView/TypeRecord.h

private:
   MemberAccess Access;
   TypeIndex Type;
   uint64_t Offset;
 };
 
 // LF_VBCLASS, LF_IVBCLASS
 class VirtualBaseClassRecord : public TypeRecord {
 public:
-  VirtualBaseClassRecord(MemberAccess Access, TypeIndex BaseType,
+  VirtualBaseClassRecord(TypeRecordKind Kind, MemberAccess Access, TypeIndex BaseType,
                          TypeIndex VBPtrType, uint64_t Offset, uint64_t Index)
-      : TypeRecord(TypeRecordKind::VirtualBaseClass), Access(Access),
+      : TypeRecord(Kind), Access(Access),
         BaseType(BaseType), VBPtrType(VBPtrType), VBPtrOffset(Offset),
         VTableIndex(Index) {}
 
   /// Rewrite member type indices with IndexMap. Returns false if a type index
   /// is not in the map.
   bool remapTypeIndices(ArrayRef<TypeIndex> IndexMap);
 
   static ErrorOr<VirtualBaseClassRecord> deserialize(TypeRecordKind Kind,
                                                      ArrayRef<uint8_t> &Data) {
     const Layout *L = nullptr;
     uint64_t Offset;
     uint64_t Index;
     CV_DESERIALIZE(Data, L, CV_NUMERIC_FIELD(Offset), CV_NUMERIC_FIELD(Index));
 
-    return VirtualBaseClassRecord(L->Attrs.getAccess(), L->BaseType,
+    return VirtualBaseClassRecord(Kind, L->Attrs.getAccess(), L->BaseType,
                                   L->VBPtrType, Offset, Index);
   }
 
   MemberAccess getAccess() const { return Access; }
   TypeIndex getBaseType() const { return BaseType; }
   TypeIndex getVBPtrType() const { return VBPtrType; }
   uint64_t getVBPtrOffset() const { return VBPtrOffset; }
   uint64_t getVTableIndex() const { return VTableIndex; }

lib/CodeGen/AsmPrinter/CodeViewDebug.h

 #include "llvm/IR/DebugLoc.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
 class StringRef;
 class LexicalScope;
+struct ClassInfo;
 
 /// \brief Collects and handles line tables information in a CodeView format.
 class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   MCStreamer &OS;
   codeview::MemoryTypeTableBuilder TypeTable;
 
   /// Represents the most general definition range.
   struct LocalVarDefRange {
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// section starts with the magic version number on first use. If GVSym is
   /// null, uses the main .debug$S section.
   void switchToDebugSectionForSymbol(const MCSymbol *GVSym);
 
   /// The next available function index for use with our .cv_* directives. Not
   /// to be confused with type indices for LF_FUNC_ID records.
   unsigned NextFuncId = 0;
 
+  /// Holds virtual base pointer type for compiler module.
+  codeview::TypeIndex VBPType;
+
   InlineSite &getInlineSite(const DILocation *InlinedAt,
                             const DISubprogram *Inlinee);
 
   codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
 
   static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children,
                                         const FunctionInfo &FI,
                                         const InlineSite &Site);
 
   /// Remember some debug info about each function. Keep it in a stable order to
   /// emit at the end of the TU.
   MapVector<const Function *, FunctionInfo> FnDebugInfo;
 
   /// Map from DIFile to .cv_file id.
   DenseMap<const DIFile *, unsigned> FileIdMap;
 
   /// All inlined subprograms in the order they should be emitted.
   SmallSetVector<const DISubprogram *, 4> InlinedSubprograms;
 
-  /// Map from DI metadata nodes to CodeView type indices. Primarily indexed by
-  /// DIType* and DISubprogram*.
-  DenseMap<const DINode *, codeview::TypeIndex> TypeIndices;
+  /// Map from a pair of DI metadata nodes and its DI type (or scope) that can
+  /// be nullptr, to CodeView type indices. Primarily indexed by
+  /// {DIType*, DIType*} and {DISubprogram*, DIType*}.
+  ///
+  /// The second entry in the key is needed for methods as DISubroutineType
+  /// representing static method type are shared with non-method function type.
+  DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
+  TypeIndices;
 
   /// Map from DICompositeType* to complete type index. Non-record types are
   /// always looked up in the normal TypeIndices map.
   DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;
 
+  /// Map from DICompositeType* to class info.
+  DenseMap<const DICompositeType *, std::unique_ptr<ClassInfo>> ClassInfoMap;
+
   typedef std::map<const DIFile *, std::string> FileToFilepathMapTy;
   FileToFilepathMapTy FileToFilepathMap;
   StringRef getFullFilepath(const DIFile *S);
 
   unsigned maybeRecordFile(const DIFile *F);
 
   void maybeRecordLocation(DebugLoc DL, const MachineFunction *MF);
 
-  void clear() {
-    assert(CurFn == nullptr);
-    FileIdMap.clear();
-    FnDebugInfo.clear();
-    FileToFilepathMap.clear();
-  }
+  void clear();
 
   /// Emit the magic version number at the start of a CodeView type or symbol
   /// section. Appears at the front of every .debug$S or .debug$T section.
   void emitCodeViewMagicVersion();
 
   void emitTypeInformation();
 
   void emitInlineeLinesSubsection();
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void collectVariableInfoFromMMITable(DenseSet<InlinedVariable> &Processed);
 
   /// Records information about a local variable in the appropriate scope. In
   /// particular, locals from inlined code live inside the inlining site.
   void recordLocalVariable(LocalVariable &&Var, const DILocation *Loc);
 
   void emitLocalVariable(const LocalVariable &Var);
 
+  /// Return virtual base pointer type.  Create it if it was not created yet.
+  codeview::TypeIndex getVBPType();
+
   /// Translates the DIType to codeview if necessary and returns a type index
   /// for it.
-  codeview::TypeIndex getTypeIndex(DITypeRef TypeRef);
+  codeview::TypeIndex getTypeIndex(DITypeRef TypeRef,
+                                   DITypeRef ClassTyRef = DITypeRef());
 
-  codeview::TypeIndex lowerType(const DIType *Ty);
+  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
   codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
   codeview::TypeIndex lowerTypePointer(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeMemberPointer(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
+  codeview::TypeIndex lowerTypeMemberFunction(const DISubroutineType *Ty,
+                                              const DIType *ClassTy);
   codeview::TypeIndex lowerTypeClass(const DICompositeType *Ty);
   codeview::TypeIndex lowerTypeUnion(const DICompositeType *Ty);
 
   /// Symbol records should point to complete types, but type records should
   /// always point to incomplete types to avoid cycles in the type graph. Only
   /// use this entry point when generating symbol records. The complete and
   /// incomplete type indices only differ for record types. All other types use
   /// the same index.
   codeview::TypeIndex getCompleteTypeIndex(DITypeRef TypeRef);
 
   codeview::TypeIndex lowerCompleteTypeClass(const DICompositeType *Ty);
   codeview::TypeIndex lowerCompleteTypeUnion(const DICompositeType *Ty);
 
+  codeview::TypeIndex lowerSubprogramType(const DISubprogram *SP);
+
+  void collectClassInfoFromInheritance(ClassInfo &Info,
+                                       const DIDerivedType *InherTy,
+                                       bool &FinalizedOffset);
+  void collectMemberInfo(ClassInfo &Info, const DIDerivedType *DDTy);
+  ClassInfo &collectClassInfo(const DICompositeType *Ty);
+
   /// Common record member lowering functionality for record types, which are
   /// structs, classes, and unions. Returns the field list index and the member
   /// count.
-  std::pair<codeview::TypeIndex, unsigned>
+  std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned>
   lowerRecordFieldList(const DICompositeType *Ty);
 
-  /// Inserts {Node, TI} into TypeIndices and checks for duplicates.
-  void recordTypeIndexForDINode(const DINode *Node, codeview::TypeIndex TI);
+  /// Inserts {Node, TI} into TypeIndices, and checks for duplicates.
+  void recordTypeIndexForDINode(const DINode *Node, codeview::TypeIndex TI,
+                                const DIType *ClassTy = nullptr);
+
+  unsigned getPointerSizeInBytes();
 
 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

 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/ScopedPrinter.h"
-#include "llvm/Target/TargetSubtargetInfo.h"
-#include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetFrameLowering.h"
+#include "llvm/Target/TargetRegisterInfo.h"
+#include "llvm/Target/TargetSubtargetInfo.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), CurFn(nullptr) {
   // If module doesn't have named metadata anchors or COFF debug section
   // is not available, skip any debug info related stuff.

 
 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
   // It's possible to ask for the FuncId of a function which doesn't have a
   // subprogram: inlining a function with debug info into a function with none.
   if (!SP)
     return TypeIndex::None();
 
   // Check if we've already translated this subprogram.
-  auto I = TypeIndices.find(SP);
+  auto I = TypeIndices.find({ SP, nullptr });
   if (I != TypeIndices.end())
     return I->second;
 
   TypeIndex ParentScope = TypeIndex(0);
   StringRef DisplayName = SP->getDisplayName();
-  FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName);
+  FuncIdRecord FuncId(ParentScope, lowerSubprogramType(SP), DisplayName);
   TypeIndex TI = TypeTable.writeFuncId(FuncId);
 
   recordTypeIndexForDINode(SP, TI);
   return TI;
 }
 
-void CodeViewDebug::recordTypeIndexForDINode(const DINode *Node, TypeIndex TI) {
-  auto InsertResult = TypeIndices.insert({Node, TI});
+void CodeViewDebug::recordTypeIndexForDINode(const DINode *Node, TypeIndex TI,
+                                             const DIType *ClassTy) {
+  auto InsertResult = TypeIndices.insert({ { Node, ClassTy }, TI });
   (void)InsertResult;
   assert(InsertResult.second && "DINode was already assigned a type index");
 }
 
+unsigned CodeViewDebug::getPointerSizeInBytes() {
+  return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
+}
+
 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
                                         const DILocation *InlinedAt) {
   if (InlinedAt) {
     // This variable was inlined. Associate it with the InlineSite.
     const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
     InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
     Site.InlinedLocals.emplace_back(Var);
   } else {
static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S) {
   SmallString<32> NullTerminatedString(S);
   NullTerminatedString.push_back('\0');
   OS.EmitBytes(NullTerminatedString);
 }
 
 void CodeViewDebug::emitTypeInformation() {
   // Do nothing if we have no debug info or if no non-trivial types were emitted
   // to TypeTable during codegen.
-  NamedMDNode *CU_Nodes =
-      MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
+  NamedMDNode *CU_Nodes = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
   if (!CU_Nodes)
     return;
   if (TypeTable.empty())
     return;
 
   // Start the .debug$T section with 0x4.
   OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
   emitCodeViewMagicVersion();
void CodeViewDebug::emitInlineeLinesSubsection() {
   OS.EmitLabel(InlineBegin);
 
   // We don't provide any extra file info.
   // FIXME: Find out if debuggers use this info.
   OS.AddComment("Inlinee lines signature");
   OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
 
   for (const DISubprogram *SP : InlinedSubprograms) {
-    assert(TypeIndices.count(SP));
-    TypeIndex InlineeIdx = TypeIndices[SP];
+    assert(TypeIndices.count({ SP, nullptr }));
+    TypeIndex InlineeIdx = TypeIndices[{ SP, nullptr }];
 
     OS.AddBlankLine();
     unsigned FileId = maybeRecordFile(SP->getFile());
     OS.AddComment("Inlined function " + SP->getDisplayName() + " starts at " +
                   SP->getFilename() + Twine(':') + Twine(SP->getLine()));
     OS.AddBlankLine();
     // The filechecksum table uses 8 byte entries for now, and file ids start at
     // 1.

 }
 
 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
                                         const DILocation *InlinedAt,
                                         const InlineSite &Site) {
   MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
            *InlineEnd = MMI->getContext().createTempSymbol();
 
-  assert(TypeIndices.count(Site.Inlinee));
-  TypeIndex InlineeIdx = TypeIndices[Site.Inlinee];
+  assert(TypeIndices.count({ Site.Inlinee, nullptr }));
+  TypeIndex InlineeIdx = TypeIndices[{ Site.Inlinee, nullptr }];
 
   // SymbolRecord
   OS.AddComment("Record length");
   OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2);   // RecordLength
   OS.EmitLabel(InlineBegin);
   OS.AddComment("Record kind: S_INLINESITE");
   OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
 
void CodeViewDebug::beginFunction(const MachineFunction *MF) {
 
   // Record beginning of function if we have a non-empty prologue.
   if (PrologEndLoc && !EmptyPrologue) {
     DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
     maybeRecordLocation(FnStartDL, MF);
   }
 }
 
-TypeIndex CodeViewDebug::lowerType(const DIType *Ty) {
+TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
   // Generic dispatch for lowering an unknown type.
   switch (Ty->getTag()) {
   case dwarf::DW_TAG_typedef:
     return lowerTypeAlias(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_base_type:
     return lowerTypeBasic(cast<DIBasicType>(Ty));
   case dwarf::DW_TAG_pointer_type:
   case dwarf::DW_TAG_reference_type:
   case dwarf::DW_TAG_rvalue_reference_type:
     return lowerTypePointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_ptr_to_member_type:
     return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_volatile_type:
     return lowerTypeModifier(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_subroutine_type:
+    if (ClassTy)
+      return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy);
+    else
       return lowerTypeFunction(cast<DISubroutineType>(Ty));
   case dwarf::DW_TAG_class_type:
   case dwarf::DW_TAG_structure_type:
     return lowerTypeClass(cast<DICompositeType>(Ty));
   case dwarf::DW_TAG_union_type:
     return lowerTypeUnion(cast<DICompositeType>(Ty));
   default:
     // Use the null type index.
     return TypeIndex();
if ((STK == SimpleTypeKind::SignedCharacter ||
     STK = SimpleTypeKind::NarrowCharacter;
 
   return TypeIndex(STK);
 }
 
 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty) {
   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
 
+  // While processing the type being pointed to it is possible we already
+  // created this pointer type.  If so, we check here and return the existing
+  // pointer type.
+  //
+  auto I = TypeIndices.find({ Ty, nullptr });
+  if (I != TypeIndices.end())
+    return I->second;
+
   // Pointers to simple types can use SimpleTypeMode, rather than having a
   // dedicated pointer type record.
   if (PointeeTI.isSimple() &&
       PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
       Ty->getTag() == dwarf::DW_TAG_pointer_type) {
     SimpleTypeMode Mode = Ty->getSizeInBits() == 64
                               ? SimpleTypeMode::NearPointer64
                               : SimpleTypeMode::NearPointer32;
TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty) {
   PointerOptions PO = PointerOptions::None;
   PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
   return TypeTable.writePointer(PR);
 }
 
 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty) {
   assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
   TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
-  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
+  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
   PointerKind PK = Asm->MAI->getPointerSize() == 8 ? PointerKind::Near64
                                                    : PointerKind::Near32;
   PointerMode PM = isa<DISubroutineType>(Ty->getBaseType())
                        ? PointerMode::PointerToMemberFunction
                        : PointerMode::PointerToDataMember;
   PointerOptions PO = PointerOptions::None; // FIXME
   // FIXME: Thread this ABI info through metadata.
   PointerToMemberRepresentation PMR = PointerToMemberRepresentation::Unknown;
   MemberPointerInfo MPI(ClassTI, PMR);
   PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8, MPI);
   return TypeTable.writePointer(PR);
 }
 
 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
   ModifierOptions Mods = ModifierOptions::None;
   bool IsModifier = true;
while (IsModifier && BaseTy) {
     default:
       IsModifier = false;
       break;
     }
     if (IsModifier)
       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
   }
   TypeIndex ModifiedTI = getTypeIndex(BaseTy);
+
+  // While processing the type being pointed to, it is possible we already
+  // created this modifier type.  If so, we check here and return the existing
+  // modifier type.
+  //
+  auto I = TypeIndices.find({ Ty, nullptr });
+  if (I != TypeIndices.end())
+    return I->second;
+
   ModifierRecord MR(ModifiedTI, Mods);
   return TypeTable.writeModifier(MR);
 }
 
 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
   SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
   for (DITypeRef ArgTypeRef : Ty->getTypeArray())
     ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
 
   TypeIndex ReturnTypeIndex = TypeIndex::Void();
   ArrayRef<TypeIndex> ArgTypeIndices = None;
   if (!ReturnAndArgTypeIndices.empty()) {
     auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
     ReturnTypeIndex = ReturnAndArgTypesRef.front();
     ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
   }
 
   ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
   TypeIndex ArgListIndex = TypeTable.writeArgList(ArgListRec);
 
   // TODO: We should use DW_AT_calling_convention to determine what CC this
   // procedure record should have.
-  // TODO: Some functions are member functions, we should use a more appropriate
-  // record for those.
   ProcedureRecord Procedure(ReturnTypeIndex, CallingConvention::NearC,
                             FunctionOptions::None, ArgTypeIndices.size(),
                             ArgListIndex);
   return TypeTable.writeProcedure(Procedure);
 }
 
-static MemberAccess translateAccessFlags(unsigned RecordTag,
-                                         const DIType *Member) {
-  switch (Member->getFlags() & DINode::FlagAccessibility) {
+TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
+                                                 const DIType *ClassTy) {
+  // Lower the containing class type.
+  //
+  TypeIndex ClassType = getTypeIndex(ClassTy);
+
+  // While processing the class type it is possible we already created this
+  // member function.  If so, we check here and return the existing one.
+  //
+  auto I = TypeIndices.find({ Ty, ClassTy });
+  if (I != TypeIndices.end())
+    return I->second;
+
+  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
+  for (DITypeRef ArgTypeRef : Ty->getTypeArray())
+    ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
+
+  TypeIndex ReturnTypeIndex = TypeIndex::Void();
+  ArrayRef<TypeIndex> ArgTypeIndices = None;
+  if (!ReturnAndArgTypeIndices.empty()) {
+    auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
+    ReturnTypeIndex = ReturnAndArgTypesRef.front();
+    ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
+  }
+  TypeIndex ThisTypeIndex = TypeIndex::Void();
+  if (!ArgTypeIndices.empty()) {
+    ThisTypeIndex = ArgTypeIndices.front();
+    ArgTypeIndices = ArgTypeIndices.drop_front();
+  }
+
+  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
+  TypeIndex ArgListIndex = TypeTable.writeArgList(ArgListRec);
+
+  // TODO: We should use DW_AT_calling_convention to determine what CC this
+  // procedure record should have.
+  // TODO: Need to use the correct values for:
+  //       CallingConvention
+  //       FunctionOptions
+  //       ThisPointerAdjustment.
+  TypeIndex TI = TypeTable.writeMemberFunction(MemberFunctionRecord(
+      ReturnTypeIndex, ClassType, ThisTypeIndex, CallingConvention::ThisCall,
+      FunctionOptions::None, ArgTypeIndices.size(), ArgListIndex, 0));
+
+  return TI;
+}
+
+TypeIndex CodeViewDebug::lowerSubprogramType(const DISubprogram *SP) {
+  auto ClassType = dyn_cast_or_null<DIType>(SP->getScope().resolve());
+  TypeIndex TI = getTypeIndex(SP->getType(), ClassType);
+
+  return TI;
+}
+
+static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
+  switch (Flags & DINode::FlagAccessibility) {
   case DINode::FlagPrivate:   return MemberAccess::Private;
   case DINode::FlagPublic:    return MemberAccess::Public;
   case DINode::FlagProtected: return MemberAccess::Protected;
   case 0:
     // If there was no explicit access control, provide the default for the tag.
     return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
                                                  : MemberAccess::Public;
   }
   llvm_unreachable("access flags are exclusive");
 }
 
+static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) {
+  if (SP->isArtificial())
+    return MethodOptions::CompilerGenerated;
+
+  // FIXME: Handle other MethodOptions.
+
+  return MethodOptions::None;
+}
+
+static MethodKind translateMethodKindFlags(const DISubprogram *SP,
+                                           bool Introduced) {
+  switch (SP->getVirtuality()) {
+  case dwarf::DW_VIRTUALITY_none:
+    break;
+  case dwarf::DW_VIRTUALITY_virtual:
+    return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
+  case dwarf::DW_VIRTUALITY_pure_virtual:
+    return Introduced ? MethodKind::PureIntroducingVirtual
+                      : MethodKind::PureVirtual;
+  default:
+    llvm_unreachable("unhandled virtuality case");
+  }
+
+  // if (isStaticMethod(SP->getLinkageName()))
+  //  return MethodKind::Static;
+
+  return MethodKind::Vanilla;
+}
+
 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
   switch (Ty->getTag()) {
   case dwarf::DW_TAG_class_type:     return TypeRecordKind::Class;
   case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
   }
   llvm_unreachable("unexpected tag");
 }
 
 /// Return the HasUniqueName option if it should be present in ClassOptions, or
 /// None otherwise.
 static ClassOptions getRecordUniqueNameOption(const DICompositeType *Ty) {
   // MSVC always sets this flag now, even for local types. Clang doesn't always
   // appear to give every type a linkage name, which may be problematic for us.
   // FIXME: Investigate the consequences of not following them here.
   return !Ty->getIdentifier().empty() ? ClassOptions::HasUniqueName
                                       : ClassOptions::None;
 }
 
+//===----------------------------------------------------------------------===//
+// ClassInfo
+//===----------------------------------------------------------------------===//
+
+struct llvm::ClassInfo {
+  typedef std::vector<const DIDerivedType *> BaseClassList;
+  struct VirtualBaseClassInfo {
+    const DIDerivedType *InheritanceNode;
+    unsigned VBIndex;
+    bool Indirect;
+
+    VirtualBaseClassInfo()
+        : InheritanceNode(nullptr), VBIndex(0), Indirect(false) {}
+
+    VirtualBaseClassInfo(const DIDerivedType *N, unsigned I, bool InDir)
+        : InheritanceNode(N), VBIndex(I), Indirect(InDir) {}
+  };
+  // ClassTypeNode -> {InheritanceNode, VBIndex, Indirect}
+  typedef MapVector<const MDNode *, VirtualBaseClassInfo>
+      VirtualBaseClassInfoList;
+  // [<MemberTypeNode, BaseOffset>]
+  typedef std::vector<std::pair<const DIDerivedType *, unsigned>> MemberList;
+  // methodName -> [<DISubprogram, Introduced>]
+  typedef std::map<StringRef,
+                   std::vector<std::pair<const DISubprogram *, bool>>>
+      MethodsMap;
+  // methodName -> [DISubroutineType]
+  typedef std::map<StringRef, std::vector<const DISubroutineType *>>
+      VirtualMethodsMap;
+
+  // Non-virtual base classes
+  BaseClassList BaseClasses;
+  // Virtual base classes (direct and indirect).
+  VirtualBaseClassInfoList VBClasses;
+  // Offset of virtual base pointer
+  int VBPOffset = ~0;
+  // Virtual function table (only if have introduced virtual methods)
+  const MDNode *VirtualFuncTab = nullptr;
+  // Direct members
+  MemberList Members;
+  // Direct methods (gathered by name), for each function: (introduced?)
+  MethodsMap Methods;
+  // Virtual methods (gathered by name), for DTOR use "~" name.
+  VirtualMethodsMap VirtualMethods;
+  // FIXME: add support to: CONSTRUCTOR, OVERLOAD, OVERLOADED ASSIGNMENT, etc.
+  // Class has Constructor
+  bool HasCTOR = false;
+  // Class has Destructor
+  bool HasDTOR = false;
+  // This class is nested within another aggregate type.
+  bool IsNested = false;
+  // Number of virtual methods (length of virtual function table)
+  unsigned VirtualMethodsCount = 0;
+};
+
+void CodeViewDebug::clear() {
+  assert(CurFn == nullptr);
+  FileIdMap.clear();
+  FnDebugInfo.clear();
+  FileToFilepathMap.clear();
+  TypeIndices.clear();
+  CompleteTypeIndices.clear();
+  ClassInfoMap.clear();
+  VBPType = codeview::TypeIndex();
+}
+
+static bool isEqualVMethodPrototype(const DISubroutineType *Ty1,
+                                    const DISubroutineType *Ty2) {
+  DITypeRefArray Elements1 = Ty1->getTypeArray();
+  DITypeRefArray Elements2 = Ty2->getTypeArray();
+
+  if (Elements1.size() != Elements2.size())
+    return false;
+
+  assert(Elements1.size() >= 2 && "non-trevial method");
+
+  for (unsigned i = 2, N = Elements1.size(); i < N; ++i)
+    if (Elements1[i].resolve() != Elements2[i].resolve())
+      return false;
+
+  return true;
+}
+
+void CodeViewDebug::collectClassInfoFromInheritance(
+    ClassInfo &Info, const DIDerivedType *InherTy, bool &FinalizedOffset) {
+  bool IsVirtual = InherTy->isVirtual();
+
+  const DIType *BaseTy = InherTy->getBaseType().resolve();
+
+  // Base type of inheritance entry might be a typedef entry.
+  // Skip all typedef entries to get to the class entry.
+  while (!isa<DICompositeType>(BaseTy)) {
+    assert(isa<DIDerivedType>(BaseTy) &&
+           "Base type expected to be derived type");
+    const DIDerivedType *DTy = cast<DIDerivedType>(BaseTy);
+    assert(DTy->getTag() == dwarf::DW_TAG_typedef);
+    BaseTy = DTy->getBaseType().resolve();
+  }
+  const DICompositeType *DDTy = dyn_cast<DICompositeType>(BaseTy);
+  ClassInfo &InherInfo = collectClassInfo(DDTy);
+
+  for (auto &I : InherInfo.VBClasses)
+    if (!Info.VBClasses.count(I.first))
+      Info.VBClasses[I.first] = ClassInfo::VirtualBaseClassInfo(
+          I.second.InheritanceNode, Info.VBClasses.size() + 1, true);
+
+  if (IsVirtual) {
+    auto VBClass = Info.VBClasses.find(DDTy);
+    if (VBClass != Info.VBClasses.end())
+      VBClass->second.Indirect = false;
+    else
+      Info.VBClasses[DDTy] = ClassInfo::VirtualBaseClassInfo(
+          InherTy, Info.VBClasses.size() + 1, false);
+  } else {
+    if (!FinalizedOffset) {
+      if (InherInfo.VBClasses.size()) {
+        FinalizedOffset = true;
+        Info.VBPOffset =
+            (InherTy->getOffsetInBits() / 8) + InherInfo.VBPOffset;
+        Info.VirtualMethodsCount = InherInfo.VirtualMethodsCount;
+      } else {
+        Info.VBPOffset =
+            (InherTy->getOffsetInBits() + DDTy->getSizeInBits()) / 8;
+      }
+    }
+    Info.BaseClasses.push_back(InherTy);
+  }
+
+  // Append "InherInfo.VirtualMethods" to "Info.VirtualMethods"
+  for (auto &I : InherInfo.VirtualMethods) {
+    StringRef MethodName = I.first;
+    auto &VirtualMethodsDst = Info.VirtualMethods[MethodName];
+
+    for (auto *SPTy : I.second) {
+      bool Found = false;
+      for (auto &VMTy : VirtualMethodsDst)
+        if (isEqualVMethodPrototype(VMTy, SPTy)) {
+          // Virtual method is not introduced.
+          Found = true;
+          break;
+        }
+      if (!Found) {
+        VirtualMethodsDst.push_back(SPTy);
+      }
+    }
+  }
+}
+
+void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
+                                      const DIDerivedType *DDTy) {
+  if (!DDTy->getName().empty()) {
+    Info.Members.push_back(std::make_pair(DDTy, 0));
+    return;
+  }
+  // Member with no name, must be nested structure/union, collects its memebers
+  assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
+  unsigned offset = DDTy->getOffsetInBits() / 8;
+  const DIType *Ty = DDTy->getBaseType().resolve();
+  assert(dyn_cast<DICompositeType>(Ty) && "Expects structure or union type");
+  const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
+  ClassInfo &NestedInfo = collectClassInfo(DCTy);
+  ClassInfo::MemberList &Members = NestedInfo.Members;
+  for (unsigned i = 0, e = Members.size(); i != e; ++i)
+    Info.Members.push_back(
+        std::make_pair(Members[i].first, Members[i].second + offset));
+}
+
+ClassInfo &CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
+  auto I = ClassInfoMap.find(Ty);
+  if (I != ClassInfoMap.end()) {
+    return *I->second;
+  }
+
+  ClassInfoMap.insert(
+      std::make_pair(Ty, std::unique_ptr<ClassInfo>(new ClassInfo())));
+  ClassInfo &Info = *(ClassInfoMap.find(Ty)->second);
+
+  std::string ConstructorName = Ty->getName();
+  std::string DestructorName = (Twine("~") + Twine(Ty->getName())).str();
+  std::string VirtualTableName = (Twine("_vptr$") + Twine(Ty->getName())).str();
+
+  bool FinalizedOffset = false;
+
+  // Add elements to structure type.
+  DINodeArray Elements = Ty->getElements();
+  for (auto *Element : Elements) {
+    if (auto *SP = dyn_cast<DISubprogram>(Element)) {
+      StringRef MethodName = SP->getName();
+      Info.Methods[MethodName].push_back(std::make_pair(SP, true));
+
+      if (MethodName == ConstructorName)
+        Info.HasCTOR = true;
+      if (MethodName == DestructorName)
+        Info.HasDTOR = true;
+
+    } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
+      if (DDTy->getTag() == dwarf::DW_TAG_member)
+        collectMemberInfo(Info, DDTy);
+      else if (DDTy->getTag() == dwarf::DW_TAG_inheritance)
+        collectClassInfoFromInheritance(Info, DDTy, FinalizedOffset);
+      else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
+        // Ignore friend members. It appears that MSVC emitted info about
+        // friends in the past, but modern versions do not.
+      } else if (DDTy->getName() == VirtualTableName) {
+        assert(!Info.VirtualFuncTab &&
+               "Class has more than one virtual table.");
+        Info.VirtualFuncTab = DDTy;
+      }
+      // FIXME: Get clang to emit nested types here and do something with
+      // them.
+    }
+    // Skip other unrecognized kinds of elements.
+  }
+  bool HasVirtualFuncTab = false;
+  for (auto &I : Info.Methods) {
+    StringRef MethodName = I.first;
+    if (MethodName == DestructorName)
+      MethodName = "~";
+
+    auto &VirtualMethods = Info.VirtualMethods[MethodName];
+    for (auto &MethodInfo : I.second) {
+      auto *SP = MethodInfo.first;
+
+      if (SP->getVirtuality() == dwarf::DW_VIRTUALITY_none)
+        // Non-virtual method, nothing to update. Just skip it.
+        continue;
+
+      for (auto &VMTy : VirtualMethods)
+        if (isEqualVMethodPrototype(VMTy, SP->getType()))
+          // Virtual method is not introduced.
+          MethodInfo.second = false;
+
+      if (MethodInfo.second) {
+        // An introduced virtual function, update counter and add to
+        // VirtualMethods.
+        Info.VirtualMethodsCount++;
+        VirtualMethods.push_back(SP->getType());
+        HasVirtualFuncTab = true;
+      }
+    }
+  }
+
+  if (!HasVirtualFuncTab)
+    Info.VirtualFuncTab = nullptr;
+
+  if (Info.VBClasses.size() > 0 && Info.VBPOffset < 0)
+    // Class has virtual function pointer, add pointer size.
+    Info.VBPOffset = (Info.VirtualFuncTab) ? getPointerSizeInBytes() : 0;
+
+  // If this type is contained within another type, then record it as being
+  // nested.
+  const DIScope *Scope = Ty->getScope().resolve();
+  if (Scope && isa<DIType>(Scope))
+    Info.IsNested = true;
+
+  return Info;
+}
+
 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
   // First, construct the forward decl.  Don't look into Ty to compute the
   // forward decl options, since it might not be available in all TUs.
   TypeRecordKind Kind = getRecordKind(Ty);
   ClassOptions CO =
       ClassOptions::ForwardReference | getRecordUniqueNameOption(Ty);
   TypeIndex FwdDeclTI = TypeTable.writeClass(ClassRecord(
       Kind, 0, CO, HfaKind::None, WindowsRTClassKind::None, TypeIndex(),
       TypeIndex(), TypeIndex(), 0, Ty->getName(), Ty->getIdentifier()));
   return FwdDeclTI;
 }
 
 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
   // Construct the field list and complete type record.
   TypeRecordKind Kind = getRecordKind(Ty);
   // FIXME: Other ClassOptions, like ContainsNestedClass and NestedClass.
   ClassOptions CO = ClassOptions::None | getRecordUniqueNameOption(Ty);
   TypeIndex FTI;
+  TypeIndex VShapeTI;
   unsigned FieldCount;
-  std::tie(FTI, FieldCount) = lowerRecordFieldList(Ty);
+  std::tie(FTI, VShapeTI, FieldCount) = lowerRecordFieldList(Ty);
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
-  return TypeTable.writeClass(ClassRecord(Kind, FieldCount, CO, HfaKind::None,
-                                          WindowsRTClassKind::None, FTI,
-                                          TypeIndex(), TypeIndex(), SizeInBytes,
-                                          Ty->getName(), Ty->getIdentifier()));
+  return TypeTable.writeClass(ClassRecord(
+      Kind, FieldCount, CO, HfaKind::None, WindowsRTClassKind::None, FTI,
+      TypeIndex(), VShapeTI, SizeInBytes, Ty->getName(), Ty->getIdentifier()));
   // FIXME: Make an LF_UDT_SRC_LINE record.
 }
 
 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO =
       ClassOptions::ForwardReference | getRecordUniqueNameOption(Ty);
   TypeIndex FwdDeclTI =
       TypeTable.writeUnion(UnionRecord(0, CO, HfaKind::None, TypeIndex(), 0,
                                        Ty->getName(), Ty->getIdentifier()));
   return FwdDeclTI;
 }
 
 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO = ClassOptions::None | getRecordUniqueNameOption(Ty);
   TypeIndex FTI;
+  TypeIndex VShapeTI; // Dummy
   unsigned FieldCount;
-  std::tie(FTI, FieldCount) = lowerRecordFieldList(Ty);
+  std::tie(FTI, VShapeTI, FieldCount) = lowerRecordFieldList(Ty);
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
   return TypeTable.writeUnion(UnionRecord(FieldCount, CO, HfaKind::None, FTI,
                                           SizeInBytes, Ty->getName(),
                                           Ty->getIdentifier()));
   // FIXME: Make an LF_UDT_SRC_LINE record.
 }
 
-std::pair<TypeIndex, unsigned>
+/// If this type is derived from a base type then return base type size.
+static uint64_t getBaseTypeSize(const DIDerivedType *Ty) {
+  unsigned Tag = Ty->getTag();
+
+  if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
+      Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
+      Tag != dwarf::DW_TAG_restrict_type)
+    return Ty->getSizeInBits();
+
+  DIType *BaseType = Ty->getBaseType().resolve();
+
+  // If this type is not derived from any type or the type is a declaration then
+  // take conservative approach.
+  if (!BaseType || BaseType->isForwardDecl())
+    return Ty->getSizeInBits();
+
+  // If this is a derived type, go ahead and get the base type, unless it's a
+  // reference then it's just the size of the field. Pointer types have no need
+  // of this since they're a different type of qualification on the type.
+  if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
+      BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
+    return Ty->getSizeInBits();
+
+  if (DIDerivedType *DT = dyn_cast<DIDerivedType>(BaseType))
+    return getBaseTypeSize(DT);
+
+  return BaseType->getSizeInBits();
+}
+
+std::tuple<TypeIndex, TypeIndex, unsigned>
 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
-  // Manually count members. MSVC appears to count everything that generates a
-  // field list record. Each individual overload in a method overload group
-  // contributes to this count, even though the overload group is a single field
-  // list record.
-  unsigned MemberCount = 0;
+  ClassInfo &Info = collectClassInfo(Ty);
   FieldListRecordBuilder Fields;
-  for (const DINode *Element : Ty->getElements()) {
-    // We assume that the frontend provides all members in source declaration
-    // order, which is what MSVC does.
-    if (!Element)
-      continue;
-    if (auto *SP = dyn_cast<DISubprogram>(Element)) {
-      // C++ method.
-      // FIXME: Overloaded methods are grouped together, so we'll need two
-      // passes to group them.
-      (void)SP;
-    } else if (auto *Member = dyn_cast<DIDerivedType>(Element)) {
-      if (Member->getTag() == dwarf::DW_TAG_member) {
-        if (Member->isStaticMember()) {
-          // Static data member.
-          Fields.writeStaticDataMember(StaticDataMemberRecord(
-              translateAccessFlags(Ty->getTag(), Member),
-              getTypeIndex(Member->getBaseType()), Member->getName()));
-          MemberCount++;
-        } else {
-          // Data member.
-          // FIXME: Make a BitFieldRecord for bitfields.
-          Fields.writeDataMember(DataMemberRecord(
-              translateAccessFlags(Ty->getTag(), Member),
-              getTypeIndex(Member->getBaseType()),
-              Member->getOffsetInBits() / 8, Member->getName()));
-          MemberCount++;
-        }
-      } else if (Member->getTag() == dwarf::DW_TAG_friend) {
-        // Ignore friend members. It appears that MSVC emitted info about
-        // friends in the past, but modern versions do not.
-      }
-      // FIXME: Get clang to emit nested types here and do something with
-      // them.
-    }
-    // Skip other unrecognized kinds of elements.
+  TypeIndex VShapeTI;
+
+  // Create base classes
+  for (auto Inheritance : Info.BaseClasses)
+    Fields.writeBaseClass(
+        BaseClassRecord(translateAccessFlags(Ty->getTag(),
+                                             Inheritance->getFlags()),
+                        getTypeIndex(Inheritance->getBaseType()),
+                        Inheritance->getOffsetInBits() / 8));
+
+  // Create virtual base classes
+  for (auto &VBInfo : Info.VBClasses) {
+    auto Inheritance = VBInfo.second.InheritanceNode;
+    TypeRecordKind Kind = VBInfo.second.Indirect
+                              ? TypeRecordKind::IndirectVirtualBaseClass
+                              : TypeRecordKind::VirtualBaseClass;
+    Fields.writeVirtualBaseClass(VirtualBaseClassRecord(
+        Kind, translateAccessFlags(Ty->getTag(), Inheritance->getFlags()),
+        getTypeIndex(Inheritance->getBaseType()), getVBPType(),
+        Info.VBPOffset, VBInfo.second.VBIndex));
+  }
+
+  // Create virtual function table descriptor.
+  if (Info.VirtualFuncTab) {
+    std::vector<VFTableSlotKind> Kinds;
+    Kinds.assign(Info.VirtualMethodsCount, VFTableSlotKind::Outer);
+
+    VShapeTI = TypeTable.writeVFTableShape(VFTableShapeRecord(Kinds));
+    PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
+                                                  : PointerKind::Near32;
+    PointerMode PM = PointerMode::Pointer;
+    PointerOptions PO = PointerOptions::None;
+    PointerRecord PR(VShapeTI, PK, PM, PO, getPointerSizeInBytes());
+    TypeIndex PointerTI = TypeTable.writePointer(PR);
+
+    Fields.writeVFPtr(VFPtrRecord(PointerTI));
+  }
+
+  // Create members
+  for (auto &MemberInfo : Info.Members) {
+    const DIDerivedType *Member = MemberInfo.first;
+    TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
+
+      Fields.writeStaticDataMember(
+          StaticDataMemberRecord(translateAccessFlags(Ty->getTag(),
+                                                      Member->getFlags()),
+                                 MemberBaseType, Member->getName()));
+      continue;
+
+    // TODO: move the member size calculation to a helper function.
+    uint64_t Size = Member->getSizeInBits();
+    uint64_t FieldSize = getBaseTypeSize(Member);
+    uint64_t OffsetInBytes = MemberInfo.second;
+
+    if (Size != FieldSize) {
+      uint64_t Offset = Member->getOffsetInBits();
+      uint64_t AlignMask = ~(Member->getAlignInBits() - 1);
+      uint64_t HiMark = (Offset + FieldSize) & AlignMask;
+      uint64_t FieldOffset = (HiMark - FieldSize);
+      Offset -= FieldOffset;
+
+      // Maybe we need to work from the other end.
+      // if (ASM()->getDataLayout().isLittleEndian())
+      //  Offset = FieldSize - (Offset + Size);
+
+      OffsetInBytes += FieldOffset / 8;
+      MemberBaseType = TypeTable.writeBitField(
+          BitFieldRecord(MemberBaseType, (uint8_t)Size, (uint8_t)Offset));
+    } else
+      // This is not a bitfield.
+      OffsetInBytes += Member->getOffsetInBits() / 8;
+
+    Fields.writeDataMember(
+        DataMemberRecord(translateAccessFlags(Ty->getTag(), Member->getFlags()),
+                         MemberBaseType, OffsetInBytes, Member->getName()));
+  }
+
+  // Create methods
+  for (auto &MethodItr : Info.Methods) {
+    StringRef Name = MethodItr.first;
+
+    std::vector<OneMethodRecord> Methods;
+    for (auto &MethodInfo : MethodItr.second) {
+      auto *SP = MethodInfo.first;
+      bool Introduced = MethodInfo.second;
+
+      TypeIndex Methodtype = getTypeIndex(SP->getType(), Ty);
+
+      unsigned VFTableOffset = -1;
+      if (Introduced)
+        VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
+
+      Methods.push_back(OneMethodRecord(
+          Methodtype, translateMethodKindFlags(SP, Introduced),
+          translateMethodOptionFlags(SP),
+          translateAccessFlags(Ty->getTag(), SP->getFlags()), VFTableOffset,
+          Name));
+    }
+    assert(Methods.size() > 0 && "Empty methods map entry");
+    if (Methods.size() == 1)
+      Fields.writeOneMethod(Methods[0]);
+    else
+      Fields.writeOverloadedMethod(OverloadedMethodRecord(
+          Methods.size(), TypeTable.writeMethodOverloadList(Methods), Name));
+
+  return std::make_tuple(TypeTable.writeFieldList(Fields), VShapeTI,
+                         Ty->getElements().size());
+
+TypeIndex CodeViewDebug::getVBPType() {
+  if (!VBPType.getIndex()) {
+    ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
+    TypeIndex ModifiedTI = TypeTable.writeModifier(MR);
+
+    PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
+                                                  : PointerKind::Near32;
+    PointerMode PM = PointerMode::Pointer;
+    PointerOptions PO = PointerOptions::None;
+    PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
+
+    VBPType = TypeTable.writePointer(PR);
   }
-  return {TypeTable.writeFieldList(Fields), MemberCount};
+
+  return VBPType;
 }
 
-TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef) {
+TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
   const DIType *Ty = TypeRef.resolve();
+  const DIType *ClassTy = ClassTyRef.resolve();
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)
     return TypeIndex::Void();
 
   // Check if we've already translated this type. Don't try to do a
   // get-or-create style insertion that caches the hash lookup across the
   // lowerType call. It will update the TypeIndices map.
-  auto I = TypeIndices.find(Ty);
+  auto I = TypeIndices.find({ Ty, ClassTy });
   if (I != TypeIndices.end())
     return I->second;
 
-  TypeIndex TI = lowerType(Ty);
+  TypeIndex TI = lowerType(Ty, ClassTy);
 
-  recordTypeIndexForDINode(Ty, TI);
+  recordTypeIndexForDINode(Ty, TI, ClassTy);
   return TI;
 }
 
 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
   const DIType *Ty = TypeRef.resolve();
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)

test/DebugInfo/COFF/types-basic.ll

 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   ArgList (0x1008) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
-; CHECK:     NumArgs: 1
+; CHECK:     NumArgs: 0
 ; CHECK:     Arguments [
-; CHECK:       ArgType: A* (0x1007)
 ; CHECK:     ]
 ; CHECK:   }
-; CHECK:   Procedure (0x1009) {
-; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
-; CHECK:     ReturnType: void (0x3)
-; CHECK:     CallingConvention: NearC (0x0)
-; CHECK:     FunctionOptions [ (0x0)
-; CHECK:     ]
-; CHECK:     NumParameters: 1
-; CHECK:     ArgListType: (A*) (0x1008)
-; CHECK:   }
+; CHECK:  MemberFunction (0x1009) {
+; CHECK:    TypeLeafKind: LF_MFUNCTION (0x1009)
+; CHECK:    ReturnType: void (0x3)
+; CHECK:    ClassType: A (0x1005)
+; CHECK:    ThisType: A* (0x1007)
+; CHECK:    CallingConvention: ThisCall (0xB)
+; CHECK:    FunctionOptions [ (0x0)
+; CHECK:    ]
+; CHECK:    NumParameters: 0
+; CHECK:    ArgListType: () (0x1008)
+; CHECK:    ThisAdjustment: 0
+; CHECK:  }
 ; CHECK:   Pointer (0x100A) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: void (A*) (0x1009)
+; CHECK:     PointeeType: void A::() (0x1009)
 ; CHECK:     PointerAttributes: 0x1006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     ClassType: A (0x1005)

 ; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
-; CHECK:   ArgList (0x100D) {
-; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
-; CHECK:     NumArgs: 0
-; CHECK:     Arguments [
-; CHECK:     ]
-; CHECK:   }
-; CHECK:   Procedure (0x100E) {
+; CHECK:   Procedure (0x100D) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
-; CHECK:     ArgListType: () (0x100D)
+; CHECK:     ArgListType: () (0x1008)
 ; CHECK:   }
-; CHECK:   FuncId (0x100F) {
+; CHECK:   FuncId (0x100E) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void () (0x100E)
+; CHECK:     FunctionType: void () (0x100D)
 ; CHECK:     Name: CharTypes
 ; CHECK:   }
 ; CHECK: ]
 
 ; CHECK: CodeViewDebugInfo [
 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: Symbols (0xF1)
 ; CHECK:     ProcStart {

 ; CHECK:       Type: void* (0x603)
 ; CHECK:       VarName: v3
 ; CHECK:     }
 ; CHECK:     Local {
 ; CHECK:       Type: int A::* (0x1006)
 ; CHECK:       VarName: v4
 ; CHECK:     }
 ; CHECK:     Local {
-; CHECK:       Type: void (A*) A::* (0x100A)
+; CHECK:       Type: void A::() A::* (0x100A)
 ; CHECK:       VarName: v5
 ; CHECK:     }
 ; CHECK:     Local {
 ; CHECK:       Type: long (0x12)
 ; CHECK:       VarName: l1
 ; CHECK:     }
 ; CHECK:     Local {
 ; CHECK:       Type: long (0x12)

 ; CHECK:       Type: const void* (0x100C)
 ; CHECK:       VarName: v6
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK:   Subsection [
 ; CHECK:     ProcStart {
-; CHECK:       Type: CharTypes (0x100F)
+; CHECK:       Type: CharTypes (0x100E)
 ; CHECK:       DisplayName: CharTypes
 ; CHECK:       LinkageName: ?CharTypes@@YAXXZ
 ; CHECK:     }
 ; CHECK:     Local {
 ; CHECK:       Type: wchar_t (0x71)
 ; CHECK:       Flags [ (0x0)
 ; CHECK:       ]
 ; CHECK:       VarName: w

test/DebugInfo/COFF/types-data-members.ll

 ; CHECK:       ForwardReference (0x80)
 ; CHECK:     ]
 ; CHECK:     FieldList: 0x0
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: DerivedClass
 ; CHECK:   }
-; CHECK:   Procedure (0x100E) {
+; CHECK:   Pointer (0x100E) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: const int (0x1004)
+; CHECK:     PointerAttributes: 0x1000C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:   }
+; CHECK:   Procedure (0x100F) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: int (0x74)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1000)
 ; CHECK:   }
-; CHECK:   Pointer (0x100F) {
+; CHECK:   Pointer (0x1010) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: int () (0x100E)
+; CHECK:     PointeeType: int () (0x100F)
 ; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
-; CHECK:   Pointer (0x1010) {
+; CHECK:   Pointer (0x1011) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: int ()* (0x100F)
+; CHECK:     PointeeType: int ()* (0x1010)
 ; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
-; CHECK:   UnknownLeaf (0x1011) {
+; CHECK:   UnknownLeaf (0x1012) {
 ; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     BaseClass {
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       BaseType: Struct (0x1003)
+; CHECK:       BaseOffset: 0x0
+; CHECK:     }
+; CHECK:     VirtualBaseClass {
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       BaseType: Class (0x100A)
+; CHECK:       VBPtrType: const int* (0x100E)
+; CHECK:       VBPtrOffset: 0xC
+; CHECK:       VBTableIndex: 0x1
+; CHECK:     }
 ; CHECK:     DataMember {
 ; CHECK:       AccessSpecifier: Public (0x3)
-; CHECK:       Type: int ()** (0x1010)
+; CHECK:       Type: int ()** (0x1011)
 ; CHECK:       FieldOffset: 0x0
 ; CHECK:       Name: _vptr$DerivedClass
 ; CHECK:     }
 ; CHECK:     DataMember {
 ; CHECK:       AccessSpecifier: Public (0x3)
 ; CHECK:       Type: int (0x74)
 ; CHECK:       FieldOffset: 0x18
 ; CHECK:       Name: d
 ; CHECK:     }
 ; CHECK:   }
-; CHECK:   Struct (0x1012) {
+; CHECK:   Struct (0x1013) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
-; CHECK:     MemberCount: 2
+; CHECK:     MemberCount: 4
 ; CHECK:     Properties [ (0x0)
 ; CHECK:     ]
-; CHECK:     FieldList: d (0x1011)
+; CHECK:     FieldList: d (0x1012)
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 48
 ; CHECK:     Name: DerivedClass
 ; CHECK:   }
-; CHECK:   Struct (0x1013) {
+; CHECK:   Struct (0x1014) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:     MemberCount: 0
 ; CHECK:     Properties [ (0x80)
 ; CHECK:       ForwardReference (0x80)
 ; CHECK:     ]
 ; CHECK:     FieldList: 0x0
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: Nested
 ; CHECK:   }
-; CHECK:   UnknownLeaf (0x1014) {
+; CHECK:   UnknownLeaf (0x1015) {
 ; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
 ; CHECK:     DataMember {
 ; CHECK:       AccessSpecifier: Public (0x3)
 ; CHECK:       Type: int (0x74)
 ; CHECK:       FieldOffset: 0x0
 ; CHECK:       Name: n
 ; CHECK:     }
 ; CHECK:   }
-; CHECK:   Struct (0x1015) {
+; CHECK:   Struct (0x1016) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:     MemberCount: 1
 ; CHECK:     Properties [ (0x0)
 ; CHECK:     ]
-; CHECK:     FieldList: n (0x1014)
+; CHECK:     FieldList: n (0x1015)
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 4
 ; CHECK:     Name: Nested
 ; CHECK:   }
-; CHECK:   Pointer (0x1016) {
+; CHECK:   Pointer (0x1017) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: DerivedClass (0x100D)
 ; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
-; CHECK:   ArgList (0x1017) {
-; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
-; CHECK:     NumArgs: 1
-; CHECK:     Arguments [
-; CHECK:       ArgType: DerivedClass* (0x1016)
-; CHECK:     ]
-; CHECK:   }
-; CHECK:   Procedure (0x1018) {
-; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:   MemberFunction (0x1018) {
+; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
-; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     ClassType: DerivedClass (0x100D)
+; CHECK:     ThisType: DerivedClass* (0x1017)
+; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
-; CHECK:     NumParameters: 1
-; CHECK:     ArgListType: (DerivedClass*) (0x1017)
+; CHECK:     NumParameters: 0
+; CHECK:     ArgListType: () (0x1000)
+; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FuncId (0x1019) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void (DerivedClass*) (0x1018)
+; CHECK:     FunctionType: void DerivedClass::() (0x1018)
 ; CHECK:     Name: DerivedClass::DerivedClass
 ; CHECK:   }
 ; CHECK: ]
 
 ; ModuleID = 'record-types.cpp'
 source_filename = "record-types.cpp"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.23918"