Index: cfe/trunk/include/clang/AST/OpenMPClause.h
===================================================================
--- cfe/trunk/include/clang/AST/OpenMPClause.h
+++ cfe/trunk/include/clang/AST/OpenMPClause.h
@@ -2099,10 +2099,12 @@
   }
 
   child_range used_children() {
-    return child_range(child_iterator(), child_iterator());
+    return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
+                       reinterpret_cast<Stmt **>(varlist_end()));
   }
   const_child_range used_children() const {
-    return const_child_range(const_child_iterator(), const_child_iterator());
+    auto Children = const_cast<OMPFirstprivateClause *>(this)->used_children();
+    return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
Index: cfe/trunk/test/Analysis/cfg-openmp.cpp
===================================================================
--- cfe/trunk/test/Analysis/cfg-openmp.cpp
+++ cfe/trunk/test/Analysis/cfg-openmp.cpp
@@ -5,7 +5,8 @@
 // CHECK:        [B1]
 // CHECK-NEXT:   1: int x;
 // CHECK-NEXT:   2: int cond;
-  int x, cond;
+// CHECK-NEXT:   3: int fp;
+  int x, cond, fp;
 // CHECK-NEXT:   [[#ATOM:]]: x
 // CHECK-NEXT:   [[#ATOM+1]]: [B1.[[#ATOM]]] (ImplicitCastExpr, LValueToRValue, int)
 // CHECK-NEXT:   [[#ATOM+2]]: argc
@@ -29,10 +30,11 @@
 // 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:  [[#DPF+7]]: fp
+// CHECK-NEXT:  [[#DPF+8]]: #pragma omp distribute parallel for if(parallel: cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#DPF+3]]];
-#pragma omp distribute parallel for if(parallel:cond)
+#pragma omp distribute parallel for if(parallel:cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#DPFS:]]: x
@@ -42,10 +44,11 @@
 // 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:  [[#DPFS+7]]: fp
+// CHECK-NEXT:  [[#DPFS+8]]: #pragma omp distribute parallel for simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#DPFS+3]]];
-#pragma omp distribute parallel for simd if(cond)
+#pragma omp distribute parallel for simd if(cond)  firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#DS:]]: x
@@ -107,10 +110,11 @@
 // 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:  [[#PF+7]]: fp
+// CHECK-NEXT:  [[#PF+8]]: #pragma omp parallel for if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#PF+3]]];
-#pragma omp parallel for if(cond)
+#pragma omp parallel for if(cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#PFS:]]: x
@@ -120,10 +124,11 @@
 // 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:  [[#PFS+7]]: fp
+// CHECK-NEXT:  [[#PFS+8]]: #pragma omp parallel for simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#PFS+3]]];
-#pragma omp parallel for simd if(cond)
+#pragma omp parallel for simd if(cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#PAR:]]: x
@@ -133,9 +138,10 @@
 // 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:  [[#PAR+7]]: fp
+// CHECK-NEXT:  [[#PAR+8]]: #pragma omp parallel if(cond) firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#PAR+3]]];
-#pragma omp parallel if(cond)
+#pragma omp parallel if(cond) firstprivate(fp)
   argc = x;
 // CHECK-NEXT:  [[#PSECT:]]: x
 // CHECK-NEXT:  [[#PSECT+1]]: [B1.[[#PSECT]]] (ImplicitCastExpr, LValueToRValue, int)
@@ -144,11 +150,12 @@
 // 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:  [[#PSECT+7]]: fp
+// CHECK-NEXT:  [[#PSECT+8]]: #pragma omp parallel sections if(cond) firstprivate(fp)
 // CHECK-NEXT:    {
 // CHECK-NEXT:        [B1.[[#PSECT+3]]];
 // CHECK-NEXT:    }
-#pragma omp parallel sections if(cond)
+#pragma omp parallel sections if(cond) firstprivate(fp)
   {
     argc = x;
   }
@@ -170,146 +177,190 @@
 // CHECK-NEXT:    [B1.[[#SINGLE+3]]];
 #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:]]:
+// CHECK-SAME:  [B1.[[#TARGET+9]]]
+// CHECK-NEXT:  [[#TARGET+1]]: [B1.[[#TARGET+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TARGET+2]]: [B1.[[#TARGET+8]]]
+// CHECK-NEXT:  [[#TARGET+3]]: [B1.[[#TARGET+8]]] = [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:  [[#TARGET+7]]: fp
+// CHECK-NEXT:  [[#TARGET+8]]: argc
+// CHECK-NEXT:  [[#TARGET+9]]: x
+// CHECK-NEXT:  [[#TARGET+10]]: #pragma omp target depend(in : argc) if(cond) firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#TARGET+3]]];
 #pragma omp target depend(in \
-                          : argc) if(cond)
+                          : argc) if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TPF+9]]]
+// CHECK-NEXT:  [[#TPF+1]]: [B1.[[#TPF+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPF+2]]: [B1.[[#TPF+8]]]
+// CHECK-NEXT:  [[#TPF+3]]: [B1.[[#TPF+8]]] = [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:  [[#TPF+7]]: fp
+// CHECK-NEXT:  [[#TPF+8]]: argc
+// CHECK-NEXT:  [[#TPF+9]]: x
+// CHECK-NEXT:  [[#TPF+10]]: #pragma omp target parallel for if(parallel: cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TPF+3]]];
-#pragma omp target parallel for if(parallel:cond)
+#pragma omp target parallel for if(parallel:cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TPFS+9]]]
+// CHECK-NEXT:  [[#TPFS+1]]: [B1.[[#TPFS+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TPFS+2]]: [B1.[[#TPFS+8]]]
+// CHECK-NEXT:  [[#TPFS+3]]: [B1.[[#TPFS+8]]] = [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:  [[#TPFS+7]]: fp
+// CHECK-NEXT:  [[#TPFS+8]]: argc
+// CHECK-NEXT:  [[#TPFS+9]]: x
+// CHECK-NEXT:  [[#TPFS+10]]: #pragma omp target parallel for simd if(target: cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TPFS+3]]];
-#pragma omp target parallel for simd if(target:cond)
+#pragma omp target parallel for simd if(target:cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TP+9]]]
+// CHECK-NEXT:  [[#TP+1]]: [B1.[[#TP+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TP+2]]: [B1.[[#TP+8]]]
+// CHECK-NEXT:  [[#TP+3]]: [B1.[[#TP+8]]] = [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:  [[#TP+7]]: fp
+// CHECK-NEXT:  [[#TP+8]]: argc
+// CHECK-NEXT:  [[#TP+9]]: x
+// CHECK-NEXT:  [[#TP+10]]: #pragma omp target parallel if(cond) firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#TP+3]]];
-#pragma omp target parallel if(cond)
+#pragma omp target parallel if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TSIMD+9]]]
+// CHECK-NEXT:  [[#TSIMD+1]]: [B1.[[#TSIMD+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TSIMD+2]]: [B1.[[#TSIMD+8]]]
+// CHECK-NEXT:  [[#TSIMD+3]]: [B1.[[#TSIMD+8]]] = [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:  [[#TSIMD+7]]: fp
+// CHECK-NEXT:  [[#TSIMD+8]]: argc
+// CHECK-NEXT:  [[#TSIMD+9]]: x
+// CHECK-NEXT:  [[#TSIMD+10]]: #pragma omp target simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TSIMD+3]]];
-#pragma omp target simd if(cond)
+#pragma omp target simd if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TTD+9]]]
+// CHECK-NEXT:  [[#TTD+1]]: [B1.[[#TTD+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TTD+2]]: [B1.[[#TTD+8]]]
+// CHECK-NEXT:  [[#TTD+3]]: [B1.[[#TTD+8]]] = [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:  [[#TTD+7]]: fp
+// CHECK-NEXT:  [[#TTD+8]]: argc
+// CHECK-NEXT:  [[#TTD+9]]: x
+// CHECK-NEXT:  [[#TTD+10]]: #pragma omp target teams distribute if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TTD+3]]];
-#pragma omp target teams distribute if(cond)
+#pragma omp target teams distribute if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TTDPF+9]]]
+// CHECK-NEXT:  [[#TTDPF+1]]: [B1.[[#TTDPF+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TTDPF+2]]: [B1.[[#TTDPF+8]]]
+// CHECK-NEXT:  [[#TTDPF+3]]: [B1.[[#TTDPF+8]]] = [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:  [[#TTDPF+7]]: fp
+// CHECK-NEXT:  [[#TTDPF+8]]: argc
+// CHECK-NEXT:  [[#TTDPF+9]]: x
+// CHECK-NEXT:  [[#TTDPF+10]]: #pragma omp target teams distribute parallel for if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TTDPF+3]]];
-#pragma omp target teams distribute parallel for if(cond)
+#pragma omp target teams distribute parallel for if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TTDPFS+9]]]
+// CHECK-NEXT:  [[#TTDPFS+1]]: [B1.[[#TTDPFS+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TTDPFS+2]]: [B1.[[#TTDPFS+8]]]
+// CHECK-NEXT:  [[#TTDPFS+3]]: [B1.[[#TTDPFS+8]]] = [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:  [[#TTDPFS+7]]: fp
+// CHECK-NEXT:  [[#TTDPFS+8]]: argc
+// CHECK-NEXT:  [[#TTDPFS+9]]: x
+// CHECK-NEXT:  [[#TTDPFS+10]]: #pragma omp target teams distribute parallel for simd if(parallel: cond) firstprivate(fp)
 // 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)
+#pragma omp target teams distribute parallel for simd if(parallel:cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TTDS+9]]]
+// CHECK-NEXT:  [[#TTDS+1]]: [B1.[[#TTDS+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TTDS+2]]: [B1.[[#TTDS+8]]]
+// CHECK-NEXT:  [[#TTDS+3]]: [B1.[[#TTDS+8]]] = [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:  [[#TTDS+7]]: fp
+// CHECK-NEXT:  [[#TTDS+8]]: argc
+// CHECK-NEXT:  [[#TTDS+9]]: x
+// CHECK-NEXT:  [[#TTDS+10]]: #pragma omp target teams distribute simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TTDS+3]]];
-#pragma omp target teams distribute simd if(cond)
+#pragma omp target teams distribute simd if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TT+9]]]
+// CHECK-NEXT:  [[#TT+1]]: [B1.[[#TT+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TT+2]]: [B1.[[#TT+8]]]
+// CHECK-NEXT:  [[#TT+3]]: [B1.[[#TT+8]]] = [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:  [[#TT+7]]: fp
+// CHECK-NEXT:  [[#TT+8]]: argc
+// CHECK-NEXT:  [[#TT+9]]: x
+// CHECK-NEXT:  [[#TT+10]]: #pragma omp target teams if(cond) firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#TT+3]]];
-#pragma omp target teams if(cond)
+#pragma omp target teams if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TASK+9]]]
+// CHECK-NEXT:  [[#TASK+1]]: [B1.[[#TASK+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TASK+2]]: [B1.[[#TASK+8]]]
+// CHECK-NEXT:  [[#TASK+3]]: [B1.[[#TASK+8]]] = [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:  [[#TASK+7]]: fp
+// CHECK-NEXT:  [[#TASK+8]]: argc
+// CHECK-NEXT:  [[#TASK+9]]: x
+// CHECK-NEXT:  [[#TASK+10]]: #pragma omp task if(cond) firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#TASK+3]]];
-#pragma omp task if(cond)
+#pragma omp task if(cond) firstprivate(fp)
   argc = x;
 // CHECK-NEXT:  [[#TG:]]: x
 // CHECK-NEXT:  [[#TG+1]]: [B1.[[#TG]]] (ImplicitCastExpr, LValueToRValue, int)
@@ -319,30 +370,38 @@
 // CHECK-NEXT:    [B1.[[#TG+3]]];
 #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:]]:
+// CHECK-SAME:  [B1.[[#TL+9]]]
+// CHECK-NEXT:  [[#TL+1]]: [B1.[[#TL+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TL+2]]: [B1.[[#TL+8]]]
+// CHECK-NEXT:  [[#TL+3]]: [B1.[[#TL+8]]] = [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:  [[#TL+7]]: fp
+// CHECK-NEXT:  [[#TL+8]]: argc
+// CHECK-NEXT:  [[#TL+9]]: x
+// CHECK-NEXT:  [[#TL+10]]: #pragma omp taskloop if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TL+3]]];
-#pragma omp taskloop if(cond)
+#pragma omp taskloop if(cond) firstprivate(fp)
   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:]]:
+// CHECK-SAME:  [B1.[[#TLS+9]]]
+// CHECK-NEXT:  [[#TLS+1]]: [B1.[[#TLS+9]]] (ImplicitCastExpr, LValueToRValue, int)
+// CHECK-NEXT:  [[#TLS+2]]: [B1.[[#TLS+8]]]
+// CHECK-NEXT:  [[#TLS+3]]: [B1.[[#TLS+8]]] = [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:  [[#TLS+7]]: fp
+// CHECK-NEXT:  [[#TLS+8]]: argc
+// CHECK-NEXT:  [[#TLS+9]]: x
+// CHECK-NEXT:  [[#TLS+10]]: #pragma omp taskloop simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TLS+3]]];
-#pragma omp taskloop simd if(cond)
+#pragma omp taskloop simd if(cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
 // CHECK-NEXT:  [[#TDPF:]]: x
@@ -352,51 +411,69 @@
 // 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:  [[#TDPF+7]]: [B1.[[#TDPF+9]]]
+// CHECK-NEXT:  [[#TDPF+8]]: #pragma omp teams distribute parallel for if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TDPF+3]]];
-// CHECK-NEXT:  [[#TDPF+8]]: #pragma omp target
+// CHECK-NEXT:  [[#TDPF+9]]: fp
+// CHECK-NEXT:  [[#TDPF+10]]: argc
+// CHECK-NEXT:  [[#TDPF+11]]: x
+// CHECK-NEXT:  [[#TDPF+12]]: cond
+// CHECK-NEXT:  [[#TDPF+13]]: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for if(cond)
+#pragma omp teams distribute parallel for if(cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDPF+7]]] [[#TDPFS:]]: x
+// CHECK-NEXT:  [B1.[[#TDPF+8]]] [[#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 if(cond)
+// CHECK-NEXT:  [[#TDPFS+7]]: [B1.[[#TDPFS+9]]]
+// CHECK-NEXT:  [[#TDPFS+8]]: #pragma omp teams distribute parallel for simd if(cond) firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TDPFS+3]]];
-// CHECK-NEXT:  [[#TDPFS+8]]: #pragma omp target
+// CHECK-NEXT:  [[#TDPFS+9]]: fp
+// CHECK-NEXT:  [[#TDPFS+10]]: argc
+// CHECK-NEXT:  [[#TDPFS+11]]: x
+// CHECK-NEXT:  [[#TDPFS+12]]: cond
+// CHECK-NEXT:  [[#TDPFS+13]]: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for simd if(cond)
+#pragma omp teams distribute parallel for simd if(cond) firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDPFS+7]]] [[#TDS:]]: x
+// CHECK-NEXT:  [B1.[[#TDPFS+8]]] [[#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:  [[#TDS+4]]: [B1.[[#TDS+6]]]
+// CHECK-NEXT:  [[#TDS+5]]: #pragma omp teams distribute simd firstprivate(fp)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
 // CHECK-NEXT:        [B1.[[#TDS+3]]];
-// CHECK-NEXT:  [[#TDS+5]]: #pragma omp target
+// CHECK-NEXT:  [[#TDS+6]]: fp
+// CHECK-NEXT:  [[#TDS+7]]: argc
+// CHECK-NEXT:  [[#TDS+8]]: x
+// CHECK-NEXT:  [[#TDS+9]]: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute simd
+#pragma omp teams distribute simd firstprivate(fp)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// CHECK-NEXT:  [B1.[[#TDS+4]]] [[#TEAMS:]]: x
+// CHECK-NEXT:  [B1.[[#TDS+5]]] [[#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:  [[#TEAMS+4]]: [B1.[[#TEAMS+6]]]
+// CHECK-NEXT:  [[#TEAMS+5]]: #pragma omp teams firstprivate(fp)
 // CHECK-NEXT:    [B1.[[#TEAMS+3]]];
-// CHECK-NEXT:  [[#TEAMS+5]]: #pragma omp target
+// CHECK-NEXT:  [[#TEAMS+6]]: fp
+// CHECK-NEXT:  [[#TEAMS+7]]: argc
+// CHECK-NEXT:  [[#TEAMS+8]]: x
+// CHECK-NEXT:  [[#TEAMS+9]]: #pragma omp target
 #pragma omp target
-#pragma omp teams
+#pragma omp teams firstprivate(fp)
   argc = x;
-// CHECK-NEXT:  [B1.[[#TEAMS+4]]]   Preds
+// CHECK-NEXT:  [B1.[[#TEAMS+5]]]   Preds
 }
 
Index: cfe/trunk/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp
@@ -8,6 +8,14 @@
 bool foobool(int argc) {
   return argc;
 }
+
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp distribute parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 extern int omp_default_mem_alloc;
 
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
Index: cfe/trunk/test/OpenMP/distribute_parallel_for_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/distribute_parallel_for_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/distribute_parallel_for_simd_firstprivate_messages.cpp
@@ -10,6 +10,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp distribute parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/parallel_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/parallel_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/parallel_firstprivate_messages.cpp
@@ -10,6 +10,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp parallel firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/parallel_for_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/parallel_for_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/parallel_for_firstprivate_messages.cpp
@@ -10,6 +10,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/parallel_for_simd_firstprivate_messages.cpp
@@ -10,6 +10,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/parallel_sections_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/parallel_sections_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/parallel_sections_firstprivate_messages.cpp
@@ -10,6 +10,15 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp parallel sections firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  {
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_firstprivate_messages.cpp
@@ -2,6 +2,13 @@
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
+void xxx(int argc) {
+  int fp, fp1; // expected-note {{initialize the variable 'fp' to silence this warning}} expected-note {{initialize the variable 'fp1' to silence this warning}}
+#pragma omp target firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ++fp1; // expected-warning {{variable 'fp1' is uninitialized when used here}}
+}
+
 typedef void **omp_allocator_handle_t;
 extern const omp_allocator_handle_t omp_default_mem_alloc;
 extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
Index: cfe/trunk/test/OpenMP/target_parallel_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_parallel_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_parallel_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target parallel firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_parallel_for_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_parallel_for_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_parallel_for_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_parallel_for_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_parallel_for_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_parallel_for_simd_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_simd_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_teams_distribute_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target teams distribute firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target teams distribute parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_simd_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target teams distribute parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_teams_distribute_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_teams_distribute_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_teams_distribute_simd_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target teams distribute simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/target_teams_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/target_teams_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/target_teams_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target teams firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/task_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/task_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/task_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp, fp1; // expected-note {{initialize the variable 'fp' to silence this warning}} expected-note {{initialize the variable 'fp1' to silence this warning}}
+#pragma omp task firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ++fp1; // expected-warning {{variable 'fp1' is uninitialized when used here}}
+}
+
 template <typename T>
 struct S {
   T b;
Index: cfe/trunk/test/OpenMP/taskloop_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/taskloop_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/taskloop_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp taskloop firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/taskloop_simd_firstprivate_messages.cpp
@@ -19,6 +19,13 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp taskloop simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/teams_distribute_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/teams_distribute_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/teams_distribute_firstprivate_messages.cpp
@@ -10,6 +10,14 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/teams_distribute_parallel_for_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/teams_distribute_parallel_for_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/teams_distribute_parallel_for_firstprivate_messages.cpp
@@ -10,6 +10,14 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/teams_distribute_parallel_for_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/teams_distribute_parallel_for_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/teams_distribute_parallel_for_simd_firstprivate_messages.cpp
@@ -10,6 +10,14 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/teams_distribute_simd_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/teams_distribute_simd_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/teams_distribute_simd_firstprivate_messages.cpp
@@ -10,6 +10,14 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target
+#pragma omp teams distribute simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
Index: cfe/trunk/test/OpenMP/teams_firstprivate_messages.cpp
===================================================================
--- cfe/trunk/test/OpenMP/teams_firstprivate_messages.cpp
+++ cfe/trunk/test/OpenMP/teams_firstprivate_messages.cpp
@@ -10,6 +10,14 @@
   return argc;
 }
 
+void xxx(int argc) {
+  int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
+#pragma omp target
+#pragma omp teams firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
+  for (int i = 0; i < 10; ++i)
+    ;
+}
+
 struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {