[OPENMP] Fix for ExprWithCleanups in 'omp atomic' constructs.

[ABataev]

Summary

This patch allows using of ExprWithCleanups expressions and other complex expressions in 'omp atomic' construct

[rjmccall]

You should generally not ignore surrounding expressions and statement in IRGen, and you *definitely* shouldn't IgnoreImplicit. If you want to strip off ExprWithCleanups, you should check specifically for that.

[ABataev]

John, you're right, I'll rework the patch. Actually, all other surrounding expressions are not allowed in atomics and would be filtered later, during deeper expression analysis. But generally you're right, IgnoreImplicit() is too rough.

[ABataev]

Removed a call to IgnoreImplicit() method.

[rjmccall]

Looks great, thanks.

lib/CodeGen/CGStmtOpenMP.cpp

void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
   OpenMPClauseKind Kind = OMPC_unknown;
   for (auto *C : S.clauses()) {
     // Find first clause (skip seq_cst clause, if it is first).
     if (C->getClauseKind() != OMPC_seq_cst) {
       Kind = C->getClauseKind();
       break;
     }
   }
+
+  const auto *CS =
+      S.getAssociatedStmt()->IgnoreContainers(/*IgnoreCaptured=*/true);
+  if (const auto *CE = dyn_cast<ExprWithCleanups>(CS))
+    enterFullExpression(CE);
   InlinedOpenMPRegionScopeRAII Region(*this, S);
+
   EmitOMPAtomicExpr(*this, Kind, IsSeqCst, S.getX(), S.getV(), S.getExpr(),
                     S.getLocStart());
 }
 
 void CodeGenFunction::EmitOMPTargetDirective(const OMPTargetDirective &) {
   llvm_unreachable("CodeGen for 'omp target' is not supported yet.");
 }
 
 void CodeGenFunction::EmitOMPTeamsDirective(const OMPTeamsDirective &) {
   llvm_unreachable("CodeGen for 'omp teams' is not supported yet.");
 }
 

lib/Sema/SemaOpenMP.cpp

if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write ||
             << getOpenMPClauseName(AtomicKind);
       } else {
         AtomicKind = C->getClauseKind();
         AtomicKindLoc = C->getLocStart();
       }
     }
   }
 
-  auto Body = CS->getCapturedStmt();
+  auto Body = CS->getCapturedStmt()->IgnoreImplicit();
   Expr *X = nullptr;
   Expr *V = nullptr;
   Expr *E = nullptr;
   // OpenMP [2.12.6, atomic Construct]
   // In the next expressions:
   // * x and v (as applicable) are both l-value expressions with scalar type.
   // * During the execution of an atomic region, multiple syntactic
   // occurrences of x must designate the same storage location.

test/OpenMP/atomic_codegen.cpp

+// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp=libiomp5 -fexceptions -fcxx-exceptions -x c++ -emit-llvm %s -o - | FileCheck %s
 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp=libiomp5 -fexceptions -fcxx-exceptions -gline-tables-only -x c++ -emit-llvm %s -o - | FileCheck %s --check-prefix=TERM_DEBUG
 // expected-no-diagnostics
 
 int a;
+int b;
+
+struct St {
+  St() {}
+  ~St() {}
+  int &get() { return a; }
+};
+
+// CHECK-LABEL: parallel_atomic_ewc
+void parallel_atomic_ewc() {
+#pragma omp parallel
+  {
+      // CHECK: invoke void @_ZN2StC1Ev(%struct.St* [[TEMP_ST_ADDR:%.+]])
+      // CHECK: [[SCALAR_ADDR:%.+]] = invoke dereferenceable(4) i32* @_ZN2St3getEv(%struct.St* [[TEMP_ST_ADDR]])
+      // CHECK: [[SCALAR_VAL:%.+]] = load atomic i32, i32* [[SCALAR_ADDR]] monotonic
+      // CHECK: store i32 [[SCALAR_VAL]], i32* @b
+      // CHECK: invoke void @_ZN2StD1Ev(%struct.St* [[TEMP_ST_ADDR]])
+#pragma omp atomic read
+      b = St().get();
+      // CHECK: invoke void @_ZN2StC1Ev(%struct.St* [[TEMP_ST_ADDR:%.+]])
+      // CHECK: [[SCALAR_ADDR:%.+]] = invoke dereferenceable(4) i32* @_ZN2St3getEv(%struct.St* [[TEMP_ST_ADDR]])
+      // CHECK: [[B_VAL:%.+]] = load i32, i32* @b
+      // CHECK: store atomic i32 [[B_VAL]], i32* [[SCALAR_ADDR]] monotonic
+      // CHECK: invoke void @_ZN2StD1Ev(%struct.St* [[TEMP_ST_ADDR]])
+#pragma omp atomic write
+      St().get() = b;
+    }
+}
+
 int &foo() { return a; }
 
 // TERM_DEBUG-LABEL: parallel_atomic
 void parallel_atomic() {
 #pragma omp parallel
   {
 #pragma omp atomic read
     // TERM_DEBUG-NOT: __kmpc_global_thread_num
     // TERM_DEBUG:     invoke {{.*}}foo{{.*}}()
     // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
-    // TERM_DEBUG:     load atomic i32,  i32* @{{.+}} monotonic, {{.*}}!dbg [[READ_LOC:![0-9]+]]
+    // TERM_DEBUG:     load atomic i32, i32* @{{.+}} monotonic, {{.*}}!dbg [[READ_LOC:![0-9]+]]
     foo() = a;
 #pragma omp atomic write
     // TERM_DEBUG-NOT: __kmpc_global_thread_num
     // TERM_DEBUG:     invoke {{.*}}foo{{.*}}()
     // TERM_DEBUG:     unwind label %[[TERM_LPAD:.+]],
     // TERM_DEBUG-NOT: __kmpc_global_thread_num
     // TERM_DEBUG:     store atomic i32 {{%.+}}, i32* @{{.+}} monotonic, {{.*}}!dbg [[WRITE_LOC:![0-9]+]]
     // TERM_DEBUG:     [[TERM_LPAD]]
     // TERM_DEBUG:     call void @__clang_call_terminate
     // TERM_DEBUG:     unreachable
     a = foo();
   }
 }
-// TERM_DEBUG-DAG: [[READ_LOC]] = !MDLocation(line: 11,
-// TERM_DEBUG-DAG: [[WRITE_LOC]] = !MDLocation(line: 17,
+// TERM_DEBUG-DAG: [[READ_LOC]] = !MDLocation(line: 41,
+// TERM_DEBUG-DAG: [[WRITE_LOC]] = !MDLocation(line: 47,