Emit CodeView type records for nested classes

[amccarth]

Summary

This is the final step in getting nested classes/structs into the type records in CodeView. Includes a simple test.

https://llvm.org/bugs/show_bug.cgi?id=28152

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1568 ↗

(On Diff #62544)

This should probably be Fields.writeNestedType(getTypeIndex(Nested)). The idea is that you should always be able to call getTypeIndex, and if that happens to reference a complete record type, we defer its emission until some time later. getTypeIndex also maintains the map from DINode* to TypeIndex, and directly calling the lower* methods bypasses that.

I should write comments in CodeViewDebug.h about this!

test/DebugInfo/COFF/types-nested-class.ll

28 ↗

(On Diff #62544)

We should see a NestedType record in A's FieldList. Right now both A and A::Nested are empty, so they share the same field list. :)

[rnk]

Oh, you should also set ClassOptions::ContainsNestedClass if the nested type list is non-empty.

We should also set ClassOptions::Nested if the scope of a class is a DICompositeType.

[amccarth]

test/DebugInfo/COFF/types-nested-class.ll

28 ↗

(On Diff #62544)

OK, that surprises me, but OK. I wouldn't have expected a type in the field list.

[amccarth]

Now includes the nested type in the field list (and includes it in the member count).

[rnk]

lgtm

test/DebugInfo/COFF/types-nested-class.ll

28 ↗

(On Diff #62544)

Yeah, I would've called it "member" list, but I was trying to stay closer to their terminology.

[amccarth]

Sets the ContainsNestedClass property when appropriate.

[rnk]

Re-lgtm

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void emitDeferredCompleteTypes();
 
   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::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned>
+  std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
   lowerRecordFieldList(const DICompositeType *Ty);
 
   /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
   codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
                                                codeview::TypeIndex TI,
                                                const DIType *ClassTy = nullptr);
 
   unsigned getPointerSizeInBytes();

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

struct llvm::ClassInfo {
 
   /// Base classes.
   std::vector<const DIDerivedType *> Inheritance;
 
   /// Direct members.
   MemberList Members;
   // Direct overloaded methods gathered by name.
   MethodsMap Methods;
+
+  std::vector<const DICompositeType *> NestedClasses;
 };
 
 void CodeViewDebug::clear() {
   assert(CurFn == nullptr);
   FileIdMap.clear();
   FnDebugInfo.clear();
   FileToFilepathMap.clear();
   LocalUDTs.clear();
if (auto *SP = dyn_cast<DISubprogram>(Element)) {
         collectMemberInfo(Info, DDTy);
       } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
         Info.Inheritance.push_back(DDTy);
       } 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.
       }
       // FIXME: Get Clang to emit function virtual table here and handle it.
-      // FIXME: Get clang to emit nested types here and do something with
-      // them.
+    } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
+      Info.NestedClasses.push_back(Composite);
     }
     // Skip other unrecognized kinds of elements.
   }
   return Info;
 }
 
 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
   // First, construct the forward decl.  Don't look into Ty to compute the

 
 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
   // Construct the field list and complete type record.
   TypeRecordKind Kind = getRecordKind(Ty);
   ClassOptions CO = getCommonClassOptions(Ty);
   TypeIndex FieldTI;
   TypeIndex VShapeTI;
   unsigned FieldCount;
-  std::tie(FieldTI, VShapeTI, FieldCount) = lowerRecordFieldList(Ty);
+  bool ContainsNestedClass;
+  std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
+      lowerRecordFieldList(Ty);
+
+  if (ContainsNestedClass)
+    CO |= ClassOptions::ContainsNestedClass;
 
   std::string FullName = getFullyQualifiedName(Ty);
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
 
   TypeIndex ClassTI = TypeTable.writeClass(ClassRecord(
       Kind, FieldCount, CO, HfaKind::None, WindowsRTClassKind::None, FieldTI,
       TypeIndex(), VShapeTI, SizeInBytes, FullName, Ty->getIdentifier()));
if (!Ty->isForwardDecl())
     DeferredCompleteTypes.push_back(Ty);
   return FwdDeclTI;
 }
 
 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO = getCommonClassOptions(Ty);
   TypeIndex FieldTI;
   unsigned FieldCount;
-  std::tie(FieldTI, std::ignore, FieldCount) = lowerRecordFieldList(Ty);
+  bool ContainsNestedClass;
+  std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
+      lowerRecordFieldList(Ty);
+
+  if (ContainsNestedClass)
+    CO |= ClassOptions::ContainsNestedClass;
+
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
   std::string FullName = getFullyQualifiedName(Ty);
 
   TypeIndex UnionTI = TypeTable.writeUnion(
       UnionRecord(FieldCount, CO, HfaKind::None, FieldTI, SizeInBytes, FullName,
                   Ty->getIdentifier()));
 
   TypeTable.writeUdtSourceLine(UdtSourceLineRecord(
       UnionTI, TypeTable.writeStringId(StringIdRecord(
                    TypeIndex(0x0), getFullFilepath(Ty->getFile()))),
       Ty->getLine()));
 
   addToUDTs(Ty, UnionTI);
 
   return UnionTI;
 }
 
-std::tuple<TypeIndex, TypeIndex, unsigned>
+std::tuple<TypeIndex, TypeIndex, unsigned, bool>
 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;
if (Methods.size() == 1)
       Fields.writeOneMethod(Methods[0]);
     else {
       TypeIndex MethodList =
           TypeTable.writeMethodOverloadList(MethodOverloadListRecord(Methods));
       Fields.writeOverloadedMethod(
           OverloadedMethodRecord(Methods.size(), MethodList, Name));
     }
   }
+
+  // Create nested classes.
+  for (const DICompositeType *Nested : Info.NestedClasses) {
+    NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
+    Fields.writeNestedType(R);
+    MemberCount++;
+  }
+
   TypeIndex FieldTI = TypeTable.writeFieldList(Fields);
-  return std::make_tuple(FieldTI, TypeIndex(), MemberCount);
+  return std::make_tuple(FieldTI, TypeIndex(), MemberCount,
+                         !Info.NestedClasses.empty());
 }
 
 TypeIndex CodeViewDebug::getVBPTypeIndex() {
   if (!VBPType.getIndex()) {
     // Make a 'const int *' type.
     ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
     TypeIndex ModifiedTI = TypeTable.writeModifier(MR);
 

llvm/trunk/test/DebugInfo/COFF/types-nested-class.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; C++ source to regenerate:
+; $ cat hello.cpp
+; struct A {
+;   struct Nested {};
+; } a;
+; $ clang hello.cpp -S -emit-llvm -g -gcodeview -o t.ll
+
+; CHECK: CodeViewTypes [
+; CHECK:   Section: .debug$T (5)
+; CHECK:   Magic: 0x4
+; CHECK:   Struct (0x1000) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 0
+; CHECK:     Properties [ (0x280)
+; CHECK:       ForwardReference (0x80)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: 0x0
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 0
+; CHECK:     Name: A
+; CHECK:     LinkageName: .?AUA@@
+; CHECK:   }
+; CHECK:   Struct (0x1001) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 0
+; CHECK:     Properties [ (0x280)
+; CHECK:       ForwardReference (0x80)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: 0x0
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 0
+; CHECK:     Name: A::Nested
+; CHECK:     LinkageName: .?AUNested@A@@
+; CHECK:   }
+; CHECK:   FieldList (0x1002) {
+; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     NestedType {
+; CHECK:       Type: A::Nested (0x1001)
+; CHECK:       Name: Nested
+; CHECK:     }
+; CHECK:   }
+; CHECK:   Struct (0x1003) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 1
+; CHECK:     Properties [ (0x210)
+; CHECK:       ContainsNestedClass (0x10)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: <field list> (0x1002)
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 1
+; CHECK:     Name: A
+; CHECK:     LinkageName: .?AUA@@
+; CHECK:   }
+; CHECK:   StringId (0x1004) {
+; CHECK:     TypeLeafKind: LF_STRING_ID (0x1605)
+; CHECK:     Id: 0x0
+; CHECK:     StringData: D:\src\hello\hello.cpp
+; CHECK:   }
+; CHECK:   UdtSourceLine (0x1005) {
+; CHECK:     TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
+; CHECK:     UDT: A (0x1003)
+; CHECK:     SourceFile: D:\src\hello\hello.cpp (0x1004)
+; CHECK:     LineNumber: 1
+; CHECK:   }
+; CHECK: ]
+
+; ModuleID = 'hello.cpp'
+source_filename = "hello.cpp"
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc19.0.23918"
+
+%struct.A = type { i8 }
+
+@"\01?a@@3UA@@A" = global %struct.A zeroinitializer, align 1
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "hello.cpp", directory: "D:\5Csrc\5Chello")
+!2 = !{}
+!3 = !{!4}
+!4 = distinct !DIGlobalVariable(name: "a", linkageName: "\01?a@@3UA@@A", scope: !0, file: !1, line: 3, type: !5, isLocal: false, isDefinition: true, variable: %struct.A* @"\01?a@@3UA@@A")
+!5 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !1, line: 1, size: 8, align: 8, elements: !6, identifier: ".?AUA@@")
+!6 = !{!7}
+!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "Nested", scope: !5, file: !1, line: 2, size: 8, align: 8, flags: DIFlagFwdDecl, identifier: ".?AUNested@A@@")
+!8 = !{i32 2, !"CodeView", i32 1}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 3.9.0 "}