[SemaCXX] _Pragma("clang optimize off") not affecting lambda.

[CarlosAlbertoEnciso]

Summary

Declaring "_Pragma("clang optimize off")" before the body of a
function with a lambda leads to the lambda functions in the body
not being affected.

For the below test:

_Pragma("clang optimize off")

void foo(int p) {
  auto lambda = [&p]() { ++p; };
  lambda();
}

_Pragma("clang optimize on")

At -O1 the attributes for the 'foo' function are:

attributes #0 = { noinline nounwind optnone uwtable ... }

At -O1 the attributes for the lambda function are:

attributes #1 = { inlinehint norecurse nounwind uwtable ... }

The incorrect attribute causes the lambda function to be considered
for inlining ignoring the given _Pragma.

[CarlosAlbertoEnciso]

Ping.

Thanks

[erichkeane]

lib/Sema/SemaDecl.cpp

12598

Should thi sonly happen if this is a definition? Additionally, does this negate the need for the other call to this in ActOnFunctionDeclarator?

[CarlosAlbertoEnciso]

lib/Sema/SemaDecl.cpp

12598

First of all, thanks for your review.

Based on your comments, I found couple of issues with my patch:

For a normal function, the setting of the 'optnone' attribute was done twice:
ActOnFunctionDeclarator and ActOnFinishFunctionBody.

The setting of the 'optnone' attribute is not consistent for both lambda and
normal functions. For normal functions being done at the start of the definition
and for lambdas at the end of the function body.

Based on the previous findings, now I am setting the 'optnone' attribute in
ActOnStartOfLambdaDefinition.

I will update the patch to reflect the changes.

[CarlosAlbertoEnciso]

Correct the issues raised by the reviews.

[CarlosAlbertoEnciso]

Ping.

Thanks

[CarlosAlbertoEnciso]

Ping.

Thanks

[CarlosAlbertoEnciso]

Thanks @erichkeane for your review.

lib/Sema/SemaDecl.cpp

Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
 
   if (getLangOpts().CoroutinesTS && getCurFunction()->isCoroutine())
     CheckCompletedCoroutineBody(FD, Body);
 
   if (FD) {
     FD->setBody(Body);
     FD->setWillHaveBody(false);
 
+    // This represents the function body for the lambda function, check if we
+    // have to apply optnone due to a pragma.
+    AddRangeBasedOptnone(FD);
+
     if (getLangOpts().CPlusPlus14) {
       if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
           FD->getReturnType()->isUndeducedType()) {
         // If the function has a deduced result type but contains no 'return'
         // statements, the result type as written must be exactly 'auto', and
         // the deduced result type is 'void'.
         if (!FD->getReturnType()->getAs<AutoType>()) {
           Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)

test/CodeGenCXX/optnone-pragma-optimize-off.cpp

+// RUN: %clang_cc1 %s -triple %itanium_abi_triple -O1 -disable-llvm-passes -emit-llvm -o - | FileCheck %s
+
+// Test the attributes for the lambda function contains 'optnone' as result of
+// the _Pragma("clang optimize off").
+
+_Pragma("clang optimize off")
+
+void foo(int p) {
+  auto lambda = [&p]() { ++p; };
+  lambda();
+  // CHECK: define {{.*}} @"_ZZ3fooiENK3$_0clEv"({{.*}}) #[[LAMBDA_ATR:[0-9]+]]
+}
+
+_Pragma("clang optimize on")
+
+// CHECK: attributes #[[LAMBDA_ATR]] = { {{.*}} optnone {{.*}} }