From: Ali Tamur <tamur@google.com>
Date: Tue, 16 Jul 2019 03:20:15 +0000 (+0000)
Subject: Revert "[OPENMP]Add support for analysis of if clauses."
X-Git-Tag: llvmorg-10-init~243
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e7e8789a632f3dcd029b0f78230e61773bdb3586;p=platform%2Fupstream%2Fllvm.git

Revert "[OPENMP]Add support for analysis of if clauses."

This reverts commit rL366068.
The patch broke 86 tests under clang/test/OpenMP/ when run with address sanitizer.

llvm-svn: 366169
---

diff --git a/clang/include/clang/AST/OpenMPClause.h b/clang/include/clang/AST/OpenMPClause.h
index eadcc62..c6daf73a 100644
--- a/clang/include/clang/AST/OpenMPClause.h
+++ b/clang/include/clang/AST/OpenMPClause.h
@@ -501,10 +501,11 @@ public:
     return const_child_range(&Condition, &Condition + 1);
   }
 
-  child_range used_children();
+  child_range used_children() {
+    return child_range(child_iterator(), child_iterator());
+  }
   const_child_range used_children() const {
-    auto Children = const_cast<OMPIfClause *>(this)->used_children();
-    return const_child_range(Children.begin(), Children.end());
+    return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const OMPClause *T) {
diff --git a/clang/lib/AST/OpenMPClause.cpp b/clang/lib/AST/OpenMPClause.cpp
index 9d8a7eb..41520b3 100644
--- a/clang/lib/AST/OpenMPClause.cpp
+++ b/clang/lib/AST/OpenMPClause.cpp
@@ -209,25 +209,6 @@ const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C)
   return nullptr;
 }
 
-/// Gets the address of the original, non-captured, expression used in the
-/// clause as the preinitializer.
-static Stmt **getAddrOfExprAsWritten(Stmt *S) {
-  if (!S)
-    return nullptr;
-  if (auto *DS = dyn_cast<DeclStmt>(S)) {
-    assert(DS->isSingleDecl() && "Only single expression must be captured.");
-    if (auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl()))
-      return OED->getInitAddress();
-  }
-  return nullptr;
-}
-
-OMPClause::child_range OMPIfClause::used_children() {
-  if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
-    return child_range(C, C + 1);
-  return child_range(&Condition, &Condition + 1);
-}
-
 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
                                            unsigned NumLoops,
                                            SourceLocation StartLoc,
diff --git a/clang/test/Analysis/cfg-openmp.cpp b/clang/test/Analysis/cfg-openmp.cpp
index b608606..2f734d1 100644
--- a/clang/test/Analysis/cfg-openmp.cpp
+++ b/clang/test/Analysis/cfg-openmp.cpp
@@ -1,402 +1,340 @@
-// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp | FileCheck %s
 
 // CHECK-LABEL:  void xxx(int argc)
 void xxx(int argc) {
 // CHECK:        [B1]
 // CHECK-NEXT:   1: int x;
-// CHECK-NEXT:   2: int cond;
-  int x, cond;
-// CHECK-NEXT:   [[#ATOM:]]: x
-// CHECK-NEXT:   [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:   [[#ATOM+2]]: argc
-// CHECK-NEXT:   [[#ATOM+3]]: [B1.[[#ATOM+2]]] = [B1.[[#ATOM+1]]]
-// CHECK-NEXT:   [[#ATOM+4]]: #pragma omp atomic read
-// CHECK-NEXT:   [B1.[[#ATOM+3]]];
+  int x;
+// CHECK-NEXT:   2: x
+// CHECK-NEXT:   3: [B1.2] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:   4: argc
+// CHECK-NEXT:   5: [B1.4] = [B1.3]
+// CHECK-NEXT:   6: #pragma omp atomic read
+// CHECK-NEXT:    [B1.5];
 #pragma omp atomic read
   argc = x;
-// CHECK-NEXT:   [[#CRIT:]]: x
-// CHECK-NEXT:   [[#CRIT+1]]: [B1.[[#CRIT]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:   [[#CRIT+2]]: argc
-// CHECK-NEXT:   [[#CRIT+3]]: [B1.[[#CRIT+2]]] = [B1.[[#CRIT+1]]]
-// CHECK-NEXT:   [[#CRIT+4]]: #pragma omp critical
-// CHECK-NEXT:   [B1.[[#CRIT+3]]];
+// CHECK-NEXT:   7: x
+// CHECK-NEXT:   8: [B1.7] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:   9: argc
+// CHECK-NEXT:  10: [B1.9] = [B1.8]
+// CHECK-NEXT:  11: #pragma omp critical
+// CHECK-NEXT:    [B1.10];
 #pragma omp critical
   argc = x;
-// CHECK-NEXT:  [[#DPF:]]: x
-// CHECK-NEXT:  [[#DPF+1]]: [B1.[[#DPF]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#DPF+2]]: argc
-// CHECK-NEXT:  [[#DPF+3]]: [B1.[[#DPF+2]]] = [B1.[[#DPF+1]]]
-// CHECK-NEXT:  [[#DPF+4]]: cond
-// CHECK-NEXT:  [[#DPF+5]]: [B1.[[#DPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#DPF+6]]: [B1.[[#DPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#DPF+7]]: #pragma omp distribute parallel for if(parallel: cond)
+// CHECK-NEXT:  12: x
+// CHECK-NEXT:  13: [B1.12] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  14: argc
+// CHECK-NEXT:  15: [B1.14] = [B1.13]
+// CHECK-NEXT:  16: #pragma omp distribute parallel for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#DPF+3]]];
-#pragma omp distribute parallel for if(parallel:cond)
+// CHECK-NEXT:        [B1.15];
+#pragma omp distribute parallel for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#DPFS:]]: x
-// CHECK-NEXT:  [[#DPFS+1]]: [B1.[[#DPFS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#DPFS+2]]: argc
-// CHECK-NEXT:  [[#DPFS+3]]: [B1.[[#DPFS+2]]] = [B1.[[#DPFS+1]]]
-// CHECK-NEXT:  [[#DPFS+4]]: cond
-// CHECK-NEXT:  [[#DPFS+5]]: [B1.[[#DPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#DPFS+6]]: [B1.[[#DPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#DPFS+7]]: #pragma omp distribute parallel for simd if(cond)
+// CHECK-NEXT:  17: x
+// CHECK-NEXT:  18: [B1.17] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  19: argc
+// CHECK-NEXT:  20: [B1.19] = [B1.18]
+// CHECK-NEXT:  21: #pragma omp distribute parallel for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#DPFS+3]]];
-#pragma omp distribute parallel for simd if(cond)
+// CHECK-NEXT:        [B1.20];
+#pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#DS:]]: x
-// CHECK-NEXT:  [[#DS+1]]: [B1.[[#DS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#DS+2]]: argc
-// CHECK-NEXT:  [[#DS+3]]: [B1.[[#DS+2]]] = [B1.[[#DS+1]]]
-// CHECK-NEXT:  [[#DS+4]]: #pragma omp distribute simd
+// CHECK-NEXT:  22: x
+// CHECK-NEXT:  23: [B1.22] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  24: argc
+// CHECK-NEXT:  25: [B1.24] = [B1.23]
+// CHECK-NEXT:  26: #pragma omp distribute simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#DS+3]]];
+// CHECK-NEXT:        [B1.25];
 #pragma omp distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#FOR:]]: x
-// CHECK-NEXT:  [[#FOR+1]]: [B1.[[#FOR]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#FOR+2]]: argc
-// CHECK-NEXT:  [[#FOR+3]]: [B1.[[#FOR+2]]] = [B1.[[#FOR+1]]]
-// CHECK-NEXT:  [[#FOR+4]]: #pragma omp for
+// CHECK-NEXT:  27: x
+// CHECK-NEXT:  28: [B1.27] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  29: argc
+// CHECK-NEXT:  30: [B1.29] = [B1.28]
+// CHECK-NEXT:  31: #pragma omp for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#FOR+3]]];
+// CHECK-NEXT:        [B1.30];
 #pragma omp for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#FS:]]: x
-// CHECK-NEXT:  [[#FS+1]]: [B1.[[#FS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#FS+2]]: argc
-// CHECK-NEXT:  [[#FS+3]]: [B1.[[#FS+2]]] = [B1.[[#FS+1]]]
-// CHECK-NEXT:  [[#FS+4]]: #pragma omp for simd
+// CHECK-NEXT:  32: x
+// CHECK-NEXT:  33: [B1.32] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  34: argc
+// CHECK-NEXT:  35: [B1.34] = [B1.33]
+// CHECK-NEXT:  36: #pragma omp for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#FS+3]]];
+// CHECK-NEXT:        [B1.35];
 #pragma omp for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#MASTER:]]: x
-// CHECK-NEXT:  [[#MASTER+1]]: [B1.[[#MASTER]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#MASTER+2]]: argc
-// CHECK-NEXT:  [[#MASTER+3]]: [B1.[[#MASTER+2]]] = [B1.[[#MASTER+1]]]
-// CHECK-NEXT:  [[#MASTER+4]]: #pragma omp master
-// CHECK-NEXT:    [B1.[[#MASTER+3]]];
+// CHECK-NEXT:  37: x
+// CHECK-NEXT:  38: [B1.37] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  39: argc
+// CHECK-NEXT:  40: [B1.39] = [B1.38]
+// CHECK-NEXT:  41: #pragma omp master
+// CHECK-NEXT:    [B1.40];
 #pragma omp master
   argc = x;
-// CHECK-NEXT:  [[#ORD:]]: x
-// CHECK-NEXT:  [[#ORD+1]]: [B1.[[#ORD]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#ORD+2]]: argc
-// CHECK-NEXT:  [[#ORD+3]]: [B1.[[#ORD+2]]] = [B1.[[#ORD+1]]]
-// CHECK-NEXT:  [[#ORD+4]]: #pragma omp ordered
-// CHECK-NEXT:    [B1.[[#ORD+3]]];
-// CHECK-NEXT:  [[#ORD+5]]: #pragma omp for ordered
+// CHECK-NEXT:  42: x
+// CHECK-NEXT:  43: [B1.42] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  44: argc
+// CHECK-NEXT:  45: [B1.44] = [B1.43]
+// CHECK-NEXT:  46: #pragma omp ordered
+// CHECK-NEXT:    [B1.45];
+// CHECK-NEXT:  47: #pragma omp for ordered
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i) {
-// CHECK-NEXT:[B1.[[#ORD+4]]]    }
+// CHECK-NEXT:[B1.46]    }
 #pragma omp for ordered
   for (int i = 0; i < 10; ++i) {
 #pragma omp ordered
     argc = x;
   }
-// CHECK-NEXT:  [[#PF:]]: x
-// CHECK-NEXT:  [[#PF+1]]: [B1.[[#PF]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PF+2]]: argc
-// CHECK-NEXT:  [[#PF+3]]: [B1.[[#PF+2]]] = [B1.[[#PF+1]]]
-// CHECK-NEXT:  [[#PF+4]]: cond
-// CHECK-NEXT:  [[#PF+5]]: [B1.[[#PF+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PF+6]]: [B1.[[#PF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#PF+7]]: #pragma omp parallel for if(cond)
+// CHECK-NEXT:  48: x
+// CHECK-NEXT:  49: [B1.48] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  50: argc
+// CHECK-NEXT:  51: [B1.50] = [B1.49]
+// CHECK-NEXT:  52: #pragma omp parallel for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#PF+3]]];
-#pragma omp parallel for if(cond)
+// CHECK-NEXT:        [B1.51];
+#pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#PFS:]]: x
-// CHECK-NEXT:  [[#PFS+1]]: [B1.[[#PFS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PFS+2]]: argc
-// CHECK-NEXT:  [[#PFS+3]]: [B1.[[#PFS+2]]] = [B1.[[#PFS+1]]]
-// CHECK-NEXT:  [[#PFS+4]]: cond
-// CHECK-NEXT:  [[#PFS+5]]: [B1.[[#PFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PFS+6]]: [B1.[[#PFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#PFS+7]]: #pragma omp parallel for simd if(cond)
+// CHECK-NEXT:  53: x
+// CHECK-NEXT:  54: [B1.53] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  55: argc
+// CHECK-NEXT:  56: [B1.55] = [B1.54]
+// CHECK-NEXT:  57: #pragma omp parallel for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#PFS+3]]];
-#pragma omp parallel for simd if(cond)
+// CHECK-NEXT:        [B1.56];
+#pragma omp parallel for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#PAR:]]: x
-// CHECK-NEXT:  [[#PAR+1]]: [B1.[[#PAR]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PAR+2]]: argc
-// CHECK-NEXT:  [[#PAR+3]]: [B1.[[#PAR+2]]] = [B1.[[#PAR+1]]]
-// CHECK-NEXT:  [[#PAR+4]]: cond
-// CHECK-NEXT:  [[#PAR+5]]: [B1.[[#PAR+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PAR+6]]: [B1.[[#PAR+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#PAR+7]]: #pragma omp parallel if(cond)
-// CHECK-NEXT:    [B1.[[#PAR+3]]];
-#pragma omp parallel if(cond)
+// CHECK-NEXT:  58: x
+// CHECK-NEXT:  59: [B1.58] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  60: argc
+// CHECK-NEXT:  61: [B1.60] = [B1.59]
+// CHECK-NEXT:  62: #pragma omp parallel
+// CHECK-NEXT:    [B1.61];
+#pragma omp parallel
   argc = x;
-// CHECK-NEXT:  [[#PSECT:]]: x
-// CHECK-NEXT:  [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PSECT+2]]: argc
-// CHECK-NEXT:  [[#PSECT+3]]: [B1.[[#PSECT+2]]] = [B1.[[#PSECT+1]]]
-// CHECK-NEXT:  [[#PSECT+4]]: cond
-// CHECK-NEXT:  [[#PSECT+5]]: [B1.[[#PSECT+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#PSECT+6]]: [B1.[[#PSECT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#PSECT+7]]: #pragma omp parallel sections if(cond)
+// CHECK-NEXT:  63: x
+// CHECK-NEXT:  64: [B1.63] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  65: argc
+// CHECK-NEXT:  66: [B1.65] = [B1.64]
+// CHECK-NEXT:  67: #pragma omp parallel sections
 // CHECK-NEXT:    {
-// CHECK-NEXT:        [B1.[[#PSECT+3]]];
+// CHECK-NEXT:        [B1.66];
 // CHECK-NEXT:    }
-#pragma omp parallel sections if(cond)
+#pragma omp parallel sections
   {
     argc = x;
   }
-// CHECK-NEXT:  [[#SIMD:]]: x
-// CHECK-NEXT:  [[#SIMD+1]]: [B1.[[#SIMD]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#SIMD+2]]: argc
-// CHECK-NEXT:  [[#SIMD+3]]: [B1.[[#SIMD+2]]] = [B1.[[#SIMD+1]]]
-// CHECK-NEXT:  [[#SIMD+4]]: #pragma omp simd
+// CHECK-NEXT:  68: x
+// CHECK-NEXT:  69: [B1.68] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  70: argc
+// CHECK-NEXT:  71: [B1.70] = [B1.69]
+// CHECK-NEXT:  72: #pragma omp simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#SIMD+3]]];
+// CHECK-NEXT:        [B1.71];
 #pragma omp simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#SINGLE:]]: x
-// CHECK-NEXT:  [[#SINGLE+1]]: [B1.[[#SINGLE]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#SINGLE+2]]: argc
-// CHECK-NEXT:  [[#SINGLE+3]]: [B1.[[#SINGLE+2]]] = [B1.[[#SINGLE+1]]]
-// CHECK-NEXT:  [[#SINGLE+4]]: #pragma omp single
-// CHECK-NEXT:    [B1.[[#SINGLE+3]]];
+// CHECK-NEXT:  73: x
+// CHECK-NEXT:  74: [B1.73] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  75: argc
+// CHECK-NEXT:  76: [B1.75] = [B1.74]
+// CHECK-NEXT:  77: #pragma omp single
+// CHECK-NEXT:    [B1.76];
 #pragma omp single
   argc = x;
-// CHECK-NEXT:  [[#TARGET:]]: x
-// CHECK-NEXT:  [[#TARGET+1]]: [B1.[[#TARGET]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TARGET+2]]: argc
-// CHECK-NEXT:  [[#TARGET+3]]: [B1.[[#TARGET+2]]] = [B1.[[#TARGET+1]]]
-// CHECK-NEXT:  [[#TARGET+4]]: cond
-// CHECK-NEXT:  [[#TARGET+5]]: [B1.[[#TARGET+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TARGET+6]]: [B1.[[#TARGET+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TARGET+7]]: #pragma omp target depend(in : argc) if(cond)
-// CHECK-NEXT:    [B1.[[#TARGET+3]]];
+// CHECK-NEXT:  78: x
+// CHECK-NEXT:  79: [B1.78] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  80: argc
+// CHECK-NEXT:  81: [B1.80] = [B1.79]
+// CHECK-NEXT:  82: #pragma omp target depend(in : argc)
+// CHECK-NEXT:    [B1.81];
 #pragma omp target depend(in \
-                          : argc) if(cond)
+                          : argc)
   argc = x;
-// CHECK-NEXT:  [[#TPF:]]: x
-// CHECK-NEXT:  [[#TPF+1]]: [B1.[[#TPF]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPF+2]]: argc
-// CHECK-NEXT:  [[#TPF+3]]: [B1.[[#TPF+2]]] = [B1.[[#TPF+1]]]
-// CHECK-NEXT:  [[#TPF+4]]: cond
-// CHECK-NEXT:  [[#TPF+5]]: [B1.[[#TPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPF+6]]: [B1.[[#TPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TPF+7]]: #pragma omp target parallel for if(parallel: cond)
+// CHECK-NEXT:  83: x
+// CHECK-NEXT:  84: [B1.83] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  85: argc
+// CHECK-NEXT:  86: [B1.85] = [B1.84]
+// CHECK-NEXT:  87: #pragma omp target parallel for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TPF+3]]];
-#pragma omp target parallel for if(parallel:cond)
+// CHECK-NEXT:        [B1.86];
+#pragma omp target parallel for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TPFS:]]: x
-// CHECK-NEXT:  [[#TPFS+1]]: [B1.[[#TPFS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPFS+2]]: argc
-// CHECK-NEXT:  [[#TPFS+3]]: [B1.[[#TPFS+2]]] = [B1.[[#TPFS+1]]]
-// CHECK-NEXT:  [[#TPFS+4]]: cond
-// CHECK-NEXT:  [[#TPFS+5]]: [B1.[[#TPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TPFS+6]]: [B1.[[#TPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TPFS+7]]: #pragma omp target parallel for simd if(target: cond)
+// CHECK-NEXT:  88: x
+// CHECK-NEXT:  89: [B1.88] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  90: argc
+// CHECK-NEXT:  91: [B1.90] = [B1.89]
+// CHECK-NEXT:  92: #pragma omp target parallel for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TPFS+3]]];
-#pragma omp target parallel for simd if(target:cond)
+// CHECK-NEXT:        [B1.91];
+#pragma omp target parallel for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TP:]]: x
-// CHECK-NEXT:  [[#TP+1]]: [B1.[[#TP]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TP+2]]: argc
-// CHECK-NEXT:  [[#TP+3]]: [B1.[[#TP+2]]] = [B1.[[#TP+1]]]
-// CHECK-NEXT:  [[#TP+4]]: cond
-// CHECK-NEXT:  [[#TP+5]]: [B1.[[#TP+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TP+6]]: [B1.[[#TP+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TP+7]]: #pragma omp target parallel if(cond)
-// CHECK-NEXT:    [B1.[[#TP+3]]];
-#pragma omp target parallel if(cond)
+// CHECK-NEXT:  93: x
+// CHECK-NEXT:  94: [B1.93] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  95: argc
+// CHECK-NEXT:  96: [B1.95] = [B1.94]
+// CHECK-NEXT:  97: #pragma omp target parallel
+// CHECK-NEXT:    [B1.96];
+#pragma omp target parallel
   argc = x;
-// CHECK-NEXT:  [[#TSIMD:]]: x
-// CHECK-NEXT:  [[#TSIMD+1]]: [B1.[[#TSIMD]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TSIMD+2]]: argc
-// CHECK-NEXT:  [[#TSIMD+3]]: [B1.[[#TSIMD+2]]] = [B1.[[#TSIMD+1]]]
-// CHECK-NEXT:  [[#TSIMD+4]]: cond
-// CHECK-NEXT:  [[#TSIMD+5]]: [B1.[[#TSIMD+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TSIMD+6]]: [B1.[[#TSIMD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TSIMD+7]]: #pragma omp target simd if(cond)
+// CHECK-NEXT:  98: x
+// CHECK-NEXT:  99: [B1.98] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 100: argc
+// CHECK-NEXT: 101: [B1.100] = [B1.99]
+// CHECK-NEXT: 102: #pragma omp target simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TSIMD+3]]];
-#pragma omp target simd if(cond)
+// CHECK-NEXT:        [B1.101];
+#pragma omp target simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TTD:]]: x
-// CHECK-NEXT:  [[#TTD+1]]: [B1.[[#TTD]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTD+2]]: argc
-// CHECK-NEXT:  [[#TTD+3]]: [B1.[[#TTD+2]]] = [B1.[[#TTD+1]]]
-// CHECK-NEXT:  [[#TTD+4]]: cond
-// CHECK-NEXT:  [[#TTD+5]]: [B1.[[#TTD+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTD+6]]: [B1.[[#TTD+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TTD+7]]: #pragma omp target teams distribute if(cond)
+// CHECK-NEXT: 103: x
+// CHECK-NEXT: 104: [B1.103] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 105: argc
+// CHECK-NEXT: 106: [B1.105] = [B1.104]
+// CHECK-NEXT: 107: #pragma omp target teams distribute
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TTD+3]]];
-#pragma omp target teams distribute if(cond)
+// CHECK-NEXT:        [B1.106];
+#pragma omp target teams distribute
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TTDPF:]]: x
-// CHECK-NEXT:  [[#TTDPF+1]]: [B1.[[#TTDPF]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDPF+2]]: argc
-// CHECK-NEXT:  [[#TTDPF+3]]: [B1.[[#TTDPF+2]]] = [B1.[[#TTDPF+1]]]
-// CHECK-NEXT:  [[#TTDPF+4]]: cond
-// CHECK-NEXT:  [[#TTDPF+5]]: [B1.[[#TTDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDPF+6]]: [B1.[[#TTDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TTDPF+7]]: #pragma omp target teams distribute parallel for if(cond)
+// CHECK-NEXT: 108: x
+// CHECK-NEXT: 109: [B1.108] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 110: argc
+// CHECK-NEXT: 111: [B1.110] = [B1.109]
+// CHECK-NEXT: 112: #pragma omp target teams distribute parallel for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TTDPF+3]]];
-#pragma omp target teams distribute parallel for if(cond)
+// CHECK-NEXT:        [B1.111];
+#pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TTDPFS:]]: x
-// CHECK-NEXT:  [[#TTDPFS+1]]: [B1.[[#TTDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDPFS+2]]: argc
-// CHECK-NEXT:  [[#TTDPFS+3]]: [B1.[[#TTDPFS+2]]] = [B1.[[#TTDPFS+1]]]
-// CHECK-NEXT:  [[#TTDPFS+4]]: cond
-// CHECK-NEXT:  [[#TTDPFS+5]]: [B1.[[#TTDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDPFS+6]]: [B1.[[#TTDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TTDPFS+7]]: #pragma omp target teams distribute parallel for simd if(parallel: cond)
+// CHECK-NEXT: 113: x
+// CHECK-NEXT: 114: [B1.113] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 115: argc
+// CHECK-NEXT: 116: [B1.115] = [B1.114]
+// CHECK-NEXT: 117: #pragma omp target teams distribute parallel for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TTDPFS+3]]];
-#pragma omp target teams distribute parallel for simd if(parallel:cond)
+// CHECK-NEXT:        [B1.116];
+#pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TTDS:]]: x
-// CHECK-NEXT:  [[#TTDS+1]]: [B1.[[#TTDS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDS+2]]: argc
-// CHECK-NEXT:  [[#TTDS+3]]: [B1.[[#TTDS+2]]] = [B1.[[#TTDS+1]]]
-// CHECK-NEXT:  [[#TTDS+4]]: cond
-// CHECK-NEXT:  [[#TTDS+5]]: [B1.[[#TTDS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TTDS+6]]: [B1.[[#TTDS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TTDS+7]]: #pragma omp target teams distribute simd if(cond)
+// CHECK-NEXT: 118: x
+// CHECK-NEXT: 119: [B1.118] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 120: argc
+// CHECK-NEXT: 121: [B1.120] = [B1.119]
+// CHECK-NEXT: 122: #pragma omp target teams distribute simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TTDS+3]]];
-#pragma omp target teams distribute simd if(cond)
+// CHECK-NEXT:        [B1.121];
+#pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TT:]]: x
-// CHECK-NEXT:  [[#TT+1]]: [B1.[[#TT]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TT+2]]: argc
-// CHECK-NEXT:  [[#TT+3]]: [B1.[[#TT+2]]] = [B1.[[#TT+1]]]
-// CHECK-NEXT:  [[#TT+4]]: cond
-// CHECK-NEXT:  [[#TT+5]]: [B1.[[#TT+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TT+6]]: [B1.[[#TT+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TT+7]]: #pragma omp target teams if(cond)
-// CHECK-NEXT:    [B1.[[#TT+3]]];
-#pragma omp target teams if(cond)
+// CHECK-NEXT: 123: x
+// CHECK-NEXT: 124: [B1.123] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 125: argc
+// CHECK-NEXT: 126: [B1.125] = [B1.124]
+// CHECK-NEXT: 127: #pragma omp target teams
+// CHECK-NEXT:    [B1.126];
+#pragma omp target teams
   argc = x;
-// CHECK-NEXT: [[#TU:]]: cond
-// CHECK-NEXT: [[#TU+1]]: [B1.[[#TU]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT: [[#TU+2]]: [B1.[[#TU+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT: [[#TU+3]]: #pragma omp target update to(x) if(target update: cond)
-#pragma omp target update to(x) if(target update:cond)
-// CHECK-NEXT:  [[#TASK:]]: x
-// CHECK-NEXT:  [[#TASK+1]]: [B1.[[#TASK]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TASK+2]]: argc
-// CHECK-NEXT:  [[#TASK+3]]: [B1.[[#TASK+2]]] = [B1.[[#TASK+1]]]
-// CHECK-NEXT:  [[#TASK+4]]: cond
-// CHECK-NEXT:  [[#TASK+5]]: [B1.[[#TASK+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TASK+6]]: [B1.[[#TASK+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TASK+7]]: #pragma omp task if(cond)
-// CHECK-NEXT:    [B1.[[#TASK+3]]];
-#pragma omp task if(cond)
+// CHECK-NEXT: 128: #pragma omp target update to(x)
+#pragma omp target update to(x)
+// CHECK-NEXT: 129: x
+// CHECK-NEXT: 130: [B1.129] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 131: argc
+// CHECK-NEXT: 132: [B1.131] = [B1.130]
   argc = x;
-// CHECK-NEXT:  [[#TG:]]: x
-// CHECK-NEXT:  [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TG+2]]: argc
-// CHECK-NEXT:  [[#TG+3]]: [B1.[[#TG+2]]] = [B1.[[#TG+1]]]
-// CHECK-NEXT:  [[#TG+4]]: #pragma omp taskgroup
-// CHECK-NEXT:    [B1.[[#TG+3]]];
+// CHECK-NEXT: 133: x
+// CHECK-NEXT: 134: [B1.133] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 135: argc
+// CHECK-NEXT: 136: [B1.135] = [B1.134]
+// CHECK-NEXT: 137: #pragma omp task
+// CHECK-NEXT:    [B1.136];
+#pragma omp task
+  argc = x;
+// CHECK-NEXT: 138: x
+// CHECK-NEXT: 139: [B1.138] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 140: argc
+// CHECK-NEXT: 141: [B1.140] = [B1.139]
+// CHECK-NEXT: 142: #pragma omp taskgroup
+// CHECK-NEXT:    [B1.141];
 #pragma omp taskgroup
   argc = x;
-// CHECK-NEXT:  [[#TL:]]: x
-// CHECK-NEXT:  [[#TL+1]]: [B1.[[#TL]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TL+2]]: argc
-// CHECK-NEXT:  [[#TL+3]]: [B1.[[#TL+2]]] = [B1.[[#TL+1]]]
-// CHECK-NEXT:  [[#TL+4]]: cond
-// CHECK-NEXT:  [[#TL+5]]: [B1.[[#TL+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TL+6]]: [B1.[[#TL+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TL+7]]: #pragma omp taskloop if(cond)
+// CHECK-NEXT: 143: x
+// CHECK-NEXT: 144: [B1.143] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 145: argc
+// CHECK-NEXT: 146: [B1.145] = [B1.144]
+// CHECK-NEXT: 147: #pragma omp taskloop
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TL+3]]];
-#pragma omp taskloop if(cond)
+// CHECK-NEXT:        [B1.146];
+#pragma omp taskloop
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TLS:]]: x
-// CHECK-NEXT:  [[#TLS+1]]: [B1.[[#TLS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TLS+2]]: argc
-// CHECK-NEXT:  [[#TLS+3]]: [B1.[[#TLS+2]]] = [B1.[[#TLS+1]]]
-// CHECK-NEXT:  [[#TLS+4]]: cond
-// CHECK-NEXT:  [[#TLS+5]]: [B1.[[#TLS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TLS+6]]: [B1.[[#TLS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TLS+7]]: #pragma omp taskloop simd if(cond)
+// CHECK-NEXT: 148: x
+// CHECK-NEXT: 149: [B1.148] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 150: argc
+// CHECK-NEXT: 151: [B1.150] = [B1.149]
+// CHECK-NEXT: 152: #pragma omp taskloop simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TLS+3]]];
-#pragma omp taskloop simd if(cond)
+// CHECK-NEXT:        [B1.151];
+#pragma omp taskloop simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [[#TDPF:]]: x
-// CHECK-NEXT:  [[#TDPF+1]]: [B1.[[#TDPF]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TDPF+2]]: argc
-// CHECK-NEXT:  [[#TDPF+3]]: [B1.[[#TDPF+2]]] = [B1.[[#TDPF+1]]]
-// CHECK-NEXT:  [[#TDPF+4]]: cond
-// CHECK-NEXT:  [[#TDPF+5]]: [B1.[[#TDPF+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TDPF+6]]: [B1.[[#TDPF+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TDPF+7]]: #pragma omp teams distribute parallel for if(cond)
+// CHECK-NEXT: 153: x
+// CHECK-NEXT: 154: [B1.153] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 155: argc
+// CHECK-NEXT: 156: [B1.155] = [B1.154]
+// CHECK-NEXT: 157: #pragma omp teams distribute parallel for
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TDPF+3]]];
-// CHECK-NEXT:  [[#TDPF+8]]: #pragma omp target
+// CHECK-NEXT:        [B1.156];
+// CHECK-NEXT: 158: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for if(cond)
+#pragma omp teams distribute parallel for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDPF+7]]] [[#TDPFS:]]: x
-// CHECK-NEXT:  [[#TDPFS+1]]: [B1.[[#TDPFS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TDPFS+2]]: argc
-// CHECK-NEXT:  [[#TDPFS+3]]: [B1.[[#TDPFS+2]]] = [B1.[[#TDPFS+1]]]
-// CHECK-NEXT:  [[#TDPFS+4]]: cond
-// CHECK-NEXT:  [[#TDPFS+5]]: [B1.[[#TDPFS+4]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TDPFS+6]]: [B1.[[#TDPFS+5]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
-// CHECK-NEXT:  [[#TDPFS+7]]: #pragma omp teams distribute parallel for simd
+// CHECK-NEXT:[B1.157] 159: x
+// CHECK-NEXT: 160: [B1.159] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 161: argc
+// CHECK-NEXT: 162: [B1.161] = [B1.160]
+// CHECK-NEXT: 163: #pragma omp teams distribute parallel for simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TDPFS+3]]];
-// CHECK-NEXT:  [[#TDPFS+8]]: #pragma omp target
+// CHECK-NEXT:        [B1.162];
+// CHECK-NEXT: 164: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for simd if(cond)
+#pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDPFS+7]]] [[#TDS:]]: x
-// CHECK-NEXT:  [[#TDS+1]]: [B1.[[#TDS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TDS+2]]: argc
-// CHECK-NEXT:  [[#TDS+3]]: [B1.[[#TDS+2]]] = [B1.[[#TDS+1]]]
-// CHECK-NEXT:  [[#TDS+4]]: #pragma omp teams distribute simd
+// CHECK-NEXT:[B1.163] 165: x
+// CHECK-NEXT: 166: [B1.165] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 167: argc
+// CHECK-NEXT: 168: [B1.167] = [B1.166]
+// CHECK-NEXT: 169: #pragma omp teams distribute simd
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.[[#TDS+3]]];
-// CHECK-NEXT:  [[#TDS+5]]: #pragma omp target
+// CHECK-NEXT:        [B1.168];
+// CHECK-NEXT: 170: #pragma omp target
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDS+4]]] [[#TEAMS:]]: x
-// CHECK-NEXT:  [[#TEAMS+1]]: [B1.[[#TEAMS]]] (ImplicitCastExpr, LValueToRValue, int)
-// CHECK-NEXT:  [[#TEAMS+2]]: argc
-// CHECK-NEXT:  [[#TEAMS+3]]: [B1.[[#TEAMS+2]]] = [B1.[[#TEAMS+1]]]
-// CHECK-NEXT:  [[#TEAMS+4]]: #pragma omp teams
-// CHECK-NEXT:    [B1.[[#TEAMS+3]]];
-// CHECK-NEXT:  [[#TEAMS+5]]: #pragma omp target
+// CHECK-NEXT:[B1.169] 171: x
+// CHECK-NEXT: 172: [B1.171] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT: 173: argc
+// CHECK-NEXT: 174: [B1.173] = [B1.172]
+// CHECK-NEXT: 175: #pragma omp teams
+// CHECK-NEXT:    [B1.174];
+// CHECK-NEXT: 176: #pragma omp target
 #pragma omp target
 #pragma omp teams
   argc = x;
-// CHECK-NEXT:  [B1.[[#TEAMS+4]]]   Preds
+// CHECK-NEXT:[B1.175]   Preds
 }
 
diff --git a/clang/test/OpenMP/cancel_if_messages.cpp b/clang/test/OpenMP/cancel_if_messages.cpp
index 222087c..3d629c9 100644
--- a/clang/test/OpenMP/cancel_if_messages.cpp
+++ b/clang/test/OpenMP/cancel_if_messages.cpp
@@ -9,16 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp parallel
-  {
-#pragma omp cancel parallel if (cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-    for (int i = 0; i < 10; ++i)
-      ;
-  }
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/distribute_parallel_for_if_messages.cpp b/clang/test/OpenMP/distribute_parallel_for_if_messages.cpp
index e628a15..a06ff23 100644
--- a/clang/test/OpenMP/distribute_parallel_for_if_messages.cpp
+++ b/clang/test/OpenMP/distribute_parallel_for_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp distribute parallel for if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp b/clang/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
index 6cf18fa..7769272 100644
--- a/clang/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
+++ b/clang/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp distribute parallel for simd if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/parallel_for_if_messages.cpp b/clang/test/OpenMP/parallel_for_if_messages.cpp
index 56bb06b..32f9ef3 100644
--- a/clang/test/OpenMP/parallel_for_if_messages.cpp
+++ b/clang/test/OpenMP/parallel_for_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp parallel for if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/parallel_for_simd_if_messages.cpp b/clang/test/OpenMP/parallel_for_simd_if_messages.cpp
index bab9339..aa1e302 100644
--- a/clang/test/OpenMP/parallel_for_simd_if_messages.cpp
+++ b/clang/test/OpenMP/parallel_for_simd_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp parallel for simd if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/parallel_if_messages.cpp b/clang/test/OpenMP/parallel_if_messages.cpp
index f095e66..7f802a9 100644
--- a/clang/test/OpenMP/parallel_if_messages.cpp
+++ b/clang/test/OpenMP/parallel_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp parallel if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/parallel_sections_if_messages.cpp b/clang/test/OpenMP/parallel_sections_if_messages.cpp
index b7c92df..8d36b6d 100644
--- a/clang/test/OpenMP/parallel_sections_if_messages.cpp
+++ b/clang/test/OpenMP/parallel_sections_if_messages.cpp
@@ -9,14 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp parallel sections if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  {
-    ;
-  }
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_data_if_messages.cpp b/clang/test/OpenMP/target_data_if_messages.cpp
index 29f898c..c6f9b4b 100644
--- a/clang/test/OpenMP/target_data_if_messages.cpp
+++ b/clang/test/OpenMP/target_data_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target data map(argc) if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 int main(int argc, char **argv) {
diff --git a/clang/test/OpenMP/target_enter_data_if_messages.cpp b/clang/test/OpenMP/target_enter_data_if_messages.cpp
index 21019e9..5123d60 100644
--- a/clang/test/OpenMP/target_enter_data_if_messages.cpp
+++ b/clang/test/OpenMP/target_enter_data_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target enter data map(to:argc) if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 int main(int argc, char **argv) {
diff --git a/clang/test/OpenMP/target_exit_data_if_messages.cpp b/clang/test/OpenMP/target_exit_data_if_messages.cpp
index 7b2385c..c45b32f 100644
--- a/clang/test/OpenMP/target_exit_data_if_messages.cpp
+++ b/clang/test/OpenMP/target_exit_data_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target exit data map(from: argc) if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 int main(int argc, char **argv) {
diff --git a/clang/test/OpenMP/target_if_messages.cpp b/clang/test/OpenMP/target_if_messages.cpp
index f381e9e..e6b667f 100644
--- a/clang/test/OpenMP/target_if_messages.cpp
+++ b/clang/test/OpenMP/target_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_parallel_for_if_messages.cpp b/clang/test/OpenMP/target_parallel_for_if_messages.cpp
index a5a181b..445dc17 100644
--- a/clang/test/OpenMP/target_parallel_for_if_messages.cpp
+++ b/clang/test/OpenMP/target_parallel_for_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target parallel for if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_parallel_for_simd_if_messages.cpp b/clang/test/OpenMP/target_parallel_for_simd_if_messages.cpp
index ef9a208..b0da801 100644
--- a/clang/test/OpenMP/target_parallel_for_simd_if_messages.cpp
+++ b/clang/test/OpenMP/target_parallel_for_simd_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target parallel for simd if(parallel: cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_parallel_if_messages.cpp b/clang/test/OpenMP/target_parallel_if_messages.cpp
index ac498a7..460e0c8 100644
--- a/clang/test/OpenMP/target_parallel_if_messages.cpp
+++ b/clang/test/OpenMP/target_parallel_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target parallel if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_simd_if_messages.cpp b/clang/test/OpenMP/target_simd_if_messages.cpp
index 5f3e9e3..94d2ab3 100644
--- a/clang/test/OpenMP/target_simd_if_messages.cpp
+++ b/clang/test/OpenMP/target_simd_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target simd if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_teams_distribute_if_messages.cpp b/clang/test/OpenMP/target_teams_distribute_if_messages.cpp
index 499cd3a..fd1ffb0 100644
--- a/clang/test/OpenMP/target_teams_distribute_if_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target teams distribute if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp b/clang/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
index 6df2307..e111402 100644
--- a/clang/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target teams distribute parallel for if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
index e88c1f1..59c7589 100644
--- a/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
@@ -9,14 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target teams distribute parallel for simd if (parallel \
-                                                          : cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_teams_distribute_simd_if_messages.cpp b/clang/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
index 53af6e7..7134a83 100644
--- a/clang/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
+++ b/clang/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target teams distribute simd if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_teams_if_messages.cpp b/clang/test/OpenMP/target_teams_if_messages.cpp
index 4bc82a3..8d3d690 100644
--- a/clang/test/OpenMP/target_teams_if_messages.cpp
+++ b/clang/test/OpenMP/target_teams_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target teams if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/target_update_if_messages.cpp b/clang/test/OpenMP/target_update_if_messages.cpp
index d967713..9ded332 100644
--- a/clang/test/OpenMP/target_update_if_messages.cpp
+++ b/clang/test/OpenMP/target_update_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target update to(argc) if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/task_if_messages.cpp b/clang/test/OpenMP/task_if_messages.cpp
index 2d47b32..305af22 100644
--- a/clang/test/OpenMP/task_if_messages.cpp
+++ b/clang/test/OpenMP/task_if_messages.cpp
@@ -9,13 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp task if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp b/clang/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
index b76599d..6f724b0 100644
--- a/clang/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
+++ b/clang/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
@@ -9,14 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target
-#pragma omp teams distribute parallel for if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}
diff --git a/clang/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp b/clang/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
index 39a0b32..c01e6e8 100644
--- a/clang/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
+++ b/clang/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
@@ -9,14 +9,6 @@ bool foobool(int argc) {
   return argc;
 }
 
-void xxx(int argc) {
-  int cond; // expected-note {{initialize the variable 'cond' to silence this warning}}
-#pragma omp target
-#pragma omp teams distribute parallel for simd if(cond) // expected-warning {{variable 'cond' is uninitialized when used here}}
-  for (int i = 0; i < 10; ++i)
-    ;
-}
-
 struct S1; // expected-note {{declared here}}
 
 template <class T, class S> // expected-note {{declared here}}