[DEBUG INFO] Source correlation for lambda captured values.

[ABataev]

Summary

When variables are implicitly captured in lambdas, debug info generated for captured variables points to location where they are used first. This patch makes debug info to point to capture default location:

extern "C" int printf(const char *, ...);

template<typename F> void invoke( const F& f ) {
    f();
}

int main () {
    int apple = 0;
    int banana = 1;
    int cherry = 2;
    invoke( 

 13.       [=]{
 14.           printf("apple = %d\n",apple);
 15.           printf("banana = %d\n",banana);
 16.           printf("cherry = %d\n",cherry);
            }

     );
    return 0;
}

Clang is generating the following code for preparing the "invoke" parameter, which is the lambda:

%0 = getelementptr inbounds %class.anon, %class.anon* %ref.tmp, i32 0, i32 0, !dbg !40
%1 = load i32, i32* %apple, align 4, !dbg !41
store i32 %1, i32* %0, align 4, !dbg !40
%2 = getelementptr inbounds %class.anon, %class.anon* %ref.tmp, i32 0, i32 1, !dbg !40
%3 = load i32, i32* %banana, align 4, !dbg !42
store i32 %3, i32* %2, align 4, !dbg !40
%4 = getelementptr inbounds %class.anon, %class.anon* %ref.tmp, i32 0, i32 2, !dbg !40
%5 = load i32, i32* %cherry, align 4, !dbg !43
store i32 %5, i32* %4, align 4, !dbg !40

!39 = !DILocation(line: 10, column: 9, scope: !4)
!40 = !DILocation(line: 13, column: 9, scope: !4)
!41 = !DILocation(line: 14, column: 35, scope: !4)
!42 = !DILocation(line: 15, column: 36, scope: !4)
!43 = !DILocation(line: 16, column: 36, scope: !4)

Notice that both the GEP and the store are associated with line 13 (as expected), however the loads are associated with lines 14,15,16.
We expect these loads to be associated with line 13.

Notice that if the code was like this:

13.       [apple, banana, cherry]{
14.           printf("apple = %d\n",apple);
15.           printf("banana = %d\n",banana);
16.           printf("cherry = %d\n",cherry);
           }

Then the loads would be associated with line 13.

[echristo]

How about:

13. [apple,
14. banana,
15. cherry]{
16. printf("apple = %d\n",apple);
17. printf("banana = %d\n",banana);
18. printf("cherry = %d\n",cherry);

Should be 13, 14, 15 yes?

-eric

[ABataev]

Yes, you're right, and it will be 13, 14, 15. It is implemented already
and this patch does not break this.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

25.08.2015 9:00, Eric Christopher пишет:

echristo added a comment.

How about:

13. [apple,
14. banana,
15. cherry]{
16. printf("apple = %d\n",apple);
17. printf("banana = %d\n",banana);
18. printf("cherry = %d\n",cherry);

Should be 13, 14, 15 yes?

-eric

http://reviews.llvm.org/D12134

[cfe-commits]

Looks like the initial mail didn't hit the mailing list? Does someone want
to restart this review and/or forward that initial mail with the
patch/description/etc?

• msg-1928-529.txt159 BDownload

[dblaikie]

Hmm, my mistake, it did - my mail client's just not threaded it together
for some reason. :/

lib/Sema/SemaLambda.cpp

= CXXConversionDecl::Create(S.Context, Class, Loc,
                                 /*isConstexpr=*/false, 
                                 CallOperator->getBody()->getLocEnd());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
   Class->addDecl(Conversion);
 }
 
 static ExprResult performLambdaVarCaptureInitialization(
-    Sema &S, LambdaScopeInfo::Capture &Capture,
-    FieldDecl *Field,
+    Sema &S, LambdaScopeInfo::Capture &Capture, FieldDecl *Field,
     SmallVectorImpl<VarDecl *> &ArrayIndexVars,
-    SmallVectorImpl<unsigned> &ArrayIndexStarts) {
+    SmallVectorImpl<unsigned> &ArrayIndexStarts, bool ImplicitCapture,
+    SourceLocation CaptureDefaultLoc) {
   assert(Capture.isVariableCapture() && "not a variable capture");
 
   auto *Var = Capture.getVariable();
   SourceLocation Loc = Capture.getLocation();
 
   // C++11 [expr.prim.lambda]p21:
   //   When the lambda-expression is evaluated, the entities that
   //   are captured by copy are used to direct-initialize each
   //   corresponding non-static data member of the resulting closure
   //   object. (For array members, the array elements are
   //   direct-initialized in increasing subscript order.) These
   //   initializations are performed in the (unspecified) order in
   //   which the non-static data members are declared.
       
   // C++ [expr.prim.lambda]p12:
   //   An entity captured by a lambda-expression is odr-used (3.2) in
   //   the scope containing the lambda-expression.
   ExprResult RefResult = S.BuildDeclarationNameExpr(
-      CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
+      CXXScopeSpec(),
+      DeclarationNameInfo(Var->getDeclName(),
+                          ImplicitCapture ? CaptureDefaultLoc : Loc),
+      Var);
   if (RefResult.isInvalid())
     return ExprError();
   Expr *Ref = RefResult.get();
 
   QualType FieldType = Field->getType();
 
   // When the variable has array type, create index variables for each
   // dimension of the array. We use these index variables to subscript
for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
 
       VarDecl *Var = From.getVariable();
       LambdaCaptureKind Kind = From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
       Captures.push_back(LambdaCapture(From.getLocation(), IsImplicit, Kind,
                                        Var, From.getEllipsisLoc()));
       Expr *Init = From.getInitExpr();
       if (!Init) {
         auto InitResult = performLambdaVarCaptureInitialization(
-            *this, From, *CurField, ArrayIndexVars, ArrayIndexStarts);
+            *this, From, *CurField, ArrayIndexVars, ArrayIndexStarts,
+            CaptureDefault != LCD_None, CaptureDefaultLoc);
         if (InitResult.isInvalid())
           return ExprError();
         Init = InitResult.get();
       } else {
         ArrayIndexStarts.push_back(ArrayIndexVars.size());
       }
       CaptureInits.push_back(Init);
     }

test/CodeGenCXX/debug-lambda-expressions.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10.0.0 -emit-llvm -o - %s -fexceptions -std=c++11 -g | FileCheck %s
 
 auto var = [](int i) { return i+1; };
 void *use = &var;
 
 extern "C" auto cvar = []{};
 
 int a() { return []{ return 1; }(); }
 
 int b(int x) { return [x]{return x;}(); }
 
 int c(int x) { return [&x]{return x;}(); }
 
 struct D { D(); D(const D&); int x; };
 int d(int x) { D y[10]; return [x,y] { return y[x].x; }(); }
 
+// CHECK-LABEL: foo
+int foo(int x) {
+// CHECK: [[X:%.+]] = alloca i32,
+// CHECK: call void @llvm.dbg.declare(
+// CHECK: [[X_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* %{{.+}}, i32 0, i32 0, !dbg ![[DBG_FOO:[0-9]+]]
+// CHECK: [[X_VAL:%.+]] = load i32, i32* [[X]], align 4, !dbg ![[DBG_FOO]]
+// CHECK: store i32 [[X_VAL]], i32* [[X_REF]], align 4, !dbg ![[DBG_FOO]]
+// CHECK: call i32 @{{.+}}, !dbg ![[DBG_FOO]]
+  return [=] {
+    return x;
+  }();
+}
+
 // Randomness for file. -- 6
 // CHECK: [[FILE:.*]] = !DIFile(filename: "{{.*}}debug-lambda-expressions.cpp",
 
 // CHECK: ![[INT:[0-9]+]] = !DIBasicType(name: "int"
 
 // A: 10
 // CHECK: ![[A_FUNC:.*]] = !DISubprogram(name: "a"{{.*}}, line: [[A_LINE:[0-9]+]]{{.*}}, isDefinition: true
 

 // VAR:
 // CHECK: !DIGlobalVariable(name: "var"
 // CHECK-SAME:              line: [[VAR_LINE:[0-9]+]]
 // CHECK-SAME:              type: ![[VAR_T:[0-9]+]]
 // CHECK: ![[VAR_T]] = !DICompositeType(tag: DW_TAG_class_type
 // CHECK-SAME:                          line: [[VAR_LINE]],
 // CHECK-SAME:                          elements: ![[VAR_ARGS:[0-9]+]]
 // CHECK: ![[VAR_ARGS]] = !{!{{[0-9]+}}}
+
+// CHECK: [[DBG_FOO:![0-9]+]] = !DILocation(line: 25,