From 9648288c3804cd4ab6c42bb7115801b6ddc8365b Mon Sep 17 00:00:00 2001 From: John McCall Date: Mon, 31 Oct 2016 21:56:26 +0000 Subject: [PATCH] A compound literal within a global lambda or block is still within the body of a function for the purposes of computing its storage duration and deciding whether its initializer must be constant. There are a number of problems in our current treatment of compound literals. C specifies that a compound literal yields an l-value referring to an object with either static or automatic storage duration, depending on where it was written; in the latter case, the literal object has a lifetime tied to the enclosing scope (much like an ObjC block), not the enclosing full-expression. To get these semantics fully correct in our current design, we would need to collect compound literals on the ExprWithCleanups, just like we do with ObjC blocks; we would probably also want to identify literals like we do with materialized temporaries. But it gets stranger; GCC adds compound literals to C++ as an extension, but makes them r-values, which are generally assumed to have temporary storage duration. Ignoring destructor ordering, the difference only matters if the object's address escapes the full-expression, which for an r-value can only happen with reference binding (which extends temporaries) or array-to-pointer decay (which does not). GCC then attempts to lock down on array-to-pointer decay in ad hoc ways. Arguably a far superior language solution for C++ (and perhaps even array r-values in C, which can occur in other ways) would be to propagate lifetime extension through array-to-pointer decay, so that initializing a pointer object to a decayed r-value array extends the lifetime of the complete object containing the array. But this would be a major change in semantics which arguably ought to be blessed by the committee(s). Anyway, I'm not fixing any of that in this patch; I did try, but it got out of hand. Fixes rdar://28949016. llvm-svn: 285643 --- clang/lib/Sema/SemaExpr.cpp | 2 +- clang/test/CodeGenCXX/compound-literals.cpp | 8 ++++++++ clang/test/Sema/compound-literal.c | 8 +++++++- clang/test/SemaCXX/compound-literal.cpp | 10 ++++++++++ 4 files changed, 26 insertions(+), 2 deletions(-) diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index d6c8413..fdb5fb5 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -5572,7 +5572,7 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, return ExprError(); LiteralExpr = Result.get(); - bool isFileScope = getCurFunctionOrMethodDecl() == nullptr; + bool isFileScope = !CurContext->isFunctionOrMethod(); if (isFileScope && !LiteralExpr->isTypeDependent() && !LiteralExpr->isValueDependent() && diff --git a/clang/test/CodeGenCXX/compound-literals.cpp b/clang/test/CodeGenCXX/compound-literals.cpp index 69632a7..1e525e2 100644 --- a/clang/test/CodeGenCXX/compound-literals.cpp +++ b/clang/test/CodeGenCXX/compound-literals.cpp @@ -55,3 +55,11 @@ union PR21912Ty { union PR21912Ty *PR21912_2 = (union PR21912Ty[]){{.d = 2.0}, {.l = 3}}; // CHECK-LABEL: define {{.*}}__cxx_global_var_init.3() // CHECK: store %union.PR21912Ty* getelementptr inbounds ([2 x %union.PR21912Ty], [2 x %union.PR21912Ty]* bitcast (<{ { double }, %union.PR21912Ty }>* @.compoundliteral.4 to [2 x %union.PR21912Ty]*), i32 0, i32 0), %union.PR21912Ty** @PR21912_2 + +// This compound literal should have local scope. +int computed_with_lambda = [] { + int *array = (int[]) { 1, 3, 5, 7 }; + return array[0]; +}(); +// CHECK-LABEL: define internal i32 @{{.*}}clEv +// CHECK: alloca [4 x i32] diff --git a/clang/test/Sema/compound-literal.c b/clang/test/Sema/compound-literal.c index c5c0c17..217dbed 100644 --- a/clang/test/Sema/compound-literal.c +++ b/clang/test/Sema/compound-literal.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s +// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -pedantic %s // REQUIRES: LP64 struct foo { int a, b; }; @@ -36,3 +36,9 @@ void IncompleteFunc(unsigned x) { // PR6080 int array[(sizeof(int[3]) == sizeof( (int[]) {0,1,2} )) ? 1 : -1]; + +// rdar://28949016 - Constant restriction should not apply to compound literals in blocks +int (^block)(int) = ^(int i) { + int *array = (int[]) {i, i + 2, i + 4}; + return array[i]; +}; diff --git a/clang/test/SemaCXX/compound-literal.cpp b/clang/test/SemaCXX/compound-literal.cpp index 3fc6150..5480b1f 100644 --- a/clang/test/SemaCXX/compound-literal.cpp +++ b/clang/test/SemaCXX/compound-literal.cpp @@ -86,3 +86,13 @@ int PR17415 = (int){PR17415}; // expected-error {{initializer element is not a c template struct Value { }; template int &check_narrowed(Value); + +#if __cplusplus >= 201103L +// Compound literals in global lambdas have automatic storage duration +// and are not subject to the constant-initialization rules. +int computed_with_lambda = [] { + int x = 5; + int result = ((int[]) { x, x + 2, x + 4, x + 6 })[0]; + return result; +}(); +#endif -- 2.7.4