[codeview] Emit retained types

[hans]

Summary

Please take a look.

[rnk]

test/DebugInfo/COFF/retained-types.ll

14 ↗

(On Diff #61629)

Can you cut the checks down to look for the two Struct records and wild card away all the type indices? All the other types are not relevant to the test. Something like:

; CHECK: Struct ({{.*}}) {
; CHECK-NEXT: ...

; CHECK: Struct ({{.*}}) {
; CHECK-NEXT: ...

I was thinking about changing our dumper output to print the name of the type on the first line of the record so that it plays better with FileCheck, something like:

Struct A (0xNNNN) {
... }
Pointer A* (0xNNNN) {
... }

[rnk]

lgtm with that change, forgot to stamp

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

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   void emitTypeInformation();
 
   void emitInlineeLinesSubsection();
 
   void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
 
   void emitDebugInfoForGlobals();
 
+  void emitDebugInfoForRetainedTypes();
+
   void emitDebugInfoForUDTs(
       ArrayRef<std::pair<std::string, codeview::TypeIndex>> UDTs);
 
   void emitDebugInfoForGlobal(const DIGlobalVariable *DIGV, MCSymbol *GVSym);
 
   /// Opens a subsection of the given kind in a .debug$S codeview section.
   /// Returns an end label for use with endCVSubsection when the subsection is
   /// finished.

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

void CodeViewDebug::endModule() {
   for (auto &P : FnDebugInfo)
     if (!P.first->isDeclarationForLinker())
       emitDebugInfoForFunction(P.first, P.second);
 
   // Emit global variable debug information.
   setCurrentSubprogram(nullptr);
   emitDebugInfoForGlobals();
 
+  // Emit retained types.
+  emitDebugInfoForRetainedTypes();
+
   // Switch back to the generic .debug$S section after potentially processing
   // comdat symbol sections.
   switchToDebugSectionForSymbol(nullptr);
 
   // Emit UDT records for any types used by global variables.
   if (!GlobalUDTs.empty()) {
     MCSymbol *SymbolsEnd = beginCVSubsection(ModuleSubstreamKind::Symbols);
     emitDebugInfoForUDTs(GlobalUDTs);
for (const DIGlobalVariable *G : CU->getGlobalVariables()) {
           emitDebugInfoForGlobal(G, GVSym);
           endCVSubsection(EndLabel);
         }
       }
     }
   }
 }
 
+void CodeViewDebug::emitDebugInfoForRetainedTypes() {
+  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
+  for (const MDNode *Node : CUs->operands()) {
+    for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
+      if (DIType *RT = dyn_cast<DIType>(Ty)) {
+        getTypeIndex(RT);
+        // FIXME: Add to global/local DTU list.
+      }
+    }
+  }
+}
+
 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
                                            MCSymbol *GVSym) {
   // DataSym record, see SymbolRecord.h for more info.
   // FIXME: Thread local data, etc
   MCSymbol *DataBegin = MMI->getContext().createTempSymbol(),
            *DataEnd = MMI->getContext().createTempSymbol();
   OS.AddComment("Record length");
   OS.emitAbsoluteSymbolDiff(DataEnd, DataBegin, 2);

llvm/trunk/test/DebugInfo/COFF/retained-types.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; This test checks that types which are used in expressions, but for which
+; there are no variables, known as retained types, get emitted.
+
+; C++ source to regenerate:
+; $ cat /tmp/a.cc
+; struct S { int x; };
+; int f(void *p) {
+;   return static_cast<S*>(p)->x;
+; }
+; $ clang /tmp/a.cc -S -emit-llvm -g -gcodeview -target x86_64-windows-msvc -o t.ll
+
+; CHECK:       Struct (0x{{[0-9a-f]+}}) {
+; CHEC-NEXT:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHEC-NEXT:     MemberCount: 0
+; CHEC-NEXT:     Properties [ (0x280)
+; CHEC-NEXT:       ForwardReference (0x80)
+; CHEC-NEXT:       HasUniqueName (0x200)
+; CHEC-NEXT:     ]
+; CHEC-NEXT:     FieldList: 0x0
+; CHEC-NEXT:     DerivedFrom: 0x0
+; CHEC-NEXT:     VShape: 0x0
+; CHEC-NEXT:     SizeOf: 0
+; CHEC-NEXT:     Name: S
+; CHEC-NEXT:     LinkageName: .?AUS@@
+; CHEC-NEXT:   }
+
+; CHECK:        Struct (0x{{[0-9a-f]+}}) {
+; CHECK-NEXT:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK-NEXT:     MemberCount: 1
+; CHECK-NEXT:     Properties [ (0x200)
+; CHECK-NEXT:       HasUniqueName (0x200)
+; CHECK-NEXT:     ]
+; CHECK-NEXT:     FieldList: <field list> (0x{{[0-9a-f]+}})
+; CHECK-NEXT:     DerivedFrom: 0x0
+; CHECK-NEXT:     VShape: 0x0
+; CHECK-NEXT:     SizeOf: 4
+; CHECK-NEXT:     Name: S
+; CHECK-NEXT:     LinkageName: .?AUS@@
+; CHECK-NEXT:   }
+
+; ModuleID = '/tmp/a.cc'
+source_filename = "/tmp/a.cc"
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--windows-msvc18.0.0"
+
+%struct.S = type { i32 }
+
+; Function Attrs: nounwind uwtable
+define i32 @"\01?f@@YAHPEAX@Z"(i8* %p) #0 !dbg !13 {
+entry:
+  %p.addr = alloca i8*, align 8
+  store i8* %p, i8** %p.addr, align 8
+  call void @llvm.dbg.declare(metadata i8** %p.addr, metadata !17, metadata !18), !dbg !19
+  %0 = load i8*, i8** %p.addr, align 8, !dbg !20
+  %1 = bitcast i8* %0 to %struct.S*, !dbg !21
+  %x = getelementptr inbounds %struct.S, %struct.S* %1, i32 0, i32 0, !dbg !22
+  %2 = load i32, i32* %x, align 4, !dbg !22
+  ret i32 %2, !dbg !23
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!9, !10, !11}
+!llvm.ident = !{!12}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (trunk 273441) (llvm/trunk 273449)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3)
+!1 = !DIFile(filename: "/tmp/a.cc", directory: "/usr/local/google/work/llvm/build.release")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !5, size: 64, align: 64)
+!5 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", file: !1, line: 1, size: 32, align: 32, elements: !6, identifier: ".?AUS@@")
+!6 = !{!7}
+!7 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !5, file: !1, line: 1, baseType: !8, size: 32, align: 32)
+!8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!9 = !{i32 2, !"CodeView", i32 1}
+!10 = !{i32 2, !"Debug Info Version", i32 3}
+!11 = !{i32 1, !"PIC Level", i32 2}
+!12 = !{!"clang version 3.9.0 (trunk 273441) (llvm/trunk 273449)"}
+!13 = distinct !DISubprogram(name: "f", linkageName: "\01?f@@YAHPEAX@Z", scope: !1, file: !1, line: 2, type: !14, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!14 = !DISubroutineType(types: !15)
+!15 = !{!8, !16}
+!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 64, align: 64)
+!17 = !DILocalVariable(name: "p", arg: 1, scope: !13, file: !1, line: 2, type: !16)
+!18 = !DIExpression()
+!19 = !DILocation(line: 2, column: 13, scope: !13)
+!20 = !DILocation(line: 3, column: 26, scope: !13)
+!21 = !DILocation(line: 3, column: 10, scope: !13)
+!22 = !DILocation(line: 3, column: 30, scope: !13)
+!23 = !DILocation(line: 3, column: 3, scope: !13)