Add a verifier check that rejects non-distinct DISubprogram function attachments.

[aprantl]

Summary

Add a verifier check that rejects non-distinct DISubprogram function attachments. They would crash the backend, which expects all DISubprograms that are not part of the type system to have a unit field.

Clang right before https://reviews.llvm.org/D79967 would generate this kind of broken IR.

rdar://problem/69534688

[vsk]

Thanks, lgtm! s/unique/non-unique/ in the summary?

llvm/lib/IR/Verifier.cpp

2396

I see we're checking this for declarations already :).

[shafik]

LGTM

[aprantl]

landed as 69534688 (forgot the attribution in the commit message).

llvm/lib/IR/Verifier.cpp

if (F.isMaterializable()) {
     // Function has a body somewhere we can't see.
     Assert(MDs.empty(), "unmaterialized function cannot have metadata", &F,
            MDs.empty() ? nullptr : MDs.front().second);
   } else if (F.isDeclaration()) {
     for (const auto &I : MDs) {
       // This is used for call site debug information.
       AssertDI(I.first != LLVMContext::MD_dbg ||
                    !cast<DISubprogram>(I.second)->isDistinct(),
                "function declaration may only have a unique !dbg attachment",
                &F);
       Assert(I.first != LLVMContext::MD_prof,
              "function declaration may not have a !prof attachment", &F);
 
       // Verify the metadata itself.
       visitMDNode(*I.second, AreDebugLocsAllowed::Yes);
     }
     Assert(!F.hasPersonalityFn(),
for (const auto &I : MDs) {
       default:
         break;
       case LLVMContext::MD_dbg: {
         ++NumDebugAttachments;
         AssertDI(NumDebugAttachments == 1,
                  "function must have a single !dbg attachment", &F, I.second);
         AssertDI(isa<DISubprogram>(I.second),
                  "function !dbg attachment must be a subprogram", &F, I.second);
+        AssertDI(cast<DISubprogram>(I.second)->isDistinct(),
+                 "function definition may only have a distinct !dbg attachment",
+                 &F);
+
         auto *SP = cast<DISubprogram>(I.second);
         const Function *&AttachedTo = DISubprogramAttachments[SP];
         AssertDI(!AttachedTo || AttachedTo == &F,
                  "DISubprogram attached to more than one function", SP, &F);
         AttachedTo = &F;
         AllowLocs = AreDebugLocsAllowed::Yes;
         break;
       }

llvm/test/DebugInfo/Generic/2009-11-03-InsertExtractValue.ll

 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 
 !llvm.module.flags = !{!6}
 !llvm.dbg.cu = !{!5}
 
-!0 = !DISubprogram(name: "bar", linkageName: "_ZN3foo3barEv", line: 3, isLocal: false, isDefinition: false, virtualIndex: 6, flags: DIFlagProtected | DIFlagPrototyped, isOptimized: false, scopeLine: 3, file: !4, scope: !1, type: !2)
+!0 = distinct !DISubprogram(name: "bar", linkageName: "_ZN3foo3barEv", line: 3, isLocal: false, isDefinition: false, virtualIndex: 6, flags: DIFlagProtected | DIFlagPrototyped, isOptimized: false, scopeLine: 3, file: !4, scope: !1, type: !2)
 !1 = !DIFile(filename: "/foo", directory: "bar.cpp")
 !2 = !DISubroutineType(types: !3)
 !3 = !{null}
 !4 = !DIFile(filename: "/foo", directory: "bar.cpp")
 !5 = distinct !DICompileUnit(language: DW_LANG_C99, isOptimized: true, emissionKind: FullDebug, file: !4, enums: !{}, retainedTypes: !{})
 
 define <{i32, i32}> @f1() !dbg !0 {
 ; CHECK: !dbgx ![[NUMBER:[0-9]+]]
   %r = insertvalue <{ i32, i32 }> zeroinitializer, i32 4, 1, !dbgx !1
 ; CHECK: !dbgx ![[NUMBER]]
   %e = extractvalue <{ i32, i32 }> %r, 0, !dbgx !1
   ret <{ i32, i32 }> %r
 }
 
 ; CHECK: DIFlagProtected
 !6 = !{i32 1, !"Debug Info Version", i32 3}

llvm/test/Verifier/unique-disubprogram.ll

+; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
+define i32 @_Z3foov() local_unnamed_addr !dbg !9 {
+  ret i32 5
+}
+!llvm.module.flags = !{!2}
+!llvm.dbg.cu = !{!5}
+!llvm.linker.options = !{}
+
+!2 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !6, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
+!6 = !DIFile(filename: "t.cpp", directory: "/")
+!7 = !{}
+; CHECK: function definition may only have a distinct !dbg attachment
+; CHECK: warning: ignoring invalid debug info
+!9 = !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !6, file: !6, line: 2, type: !11, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !7)
+!11 = !DISubroutineType(types: !7)