Index: lib/CodeGen/CGExpr.cpp
===================================================================
--- lib/CodeGen/CGExpr.cpp
+++ lib/CodeGen/CGExpr.cpp
@@ -2443,6 +2443,7 @@
   }
 }
 
+const char *VersionSuffix = "_v2";
 static void emitCheckHandlerCall(CodeGenFunction &CGF,
                                  llvm::FunctionType *FnType,
                                  ArrayRef<llvm::Value *> FnArgs,
@@ -2453,7 +2454,8 @@
   bool NeedsAbortSuffix =
       IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable;
   std::string FnName = ("__ubsan_handle_" + CheckName +
-                        (NeedsAbortSuffix ? "_abort" : "")).str();
+                        (NeedsAbortSuffix ? "_abort" : "") + VersionSuffix)
+                           .str();
   bool MayReturn =
       !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable;
 
Index: test/CodeGen/catch-undef-behavior.c
===================================================================
--- test/CodeGen/catch-undef-behavior.c
+++ test/CodeGen/catch-undef-behavior.c
@@ -54,7 +54,7 @@
   // CHECK-TRAP:  br i1 %[[OK]], {{.*}}
 
   // CHECK-UBSAN:      %[[ARG:.*]] = ptrtoint {{.*}} %[[PTR]] to i64
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]])
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %[[ARG]])
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW:#[0-9]+]]
   // CHECK-TRAP-NEXT: unreachable
@@ -62,7 +62,7 @@
   // With -fsanitize=null, only perform the null check.
   // CHECK-NULL: %[[NULL:.*]] = icmp ne {{.*}}, null
   // CHECK-NULL: br i1 %[[NULL]]
-  // CHECK-NULL: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %{{.*}})
+  // CHECK-NULL: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), i64 %{{.*}})
 #line 100
   u.i=1;
 }
@@ -77,7 +77,7 @@
   // CHECK-COMMON-NEXT: icmp eq i64 %[[MISALIGN]], 0
 
   // CHECK-UBSAN:      %[[ARG:.*]] = ptrtoint
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), i64 %[[ARG]])
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), i64 %[[ARG]])
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -112,8 +112,8 @@
 
   // CHECK-UBSAN:      %[[ARG1:.*]] = zext
   // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
-  // CHECK-UBSAN-NOT:  call void @__ubsan_handle_shift_out_of_bounds
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds_v2(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
+  // CHECK-UBSAN-NOT:  call void @__ubsan_handle_shift_out_of_bounds_v2
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP:      unreachable
@@ -132,7 +132,7 @@
 
   // CHECK-UBSAN:      %[[ARG1:.*]] = zext
   // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds(i8* bitcast ({{.*}} @[[LINE_400]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_shift_out_of_bounds_v2(i8* bitcast ({{.*}} @[[LINE_400]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -145,7 +145,7 @@
 
 // CHECK-COMMON-LABEL: @load
 int load(int *p) {
-  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_500]] to i8*), i64 %{{.*}})
+  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_500]] to i8*), i64 %{{.*}})
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -155,7 +155,7 @@
 
 // CHECK-COMMON-LABEL: @store
 void store(int *p, int q) {
-  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_600]] to i8*), i64 %{{.*}})
+  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_600]] to i8*), i64 %{{.*}})
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -167,7 +167,7 @@
 
 // CHECK-COMMON-LABEL: @member_access
 int *member_access(struct S *p) {
-  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch(i8* bitcast ({{.*}} @[[LINE_700]] to i8*), i64 %{{.*}})
+  // CHECK-UBSAN: call void @__ubsan_handle_type_mismatch_v2(i8* bitcast ({{.*}} @[[LINE_700]] to i8*), i64 %{{.*}})
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -179,7 +179,7 @@
 int signed_overflow(int a, int b) {
   // CHECK-UBSAN:      %[[ARG1:.*]] = zext
   // CHECK-UBSAN-NEXT: %[[ARG2:.*]] = zext
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_800]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_add_overflow_v2(i8* bitcast ({{.*}} @[[LINE_800]] to i8*), i64 %[[ARG1]], i64 %[[ARG2]])
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -202,7 +202,7 @@
   // CHECK-UBSAN:      icmp sgt i32 %[[PARAM:.*]], 0
   //
   // CHECK-UBSAN:      %[[ARG:.*]] = zext i32 %[[PARAM]] to i64
-  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_vla_bound_not_positive(i8* bitcast ({{.*}} @[[LINE_900]] to i8*), i64 %[[ARG]])
+  // CHECK-UBSAN-NEXT: call void @__ubsan_handle_vla_bound_not_positive_v2(i8* bitcast ({{.*}} @[[LINE_900]] to i8*), i64 %[[ARG]])
 #line 900
   int arr[n * 3];
 }
@@ -219,7 +219,7 @@
   // CHECK-COMMON: %[[INBOUNDS:.*]] = icmp ule i128 %{{.*}}, -20282409603651670423947251286016
   // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1000]] to i8*),
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1000]] to i8*),
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -234,7 +234,7 @@
   // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
   // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1100]] to i8*),
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1100]] to i8*),
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -251,7 +251,7 @@
 
   // CHECK-UBSAN: %[[CAST:.*]] = bitcast float %[[F]] to i32
   // CHECK-UBSAN: %[[ARG:.*]] = zext i32 %[[CAST]] to i64
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1200]] to i8*), i64 %[[ARG]]
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1200]] to i8*), i64 %[[ARG]]
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -270,7 +270,7 @@
 
   // CHECK-UBSAN: store x86_fp80 %[[F]], x86_fp80* %[[ALLOCA:.*]], align 16, !nosanitize
   // CHECK-UBSAN: %[[ARG:.*]] = ptrtoint x86_fp80* %[[ALLOCA]] to i64
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1300]] to i8*), i64 %[[ARG]]
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1300]] to i8*), i64 %[[ARG]]
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -285,7 +285,7 @@
   // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
   // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1400]] to i8*),
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1400]] to i8*),
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -300,7 +300,7 @@
   // CHECK-COMMON: %[[INBOUNDS:.*]] = and i1 %[[GE]], %[[LE]]
   // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1500]] to i8*),
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1500]] to i8*),
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -317,7 +317,7 @@
   // CHECK-COMMON: %[[INBOUNDS:.*]] = xor i1 %[[OUTOFBOUNDS]], true
   // CHECK-COMMON-NEXT: br i1 %[[INBOUNDS]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow(i8* bitcast ({{.*}} @[[LINE_1600]] to i8*),
+  // CHECK-UBSAN: call void @__ubsan_handle_float_cast_overflow_v2(i8* bitcast ({{.*}} @[[LINE_1600]] to i8*),
 
   // CHECK-TRAP:      call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP-NEXT: unreachable
@@ -355,7 +355,7 @@
   // CHECK-COMMON: %[[OK:.*]] = icmp ule i8 {{.*}}, 1
   // CHECK-COMMON: br i1 %[[OK]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_load_invalid_value(i8* bitcast ({{.*}}), i64 {{.*}})
+  // CHECK-UBSAN: call void @__ubsan_handle_load_invalid_value_v2(i8* bitcast ({{.*}}), i64 {{.*}})
 
   // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP: unreachable
@@ -368,7 +368,7 @@
   // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null
   // CHECK-COMMON: br i1 [[OK]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_return
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_return_v2
 
   // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP: unreachable
@@ -381,7 +381,7 @@
   // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null
   // CHECK-COMMON: br i1 [[OK]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
 
   // CHECK-TRAP: call void @llvm.trap() [[NR_NUW]]
   // CHECK-TRAP: unreachable
@@ -393,11 +393,11 @@
 // CHECK-COMMON-LABEL: @call_memcpy_nonnull
 void call_memcpy_nonnull(void *p, void *q, int sz) {
   // CHECK-COMMON: icmp ne i8* {{.*}}, null
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
   // CHECK-TRAP: call void @llvm.trap()
 
   // CHECK-COMMON: icmp ne i8* {{.*}}, null
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
   // CHECK-TRAP: call void @llvm.trap()
   memcpy(p, q, sz);
 }
@@ -407,11 +407,11 @@
 // CHECK-COMMON-LABEL: @call_memmove_nonnull
 void call_memmove_nonnull(void *p, void *q, int sz) {
   // CHECK-COMMON: icmp ne i8* {{.*}}, null
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
   // CHECK-TRAP: call void @llvm.trap()
 
   // CHECK-COMMON: icmp ne i8* {{.*}}, null
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
   // CHECK-TRAP: call void @llvm.trap()
   memmove(p, q, sz);
 }
@@ -422,8 +422,8 @@
   // CHECK-COMMON: [[OK:%.*]] = icmp ne i32* {{.*}}, null
   // CHECK-COMMON: br i1 [[OK]]
 
-  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg
-  // CHECK-UBSAN-NOT: __ubsan_handle_nonnull_arg
+  // CHECK-UBSAN: call void @__ubsan_handle_nonnull_arg_v2
+  // CHECK-UBSAN-NOT: __ubsan_handle_nonnull_arg_v2
 
   // CHECK-COMMON: call void (i32, ...) @nonnull_variadic
   nonnull_variadic(a, b);
Index: test/CodeGen/cfi-check-fail.c
===================================================================
--- test/CodeGen/cfi-check-fail.c
+++ test/CodeGen/cfi-check-fail.c
@@ -31,7 +31,7 @@
 // CHECK: [[HANDLE0]]:
 // CHECK:   %[[DATA0:.*]] = ptrtoint i8* %[[DATA]] to i64,
 // CHECK:   %[[ADDR0:.*]] = ptrtoint i8* %[[ADDR]] to i64,
-// CHECK:   call void @__ubsan_handle_cfi_check_fail(i64 %[[DATA0]], i64 %[[ADDR0]], i64 %[[VTVALID]])
+// CHECK:   call void @__ubsan_handle_cfi_check_fail_v2(i64 %[[DATA0]], i64 %[[ADDR0]], i64 %[[VTVALID]])
 // CHECK:   br label %[[CONT1]]
 
 // CHECK: [[CONT1]]:
@@ -49,7 +49,7 @@
 // CHECK: [[HANDLE2]]:
 // CHECK:   %[[DATA2:.*]] = ptrtoint i8* %[[DATA]] to i64,
 // CHECK:   %[[ADDR2:.*]] = ptrtoint i8* %[[ADDR]] to i64,
-// CHECK:   call void @__ubsan_handle_cfi_check_fail_abort(i64 %[[DATA2]], i64 %[[ADDR2]], i64 %[[VTVALID]])
+// CHECK:   call void @__ubsan_handle_cfi_check_fail_abort_v2(i64 %[[DATA2]], i64 %[[ADDR2]], i64 %[[VTVALID]])
 // CHECK:   unreachable
 
 // CHECK: [[CONT3]]:
@@ -59,7 +59,7 @@
 // CHECK: [[HANDLE3]]:
 // CHECK:   %[[DATA3:.*]] = ptrtoint i8* %[[DATA]] to i64,
 // CHECK:   %[[ADDR3:.*]] = ptrtoint i8* %[[ADDR]] to i64,
-// CHECK:   call void @__ubsan_handle_cfi_check_fail(i64 %[[DATA3]], i64 %[[ADDR3]], i64 %[[VTVALID]])
+// CHECK:   call void @__ubsan_handle_cfi_check_fail_v2(i64 %[[DATA3]], i64 %[[ADDR3]], i64 %[[VTVALID]])
 // CHECK:   br label %[[CONT4]]
 
 // CHECK: [[CONT4]]:
Index: test/CodeGen/cfi-check-fail2.c
===================================================================
--- test/CodeGen/cfi-check-fail2.c
+++ test/CodeGen/cfi-check-fail2.c
@@ -31,7 +31,7 @@
 // CHECK: [[HANDLE0]]:
 // CHECK:   %[[DATA0:.*]] = ptrtoint i8* %[[DATA]] to i64,
 // CHECK:   %[[ADDR0:.*]] = ptrtoint i8* %[[ADDR]] to i64,
-// CHECK:   call void @__ubsan_handle_cfi_check_fail_abort(i64 %[[DATA0]], i64 %[[ADDR0]], i64 %[[VTVALID]])
+// CHECK:   call void @__ubsan_handle_cfi_check_fail_abort_v2(i64 %[[DATA0]], i64 %[[ADDR0]], i64 %[[VTVALID]])
 // CHECK:   unreachable
 
 // CHECK: [[CONT1]]:
Index: test/CodeGen/compound-assign-overflow.c
===================================================================
--- test/CodeGen/compound-assign-overflow.c
+++ test/CodeGen/compound-assign-overflow.c
@@ -15,14 +15,14 @@
 void compaddsigned() {
 #line 100
   x += ((int32_t)1);
-  // CHECK: @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), {{.*}})
+  // CHECK: @__ubsan_handle_add_overflow_v2(i8* bitcast ({{.*}} @[[LINE_100]] to i8*), {{.*}})
 }
 
 // CHECK: @compaddunsigned
 void compaddunsigned() {
 #line 200
   x += ((uint32_t)1U);
-  // CHECK: @__ubsan_handle_add_overflow(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), {{.*}})
+  // CHECK: @__ubsan_handle_add_overflow_v2(i8* bitcast ({{.*}} @[[LINE_200]] to i8*), {{.*}})
 }
 
 int8_t a, b;
@@ -31,5 +31,5 @@
 void compdiv() {
 #line 300
   a /= b;
-  // CHECK: @__ubsan_handle_divrem_overflow(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), {{.*}})
+  // CHECK: @__ubsan_handle_divrem_overflow_v2(i8* bitcast ({{.*}} @[[LINE_300]] to i8*), {{.*}})
 }
Index: test/CodeGen/sanitize-recover.c
===================================================================
--- test/CodeGen/sanitize-recover.c
+++ test/CodeGen/sanitize-recover.c
@@ -8,10 +8,10 @@
   extern volatile unsigned x, y, z;
 
   // RECOVER: uadd.with.overflow.i32
-  // RECOVER: ubsan_handle_add_overflow(
+  // RECOVER: __ubsan_handle_add_overflow_v2(
   // RECOVER-NOT: unreachable
   // ABORT: uadd.with.overflow.i32
-  // ABORT: ubsan_handle_add_overflow_abort(
+  // ABORT: __ubsan_handle_add_overflow_abort_v2(
   // ABORT: unreachable
   x = y + z;
 }
@@ -33,7 +33,7 @@
   // PARTIAL:      br i1 %[[CHECK012]], {{.*}} !prof ![[WEIGHT_MD:.*]], !nosanitize
 
   // PARTIAL:      br i1 %[[CHECK02]], {{.*}}
-  // PARTIAL:      call void @__ubsan_handle_type_mismatch_abort(
+  // PARTIAL:      call void @__ubsan_handle_type_mismatch_abort_v2(
   // PARTIAL-NEXT: unreachable
-  // PARTIAL:      call void @__ubsan_handle_type_mismatch(
+  // PARTIAL:      call void @__ubsan_handle_type_mismatch_v2(
 }
Index: test/CodeGen/sanitize-trap.c
===================================================================
--- test/CodeGen/sanitize-trap.c
+++ test/CodeGen/sanitize-trap.c
@@ -22,7 +22,7 @@
   // CHECK: {{^|:}}[[L4]]
   // CHECK-NEXT: zext
   // CHECK-NEXT: zext
-  // CHECK-NEXT: __ubsan_handle_divrem_overflow
+  // CHECK-NEXT: __ubsan_handle_divrem_overflow_abort_v2
 
   // CHECK: {{^|:}}[[L3]]
   // CHECK-NEXT: sdiv i32 %[[N]], %[[D]]
Index: test/CodeGen/ubsan-strip-path-components.cpp
===================================================================
--- test/CodeGen/ubsan-strip-path-components.cpp
+++ test/CodeGen/ubsan-strip-path-components.cpp
@@ -24,6 +24,6 @@
 void f() {
   // CHECK-LABEL: @_Z1fv(
   g(__FILE__);
-  // CHECK: call void @__ubsan_handle_builtin_unreachable(i8* bitcast ({ { [{{.*}} x i8]*, i32, i32 } }* @[[STATIC_DATA]] to i8*)) {{.*}}, !nosanitize
+  // CHECK: call void @__ubsan_handle_builtin_unreachable_v2(i8* bitcast ({ { [{{.*}} x i8]*, i32, i32 } }* @[[STATIC_DATA]] to i8*)) {{.*}}, !nosanitize
   __builtin_unreachable();
 }
Index: test/CodeGen/ubsan-type-blacklist.cpp
===================================================================
--- test/CodeGen/ubsan-type-blacklist.cpp
+++ test/CodeGen/ubsan-type-blacklist.cpp
@@ -14,8 +14,8 @@
 // DEFAULT: @_Z7checkmev
 // TYPE: @_Z7checkmev
 void checkme() {
-// DEFAULT: call void @__ubsan_handle_dynamic_type_cache_miss({{.*}} ({{.*}}* @bar to
-// TYPE-NOT: @__ubsan_handle_dynamic_type_cache_miss
+// DEFAULT: call void @__ubsan_handle_dynamic_type_cache_miss_v2({{.*}} ({{.*}}* @bar to
+// TYPE-NOT: @__ubsan_handle_dynamic_type_cache_miss_v2
   Foo* foo = static_cast<Foo*>(&bar); // down-casting
 // DEFAULT: ret void
 // TYPE: ret void
Index: test/CodeGen/unsigned-overflow.c
===================================================================
--- test/CodeGen/unsigned-overflow.c
+++ test/CodeGen/unsigned-overflow.c
@@ -16,7 +16,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
-  // CHECK: call void @__ubsan_handle_add_overflow
+  // CHECK: call void @__ubsan_handle_add_overflow_abort_v2
   li = lj + lk;
 }
 
@@ -28,7 +28,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 [[T1]], i64 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
-  // CHECK: call void @__ubsan_handle_sub_overflow
+  // CHECK: call void @__ubsan_handle_sub_overflow_abort_v2
   li = lj - lk;
 }
 
@@ -40,7 +40,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 [[T1]], i64 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i64, i1 } [[T3]], 1
-  // CHECK: call void @__ubsan_handle_mul_overflow
+  // CHECK: call void @__ubsan_handle_mul_overflow_abort_v2
   li = lj * lk;
 }
 
@@ -52,7 +52,7 @@
   // CHECK-NEXT: [[T2:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 1)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i64, i1 } [[T2]], 0
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T2]], 1
-  // CHECK:      call void @__ubsan_handle_add_overflow
+  // CHECK:      call void @__ubsan_handle_add_overflow_abort_v2
 }
 
 // CHECK-LABEL: define void @testlongpreinc()
@@ -63,7 +63,7 @@
   // CHECK-NEXT: [[T2:%.*]] = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 [[T1]], i64 1)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i64, i1 } [[T2]], 0
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i64, i1 } [[T2]], 1
-  // CHECK:      call void @__ubsan_handle_add_overflow
+  // CHECK:      call void @__ubsan_handle_add_overflow_abort_v2
 }
 
 // CHECK-LABEL: define void @testintadd()
@@ -74,7 +74,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
-  // CHECK:      call void @__ubsan_handle_add_overflow
+  // CHECK:      call void @__ubsan_handle_add_overflow_abort_v2
   ii = ij + ik;
 }
 
@@ -86,7 +86,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 [[T1]], i32 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
-  // CHECK:      call void @__ubsan_handle_sub_overflow
+  // CHECK:      call void @__ubsan_handle_sub_overflow_abort_v2
   ii = ij - ik;
 }
 
@@ -98,7 +98,7 @@
   // CHECK-NEXT: [[T3:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[T1]], i32 [[T2]])
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T3]], 0
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T3]], 1
-  // CHECK:      call void @__ubsan_handle_mul_overflow
+  // CHECK:      call void @__ubsan_handle_mul_overflow_abort_v2
   ii = ij * ik;
 }
 
@@ -110,7 +110,7 @@
   // CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 1)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
-  // CHECK:      call void @__ubsan_handle_add_overflow
+  // CHECK:      call void @__ubsan_handle_add_overflow_abort_v2
 }
 
 // CHECK-LABEL: define void @testintpreinc()
@@ -121,5 +121,5 @@
   // CHECK-NEXT: [[T2:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T1]], i32 1)
   // CHECK-NEXT: [[T3:%.*]] = extractvalue { i32, i1 } [[T2]], 0
   // CHECK-NEXT: [[T4:%.*]] = extractvalue { i32, i1 } [[T2]], 1
-  // CHECK:      call void @__ubsan_handle_add_overflow
+  // CHECK:      call void @__ubsan_handle_add_overflow_abort_v2
 }
Index: test/CodeGen/unsigned-promotion.c
===================================================================
--- test/CodeGen/unsigned-promotion.c
+++ test/CodeGen/unsigned-promotion.c
@@ -20,7 +20,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_add_overflow
+  // CHECKS:        call void @__ubsan_handle_add_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i16, i16* @sj
   // CHECKU:      [[T2:%.*]] = zext i16 [[T1]]
@@ -42,7 +42,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_sub_overflow
+  // CHECKS:        call void @__ubsan_handle_sub_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i16, i16* @sj
   // CHECKU:      [[T2:%.*]] = zext i16 [[T1]]
@@ -64,7 +64,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.smul.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_mul_overflow
+  // CHECKS:        call void @__ubsan_handle_mul_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i16, i16* @sj
   // CHECKU:      [[T2:%.*]] = zext i16 [[T1]]
@@ -85,7 +85,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_add_overflow
+  // CHECKS:        call void @__ubsan_handle_add_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i8, i8* @cj
   // CHECKU:      [[T2:%.*]] = zext i8 [[T1]]
@@ -107,7 +107,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_sub_overflow
+  // CHECKS:        call void @__ubsan_handle_sub_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i8, i8* @cj
   // CHECKU:      [[T2:%.*]] = zext i8 [[T1]]
@@ -129,7 +129,7 @@
   // CHECKS:        [[T1:%.*]] = call { i32, i1 } @llvm.smul.with.overflow.i32(i32 [[T2:%.*]], i32 [[T3:%.*]])
   // CHECKS-NEXT:   [[T4:%.*]] = extractvalue { i32, i1 } [[T1]], 0
   // CHECKS-NEXT:   [[T5:%.*]] = extractvalue { i32, i1 } [[T1]], 1
-  // CHECKS:        call void @__ubsan_handle_mul_overflow
+  // CHECKS:        call void @__ubsan_handle_mul_overflow_abort_v2
   //
   // CHECKU:      [[T1:%.*]] = load i8, i8* @cj
   // CHECKU:      [[T2:%.*]] = zext i8 [[T1]]
Index: test/CodeGenCXX/bitsets.cpp
===================================================================
--- test/CodeGenCXX/bitsets.cpp
+++ test/CodeGenCXX/bitsets.cpp
@@ -77,9 +77,9 @@
   // NDIAG-NEXT: unreachable
   // DIAG-NEXT: [[VTINT:%[^ ]*]] = ptrtoint i8* [[VT]] to i64
   // DIAG-NEXT: [[VTVALID:%[^ ]*]] = zext i1 [[VTVALID0]] to i64
-  // DIAG-ABORT-NEXT: call void @__ubsan_handle_cfi_check_fail_abort(i8* getelementptr inbounds ({{.*}} @[[BADTYPESTATIC]], i32 0, i32 0), i64 [[VTINT]], i64 [[VTVALID]])
+  // DIAG-ABORT-NEXT: call void @__ubsan_handle_cfi_check_fail_abort_v2(i8* getelementptr inbounds ({{.*}} @[[BADTYPESTATIC]], i32 0, i32 0), i64 [[VTINT]], i64 [[VTVALID]])
   // DIAG-ABORT-NEXT: unreachable
-  // DIAG-RECOVER-NEXT: call void @__ubsan_handle_cfi_check_fail(i8* getelementptr inbounds ({{.*}} @[[BADTYPESTATIC]], i32 0, i32 0), i64 [[VTINT]], i64 [[VTVALID]])
+  // DIAG-RECOVER-NEXT: call void @__ubsan_handle_cfi_check_fail_v2(i8* getelementptr inbounds ({{.*}} @[[BADTYPESTATIC]], i32 0, i32 0), i64 [[VTINT]], i64 [[VTVALID]])
   // DIAG-RECOVER-NEXT: br label %[[CONTBB]]
 
   // CFI: [[CONTBB]]
Index: test/CodeGenCXX/catch-undef-behavior.cpp
===================================================================
--- test/CodeGenCXX/catch-undef-behavior.cpp
+++ test/CodeGenCXX/catch-undef-behavior.cpp
@@ -36,7 +36,7 @@
   int &r = *p;
 
   // A reference is not required to refer to an object within its lifetime.
-  // CHECK-NOT: __ubsan_handle_dynamic_type_cache_miss
+  // CHECK-NOT: __ubsan_handle_dynamic_type_cache_miss_v2
   S &r2 = *q;
 }
 
@@ -86,7 +86,7 @@
   // CHECK-NEXT: icmp eq i64 %[[CACHEVAL]], %[[HASH]]
   // CHECK-NEXT: br i1
 
-  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss({{.*}}, i64 %{{.*}}, i64 %[[HASH]])
+  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss_v2({{.*}}, i64 %{{.*}}, i64 %[[HASH]])
   // CHECK-NOT: unreachable
   // CHECK: {{.*}}:
 
@@ -121,7 +121,7 @@
   // [...]
   // CHECK: getelementptr inbounds [128 x i64], [128 x i64]* @__ubsan_vptr_type_cache, i32 0, i64 %
   // CHECK: br i1
-  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss({{.*}}, i64 %{{.*}}, i64 %{{.*}})
+  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss_v2({{.*}}, i64 %{{.*}}, i64 %{{.*}})
   // CHECK-NOT: unreachable
   // CHECK: {{.*}}:
 
@@ -149,8 +149,8 @@
   // CHECK-NEXT: %[[VALID:.*]] = and i1 %[[RHS_INBOUNDS]], %[[VALID_BASE]]
   // CHECK-NEXT: br i1 %[[VALID]]
 
-  // CHECK: call void @__ubsan_handle_shift_out_of_bounds
-  // CHECK-NOT: call void @__ubsan_handle_shift_out_of_bounds
+  // CHECK: call void @__ubsan_handle_shift_out_of_bounds_v2
+  // CHECK-NOT: call void @__ubsan_handle_shift_out_of_bounds_v2
 
   // CHECK: %[[RET:.*]] = shl i32 %[[LHS]], %[[RHS]]
   // CHECK-NEXT: ret i32 %[[RET]]
@@ -159,7 +159,7 @@
 
 // CHECK-LABEL: @_Z9no_return
 int no_return() {
-  // CHECK:      call void @__ubsan_handle_missing_return(i8* bitcast ({{.*}}* @{{.*}} to i8*)) [[NR_NUW:#[0-9]+]]
+  // CHECK:      call void @__ubsan_handle_missing_return_v2(i8* bitcast ({{.*}}* @{{.*}} to i8*)) [[NR_NUW:#[0-9]+]]
   // CHECK-NEXT: unreachable
 }
 
@@ -167,7 +167,7 @@
 bool sour_bool(bool *p) {
   // CHECK: %[[OK:.*]] = icmp ule i8 {{.*}}, 1
   // CHECK: br i1 %[[OK]]
-  // CHECK: call void @__ubsan_handle_load_invalid_value(i8* bitcast ({{.*}}), i64 {{.*}})
+  // CHECK: call void @__ubsan_handle_load_invalid_value_v2(i8* bitcast ({{.*}}), i64 {{.*}})
   return *p;
 }
 
@@ -179,19 +179,19 @@
 int bad_enum_value() {
   // CHECK: %[[E1:.*]] = icmp ule i32 {{.*}}, 127
   // CHECK: br i1 %[[E1]]
-  // CHECK: call void @__ubsan_handle_load_invalid_value(
+  // CHECK: call void @__ubsan_handle_load_invalid_value_v2(
   int a = e1;
 
   // CHECK: %[[E2HI:.*]] = icmp sle i32 {{.*}}, 127
   // CHECK: %[[E2LO:.*]] = icmp sge i32 {{.*}}, -128
   // CHECK: %[[E2:.*]] = and i1 %[[E2HI]], %[[E2LO]]
   // CHECK: br i1 %[[E2]]
-  // CHECK: call void @__ubsan_handle_load_invalid_value(
+  // CHECK: call void @__ubsan_handle_load_invalid_value_v2(
   int b = e2;
 
   // CHECK: %[[E3:.*]] = icmp ule i32 {{.*}}, 2147483647
   // CHECK: br i1 %[[E3]]
-  // CHECK: call void @__ubsan_handle_load_invalid_value(
+  // CHECK: call void @__ubsan_handle_load_invalid_value_v2(
   int c = e3;
   return a + b + c;
 }
@@ -213,12 +213,12 @@
   // CHECK: %[[E12:.*]] = and i1 %[[E1]], %[[E2]]
   // CHECK: br i1 %[[E12]],
 
-  // CHECK: call void @__ubsan_handle_type_mismatch
+  // CHECK: call void @__ubsan_handle_type_mismatch_v2
   // CHECK: br label
 
   // CHECK: br i1 %{{.*}},
 
-  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss
+  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss_v2
   // CHECK: br label
   (void) static_cast<T*>(p);
 }
@@ -238,12 +238,12 @@
   // CHECK: %[[E123:.*]] = and i1 %[[E12]], %[[E3]]
   // CHECK: br i1 %[[E123]],
 
-  // CHECK: call void @__ubsan_handle_type_mismatch
+  // CHECK: call void @__ubsan_handle_type_mismatch_v2
   // CHECK: br label
 
   // CHECK: br i1 %{{.*}},
 
-  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss
+  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss_v2
   // CHECK: br label
   (void) static_cast<T&>(p);
 }
@@ -252,22 +252,22 @@
 int array_index(const int (&a)[4], int n) {
   // CHECK: %[[K1_OK:.*]] = icmp ult i64 %{{.*}}, 4
   // CHECK: br i1 %[[K1_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   int k1 = a[n];
 
   // CHECK: %[[R1_OK:.*]] = icmp ule i64 %{{.*}}, 4
   // CHECK: br i1 %[[R1_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   const int *r1 = &a[n];
 
   // CHECK: %[[K2_OK:.*]] = icmp ult i64 %{{.*}}, 8
   // CHECK: br i1 %[[K2_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   int k2 = ((const int(&)[8])a)[n];
 
   // CHECK: %[[K3_OK:.*]] = icmp ult i64 %{{.*}}, 4
   // CHECK: br i1 %[[K3_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   int k3 = n[a];
 
   return k1 + *r1 + k2;
@@ -279,11 +279,11 @@
 
   // CHECK: %[[IDX2_OK:.*]] = icmp ult i64 %{{.*}}, 6
   // CHECK: br i1 %[[IDX2_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
 
   // CHECK: %[[IDX1_OK:.*]] = icmp ult i64 %{{.*}}, 4
   // CHECK: br i1 %[[IDX1_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   return arr[n][m];
 }
 
@@ -291,12 +291,12 @@
 int array_arith(const int (&a)[4], int n) {
   // CHECK: %[[K1_OK:.*]] = icmp ule i64 %{{.*}}, 4
   // CHECK: br i1 %[[K1_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   const int *k1 = a + n;
 
   // CHECK: %[[K2_OK:.*]] = icmp ule i64 %{{.*}}, 8
   // CHECK: br i1 %[[K2_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   const int *k2 = (const int(&)[8])a + n;
 
   return *k1 + *k2;
@@ -310,20 +310,20 @@
 int struct_array_index(ArrayMembers *p, int n) {
   // CHECK: %[[IDX_OK:.*]] = icmp ult i64 %{{.*}}, 5
   // CHECK: br i1 %[[IDX_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   return p->a1[n];
 }
 
 // CHECK-LABEL: @_Z16flex_array_index
 int flex_array_index(ArrayMembers *p, int n) {
-  // CHECK-NOT: call void @__ubsan_handle_out_of_bounds(
+  // CHECK-NOT: call void @__ubsan_handle_out_of_bounds_v2(
   return p->a2[n];
 }
 
 extern int incomplete[];
 // CHECK-LABEL: @_Z22incomplete_array_index
 int incomplete_array_index(int n) {
-  // CHECK-NOT: call void @__ubsan_handle_out_of_bounds(
+  // CHECK-NOT: call void @__ubsan_handle_out_of_bounds_v2(
   return incomplete[n];
 }
 
@@ -332,7 +332,7 @@
 int vector_index(V4I v, int n) {
   // CHECK: %[[IDX_OK:.*]] = icmp ult i64 %{{.*}}, 4
   // CHECK: br i1 %[[IDX_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   return v[n];
 }
 
@@ -340,7 +340,7 @@
 char string_index(int n) {
   // CHECK: %[[IDX_OK:.*]] = icmp ult i64 %{{.*}}, 6
   // CHECK: br i1 %[[IDX_OK]]
-  // CHECK: call void @__ubsan_handle_out_of_bounds(
+  // CHECK: call void @__ubsan_handle_out_of_bounds_v2(
   return "Hello"[n];
 }
 
@@ -430,7 +430,7 @@
   // CHECK: %[[MISALIGN:.*]] = and i64 %{{.*}}, 7
   // CHECK: icmp eq i64 %[[MISALIGN]], 0
 
-  // CHECK: call void @__ubsan_handle_type_mismatch
+  // CHECK: call void @__ubsan_handle_type_mismatch_v2
   return t;
 }
 
@@ -443,23 +443,23 @@
   // CHECK-NOT: br i1
 
   // CHECK: call i64 @llvm.objectsize
-  // CHECK: call void @__ubsan_handle_type_mismatch
-  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss
+  // CHECK: call void @__ubsan_handle_type_mismatch_v2
+  // CHECK: call void @__ubsan_handle_dynamic_type_cache_miss_v2
   const S& s = getV();
 }
 }
 
 namespace CopyValueRepresentation {
   // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S3aSERKS0_
-  // CHECK-NOT: call {{.*}} @__ubsan_handle_load_invalid_value
+  // CHECK-NOT: call {{.*}} @__ubsan_handle_load_invalid_value_v2
   // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S4aSEOS0_
-  // CHECK-NOT: call {{.*}} @__ubsan_handle_load_invalid_value
+  // CHECK-NOT: call {{.*}} @__ubsan_handle_load_invalid_value_v2
   // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S1C2ERKS0_
-  // CHECK-NOT: call {{.*}} __ubsan_handle_load_invalid_value
+  // CHECK-NOT: call {{.*}} __ubsan_handle_load_invalid_value_v2
   // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S2C2ERKS0_
-  // CHECK: __ubsan_handle_load_invalid_value
+  // CHECK: __ubsan_handle_load_invalid_value_v2
   // CHECK-LABEL: define {{.*}} @_ZN23CopyValueRepresentation2S5C2ERKS0_
-  // CHECK-NOT: call {{.*}} __ubsan_handle_load_invalid_value
+  // CHECK-NOT: call {{.*}} __ubsan_handle_load_invalid_value_v2
 
   struct CustomCopy { CustomCopy(); CustomCopy(const CustomCopy&); };
   struct S1 {