diff --git a/docs/UndefinedBehaviorSanitizer.rst b/docs/UndefinedBehaviorSanitizer.rst
index 7a4eaf4f60d5..38cd3645bcea 100644
--- a/docs/UndefinedBehaviorSanitizer.rst
+++ b/docs/UndefinedBehaviorSanitizer.rst
@@ -205,8 +205,8 @@ Minimal Runtime
 
 There is a minimal UBSan runtime available suitable for use in production
 environments. This runtime has a small attack surface. It only provides very
-basic issue logging and deduplication, and does not support ``-fsanitize=vptr``
-checking.
+basic issue logging and deduplication, and does not support
+``-fsanitize=function`` and ``-fsanitize=vptr`` checking.
 
 To use the minimal runtime, add ``-fsanitize-minimal-runtime`` to the clang
 command line options. For example, if you're used to compiling with
diff --git a/include/clang/AST/OpenMPClause.h b/include/clang/AST/OpenMPClause.h
index c6daf73a623b..eadcc62a3457 100644
--- a/include/clang/AST/OpenMPClause.h
+++ b/include/clang/AST/OpenMPClause.h
@@ -501,11 +501,10 @@ class OMPIfClause : public OMPClause, public OMPClauseWithPreInit {
     return const_child_range(&Condition, &Condition + 1);
   }
 
-  child_range used_children() {
-    return child_range(child_iterator(), child_iterator());
-  }
+  child_range used_children();
   const_child_range used_children() const {
-    return const_child_range(const_child_iterator(), const_child_iterator());
+    auto Children = const_cast<OMPIfClause *>(this)->used_children();
+    return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
diff --git a/include/clang/Basic/BuiltinsAArch64.def b/include/clang/Basic/BuiltinsAArch64.def
index 5ba03da4a7a0..7701ad98f483 100644
--- a/include/clang/Basic/BuiltinsAArch64.def
+++ b/include/clang/Basic/BuiltinsAArch64.def
@@ -65,6 +65,8 @@ BUILTIN(__builtin_arm_dmb, "vUi", "nc")
 BUILTIN(__builtin_arm_dsb, "vUi", "nc")
 BUILTIN(__builtin_arm_isb, "vUi", "nc")
 
+BUILTIN(__builtin_arm_jcvt, "Zid", "nc")
+
 // Prefetch
 BUILTIN(__builtin_arm_prefetch, "vvC*UiUiUiUi", "nc")
 
diff --git a/lib/AST/OpenMPClause.cpp b/lib/AST/OpenMPClause.cpp
index 41520b380276..9d8a7ebc3023 100644
--- a/lib/AST/OpenMPClause.cpp
+++ b/lib/AST/OpenMPClause.cpp
@@ -209,6 +209,25 @@ 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/lib/Analysis/CFG.cpp b/lib/Analysis/CFG.cpp
index de89105a2925..0ed1e988a196 100644
--- a/lib/Analysis/CFG.cpp
+++ b/lib/Analysis/CFG.cpp
@@ -4746,8 +4746,9 @@ CFGBlock *CFGBuilder::VisitOMPExecutableDirective(OMPExecutableDirective *D,
 
   // Reverse the elements to process them in natural order. Iterators are not
   // bidirectional, so we need to create temp vector.
-  for (Stmt *S : llvm::reverse(llvm::to_vector<8>(
-           OMPExecutableDirective::used_clauses_children(D->clauses())))) {
+  SmallVector<Stmt *, 8> Used(
+      OMPExecutableDirective::used_clauses_children(D->clauses()));
+  for (Stmt *S : llvm::reverse(Used)) {
     assert(S && "Expected non-null used-in-clause child.");
     if (CFGBlock *R = Visit(S))
       B = R;
diff --git a/lib/Basic/Targets/AArch64.cpp b/lib/Basic/Targets/AArch64.cpp
index 6011ae17b78e..a02530ad0675 100644
--- a/lib/Basic/Targets/AArch64.cpp
+++ b/lib/Basic/Targets/AArch64.cpp
@@ -118,6 +118,28 @@ void AArch64TargetInfo::getTargetDefinesARMV82A(const LangOptions &Opts,
   getTargetDefinesARMV81A(Opts, Builder);
 }
 
+void AArch64TargetInfo::getTargetDefinesARMV83A(const LangOptions &Opts,
+                                                MacroBuilder &Builder) const {
+  Builder.defineMacro("__ARM_FEATURE_JCVT", "1");
+  // Also include the Armv8.2 defines
+  getTargetDefinesARMV82A(Opts, Builder);
+}
+
+void AArch64TargetInfo::getTargetDefinesARMV84A(const LangOptions &Opts,
+                                                MacroBuilder &Builder) const {
+  // Also include the Armv8.3 defines
+  // FIXME: Armv8.4 makes some extensions mandatory. Handle them here.
+  getTargetDefinesARMV83A(Opts, Builder);
+}
+
+void AArch64TargetInfo::getTargetDefinesARMV85A(const LangOptions &Opts,
+                                                MacroBuilder &Builder) const {
+  // Also include the Armv8.4 defines
+  // FIXME: Armv8.5 makes some extensions mandatory. Handle them here.
+  getTargetDefinesARMV84A(Opts, Builder);
+}
+
+
 void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                          MacroBuilder &Builder) const {
   // Target identification.
@@ -209,6 +231,15 @@ void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
   case llvm::AArch64::ArchKind::ARMV8_2A:
     getTargetDefinesARMV82A(Opts, Builder);
     break;
+  case llvm::AArch64::ArchKind::ARMV8_3A:
+    getTargetDefinesARMV83A(Opts, Builder);
+    break;
+  case llvm::AArch64::ArchKind::ARMV8_4A:
+    getTargetDefinesARMV84A(Opts, Builder);
+    break;
+  case llvm::AArch64::ArchKind::ARMV8_5A:
+    getTargetDefinesARMV85A(Opts, Builder);
+    break;
   }
 
   // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8) builtins work.
@@ -256,6 +287,12 @@ bool AArch64TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
       ArchKind = llvm::AArch64::ArchKind::ARMV8_1A;
     if (Feature == "+v8.2a")
       ArchKind = llvm::AArch64::ArchKind::ARMV8_2A;
+    if (Feature == "+v8.3a")
+      ArchKind = llvm::AArch64::ArchKind::ARMV8_3A;
+    if (Feature == "+v8.4a")
+      ArchKind = llvm::AArch64::ArchKind::ARMV8_4A;
+    if (Feature == "+v8.5a")
+      ArchKind = llvm::AArch64::ArchKind::ARMV8_5A;
     if (Feature == "+fullfp16")
       HasFullFP16 = 1;
     if (Feature == "+dotprod")
diff --git a/lib/Basic/Targets/AArch64.h b/lib/Basic/Targets/AArch64.h
index 0241b585c4d1..de0aed78e037 100644
--- a/lib/Basic/Targets/AArch64.h
+++ b/lib/Basic/Targets/AArch64.h
@@ -59,6 +59,12 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
                                MacroBuilder &Builder) const;
   void getTargetDefinesARMV82A(const LangOptions &Opts,
                                MacroBuilder &Builder) const;
+  void getTargetDefinesARMV83A(const LangOptions &Opts,
+                               MacroBuilder &Builder) const;
+  void getTargetDefinesARMV84A(const LangOptions &Opts,
+                               MacroBuilder &Builder) const;
+  void getTargetDefinesARMV85A(const LangOptions &Opts,
+                               MacroBuilder &Builder) const;
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 
diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
index c58d1018fa0e..acaa81ae8a9a 100644
--- a/lib/CodeGen/CGBuiltin.cpp
+++ b/lib/CodeGen/CGBuiltin.cpp
@@ -6977,6 +6977,14 @@ Value *CodeGenFunction::EmitAArch64BuiltinExpr(unsigned BuiltinID,
         CGM.getIntrinsic(Intrinsic::bitreverse, Arg->getType()), Arg, "rbit");
   }
 
+  if (BuiltinID == AArch64::BI__builtin_arm_jcvt) {
+    assert((getContext().getTypeSize(E->getType()) == 32) &&
+           "__jcvt of unusual size!");
+    llvm::Value *Arg = EmitScalarExpr(E->getArg(0));
+    return Builder.CreateCall(
+        CGM.getIntrinsic(Intrinsic::aarch64_fjcvtzs), Arg);
+  }
+
   if (BuiltinID == AArch64::BI__clear_cache) {
     assert(E->getNumArgs() == 2 && "__clear_cache takes 2 arguments");
     const FunctionDecl *FD = E->getDirectCallee();
diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 8340f48abcb6..4d19a12e5cb0 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -2927,7 +2927,7 @@ enum class CheckRecoverableKind {
 
 static CheckRecoverableKind getRecoverableKind(SanitizerMask Kind) {
   assert(Kind.countPopulation() == 1);
-  if (Kind == SanitizerKind::Vptr)
+  if (Kind == SanitizerKind::Function || Kind == SanitizerKind::Vptr)
     return CheckRecoverableKind::AlwaysRecoverable;
   else if (Kind == SanitizerKind::Return || Kind == SanitizerKind::Unreachable)
     return CheckRecoverableKind::Unrecoverable;
diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index a51a9711ff17..bd9e14206a09 100644
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -114,7 +114,7 @@ enum TypeEvaluationKind {
   SANITIZER_CHECK(DivremOverflow, divrem_overflow, 0)                          \
   SANITIZER_CHECK(DynamicTypeCacheMiss, dynamic_type_cache_miss, 0)            \
   SANITIZER_CHECK(FloatCastOverflow, float_cast_overflow, 0)                   \
-  SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 0)             \
+  SANITIZER_CHECK(FunctionTypeMismatch, function_type_mismatch, 1)             \
   SANITIZER_CHECK(ImplicitConversion, implicit_conversion, 0)                  \
   SANITIZER_CHECK(InvalidBuiltin, invalid_builtin, 0)                          \
   SANITIZER_CHECK(LoadInvalidValue, load_invalid_value, 0)                     \
diff --git a/lib/Driver/SanitizerArgs.cpp b/lib/Driver/SanitizerArgs.cpp
index 9132faa91764..6b6a9feec42c 100644
--- a/lib/Driver/SanitizerArgs.cpp
+++ b/lib/Driver/SanitizerArgs.cpp
@@ -31,7 +31,8 @@ static const SanitizerMask NeedsUbsanRt =
 static const SanitizerMask NeedsUbsanCxxRt =
     SanitizerKind::Vptr | SanitizerKind::CFI;
 static const SanitizerMask NotAllowedWithTrap = SanitizerKind::Vptr;
-static const SanitizerMask NotAllowedWithMinimalRuntime = SanitizerKind::Vptr;
+static const SanitizerMask NotAllowedWithMinimalRuntime =
+    SanitizerKind::Function | SanitizerKind::Vptr;
 static const SanitizerMask RequiresPIE =
     SanitizerKind::DataFlow | SanitizerKind::HWAddress | SanitizerKind::Scudo;
 static const SanitizerMask NeedsUnwindTables =
diff --git a/lib/Driver/ToolChains/Solaris.cpp b/lib/Driver/ToolChains/Solaris.cpp
index c65b78373959..38f24d4cf7e7 100644
--- a/lib/Driver/ToolChains/Solaris.cpp
+++ b/lib/Driver/ToolChains/Solaris.cpp
@@ -65,10 +65,6 @@ void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back("-Bdynamic");
     if (Args.hasArg(options::OPT_shared)) {
       CmdArgs.push_back("-shared");
-    } else {
-      CmdArgs.push_back("--dynamic-linker");
-      CmdArgs.push_back(
-          Args.MakeArgString(getToolChain().GetFilePath("ld.so.1")));
     }
 
     // libpthread has been folded into libc since Solaris 10, no need to do
diff --git a/lib/Headers/arm_acle.h b/lib/Headers/arm_acle.h
index 08d65fa0d069..096cc261af2c 100644
--- a/lib/Headers/arm_acle.h
+++ b/lib/Headers/arm_acle.h
@@ -597,6 +597,14 @@ __crc32cd(uint32_t __a, uint64_t __b) {
 }
 #endif
 
+/* Armv8.3-A Javascript conversion intrinsic */
+#if __ARM_64BIT_STATE && defined(__ARM_FEATURE_JCVT)
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__jcvt(double __a) {
+  return __builtin_arm_jcvt(__a);
+}
+#endif
+
 /* 10.1 Special register intrinsics */
 #define __arm_rsr(sysreg) __builtin_arm_rsr(sysreg)
 #define __arm_rsr64(sysreg) __builtin_arm_rsr64(sysreg)
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index b3b34699eb64..bc1069609336 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -5640,6 +5640,9 @@ void InitializationSequence::InitializeFrom(Sema &S,
   bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
          Entity.isParameterKind();
 
+  if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
+    return;
+
   // We're at the end of the line for C: it's either a write-back conversion
   // or it's a C assignment. There's no need to check anything else.
   if (!S.getLangOpts().CPlusPlus) {
@@ -5649,9 +5652,6 @@ void InitializationSequence::InitializeFrom(Sema &S,
       return;
     }
 
-    if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
-      return;
-
     if (TryOCLZeroOpaqueTypeInitialization(S, *this, DestType, Initializer))
       return;
 
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 77e6767c2b81..d8c4ea48ebce 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1851,6 +1851,10 @@ static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
              (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
     SCS.Second = ICK_Zero_Queue_Conversion;
     FromType = ToType;
+  } else if (ToType->isSamplerT() &&
+             From->isIntegerConstantExpr(S.getASTContext())) {
+    SCS.Second = ICK_Compatible_Conversion;
+    FromType = ToType;
   } else {
     // No second conversion required.
     SCS.Second = ICK_Identity;
diff --git a/lib/Sema/SemaTemplateVariadic.cpp b/lib/Sema/SemaTemplateVariadic.cpp
index 9b23624a9a81..d97626551a41 100644
--- a/lib/Sema/SemaTemplateVariadic.cpp
+++ b/lib/Sema/SemaTemplateVariadic.cpp
@@ -619,6 +619,7 @@ ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
   if (!Pattern->containsUnexpandedParameterPack()) {
     Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
     << Pattern->getSourceRange();
+    CorrectDelayedTyposInExpr(Pattern);
     return ExprError();
   }
 
diff --git a/test/Analysis/cfg-openmp.cpp b/test/Analysis/cfg-openmp.cpp
index 2f734d14b021..dd417bf408c8 100644
--- a/test/Analysis/cfg-openmp.cpp
+++ b/test/Analysis/cfg-openmp.cpp
@@ -1,340 +1,402 @@
-// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp | FileCheck %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=debug.DumpCFG %s 2>&1 -fopenmp -fopenmp-version=45 | FileCheck %s
 
 // CHECK-LABEL:  void xxx(int argc)
 void xxx(int argc) {
 // CHECK:        [B1]
 // CHECK-NEXT:   1: int x;
-  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];
+// 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]]];
 #pragma omp atomic read
   argc = x;
-// 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];
+// 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]]];
 #pragma omp critical
   argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.15];
-#pragma omp distribute parallel for
+// CHECK-NEXT:        [B1.[[#DPF+3]]];
+#pragma omp distribute parallel for if(parallel:cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.20];
-#pragma omp distribute parallel for simd
+// CHECK-NEXT:        [B1.[[#DPFS+3]]];
+#pragma omp distribute parallel for simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.25];
+// CHECK-NEXT:        [B1.[[#DS+3]]];
 #pragma omp distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:]]: 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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.30];
+// CHECK-NEXT:        [B1.[[#FOR+3]]];
 #pragma omp for
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.35];
+// CHECK-NEXT:        [B1.[[#FS+3]]];
 #pragma omp for simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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];
+// 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]]];
 #pragma omp master
   argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i) {
-// CHECK-NEXT:[B1.46]    }
+// CHECK-NEXT:[B1.[[#ORD+4]]]    }
 #pragma omp for ordered
   for (int i = 0; i < 10; ++i) {
 #pragma omp ordered
     argc = x;
   }
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.51];
-#pragma omp parallel for
+// CHECK-NEXT:        [B1.[[#PF+3]]];
+#pragma omp parallel for if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.56];
-#pragma omp parallel for simd
+// CHECK-NEXT:        [B1.[[#PFS+3]]];
+#pragma omp parallel for simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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
+// 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)
   argc = x;
-// 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:  [[#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:    {
-// CHECK-NEXT:        [B1.66];
+// CHECK-NEXT:        [B1.[[#PSECT+3]]];
 // CHECK-NEXT:    }
-#pragma omp parallel sections
+#pragma omp parallel sections if(cond)
   {
     argc = x;
   }
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.71];
+// CHECK-NEXT:        [B1.[[#SIMD+3]]];
 #pragma omp simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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];
+// 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]]];
 #pragma omp single
   argc = x;
-// 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];
+// 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]]];
 #pragma omp target depend(in \
-                          : argc)
+                          : argc) if(cond)
   argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.86];
-#pragma omp target parallel for
+// CHECK-NEXT:        [B1.[[#TPF+3]]];
+#pragma omp target parallel for if(parallel:cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.91];
-#pragma omp target parallel for simd
+// CHECK-NEXT:        [B1.[[#TPFS+3]]];
+#pragma omp target parallel for simd if(target:cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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
+// 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)
   argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.101];
-#pragma omp target simd
+// CHECK-NEXT:        [B1.[[#TSIMD+3]]];
+#pragma omp target simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.106];
-#pragma omp target teams distribute
+// CHECK-NEXT:        [B1.[[#TTD+3]]];
+#pragma omp target teams distribute if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.111];
-#pragma omp target teams distribute parallel for
+// CHECK-NEXT:        [B1.[[#TTDPF+3]]];
+#pragma omp target teams distribute parallel for if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.116];
-#pragma omp target teams distribute parallel for simd
+// CHECK-NEXT:        [B1.[[#TTDPFS+3]]];
+#pragma omp target teams distribute parallel for simd if(parallel:cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.121];
-#pragma omp target teams distribute simd
+// CHECK-NEXT:        [B1.[[#TTDS+3]]];
+#pragma omp target teams distribute simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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
+// 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)
   argc = x;
-// 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]
+// 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)
   argc = x;
-// 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];
+// 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]]];
 #pragma omp taskgroup
   argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.146];
-#pragma omp taskloop
+// CHECK-NEXT:        [B1.[[#TL+3]]];
+#pragma omp taskloop if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.151];
-#pragma omp taskloop simd
+// CHECK-NEXT:        [B1.[[#TLS+3]]];
+#pragma omp taskloop simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [[#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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.156];
-// CHECK-NEXT: 158: #pragma omp target
+// CHECK-NEXT:        [B1.[[#TDPF+3]]];
+// CHECK-NEXT:  [[#TDPF+8]]: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for
+#pragma omp teams distribute parallel for if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [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 if(cond)
 // CHECK-NEXT:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.162];
-// CHECK-NEXT: 164: #pragma omp target
+// CHECK-NEXT:        [B1.[[#TDPFS+3]]];
+// CHECK-NEXT:  [[#TDPFS+8]]: #pragma omp target
 #pragma omp target
-#pragma omp teams distribute parallel for simd
+#pragma omp teams distribute parallel for simd if(cond)
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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:  [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:    for (int i = 0; i < 10; ++i)
-// CHECK-NEXT:        [B1.168];
-// CHECK-NEXT: 170: #pragma omp target
+// CHECK-NEXT:        [B1.[[#TDS+3]]];
+// CHECK-NEXT:  [[#TDS+5]]: #pragma omp target
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i)
     argc = x;
-// 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
+// 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
 #pragma omp target
 #pragma omp teams
   argc = x;
-// CHECK-NEXT:[B1.175]   Preds
+// CHECK-NEXT:  [B1.[[#TEAMS+4]]]   Preds
 }
 
diff --git a/test/CodeGen/arm_acle.c b/test/CodeGen/arm_acle.c
index e8a744372de2..beca93735067 100644
--- a/test/CodeGen/arm_acle.c
+++ b/test/CodeGen/arm_acle.c
@@ -2,6 +2,9 @@
 // RUN: %clang_cc1 -ffreestanding -triple armv8-eabi -target-cpu cortex-a57 -O2  -fexperimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=ARM -check-prefix=AArch32 -check-prefix=ARM-NEWPM -check-prefix=AArch32-NEWPM
 // RUN: %clang_cc1 -ffreestanding -triple aarch64-eabi -target-cpu cortex-a57 -target-feature +neon -target-feature +crc -target-feature +crypto -O2 -fno-experimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=ARM -check-prefix=AArch64 -check-prefix=ARM-LEGACY -check-prefix=AArch64-LEGACY
 // RUN: %clang_cc1 -ffreestanding -triple aarch64-eabi -target-cpu cortex-a57 -target-feature +neon -target-feature +crc -target-feature +crypto -O2 -fexperimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=ARM -check-prefix=AArch64 -check-prefix=ARM-NEWPM -check-prefix=AArch64-NEWPM
+// RUN: %clang_cc1 -ffreestanding -triple aarch64-eabi -target-cpu cortex-a57 -target-feature +v8.3a -O2 -fexperimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=AArch64-v8_3
+// RUN: %clang_cc1 -ffreestanding -triple aarch64-eabi -target-cpu cortex-a57 -target-feature +v8.4a -O2 -fexperimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=AArch64-v8_3
+// RUN: %clang_cc1 -ffreestanding -triple aarch64-eabi -target-cpu cortex-a57 -target-feature +v8.5a -O2 -fexperimental-new-pass-manager -S -emit-llvm -o - %s | FileCheck %s -check-prefix=AArch64-v8_3
 
 #include <arm_acle.h>
 
@@ -823,3 +826,11 @@ void test_wsrp(void *v) {
 
 // AArch64: ![[M0]] = !{!"1:2:3:4:5"}
 // AArch64: ![[M1]] = !{!"sysreg"}
+
+// AArch64-v8_3-LABEL: @test_jcvt(
+// AArch64-v8_3: call i32 @llvm.aarch64.fjcvtzs
+#ifdef __ARM_64BIT_STATE
+int32_t test_jcvt(double v) {
+  return __jcvt(v);
+}
+#endif
diff --git a/test/CodeGen/builtins-arm64.c b/test/CodeGen/builtins-arm64.c
index f164c2f6f364..5ec63fba82b5 100644
--- a/test/CodeGen/builtins-arm64.c
+++ b/test/CodeGen/builtins-arm64.c
@@ -58,6 +58,12 @@ void prefetch() {
 // CHECK: call {{.*}} @llvm.prefetch(i8* null, i32 0, i32 3, i32 0)
 }
 
+int32_t jcvt(double v) {
+  //CHECK-LABEL: @jcvt(
+  //CHECK: call i32 @llvm.aarch64.fjcvtzs
+  return __builtin_arm_jcvt(v);
+}
+
 __typeof__(__builtin_arm_rsr("1:2:3:4:5")) rsr(void);
 
 uint32_t rsr() {
diff --git a/test/CodeGen/ubsan-function.cpp b/test/CodeGen/ubsan-function.cpp
new file mode 100644
index 000000000000..749e6214242c
--- /dev/null
+++ b/test/CodeGen/ubsan-function.cpp
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -o - %s -fsanitize=function -fno-sanitize-recover=all | FileCheck %s
+
+// CHECK-LABEL: define void @_Z3funv() #0 prologue <{ i32, i32 }> <{ i32 846595819, i32 trunc (i64 sub (i64 ptrtoint (i8** @0 to i64), i64 ptrtoint (void ()* @_Z3funv to i64)) to i32) }> {
+void fun() {}
+
+// CHECK-LABEL: define void @_Z6callerPFvvE(void ()* %f)
+// CHECK: getelementptr <{ i32, i32 }>, <{ i32, i32 }>* {{.*}}, i32 0, i32 0, !nosanitize
+// CHECK: load i32, i32* {{.*}}, align {{.*}}, !nosanitize
+// CHECK: icmp eq i32 {{.*}}, 846595819, !nosanitize
+// CHECK: br i1 {{.*}}, label %[[LABEL1:.*]], label %[[LABEL4:.*]], !nosanitize
+// CHECK: [[LABEL1]]:
+// CHECK: getelementptr <{ i32, i32 }>, <{ i32, i32 }>* {{.*}}, i32 0, i32 1, !nosanitize
+// CHECK: load i32, i32* {{.*}}, align {{.*}}, !nosanitize
+// CHECK: icmp eq i8* {{.*}}, bitcast ({ i8*, i8* }* @_ZTIFvvE to i8*), !nosanitize
+// CHECK: br i1 {{.*}}, label %[[LABEL3:.*]], label %[[LABEL2:[^,]*]], {{.*}}!nosanitize
+// CHECK: [[LABEL2]]:
+// CHECK: call void @__ubsan_handle_function_type_mismatch_v1_abort(i8* {{.*}}, i64 {{.*}}, i64 {{.*}}, i64 {{.*}}) #{{.*}}, !nosanitize
+// CHECK-NOT: unreachable
+// CHECK: br label %[[LABEL3]], !nosanitize
+// CHECK: [[LABEL3]]:
+// CHECK: br label %[[LABEL4]], !nosanitize
+void caller(void (*f)()) { f(); }
diff --git a/test/CodeGenOpenCL/sampler.cl b/test/CodeGenOpenCL/sampler.cl
index 74b6d55d5d37..1ef1f538b256 100644
--- a/test/CodeGenOpenCL/sampler.cl
+++ b/test/CodeGenOpenCL/sampler.cl
@@ -1,5 +1,6 @@
 // RUN: %clang_cc1 %s -emit-llvm -triple spir-unknown-unknown -o - -O0 | FileCheck %s
 // RUN: %clang_cc1 %s -cl-std=CL2.0 -emit-llvm -triple spir-unknown-unknown -o - -O0 | FileCheck %s
+// RUN: %clang_cc1 %s -cl-std=c++ -emit-llvm -triple spir-unknown-unknown -o - -O0 | FileCheck %s
 //
 // This test covers 5 cases of sampler initialzation:
 //   1. function argument passing
@@ -29,7 +30,7 @@ const sampler_t glb_smp_const = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORD
 int get_sampler_initializer(void);
 
 void fnc4smp(sampler_t s) {}
-// CHECK: define spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* %
+// CHECK: define spir_func void [[FUNCNAME:@.*fnc4smp.*]](%opencl.sampler_t addrspace(2)* %
 
 kernel void foo(sampler_t smp_par) {
   // CHECK-LABEL: define spir_kernel void @foo(%opencl.sampler_t addrspace(2)* %smp_par)
@@ -45,32 +46,32 @@ kernel void foo(sampler_t smp_par) {
   fnc4smp(smp);
   // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 19)
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_ptr]]
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1b
   fnc4smp(smp);
   // CHECK-NOT: call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 19)
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_ptr]]
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1a/2a
   fnc4smp(glb_smp);
   // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1a/2c
   fnc4smp(glb_smp_const);
   // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1c
   fnc4smp(smp_par);
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_par_ptr]]
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   fnc4smp(5);
   // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 5)
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   const sampler_t const_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
   fnc4smp(const_smp);
@@ -78,12 +79,12 @@ kernel void foo(sampler_t smp_par) {
   // CHECK: store %opencl.sampler_t addrspace(2)* [[CONST_SAMP]], %opencl.sampler_t addrspace(2)** [[CONST_SMP_PTR:%[a-zA-Z0-9]+]]
   fnc4smp(const_smp);
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[CONST_SMP_PTR]]
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   constant sampler_t constant_smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_NORMALIZED_COORDS_TRUE | CLK_FILTER_LINEAR;
   fnc4smp(constant_smp);
   // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
-  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+  // CHECK: call spir_func void [[FUNCNAME]](%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // TODO: enable sampler initialization with non-constant integer.
   //const sampler_t const_smp_func_init = get_sampler_initializer();
diff --git a/test/Driver/Inputs/solaris_sparc_tree/usr/lib/ld.so.1 b/test/Driver/Inputs/solaris_sparc_tree/usr/lib/ld.so.1
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/test/Driver/Inputs/solaris_sparc_tree/usr/lib/sparcv9/ld.so.1 b/test/Driver/Inputs/solaris_sparc_tree/usr/lib/sparcv9/ld.so.1
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/test/Driver/Inputs/solaris_x86_tree/usr/lib/amd64/ld.so.1 b/test/Driver/Inputs/solaris_x86_tree/usr/lib/amd64/ld.so.1
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/test/Driver/Inputs/solaris_x86_tree/usr/lib/ld.so.1 b/test/Driver/Inputs/solaris_x86_tree/usr/lib/ld.so.1
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/test/Driver/fsanitize.c b/test/Driver/fsanitize.c
index 01367c7e6788..2896eda5aaa0 100644
--- a/test/Driver/fsanitize.c
+++ b/test/Driver/fsanitize.c
@@ -759,9 +759,12 @@
 // CHECK-TSAN-MINIMAL: error: invalid argument '-fsanitize-minimal-runtime' not allowed with '-fsanitize=thread'
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-MINIMAL
-// CHECK-UBSAN-MINIMAL: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute|function),?){18}"}}
+// CHECK-UBSAN-MINIMAL: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){17}"}}
 // CHECK-UBSAN-MINIMAL: "-fsanitize-minimal-runtime"
 
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize=function -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-FUNCTION-MINIMAL
+// CHECK-UBSAN-FUNCTION-MINIMAL: error: invalid argument '-fsanitize=function' not allowed with '-fsanitize-minimal-runtime'
+
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize=vptr -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-VPTR-MINIMAL
 // CHECK-UBSAN-VPTR-MINIMAL: error: invalid argument '-fsanitize=vptr' not allowed with '-fsanitize-minimal-runtime'
 
diff --git a/test/Driver/solaris-ld.c b/test/Driver/solaris-ld.c
index 2fc5c91272aa..59d03c4d8225 100644
--- a/test/Driver/solaris-ld.c
+++ b/test/Driver/solaris-ld.c
@@ -11,7 +11,6 @@
 // CHECK-LD-SPARC32: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "sparc-sun-solaris2.11"
 // CHECK-LD-SPARC32-SAME: "-isysroot" "[[SYSROOT:[^"]+]]"
 // CHECK-LD-SPARC32: "{{.*}}ld{{(.exe)?}}"
-// CHECK-LD-SPARC32-SAME: "--dynamic-linker" "[[SYSROOT]]/usr/lib{{/|\\\\}}ld.so.1"
 // CHECK-LD-SPARC32-SAME: "[[SYSROOT]]/usr/gcc/4.8/lib/gcc/sparc-sun-solaris2.11/4.8.2{{/|\\\\}}crt1.o"
 // CHECK-LD-SPARC32-SAME: "[[SYSROOT]]/usr/lib{{/|\\\\}}crti.o"
 // CHECK-LD-SPARC32-SAME: "[[SYSROOT]]/usr/gcc/4.8/lib/gcc/sparc-sun-solaris2.11/4.8.2{{/|\\\\}}crtbegin.o"
@@ -35,7 +34,6 @@
 // CHECK-LD-SPARC64: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "sparcv9-sun-solaris2.11"
 // CHECK-LD-SPARC64-SAME: "-isysroot" "[[SYSROOT:[^"]+]]"
 // CHECK-LD-SPARC64: "{{.*}}ld{{(.exe)?}}"
-// CHECK-LD-SPARC64-SAME: "--dynamic-linker" "[[SYSROOT]]/usr/lib/sparcv9{{/|\\\\}}ld.so.1"
 // CHECK-LD-SPARC64-SAME: "[[SYSROOT]]/usr/gcc/4.8/lib/gcc/sparc-sun-solaris2.11/4.8.2/sparcv9{{/|\\\\}}crt1.o"
 // CHECK-LD-SPARC64-SAME: "[[SYSROOT]]/usr/lib/sparcv9{{/|\\\\}}crti.o"
 // CHECK-LD-SPARC64-SAME: "[[SYSROOT]]/usr/gcc/4.8/lib/gcc/sparc-sun-solaris2.11/4.8.2/sparcv9{{/|\\\\}}crtbegin.o"
@@ -59,7 +57,6 @@
 // CHECK-LD-X32: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "i386-pc-solaris2.11"
 // CHECK-LD-X32-SAME: "-isysroot" "[[SYSROOT:[^"]+]]"
 // CHECK-LD-X32: "{{.*}}ld{{(.exe)?}}"
-// CHECK-LD-X32-SAME: "--dynamic-linker" "[[SYSROOT]]/usr/lib{{/|\\\\}}ld.so.1"
 // CHECK-LD-X32-SAME: "[[SYSROOT]]/usr/lib{{/|\\\\}}crt1.o"
 // CHECK-LD-X32-SAME: "[[SYSROOT]]/usr/lib{{/|\\\\}}crti.o"
 // CHECK-LD-X32-SAME: "[[SYSROOT]]/usr/gcc/4.9/lib/gcc/i386-pc-solaris2.11/4.9.4{{/|\\\\}}crtbegin.o"
@@ -83,7 +80,6 @@
 // CHECK-LD-X64: {{.*}}clang{{(.exe)?}}" "-cc1" "-triple" "x86_64-pc-solaris2.11"
 // CHECK-LD-X64-SAME: "-isysroot" "[[SYSROOT:[^"]+]]"
 // CHECK-LD-X64: "{{.*}}ld{{(.exe)?}}"
-// CHECK-LD-X64-SAME: "--dynamic-linker" "[[SYSROOT]]/usr/lib/amd64{{/|\\\\}}ld.so.1"
 // CHECK-LD-X64-SAME: "[[SYSROOT]]/usr/lib/amd64{{/|\\\\}}crt1.o"
 // CHECK-LD-X64-SAME: "[[SYSROOT]]/usr/lib/amd64{{/|\\\\}}crti.o"
 // CHECK-LD-X64-SAME: "[[SYSROOT]]/usr/gcc/4.9/lib/gcc/i386-pc-solaris2.11/4.9.4/amd64{{/|\\\\}}crtbegin.o"
diff --git a/test/OpenMP/cancel_if_messages.cpp b/test/OpenMP/cancel_if_messages.cpp
index 3d629c927e90..222087ca9e61 100644
--- a/test/OpenMP/cancel_if_messages.cpp
+++ b/test/OpenMP/cancel_if_messages.cpp
@@ -9,6 +9,16 @@ 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/test/OpenMP/distribute_parallel_for_if_messages.cpp b/test/OpenMP/distribute_parallel_for_if_messages.cpp
index a06ff2377c04..e628a15c3ab4 100644
--- a/test/OpenMP/distribute_parallel_for_if_messages.cpp
+++ b/test/OpenMP/distribute_parallel_for_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp b/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
index 7769272026e6..6cf18faf0a87 100644
--- a/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
+++ b/test/OpenMP/distribute_parallel_for_simd_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/parallel_for_if_messages.cpp b/test/OpenMP/parallel_for_if_messages.cpp
index 32f9ef3a7def..56bb06be0cc7 100644
--- a/test/OpenMP/parallel_for_if_messages.cpp
+++ b/test/OpenMP/parallel_for_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/parallel_for_simd_if_messages.cpp b/test/OpenMP/parallel_for_simd_if_messages.cpp
index aa1e302d0424..bab9339d4917 100644
--- a/test/OpenMP/parallel_for_simd_if_messages.cpp
+++ b/test/OpenMP/parallel_for_simd_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/parallel_if_messages.cpp b/test/OpenMP/parallel_if_messages.cpp
index 7f802a9e4236..f095e66bbfa5 100644
--- a/test/OpenMP/parallel_if_messages.cpp
+++ b/test/OpenMP/parallel_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/parallel_sections_if_messages.cpp b/test/OpenMP/parallel_sections_if_messages.cpp
index 8d36b6d5d308..b7c92df4f30d 100644
--- a/test/OpenMP/parallel_sections_if_messages.cpp
+++ b/test/OpenMP/parallel_sections_if_messages.cpp
@@ -9,6 +9,14 @@ 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/test/OpenMP/target_data_if_messages.cpp b/test/OpenMP/target_data_if_messages.cpp
index c6f9b4b34eee..29f898c6d9fa 100644
--- a/test/OpenMP/target_data_if_messages.cpp
+++ b/test/OpenMP/target_data_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_enter_data_if_messages.cpp b/test/OpenMP/target_enter_data_if_messages.cpp
index 5123d607dc6a..21019e9ae7f8 100644
--- a/test/OpenMP/target_enter_data_if_messages.cpp
+++ b/test/OpenMP/target_enter_data_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_exit_data_if_messages.cpp b/test/OpenMP/target_exit_data_if_messages.cpp
index c45b32ff3fe7..7b2385c16cd2 100644
--- a/test/OpenMP/target_exit_data_if_messages.cpp
+++ b/test/OpenMP/target_exit_data_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_if_messages.cpp b/test/OpenMP/target_if_messages.cpp
index e6b667f2cffb..f381e9eb91eb 100644
--- a/test/OpenMP/target_if_messages.cpp
+++ b/test/OpenMP/target_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_parallel_for_if_messages.cpp b/test/OpenMP/target_parallel_for_if_messages.cpp
index 445dc1775b0f..a5a181b9d273 100644
--- a/test/OpenMP/target_parallel_for_if_messages.cpp
+++ b/test/OpenMP/target_parallel_for_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_parallel_for_simd_if_messages.cpp b/test/OpenMP/target_parallel_for_simd_if_messages.cpp
index b0da8017019f..ef9a2089d108 100644
--- a/test/OpenMP/target_parallel_for_simd_if_messages.cpp
+++ b/test/OpenMP/target_parallel_for_simd_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_parallel_if_messages.cpp b/test/OpenMP/target_parallel_if_messages.cpp
index 460e0c8655f0..ac498a7108b0 100644
--- a/test/OpenMP/target_parallel_if_messages.cpp
+++ b/test/OpenMP/target_parallel_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_simd_if_messages.cpp b/test/OpenMP/target_simd_if_messages.cpp
index 94d2ab308daa..5f3e9e3910ac 100644
--- a/test/OpenMP/target_simd_if_messages.cpp
+++ b/test/OpenMP/target_simd_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_teams_distribute_if_messages.cpp b/test/OpenMP/target_teams_distribute_if_messages.cpp
index fd1ffb08cbe8..499cd3ac5805 100644
--- a/test/OpenMP/target_teams_distribute_if_messages.cpp
+++ b/test/OpenMP/target_teams_distribute_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp b/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
index e1114028b687..6df23076472e 100644
--- a/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
+++ b/test/OpenMP/target_teams_distribute_parallel_for_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp b/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
index 59c75893a171..e88c1f1dbbff 100644
--- a/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
+++ b/test/OpenMP/target_teams_distribute_parallel_for_simd_if_messages.cpp
@@ -9,6 +9,14 @@ 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/test/OpenMP/target_teams_distribute_simd_if_messages.cpp b/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
index 7134a8394cbb..53af6e759d21 100644
--- a/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
+++ b/test/OpenMP/target_teams_distribute_simd_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_teams_if_messages.cpp b/test/OpenMP/target_teams_if_messages.cpp
index 8d3d690d631f..4bc82a349398 100644
--- a/test/OpenMP/target_teams_if_messages.cpp
+++ b/test/OpenMP/target_teams_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/target_update_if_messages.cpp b/test/OpenMP/target_update_if_messages.cpp
index 9ded332b04eb..d967713e456f 100644
--- a/test/OpenMP/target_update_if_messages.cpp
+++ b/test/OpenMP/target_update_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/task_if_messages.cpp b/test/OpenMP/task_if_messages.cpp
index 305af22149d8..2d47b32b9a15 100644
--- a/test/OpenMP/task_if_messages.cpp
+++ b/test/OpenMP/task_if_messages.cpp
@@ -9,6 +9,13 @@ 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/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp b/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
index 6f724b050178..b76599d41a46 100644
--- a/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
+++ b/test/OpenMP/teams_distribute_parallel_for_if_messages.cpp
@@ -9,6 +9,14 @@ 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/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp b/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
index c01e6e87e39a..39a0b326383a 100644
--- a/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
+++ b/test/OpenMP/teams_distribute_parallel_for_simd_if_messages.cpp
@@ -9,6 +9,14 @@ 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}}
diff --git a/test/SemaTemplate/typo-variadic.cpp b/test/SemaTemplate/typo-variadic.cpp
new file mode 100644
index 000000000000..c9b777aebbe9
--- /dev/null
+++ b/test/SemaTemplate/typo-variadic.cpp
@@ -0,0 +1,2 @@
+// RUN: %clang_cc1 -fsyntax-only %s -verify
+int x = m(s...); // expected-error{{pack expansion does not}} expected-error{{undeclared identifier}}
diff --git a/tools/scan-view/share/ScanView.py b/tools/scan-view/share/ScanView.py
index c40366b2e849..a6cc7692ffe0 100644
--- a/tools/scan-view/share/ScanView.py
+++ b/tools/scan-view/share/ScanView.py
@@ -764,11 +764,11 @@ def send_patched_file(self, path, ctype):
             variables['report'] = m.group(2)
 
         try:
-            f = open(path,'r')
+            f = open(path,'rb')
         except IOError:
             return self.send_404()
         fs = os.fstat(f.fileno())
-        data = f.read()
+        data = f.read().decode('utf-8')
         for a,b in kReportReplacements:
             data = a.sub(b % variables, data)
         return self.send_string(data, ctype, mtime=fs.st_mtime)