[CodeView] Emit UdtSourceLine information for enums

[asmith]

Summary

• Emit UdtSourceLine information for enums to match MSVC

• Add a method to add UDTSrcLine and call it for all Class/Struct/Union/Enum

• Update test cases to verify the changes

[rnk]

We also probably need to emit S_UDT symbol records in the right place. Can you factor out a method with this code from lowerCompleteTypeClass and make Class, Enum, and Union code call it? This is the duplicated code that has already diverged a little bit:

if (const auto *File = Ty->getFile()) {
  StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
  TypeIndex SIDI = TypeTable.writeLeafType(SIDR);

  UdtSourceLineRecord USLR(ClassTI, SIDI, Ty->getLine());
  TypeTable.writeLeafType(USLR);
}

addToUDTs(Ty);

[rnk]

lgtm

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1791

We should call addToUDTs(Ty) here as a followup. MSVC emits S_UDT records for enums as well as typedefs, structs, etc.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
                                             const DICompositeType *Class);
 
   codeview::TypeIndex getScopeIndex(const DIScope *Scope);
 
   codeview::TypeIndex getVBPTypeIndex();
 
   void addToUDTs(const DIType *Ty);
 
+  void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
+
   codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
   codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeArray(const DICompositeType *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);

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if (isa<DISubprogram>(Scope)) {
       CO |= ClassOptions::Scoped;
       break;
     }
   }
 
   return CO;
 }
 
+void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
+  switch (Ty->getTag()) {
+  case dwarf::DW_TAG_class_type:
+  case dwarf::DW_TAG_structure_type:
+  case dwarf::DW_TAG_union_type:
+  case dwarf::DW_TAG_enumeration_type:
+    break;
+  default:
+    return;
+  }
+
+  if (const auto *File = Ty->getFile()) {
+    StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
+    TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
+
+    UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine());
+    TypeTable.writeLeafType(USLR);
+  }
+}
+
 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
   ClassOptions CO = getCommonClassOptions(Ty);
   TypeIndex FTI;
   unsigned EnumeratorCount = 0;
 
   if (Ty->isForwardDecl()) {
     CO |= ClassOptions::ForwardReference;
   } else {
if (Ty->isForwardDecl()) {
     }
     FTI = TypeTable.insertRecord(ContinuationBuilder);
   }
 
   std::string FullName = getFullyQualifiedName(Ty);
 
   EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
                 getTypeIndex(Ty->getBaseType()));
-  return TypeTable.writeLeafType(ER);
+  TypeIndex EnumTI = TypeTable.writeLeafType(ER);
+
+  addUDTSrcLine(Ty, EnumTI);
+
+  return EnumTI;
 }
 
 //===----------------------------------------------------------------------===//
 // ClassInfo
 //===----------------------------------------------------------------------===//
 
 struct llvm::ClassInfo {
   struct MemberInfo {
TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
   std::string FullName = getFullyQualifiedName(Ty);
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
 
   ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
                  SizeInBytes, FullName, Ty->getIdentifier());
   TypeIndex ClassTI = TypeTable.writeLeafType(CR);
 
-  if (const auto *File = Ty->getFile()) {
-    StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
-    TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
-
-    UdtSourceLineRecord USLR(ClassTI, SIDI, Ty->getLine());
-    TypeTable.writeLeafType(USLR);
-  }
+  addUDTSrcLine(Ty, ClassTI);
 
   addToUDTs(Ty);
 
   return ClassTI;
 }
 
 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
   ClassOptions CO =
TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
 
   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
   std::string FullName = getFullyQualifiedName(Ty);
 
   UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
                  Ty->getIdentifier());
   TypeIndex UnionTI = TypeTable.writeLeafType(UR);
 
-  StringIdRecord SIR(TypeIndex(0x0), getFullFilepath(Ty->getFile()));
-  TypeIndex SIRI = TypeTable.writeLeafType(SIR);
-
-  UdtSourceLineRecord USLR(UnionTI, SIRI, Ty->getLine());
-  TypeTable.writeLeafType(USLR);
+  addUDTSrcLine(Ty, UnionTI);
 
   addToUDTs(Ty);
 
   return UnionTI;
 }
 
 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {

test/DebugInfo/COFF/enum.ll

 ; CHECK-NEXT:    TypeLeafKind: LF_ENUM (0x1507)
 ; CHECK-NEXT:    NumEnumerators: 1
 ; CHECK-NEXT:    Properties [ (0x0)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    UnderlyingType: int (0x74)
 ; CHECK-NEXT:    FieldListType: <field list> (0x1000)
 ; CHECK-NEXT:    Name: E
 ; CHECK-NEXT:  }
+; CHECK-NEXT:  StringId (0x1002) {
+; CHECK-NEXT:    TypeLeafKind: LF_STRING_ID (0x1605)
+; CHECK-NEXT:    Id: 0x0
+; CHECK-NEXT:    StringData: \<stdin>
+; CHECK-NEXT:  }
+; CHECK-NEXT:  UdtSourceLine (0x1003) {
+; CHECK-NEXT:    TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
+; CHECK-NEXT:    UDT: E (0x1001)
+; CHECK-NEXT:    SourceFile: \<stdin> (0x1002)
+; CHECK-NEXT:    LineNumber: 1
+; CHECK_NEXT  }
 
 source_filename = "test/DebugInfo/COFF/enum.ll"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 @"\01?e@@3W4E@@A" = global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!2}

test/DebugInfo/COFF/nested-types.ll

 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   NestedType {
 ; CHECK-NEXT:     TypeLeafKind: LF_NESTTYPE (0x1510)
 ; CHECK-NEXT:     Type: HasNested::InnerStruct ([[INNERSTRUCT]])
 ; CHECK-NEXT:     Name: InnerStruct
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: }
 ;
-; CHECK:      Struct (0x1007) {
+; CHECK:      Struct (0x{{.*}}) {
 ; CHECK-NEXT:   TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK-NEXT:   MemberCount: 4
 ; CHECK-NEXT:   Properties [ (0x210)
 ; CHECK-NEXT:     ContainsNestedClass (0x10)
 ; CHECK-NEXT:     HasUniqueName (0x200)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   FieldList: <field list> ([[HASNESTED_MEMBERS]])
 ; CHECK-NEXT:   DerivedFrom: 0x0
 ; CHECK-NEXT:   VShape: 0x0
 ; CHECK-NEXT:   SizeOf: 1
 ; CHECK-NEXT:   Name: HasNested
 ; CHECK-NEXT:   LinkageName: .?AUHasNested@@
 ; CHECK-NEXT: }