[CodeGen] Add to emitted DebugLoc information about coverage when it's required

[calixte]

Summary

Some lines have a hit counter where they should not have one.
Cleanup stuff is located to the last line of the body which is most of the time a '}'.
And Exception stuff is added at the beginning of a function and at the end (represented by '{' and '}').
So in such cases, the DebugLoc used in GCOVProfiling.cpp must be marked as not covered.
This patch is a followup of https://reviews.llvm.org/D49915.
Tests in projects/compiler_rt are fixed by: https://reviews.llvm.org/D49917

[dblaikie]

Test coverage?

[calixte]

• Use ImplicitCode instead of Covered
• Set Artificial location as ImplicitCode to avoid coverage on landing pads

[calixte]

• Add some ImplicitCode when there is some stuff at the end of a function
• Fix the tests

[calixte]

• only put an ImplicitCode for EmitLandingPad
• fix tests (were broken with clanf-format-diff)

[MaskRay]

@calixte This was reverted and never relanded. Is D49915 (DILocation::ImplicitCode) still needed?

lib/CodeGen/CGDebugInfo.h

public:
   llvm::MDNode *getInlinedAt() const { return CurInlinedAt; }
 
   // Converts a SourceLocation to a DebugLoc
   llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Loc);
 
   /// Emit metadata to indicate a change in line/column information in
   /// the source file. If the location is invalid, the previous
   /// location will be reused.
-  void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc);
+  /// \param ImplicitCode  True if the Loc must have coverage information
+  void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc,
+                    bool ImplicitCode = false);
 
   /// Emit a call to llvm.dbg.function.start to indicate
   /// start of a new function.
   /// \param Loc       The location of the function header.
   /// \param ScopeLoc  The location of the function body.
   void EmitFunctionStart(GlobalDecl GD, SourceLocation Loc,
                          SourceLocation ScopeLoc, QualType FnType,
                          llvm::Function *Fn, bool CurFnIsThunk,
StringRef internString(StringRef A, StringRef B = StringRef()) {
     return StringRef(Data, A.size() + B.size());
   }
 };
 
 /// A scoped helper to set the current debug location to the specified
 /// location or preferred location of the specified Expr.
 class ApplyDebugLocation {
 private:
-  void init(SourceLocation TemporaryLocation, bool DefaultToEmpty = false);
+  void init(SourceLocation TemporaryLocation, bool DefaultToEmpty = false,
+            bool ImplicitCode = false);
   ApplyDebugLocation(CodeGenFunction &CGF, bool DefaultToEmpty,
-                     SourceLocation TemporaryLocation);
+                     SourceLocation TemporaryLocation,
+                     bool ImplicitCode = false);
 
   llvm::DebugLoc OriginalLocation;
   CodeGenFunction *CGF;
 
 public:
   /// Set the location to the (valid) TemporaryLocation.
-  ApplyDebugLocation(CodeGenFunction &CGF, SourceLocation TemporaryLocation);
+  ApplyDebugLocation(CodeGenFunction &CGF, SourceLocation TemporaryLocation,
+                     bool ImplicitCode = false);
   ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E);
   ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc);
   ApplyDebugLocation(ApplyDebugLocation &&Other) : CGF(Other.CGF) {
     Other.CGF = nullptr;
   }
 
   ~ApplyDebugLocation();
 
   /// Apply TemporaryLocation if it is valid. Otherwise switch
   /// to an artificial debug location that has a valid scope, but no
   /// line information.
   ///
   /// Artificial locations are useful when emitting compiler-generated
   /// helper functions that have no source location associated with
   /// them. The DWARF specification allows the compiler to use the
   /// special line number 0 to indicate code that can not be
   /// attributed to any source location. Note that passing an empty
   /// SourceLocation to CGDebugInfo::setLocation() will result in the
   /// last valid location being reused.
   static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF) {
-    return ApplyDebugLocation(CGF, false, SourceLocation());
+    return ApplyDebugLocation(CGF, false, SourceLocation(),
+                              true /* ImplicitCode */);
   }
   /// Apply TemporaryLocation if it is valid. Otherwise switch
   /// to an artificial debug location that has a valid scope, but no
   /// line information.
   static ApplyDebugLocation
   CreateDefaultArtificial(CodeGenFunction &CGF,
                           SourceLocation TemporaryLocation) {
-    return ApplyDebugLocation(CGF, false, TemporaryLocation);
+    return ApplyDebugLocation(CGF, false, TemporaryLocation,
+                              true /* ImplicitCode */);
   }
 
   /// Set the IRBuilder to not attach debug locations.  Note that
   /// passing an empty SourceLocation to \a CGDebugInfo::setLocation()
   /// will result in the last valid location being reused.  Note that
   /// all instructions that do not have a location at the beginning of
   /// a function are counted towards to function prologue.
   static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF) {

lib/CodeGen/CGDebugInfo.cpp

 }
 
 CGDebugInfo::~CGDebugInfo() {
   assert(LexicalBlockStack.empty() &&
          "Region stack mismatch, stack not empty!");
 }
 
 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
-                                       SourceLocation TemporaryLocation)
+                                       SourceLocation TemporaryLocation,
+                                       bool ImplicitCode)
     : CGF(&CGF) {
-  init(TemporaryLocation);
+  init(TemporaryLocation, false /* DefaultToEmpty */, ImplicitCode);
 }
 
 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
                                        bool DefaultToEmpty,
-                                       SourceLocation TemporaryLocation)
+                                       SourceLocation TemporaryLocation,
+                                       bool ImplicitCode)
     : CGF(&CGF) {
-  init(TemporaryLocation, DefaultToEmpty);
+  init(TemporaryLocation, DefaultToEmpty, ImplicitCode);
 }
 
 void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
-                              bool DefaultToEmpty) {
+                              bool DefaultToEmpty, bool ImplicitCode) {
   auto *DI = CGF->getDebugInfo();
   if (!DI) {
     CGF = nullptr;
     return;
   }
 
   OriginalLocation = CGF->Builder.getCurrentDebugLocation();
 
   if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled())
     return;
 
   if (TemporaryLocation.isValid()) {
-    DI->EmitLocation(CGF->Builder, TemporaryLocation);
+    DI->EmitLocation(CGF->Builder, TemporaryLocation, ImplicitCode);
     return;
   }
 
   if (DefaultToEmpty) {
     CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
     return;
   }
 

 }
 
 void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) {
   assert(CurInlinedAt && "unbalanced inline scope stack");
   EmitFunctionEnd(Builder, nullptr);
   setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
 }
 
-void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) {
+void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc,
+                               bool ImplicitCode) {
   // Update our current location
   setLocation(Loc);
 
   if (CurLoc.isInvalid() || CurLoc.isMacroID())
     return;
 
   llvm::MDNode *Scope = LexicalBlockStack.back();
-  Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
-      getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
+  Builder.SetCurrentDebugLocation(
+      llvm::DebugLoc::get(getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope,
+                          CurInlinedAt, ImplicitCode));
 }
 
 void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
   llvm::MDNode *Back = nullptr;
   if (!LexicalBlockStack.empty())
     Back = LexicalBlockStack.back().get();
   LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
       cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder,
   CreateLexicalBlock(Loc);
 }
 
 void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder,
                                       SourceLocation Loc) {
   assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
 
   // Provide an entry in the line table for the end of the block.
-  EmitLocation(Builder, Loc);
+  EmitLocation(Builder, Loc, true /* ImplicitCode */);
 
   if (DebugKind <= codegenoptions::DebugLineTablesOnly)
     return;
 
   LexicalBlockStack.pop_back();
 }
 
 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) {
   assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
   unsigned RCount = FnBeginRegionCount.back();
   assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
 
   // Pop all regions for this function.
   while (LexicalBlockStack.size() != RCount) {
     // Provide an entry in the line table for the end of the block.
-    EmitLocation(Builder, CurLoc);
+    EmitLocation(Builder, CurLoc, true /* ImplicitCode */);
     LexicalBlockStack.pop_back();
   }
   FnBeginRegionCount.pop_back();
 
   if (Fn && Fn->getSubprogram())
     DBuilder.finalizeSubprogram(Fn->getSubprogram());
 }
 

lib/CodeGen/CodeGenFunction.h

public:
     /// cleanups.
     ~LexicalScope() {
       if (CGDebugInfo *DI = CGF.getDebugInfo())
         DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
 
       // If we should perform a cleanup, force them now.  Note that
       // this ends the cleanup scope before rescoping any labels.
       if (PerformCleanup) {
-        ApplyDebugLocation DL(CGF, Range.getEnd());
+        ApplyDebugLocation DL(CGF, Range.getEnd(), true /* ImplicitCode */);
         ForceCleanup();
       }
     }
 
     /// Force the emission of cleanups now, instead of waiting
     /// until this object is destroyed.
     void ForceCleanup() {
       CGF.CurLexicalScope = ParentScope;

lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::FinishFunction(SourceLocation EndLoc) {
   //
   // If there are multiple branches to the return block, the branch
   // instructions will get the location of the return statements and
   // all will be fine.
   if (CGDebugInfo *DI = getDebugInfo()) {
     if (OnlySimpleReturnStmts)
       DI->EmitLocation(Builder, LastStopPoint);
     else
-      DI->EmitLocation(Builder, EndLoc);
+      DI->EmitLocation(Builder, EndLoc, true /* ImplicitCode */);
   }
 
   // Pop any cleanups that might have been associated with the
   // parameters.  Do this in whatever block we're currently in; it's
   // important to do this before we enter the return block or return
   // edges will be *really* confused.
   bool HasCleanups = EHStack.stable_begin() != PrologueCleanupDepth;
   bool HasOnlyLifetimeMarkers =
       HasCleanups && EHStack.containsOnlyLifetimeMarkers(PrologueCleanupDepth);
   bool EmitRetDbgLoc = !HasCleanups || HasOnlyLifetimeMarkers;
   if (HasCleanups) {
     // Make sure the line table doesn't jump back into the body for
     // the ret after it's been at EndLoc.
     if (CGDebugInfo *DI = getDebugInfo())
       if (OnlySimpleReturnStmts)
-        DI->EmitLocation(Builder, EndLoc);
+        DI->EmitLocation(Builder, EndLoc, true /* ImplicitCode */);
 
     PopCleanupBlocks(PrologueCleanupDepth);
   }
 
   // Emit function epilog (to return).
   llvm::DebugLoc Loc = EmitReturnBlock();
 
   if (ShouldInstrumentFunction()) {
for (FunctionArgList::const_iterator i = Args.begin(), e = Args.end();
     else
       Ty = VD->getType();
 
     if (Ty->isVariablyModifiedType())
       EmitVariablyModifiedType(Ty);
   }
   // Emit a location at the end of the prologue.
   if (CGDebugInfo *DI = getDebugInfo())
-    DI->EmitLocation(Builder, StartLoc);
+    DI->EmitLocation(Builder, StartLoc, true /* ImplicitCode */);
 
   // TODO: Do we need to handle this in two places like we do with
   // target-features/target-cpu?
   if (CurFuncDecl)
     if (const auto *VecWidth = CurFuncDecl->getAttr<MinVectorWidthAttr>())
       LargestVectorWidth = VecWidth->getVectorWidth();
 }
 

test/CodeGen/debug-info-scope-file.c

 // RUN: %clang_cc1 -debug-info-kind=limited -emit-llvm < %s | FileCheck %s
 
 // Check that, just because we emitted a function from a different file doesn't
 // mean we insert a file-change inside the next function.
 
 // CHECK: ret void, !dbg [[F1_LINE:![0-9]*]]
 // CHECK: ret void, !dbg [[F2_LINE:![0-9]*]]
-// CHECK: [[F1:![0-9]*]] = distinct !DISubprogram(name: "f1",{{.*}} isDefinition: true
-// CHECK: [[F1_LINE]] = !DILocation({{.*}}, scope: [[F1]])
-// CHECK: [[F2:![0-9]*]] = distinct !DISubprogram(name: "f2",{{.*}} isDefinition: true
-// CHECK: [[F2_LINE]] = !DILocation({{.*}}, scope: [[F2]])
+// CHECK: [[F1:![0-9]*]] = distinct !DISubprogram(name: "f1",{{.*}}
+// isDefinition: true CHECK: [[F1_LINE]] = !DILocation({{.*}}, scope: [[F1]],
+// isImplicitCode: true) CHECK: [[F2:![0-9]*]] = distinct !DISubprogram(name:
+// "f2",{{.*}} isDefinition: true CHECK: [[F2_LINE]] = !DILocation({{.*}},
+// scope: [[F2]], isImplicitCode: true)
 
 void f1() {
 }
 
 # 2 "foo.c"
 
 void f2() {
 }
 

test/CodeGenCXX/debug-info-inheriting-constructor.cpp

 // CHECK-SAME: metadata ![[THIS:[0-9]+]], metadata !DIExpression()), !dbg ![[LOC:[0-9]+]]
 // CHECK: ret void, !dbg ![[NOINL:[0-9]+]]
 // CHECK: ![[FOO:.*]] = distinct !DISubprogram(name: "foo"
 // CHECK-DAG: ![[A:.*]] = distinct !DISubprogram(name: "A", linkageName: "_ZN1BCI11AEiz"
 void foo() {
 // CHECK-DAG: ![[LOC]] = !DILocation(line: 0, scope: ![[A]], inlinedAt: ![[INL:[0-9]+]])
 // CHECK-DAG: ![[INL]] = !DILocation(line: [[@LINE+1]], scope: ![[FOO]])
   B b(0);
-// CHECK: ![[NOINL]] = !DILocation(line: [[@LINE+1]], scope: !{{[0-9]+}})
+  // CHECK: ![[NOINL]] = !DILocation(line: [[@LINE+1]], scope: !{{[0-9]+}},
+  // isImplicitCode: true)
 }

test/CodeGenCXX/debug-info-nested-exprs.cpp

int a = bar(x, y) +
           qux(y, z);
   // NONEST: call i32 @{{.*}}bar{{.*}}, !dbg ![[LOC:[0-9]+]]
   // NONEST: call i32 @{{.*}}baz{{.*}}, !dbg ![[LOC]]
   // NONEST: call i32 @{{.*}}qux{{.*}}, !dbg ![[LOC]]
   // NONEST: store i32 {{.*}}, i32* %a,{{.*}} !dbg ![[LOC]]
   // NESTED: call i32 @{{.*}}bar{{.*}}, !dbg ![[BAR:[0-9]+]]
   // NESTED: call i32 @{{.*}}baz{{.*}}, !dbg ![[BAZ:[0-9]+]]
   // NESTED: call i32 @{{.*}}qux{{.*}}, !dbg ![[QUX:[0-9]+]]
-  // NESTED: store i32 {{.*}}, i32* %a,{{.*}} !dbg ![[BAR]]
   // COLUMNS: call i32 @{{.*}}bar{{.*}}, !dbg ![[BAR:[0-9]+]]
   // COLUMNS: call i32 @{{.*}}baz{{.*}}, !dbg ![[BAZ:[0-9]+]]
   // COLUMNS: call i32 @{{.*}}qux{{.*}}, !dbg ![[QUX:[0-9]+]]
   // COLUMNS: store i32 {{.*}}, i32* %a,{{.*}} !dbg ![[DECLA:[0-9]+]]
 
   int i = 1, b = 0, c = 0;
   // NONEST: store i32 1, i32* %i,{{.*}} !dbg ![[ILOC:[0-9]+]]
   // NONEST: store i32 0, i32* %b,{{.*}} !dbg ![[ILOC]]
int foo(int x, int y, int z) {
 
   int d = onearg(
       noargs());
   // NONEST: call i32 @{{.*}}noargs{{.*}}, !dbg ![[DECLD:[0-9]+]]
   // NONEST: call i32 @{{.*}}onearg{{.*}}, !dbg ![[DECLD]]
   // NONEST: store i32 %{{[^,]+}}, i32* %d,{{.*}} !dbg ![[DECLD]]
   // NESTED: call i32 @{{.*}}noargs{{.*}}, !dbg ![[DNOARGS:[0-9]+]]
   // NESTED: call i32 @{{.*}}onearg{{.*}}, !dbg ![[DECLD:[0-9]+]]
-  // NESTED: store i32 %{{[^,]+}}, i32* %d,{{.*}} !dbg ![[DECLD]]
   // COLUMNS: call i32 @{{.*}}noargs{{.*}}, !dbg ![[DNOARGS:[0-9]+]]
   // COLUMNS: call i32 @{{.*}}onearg{{.*}}, !dbg ![[DONEARG:[0-9]+]]
   // COLUMNS: store i32 %{{[^,]+}}, i32* %d,{{.*}} !dbg ![[DECLD:[0-9]+]]
   
   d = onearg(noargs());
   // NONEST: call i32 @{{.*}}noargs{{.*}}, !dbg ![[SETD:[0-9]+]]
   // NONEST: call i32 @{{.*}}onearg{{.*}}, !dbg ![[SETD]]
   // NONEST: store i32 %{{[^,]+}}, i32* %d,{{.*}} !dbg ![[SETD]]

 // NESTED: ![[DNOARGS]] = !DILocation
 // NESTED: ![[RANGEFOR]] = !DILocation(
 // NESTED-SAME: line: [[RANGEFOR_LINE:[0-9]+]]
 // NESTED: ![[RANGEFOR_BODY]] = !DILocation(
 // NESTED-SAME: line: [[RANGEFOR_LINE]]
 // NESTED: ![[RETSUB]] = !DILocation(
 // NESTED: ![[RETMUL]] = !DILocation(
 
-// COLUMNS: ![[DECLA]] = !DILocation(
 // COLUMNS: ![[BAR]] = !DILocation(
 // COLUMNS: ![[BAZ]] = !DILocation(
 // COLUMNS: ![[QUX]] = !DILocation(
+// COLUMNS: ![[DECLA]] = !DILocation(
 // COLUMNS: ![[ILOC]] = !DILocation(
 // COLUMNS: ![[BLOC]] = !DILocation(
 // COLUMNS: ![[CLOC]] = !DILocation(
-// COLUMNS: ![[DECLD]] = !DILocation(
 // COLUMNS: ![[DNOARGS]] = !DILocation(
 // COLUMNS: ![[DONEARG]] = !DILocation(
+// COLUMNS: ![[DECLD]] = !DILocation(
 // COLUMNS: ![[SETDNOARGS]] = !DILocation(
 // COLUMNS: ![[SETDONEARG]] = !DILocation(
 // COLUMNS: ![[SETD]] = !DILocation(
 // COLUMNS: ![[RANGEFOR_NOARGS]] = !DILocation(
 // COLUMNS: ![[RANGEFOR_RANGE]] = !DILocation(
 // COLUMNS: ![[RANGEFOR_BODY]] = !DILocation(
 // COLUMNS: ![[ANDLHS]] = !DILocation
 // COLUMNS: ![[ANDRHS]] = !DILocation
 // COLUMNS: ![[AND_CREATE]] = !DILocation
 // COLUMNS: ![[AND_FUNC]] = !DILocation
 // COLUNMS: ![[RETSUB]] = !DILocation(
 // COLUMNS: ![[RETMUL]] = !DILocation(

test/CodeGenCXX/linetable-virtual-variadic.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -debug-info-kind=line-tables-only %s -o - | FileCheck %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -debug-info-kind=line-directives-only %s -o - | FileCheck %s
 // Crasher for PR22929.
 class Base {
   virtual void VariadicFunction(...);
 };
 
 class Derived : public virtual Base {
   virtual void VariadicFunction(...);
 };
 
 void Derived::VariadicFunction(...) { }
 
-// CHECK: define void @_ZN7Derived16VariadicFunctionEz({{.*}} !dbg ![[SP:[0-9]+]]
-// CHECK: ret void, !dbg ![[LOC:[0-9]+]]
-// CHECK: define void @_ZT{{.+}}N7Derived16VariadicFunctionEz({{.*}} !dbg ![[SP_I:[0-9]+]]
-// CHECK: ret void, !dbg ![[LOC_I:[0-9]+]]
+// CHECK: define void @_ZN7Derived16VariadicFunctionEz({{.*}} !dbg
+// ![[SP:[0-9]+]] CHECK: ret void, !dbg ![[LOC:[0-9]+]] CHECK: define void
+// @_ZT{{.+}}N7Derived16VariadicFunctionEz({{.*}} !dbg ![[SP_I:[0-9]+]] CHECK:
+// ret void, !dbg ![[LOC_I:[0-9]+]]
 //
 // CHECK: ![[SP]] = distinct !DISubprogram(name: "VariadicFunction"
-// CHECK: ![[LOC]] = !DILocation({{.*}}scope: ![[SP]])
+// CHECK: ![[LOC]] = !DILocation({{.*}}scope: ![[SP]], isImplicitCode: true)
 // CHECK: ![[SP_I]] = distinct !DISubprogram(name: "VariadicFunction"
-// CHECK: ![[LOC_I]] = !DILocation({{.*}}scope: ![[SP_I]])
+// CHECK: ![[LOC_I]] = !DILocation({{.*}}scope: ![[SP_I]], isImplicitCode: true)

test/CodeGenObjC/arc-linetable.m

 @implementation AppDelegate : NSObject
 
 // CHECK: ![[TESTNOSIDEEFFECT:.*]] = distinct !DISubprogram(name: "-[AppDelegate testNoSideEffect:]"
 // CHECK-SAME:                                              line: [[@LINE+2]]
 // CHECK-SAME:                                              isLocal: true, isDefinition: true
 - (int)testNoSideEffect:(NSString *)foo {
   int x = 1;
   return 1; // Return expression
-  // CHECK: ![[RET1]] = !DILocation(line: [[@LINE+1]], scope: ![[TESTNOSIDEEFFECT]])
+  // CHECK: ![[RET1]] = !DILocation(line: [[@LINE+1]], scope:
+  // ![[TESTNOSIDEEFFECT]], isImplicitCode: true)
 }           // Cleanup + Ret
 
 - (int)testNoCleanup {
   // CHECK: ![[RET2]] = !DILocation(line: [[@LINE+1]], scope: !{{.*}})
   return 1;
 }
 
 - (int)testSideEffect:(NSString *)foo {

test/CodeGenObjC/debug-info-blocks.m

 // Test that we do emit scope info for the helper functions, and that the
 // parameters to these functions are marked as artificial (so the debugger
 // doesn't accidentally step into the function).
 // CHECK: define {{.*}} @__copy_helper_block_{{.*}}(i8*, i8*)
 // CHECK-NOT: ret
 // CHECK: call {{.*}}, !dbg ![[DBG_LINE:[0-9]+]]
 // CHECK-NOT: ret
 // CHECK: load {{.*}}, !dbg ![[COPY_LINE:[0-9]+]]
-// CHECK: ret void, !dbg ![[COPY_LINE]]
 // CHECK: define {{.*}} @__destroy_helper_block_{{.*}}(i8*)
 // CHECK-NOT: ret
 // CHECK: load {{.*}}, !dbg ![[DESTROY_LINE:[0-9]+]]
-// CHECK: ret void, !dbg ![[DESTROY_LINE]]
 
 typedef unsigned int NSUInteger;
 
 @protocol NSObject
 @end  
    
 @interface NSObject <NSObject>
 - (id)init;