DebugInfo: Blocks: Do not depend on LLVM argument numbering when choosing the debug info argument numbering.

Due to the possible presence of return-by-out parameters, using the LLVM
argument number count when numbering debug info arguments can end up
off-by-one. This could produce two arguments with the same number, which
would in turn cause LLVM to emit only one of those arguments (whichever
it found last) or assert (r215157).

llvm-svn: 215227

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -2947,6 +2947,7 @@ namespace {
 
 void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
                                                        llvm::Value *Arg,
+                                                       unsigned ArgNo,
                                                        llvm::Value *LocalAddr,
                                                        CGBuilderTy &Builder) {
   assert(DebugKind >= CodeGenOptions::LimitedDebugInfo);
@@ -3078,7 +3079,7 @@ void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
                                  llvm::DIDescriptor(scope),
                                  Arg->getName(), tunit, line, type,
                                  CGM.getLangOpts().Optimize, flags,
-                                 cast<llvm::Argument>(Arg)->getArgNo() + 1);
+                                 ArgNo);
 
   if (LocalAddr) {
     // Insert an llvm.dbg.value into the current block.

clang/lib/CodeGen/CGDebugInfo.h

@@ -266,7 +266,7 @@ public:
   /// llvm.dbg.declare for the block-literal argument to a block
   /// invocation function.
   void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block,
-                                            llvm::Value *Arg,
+                                            llvm::Value *Arg, unsigned ArgNo,
                                             llvm::Value *LocalAddr,
                                             CGBuilderTy &Builder);
 

clang/lib/CodeGen/CGDecl.cpp

@@ -1634,7 +1634,8 @@ void CodeGenFunction::EmitParmDecl(const VarDecl &D, llvm::Value *Arg,
         if (CGM.getCodeGenOpts().getDebugInfo()
               >= CodeGenOptions::LimitedDebugInfo) {
           DI->setLocation(D.getLocation());
-          DI->EmitDeclareOfBlockLiteralArgVariable(*BlockInfo, Arg, LocalAddr, Builder);
+          DI->EmitDeclareOfBlockLiteralArgVariable(*BlockInfo, Arg, ArgNo,
+                                                   LocalAddr, Builder);
         }
       }
 

clang/test/CodeGen/debug-info-block-out-return.c

@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -g -fblocks -emit-llvm -o - %s | FileCheck %s
+
+// Check that arg numbering is not affected by LLVM IR argument numbering -
+// since the latter is affected by return-by-out-parameter ABI requirements
+
+// 1 for the argument number (1 indexed), 2 for the line number
+// 16777218 == 1 << 24 | 2
+// 33554434 == 2 << 24 | 2
+// This explains the two magic numbers below, testing that these two arguments
+// are numbered correctly. If they are not numbered correctly they may appear
+// out of order or not at all (the latter would occur if they were both assigned
+// the same argument number by mistake).
+
+// CHECK: metadata !".block_descriptor", metadata !{{[0-9]*}}, i32 16777218, {{.*}} ; [ DW_TAG_arg_variable ] [.block_descriptor]
+// CHECK: metadata !"param", metadata !{{[0-9]*}}, i32 33554434, {{.*}} ; [ DW_TAG_arg_variable ] [param]
+
+// Line directive so we don't have to worry about how many lines preceed the
+// test code (as the line number is mangled in with the argument number as shown
+// above)
+#line 1
+typedef struct { int array[12]; } BigStruct_t;
+BigStruct_t (^a)() = ^(int param) {
+    BigStruct_t b;
+    return b;
+};