[RS4GC] Check that GC pointers are non-integral

[tolziplohu]

Summary

As discussed in https://reviews.llvm.org/D103492, input to the RewriteStatepointsForGC pass is only valid if the address space used for GC pointers is specified as non-integral.
This patch makes the RS4GC pass actually check this, and produce a fatal error if it isn't the case.

Exactly one of the existing tests for RS4GC actually marked address space 1 as non-integral, so I updated the rest of them to do that.
That actually means that previously, optimization passes could perform invalid optimizations on the test cases had they been run, so it could have been a latent soundness issue.

This patch hardcodes address space 1 as marking GC pointers.
Theoretically it should be configurable, but it was already hardcoded in other places so another patch is still needed to support that.

[tolziplohu]

Reformat following clang-format's suggestions

[tolziplohu]

Update for newly allowed non-integral inttoptr

[reames]

LGTM

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 /// Apart from attributes and metadata, we also remove instructions that imply
 /// constant physical memory: llvm.invariant.start.
 static void stripNonValidData(Module &M);
 
 static bool shouldRewriteStatepointsIn(Function &F);
 
 PreservedAnalyses RewriteStatepointsForGC::run(Module &M,
                                                ModuleAnalysisManager &AM) {
+  // The abstract machine model of RS4GC's input requires non-integral semantics
+  // for GC pointers.
+  if (!M.getDataLayout().isNonIntegralAddressSpace(1))
+    report_fatal_error(
+        "Address space 1 must be non-integral for RewriteStatepointsForGC pass",
+        false);
+
   bool Changed = false;
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
   for (Function &F : M) {
     // Nothing to do for declarations.
     if (F.isDeclaration() || F.empty())
       continue;
 
     // Policy choice says not to rewrite - the most common reason is that we're
public:
   static char ID; // Pass identification, replacement for typeid
 
   RewriteStatepointsForGCLegacyPass() : ModulePass(ID), Impl() {
     initializeRewriteStatepointsForGCLegacyPassPass(
         *PassRegistry::getPassRegistry());
   }
 
   bool runOnModule(Module &M) override {
+    // The abstract machine model of RS4GC's input requires non-integral semantics
+    // for GC pointers.
+    if (!M.getDataLayout().isNonIntegralAddressSpace(1))
+      report_fatal_error(
+          "Address space 1 must be non-integral for RewriteStatepointsForGC pass",
+          false);
+
     bool Changed = false;
     for (Function &F : M) {
       // Nothing to do for declarations.
       if (F.isDeclaration() || F.empty())
         continue;
 
       // Policy choice says not to rewrite - the most common reason is that
       // we're compiling code without a GCStrategy.
if (IID == Intrinsic::experimental_deoptimize) {
       //   memcpy(dest_base, dest_offset, source_base, source_offset, ...)
       auto &Context = Call->getContext();
       auto &DL = Call->getModule()->getDataLayout();
       auto GetBaseAndOffset = [&](Value *Derived) {
         assert(Result.PointerToBase.count(Derived));
         unsigned AddressSpace = Derived->getType()->getPointerAddressSpace();
         unsigned IntPtrSize = DL.getPointerSizeInBits(AddressSpace);
         Value *Base = Result.PointerToBase.find(Derived)->second;
+        // addrspacecast to an integral address space is required for ptrtoint.
+        // It doesn't create problems with statepoints, because this runs after
+        // the RS4GC pass.
+        Value *Base_integral = Builder.CreateAddrSpaceCast(
+            Base, Base->getType()->getPointerElementType()->getPointerTo(0),
+            suffixed_name_or(Base, ".integral", ""));
+        Derived = Builder.CreateAddrSpaceCast(
+            Derived, Base->getType()->getPointerElementType()->getPointerTo(0),
+            suffixed_name_or(Derived, ".integral", ""));
         Value *Base_int = Builder.CreatePtrToInt(
-            Base, Type::getIntNTy(Context, IntPtrSize));
+            Base_integral, Type::getIntNTy(Context, IntPtrSize));
         Value *Derived_int = Builder.CreatePtrToInt(
             Derived, Type::getIntNTy(Context, IntPtrSize));
         return std::make_pair(Base, Builder.CreateSub(Derived_int, Base_int));
       };
 
       auto *Dest = CallArgs[0];
       Value *DestBase, *DestOffset;
       std::tie(DestBase, DestOffset) = GetBaseAndOffset(Dest);
for (auto *Callsite : Intrinsics)
     case Intrinsic::experimental_gc_get_pointer_offset: {
       Changed = true;
       Value *Derived = Callsite->getOperand(0);
       Value *Base = findBasePointer(Derived, DVCache);
       assert(!DVCache.count(Callsite));
       unsigned AddressSpace = Derived->getType()->getPointerAddressSpace();
       unsigned IntPtrSize = DL.getPointerSizeInBits(AddressSpace);
       IRBuilder<> Builder(Callsite);
+      // addrspacecast to an integral address space is required for ptrtoint.
+      // It doesn't create problems with statepoints, because this runs after the RS4GC pass.
+      Base = Builder.CreateAddrSpaceCast(
+          Base, Base->getType()->getPointerElementType()->getPointerTo(0),
+          suffixed_name_or(Base, ".integral", ""));
+      Derived = Builder.CreateAddrSpaceCast(
+          Derived, Base->getType()->getPointerElementType()->getPointerTo(0),
+          suffixed_name_or(Derived, ".integral", ""));
       Value *BaseInt =
           Builder.CreatePtrToInt(Base, Type::getIntNTy(Context, IntPtrSize),
                                  suffixed_name_or(Base, ".int", ""));
       Value *DerivedInt =
           Builder.CreatePtrToInt(Derived, Type::getIntNTy(Context, IntPtrSize),
                                  suffixed_name_or(Derived, ".int", ""));
       Value *Offset = Builder.CreateSub(DerivedInt, BaseInt);
       Callsite->replaceAllUsesWith(Offset);

llvm/test/Transforms/RewriteStatepointsForGC/X86/intrinsic-attributes.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; CHECK: Function Attrs: nounwind readnone
 ; CHECK: declare i64 @llvm.x86.sse2.cvttsd2si64(<2 x double>)
 declare i64 @llvm.x86.sse2.cvttsd2si64(<2 x double>)
 
 define i64 @test(<2 x double> %arg) {
   %ret = call i64 @llvm.x86.sse2.cvttsd2si64(<2 x double> %arg)
   ret i64 %ret
 }
 

llvm/test/Transforms/RewriteStatepointsForGC/base-inference.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; A collection of tests for exercising the base inference logic in the
 ; findBasePointers.  That is, the logic which proves a potentially derived
 ; pointer is actually a base pointer itself.
 
 define i8 addrspace(1)* @test(i8 addrspace(1)* %a) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[A:%.*]]) ]
 ; CHECK-NEXT:    [[A_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @site_for_call_safpeoint()
 
 ; derived %merged_value base %merged_value.base
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[RUNTIME_CONDITION:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare i1 @runtime_value() "gc-leaf-function"
 
 declare void @do_safepoint()
 
 define void @select_of_phi(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y) gc "statepoint-example" {
 ; CHECK-LABEL: @select_of_phi(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @do_safepoint()
 
 ; derived %next base %base_obj
 define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-12.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
 
 @global = external addrspace(1) global i8
 
 ; derived %select base null
 define i8 @test(i1 %cond) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    [[DERIVED1:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 1
 ; CHECK-NEXT:    [[DERIVED2:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 2

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-13.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 @global = external addrspace(1) global i8
 
 define i8 @test(i64 %offset) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:    [[DERIVED:%.*]] = getelementptr i8, i8 addrspace(1)* @global, i64 [[OFFSET:%.*]]
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @extern, i32 0, i32 0, i32 0, i32 0)
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i8, i8 addrspace(1)* [[DERIVED]], align 1
 ; CHECK-NEXT:    ret i8 [[LOAD]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; derived %merged_value base %base_obj
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[RUNTIME_CONDITION:%.*]], label [[MERGE:%.*]], label [[THERE:%.*]]
 ; CHECK:       there:
 ; CHECK-NEXT:    [[DERIVED_OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
 ; CHECK-NEXT:    br label [[MERGE]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; derived %next.i64 base %base_obj
 
 define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = getelementptr i64, i64 addrspace(1)* [[BASE_OBJ:%.*]], i32 1
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @foo()
 
 declare i64 addrspace(1)* @generate_obj()
 
 declare void @consume_obj(i64 addrspace(1)*)
 
 ; derived %obj_to_consume base %obj_to_consume.base
 define void @test(i32 %condition) gc "statepoint-example" {

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @foo()
 
 ; derived %merged_value base %merged_value.base
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[RUNTIME_CONDITION:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @site_for_call_safpeoint()
 
 ; derived %merged_value base %merged_value.base
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[RUNTIME_CONDITION_X:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @site_for_call_safpeoint()
 
 ; derived %merged_value base %merged_value.base
 define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj_x, i64 addrspace(1)* %base_obj_y, i1 %runtime_condition_x, i1 %runtime_condition_y) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[RUNTIME_CONDITION_X:%.*]], label [[HERE:%.*]], label [[THERE:%.*]]
 ; CHECK:       here:

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; derived %next_element_ptr base %array_obj
 define i32 @null_in_array(i64 addrspace(1)* %array_obj) gc "statepoint-example" {
 ; CHECK-LABEL: @null_in_array(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[ARRAY_LEN_POINTER_I64:%.*]] = getelementptr i64, i64 addrspace(1)* [[ARRAY_OBJ:%.*]], i32 1
 ; CHECK-NEXT:    [[ARRAY_LEN_POINTER_I32:%.*]] = bitcast i64 addrspace(1)* [[ARRAY_LEN_POINTER_I64]] to i32 addrspace(1)*
 ; CHECK-NEXT:    [[ARRAY_LEN:%.*]] = load i32, i32 addrspace(1)* [[ARRAY_LEN_POINTER_I32]], align 4
 ; CHECK-NEXT:    [[ARRAY_ELEMS:%.*]] = bitcast i32 addrspace(1)* [[ARRAY_LEN_POINTER_I32]] to i64 addrspace(1)* addrspace(1)*

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S  2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S  2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare i1 @runtime_value() "gc-leaf-function"
 
 ; derived %next base %base_obj
 define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
 ; CHECK-LABEL: @maybe_GEP(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:

llvm/test/Transforms/RewriteStatepointsForGC/base-pointers.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
 
 declare void @use_obj(i64 addrspace(1)*) "gc-leaf-function"
 
 ; The rewriting needs to make %obj loop variant by inserting a phi
 ; of the original value and it's relocation.
 define void @test() gc "statepoint-example" {
 ; CHECK-LABEL: @test(

llvm/test/Transforms/RewriteStatepointsForGC/base-vector-inseltpoison.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
+target datalayout = "ni:1"
 
 define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC:%.*]], i32 [[IDX:%.*]]
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]
 ; CHECK-NEXT:    [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
 ; CHECK-NEXT:    [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*

llvm/test/Transforms/RewriteStatepointsForGC/base-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
+target datalayout = "ni:1"
 
 define i64 addrspace(1)* @test(<2 x i64 addrspace(1)*> %vec, i32 %idx) gc "statepoint-example" {
 ; Note that the second extractelement is actually redundant here.  A correct output would
 ; be to reuse the existing obj as a base since it is actually a base pointer.
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ:%.*]] = extractelement <2 x i64 addrspace(1)*> [[VEC:%.*]], i32 [[IDX:%.*]]
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ]]) ]

llvm/test/Transforms/RewriteStatepointsForGC/basic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @g()
 declare i32 @h()
 
 define i32 addrspace(1)* @f0(i32 addrspace(1)* %arg) gc "statepoint-example" {
 ; CHECK-LABEL: @f0(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @g, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 100), "gc-live"(i32 addrspace(1)* [[ARG:%.*]]) ]
 ; CHECK-NEXT:    [[ARG_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)

llvm/test/Transforms/RewriteStatepointsForGC/basics.ll

 ; This is a collection of really basic tests for gc.statepoint rewriting.
 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 
+target datalayout = "ni:1"
+
 ; Trivial relocation over a single call
 
 declare void @foo()
 
 define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 entry:
 ; CHECK-LABEL: entry:

llvm/test/Transforms/RewriteStatepointsForGC/call-gc-result.ll

 ;; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 ;; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 ;; This test is to verify that gc_result from a call statepoint
 ;; can have preceding phis in its parent basic block. Unlike
 ;; invoke statepoint, call statepoint does not terminate the
 ;; block, and thus its gc_result is in the same block with the
 ;; call statepoint.
 
+target datalayout = "ni:1"
+
 declare i32 @foo()
 
 define i32 @test1(i1 %cond, i32 %a) gc "statepoint-example" {
 entry:
   br i1 %cond, label %branch1, label %branch2
   
 branch1:
   %b = add i32 %a, 1

llvm/test/Transforms/RewriteStatepointsForGC/codegen-cond.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; A null test of a single value
 
+target datalayout = "ni:1"
+
 define i1 @test(i8 addrspace(1)* %p, i1 %rare) gc "statepoint-example" {
 ; CHECK-LABEL: @test
 entry:
   %cond = icmp eq i8 addrspace(1)* %p, null
   br i1 %rare, label %safepoint, label %continue, !prof !0
 
 safepoint:                                        ; preds = %entry
   call void @safepoint() [ "deopt"() ]

llvm/test/Transforms/RewriteStatepointsForGC/constants.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
+; XFAIL: *
+
+target datalayout = "ni:1"
 
 ; constants don't get relocated.
 @G = addrspace(1) global i8 5
 
 declare void @foo()
 
 define i8 @test() gc "statepoint-example" {
 ; CHECK-LABEL: @test

llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic-cconv.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare cc42 double @llvm.experimental.deoptimize.f64(...)
 
 define double @caller_3() gc "statepoint-example" {
 ; CHECK-LABEL: @caller_3(
 ; CHECK: call cc42 token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint
 ; CHECK:  unreachable
 
 entry:
   %val = call cc42 double(...) @llvm.experimental.deoptimize.f64() [ "deopt"() ]
   ret double %val
 }

llvm/test/Transforms/RewriteStatepointsForGC/deopt-intrinsic.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare i32 @llvm.experimental.deoptimize.i32(...)
 declare void @llvm.experimental.deoptimize.isVoid(...)
 
 define i32 @caller_0(i32 addrspace(1)* %ptr) gc "statepoint-example" {
 ; CHECK-LABEL: @caller_0(
 ; CHECK: @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @__llvm_deoptimize, i32 0

llvm/test/Transforms/RewriteStatepointsForGC/deopt-lowering-attrs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; Check that the "deopt-lowering" function attribute gets transcoded into
 ; flags on the resulting statepoint
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @foo()
 declare void @bar() "deopt-lowering"="live-in"
 declare void @baz() "deopt-lowering"="live-through"
 
 define void @test1() gc "statepoint-example" {
 ; CHECK-LABEL: @test1(

llvm/test/Transforms/RewriteStatepointsForGC/deref-pointers.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; CHECK: declare i8 addrspace(1)* @some_function_ret_deref()
 ; CHECK: define i8 addrspace(1)* @test_deref_arg(i8 addrspace(1)* %a)
 ; CHECK: define i8 addrspace(1)* @test_deref_or_null_arg(i8 addrspace(1)* %a)
 ; CHECK: define i8 addrspace(1)* @test_noalias_arg(i8 addrspace(1)* %a)
 
+target datalayout = "ni:1"
+
 declare void @foo()
 
 declare i8 addrspace(1)* @some_function() "gc-leaf-function"
 
 declare void @some_function_consumer(i8 addrspace(1)*) "gc-leaf-function"
 
 declare dereferenceable(4) i8 addrspace(1)* @some_function_ret_deref() "gc-leaf-function"
 declare noalias i8 addrspace(1)* @some_function_ret_noalias() "gc-leaf-function"

llvm/test/Transforms/RewriteStatepointsForGC/drop-invalid-metadata.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; This test checks that metadata that's invalid after RS4GC is dropped. 
 ; We can miscompile if optimizations scheduled after RS4GC uses the
 ; metadata that's infact invalid.
 
+target datalayout = "ni:1"
+
 declare void @bar()
 
 declare void @baz(i32)
 ; Confirm that loadedval instruction does not contain invariant.load metadata.
 ; but contains the range metadata.
 ; Since loadedval is not marked invariant, it will prevent incorrectly sinking
 ; %loadedval in LICM and avoid creation of an unrelocated use of %baseaddr.
 define void @test_invariant_load() gc "statepoint-example" {

llvm/test/Transforms/RewriteStatepointsForGC/gc-relocate-creation.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
 ; This test is to verify gc.relocate can handle pointer to vector of
 ; pointers (<2 x i32 addrspace(1)*> addrspace(1)* in this case).
 ; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)*> addrspace(1)*
 ; type will fail because llvm does not support mangling vector of pointers.
 ; The new scheme will create all gc.relocate to i8 addrspace(1)* type and
 ; then bitcast to the correct type.
 
+target datalayout = "ni:1"
+
 declare void @foo()
 
 declare void @use(...) "gc-leaf-function"
 
 define void @test1(<2 x i32 addrspace(1)*> addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(<2 x i32 addrspace(1)*> addrspace(1)* [[OBJ:%.*]]) ]

llvm/test/Transforms/RewriteStatepointsForGC/intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; Use instcombine to cleanup offset computation.
 ; Use gvn to remove duplicate computation.
 ; RUN: opt -passes=rewrite-statepoints-for-gc,gvn,instcombine -S < %s | FileCheck %s
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare i8 addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1i8.p1i8(i8 addrspace(1)* readnone nocapture) nounwind readnone willreturn
 declare i8 addrspace(1)* addrspace(1)* @llvm.experimental.gc.get.pointer.base.p1p1i8.p1p1i8(i8 addrspace(1)* addrspace(1)* readnone nocapture) nounwind readnone willreturn
 declare i64 @llvm.experimental.gc.get.pointer.offset.p1i8(i8 addrspace(1)* readnone nocapture) nounwind readnone willreturn
 declare i64 @llvm.experimental.gc.get.pointer.offset.p1p1i8(i8 addrspace(1)* addrspace(1)* readnone nocapture) nounwind readnone willreturn
 
 declare void @foo() readonly
 
 define i8 addrspace(1)* addrspace(1)* @test_simple(i8 addrspace(1)* %obj1, i8 addrspace(1)* %obj2, i32 %len, i1 %c) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_simple
 ; CHECK-SAME: (i8 addrspace(1)* [[OBJ1:%.*]], i8 addrspace(1)* [[OBJ2:%.*]], i32 [[LEN:%.*]], i1 [[C:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[OBJ1_12:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ1]], i64 12
 ; CHECK-NEXT:    [[OBJ2_16:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[OBJ2]], i64 16
 ; CHECK-NEXT:    [[OBJ_X_BASE1:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ1]], i8 addrspace(1)* [[OBJ2]], !is_base_value !0
 ; CHECK-NEXT:    [[OBJ_X:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ1_12]], i8 addrspace(1)* [[OBJ2_16]]
 ; CHECK-NEXT:    [[OBJ_Y_BASE:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ2]], i8 addrspace(1)* [[OBJ1]]
 ; CHECK-NEXT:    [[OBJ_Y:%.*]] = select i1 [[C]], i8 addrspace(1)* [[OBJ2_16]], i8 addrspace(1)* [[OBJ1_12]]
 ; CHECK-NEXT:    [[OBJ_YA:%.*]] = bitcast i8 addrspace(1)* [[OBJ_Y]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT:    [[OBJ_X_BASE1_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_X_BASE1]] to i64
-; CHECK-NEXT:    [[OBJ_X_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_X]] to i64
+; CHECK-NEXT:    [[OBJ_X_BASE1_INTP:%.*]] = addrspacecast i8 addrspace(1)* [[OBJ_X_BASE1]] to i8*
+; CHECK-NEXT:    [[OBJ_X_INTP:%.*]] = addrspacecast i8 addrspace(1)* [[OBJ_X]] to i8*
+; CHECK-NEXT:    [[OBJ_X_BASE1_INT:%.*]] = ptrtoint i8* [[OBJ_X_BASE1_INTP]] to i64
+; CHECK-NEXT:    [[OBJ_X_INT:%.*]] = ptrtoint i8* [[OBJ_X_INTP]] to i64
 ; CHECK-NEXT:    [[OBJ_X_OFFSET:%.*]] = sub i64 [[OBJ_X_INT]], [[OBJ_X_BASE1_INT]]
 ; CHECK-NEXT:    [[OBJ_Y_BASE_CAST:%.*]] = bitcast i8 addrspace(1)* [[OBJ_Y_BASE]] to i8 addrspace(1)* addrspace(1)*
-; CHECK-NEXT:    [[OBJ_Y_BASE_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_Y_BASE]] to i64
-; CHECK-NEXT:    [[OBJ_YA_INT:%.*]] = ptrtoint i8 addrspace(1)* [[OBJ_Y]] to i64
+; CHECK-NEXT:    [[OBJ_Y_BASE_INTP:%.*]] = addrspacecast i8 addrspace(1)* [[OBJ_Y_BASE]] to i8*
+; CHECK-NEXT:    [[OBJ_YA_INTP:%.*]] = addrspacecast i8 addrspace(1)* [[OBJ_Y]] to i8*
+; CHECK-NEXT:    [[OBJ_Y_BASE_INT:%.*]] = ptrtoint i8* [[OBJ_Y_BASE_INTP]] to i64
+; CHECK-NEXT:    [[OBJ_YA_INT:%.*]] = ptrtoint i8* [[OBJ_YA_INTP]] to i64
 ; CHECK-NEXT:    [[OBJ_YA_OFFSET:%.*]] = sub i64 [[OBJ_YA_INT]], [[OBJ_Y_BASE_INT]]
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* nonnull @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i8 addrspace(1)* [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], i8 addrspace(1)* [[OBJ_X_BASE1]], i64 [[OBJ_X_OFFSET]], i8 addrspace(1)* addrspace(1)* [[OBJ_Y_BASE_CAST]], i64 [[OBJ_YA_OFFSET]]), "gc-live"(i8 addrspace(1)* addrspace(1)* [[OBJ_YA]], i8 addrspace(1)* [[OBJ_Y_BASE]]) ]
 ; CHECK-NEXT:    [[OBJ_YA_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
 ; CHECK-NEXT:    [[OBJ_YA_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_YA_RELOCATED]] to i8 addrspace(1)* addrspace(1)*
 ; CHECK-NEXT:    ret i8 addrspace(1)* addrspace(1)* [[OBJ_YA_RELOCATED_CASTED]]
 ;
 entry:
   %obj1.12 = getelementptr inbounds i8, i8 addrspace(1)* %obj1, i64 12

llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 ; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
 declare i32 @personality_function()
 
 define i64 addrspace(1)* @test_basic(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke
   ; CHECK: statepoint

llvm/test/Transforms/RewriteStatepointsForGC/leaf-function.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 ; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @foo() "gc-leaf-function"
 declare void @bar()
 
 ; Calls of functions with the "gc-leaf-function" attribute shouldn't be turned
 ; into a safepoint.  An entry safepoint should get inserted, though.
 define void @test_leaf_function() gc "statepoint-example" {
 ; CHECK-LABEL: test_leaf_function
 ; CHECK-NOT: gc.statepoint

llvm/test/Transforms/RewriteStatepointsForGC/libcall.ll

 ; A call to a libcall function is not a statepoint.
 ; This test verifies that calls to libcalls functions do not get converted to
 ; statepoint calls.
 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare double @ldexp(double %x, i32 %n) nounwind readnone
 
 define double @test_libcall(double %x) gc "statepoint-example" {
 ; CHECK-LABEL: test_libcall
 ; CHECK-NEXT: %res = call double @ldexp(double %x, i32 5)
 ; CHECK-NEXT: ret double %res
   %res = call double @ldexp(double %x, i32 5) nounwind readnone
   ret double %res
 }

llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit-inseltpoison.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that we can correctly handle vectors of pointers in statepoint
 ; rewriting.
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
+target datalayout = "ni:1"
+
 ; A non-vector relocation for comparison
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ:%.*]]) ]
 ; CHECK-NEXT:    [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
 ; CHECK-NEXT:    [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
 ; CHECK-NEXT:    ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]

llvm/test/Transforms/RewriteStatepointsForGC/live-vector-nosplit.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that we can correctly handle vectors of pointers in statepoint
 ; rewriting.
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
+target datalayout = "ni:1"
+
 ; A non-vector relocation for comparison
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i64 addrspace(1)* [[OBJ:%.*]]) ]
 ; CHECK-NEXT:    [[OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
 ; CHECK-NEXT:    [[OBJ_RELOCATED_CASTED:%.*]] = bitcast i8 addrspace(1)* [[OBJ_RELOCATED]] to i64 addrspace(1)*
 ; CHECK-NEXT:    ret i64 addrspace(1)* [[OBJ_RELOCATED_CASTED]]

llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll

 ; A collection of liveness test cases to ensure we're reporting the
 ; correct live values at statepoints
 ; RUN: opt -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S < %s | FileCheck %s
 
 ; Tests to make sure we consider %obj live in both the taken and untaken 
 ; predeccessor of merge.
 
+target datalayout = "ni:1"
+
 define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 entry:
   br i1 %cmp, label %taken, label %untaken
 
 taken:                                            ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint

llvm/test/Transforms/RewriteStatepointsForGC/meetBDVState-hangs.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 
 ; Regression test to incorrectly testing fixed state causing infinite loop.
 ; CHECK: test
 target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "ni:1"
 
 declare void @bar(i8 addrspace(1)* nocapture readonly)
 declare noalias i8 addrspace(1)* @foo()
 
 define i8 addrspace(1)* @test(i1 %c, i1 %c1, i1 %c2, i1 %c3, i1 %c4, i1 %c5, i1 %c.exit) gc "statepoint-example" {
 entry:
   br i1 %c, label %ph.L, label %ph.R
 ph.L:

llvm/test/Transforms/RewriteStatepointsForGC/patchable-statepoints.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @f()
 declare i32 @personality_function()
 
 define void @test_id() gc "statepoint-example" personality i32 ()* @personality_function {
 ; CHECK-LABEL: @test_id(
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK: invoke token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 100, i32 0, void ()* @f

llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Test to make sure we destroy LCSSA's single entry phi nodes before
 ; running liveness
 
+target datalayout = "ni:1"
+
 declare void @consume(...) "gc-leaf-function"
 
 define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test6
 entry:
   br label %next
 
 next:                                             ; preds = %entry

llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll

 
 ;; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 ;; RUN: opt -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
 ;; This test is to verify that RewriteStatepointsForGC correctly relocates values
 ;; defined by invoke instruction results. 
 
+target datalayout = "ni:1"
+
 declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function"
 
 declare void @gc_call()
 
 declare i32* @fake_personality_function()
 
 define i64* addrspace(1)* @test() gc "statepoint-example" personality i32* ()* @fake_personality_function {
 ; CHECK-LABEL: @test(

llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -spp-rematerialization-threshold=0 -S | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @foo()
 
 declare void @use(...) "gc-leaf-function"
 
 define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 ; CHECK-DAG: %obj.relocated

llvm/test/Transforms/RewriteStatepointsForGC/rematerialize-derived-pointers.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
+target datalayout = "ni:1"
 
 declare void @use_obj16(i16 addrspace(1)*) "gc-leaf-function"
 declare void @use_obj32(i32 addrspace(1)*) "gc-leaf-function"
 declare void @use_obj64(i64 addrspace(1)*) "gc-leaf-function"
 
 declare void @do_safepoint()
 
 define void @test_gep_const(i32 addrspace(1)* %base) gc "statepoint-example" {

llvm/test/Transforms/RewriteStatepointsForGC/rewrite-invoke.ll

 ; RUN: opt -rewrite-statepoints-for-gc -verify -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc,verify -S < %s | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare i8 addrspace(1)* @gc_call()
 
 declare i32* @fake_personality_function()
 
 define i8 addrspace(1)* @test(i1 %c) gc "statepoint-example" personality i32* ()* @fake_personality_function {
 ; CHECK-LABEL: @test(
 entry:
   br i1 %c, label %gc_invoke, label %normal_dest

llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector-2.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
 ; Assertions are almost autogenerated except for last testcase widget, which was
 ; updated (with -DAG instead of -NEXT) to fix buildbot failure reproducible only on two boxes.
 
+target datalayout = "ni:1"
+
 ; Uses of extractelement that are of scalar type should not have the BDV
 ; incorrectly identified as a vector type.
 define void @widget() gc "statepoint-example" {
 ; CHECK-LABEL: @widget(
 ; CHECK-NEXT:  bb6:
 ; CHECK-NEXT:    [[BASE_EE:%.*]] = extractelement <2 x i8 addrspace(1)*> zeroinitializer, i32 1, !is_base_value !0
 ; CHECK-NEXT:    [[TMP:%.*]] = extractelement <2 x i8 addrspace(1)*> undef, i32 1
 ; CHECK-NEXT:    br i1 undef, label [[BB7:%.*]], label [[BB9:%.*]]

llvm/test/Transforms/RewriteStatepointsForGC/scalar-base-vector.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck  %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck  %s
 
+target datalayout = "ni:1"
+
 declare void @do_safepoint()
 declare i8 addrspace(1)* @def_ptr()
 
 define i32 addrspace(1)* @test1(i8 addrspace(1)* %base1, <2 x i64> %offsets) gc "statepoint-example" {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 undef, label [[FIRST:%.*]], label [[SECOND:%.*]]
 ; CHECK:       first:

llvm/test/Transforms/RewriteStatepointsForGC/statepoint-attrs.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 ; Ensure statepoints copy (valid) attributes from callsites.
 
+target datalayout = "ni:1"
+
 declare void @f(i8 addrspace(1)* %obj)
 
 ; copy over norecurse noimplicitfloat to statepoint call
 define void @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
 ; CHECK-LABEL: test1(
 ; CHECK: %statepoint_token = call token (i64, i32, void (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8f(i64 2882400000, i32 0, void (i8 addrspace(1)*)* @f, i32 1, i32 0, i8 addrspace(1)* %arg, i32 0, i32 0) #1 [ "gc-live"(i8 addrspace(1)* %arg) ]
 
  call void @f(i8 addrspace(1)* %arg) #1
  ret void
 }
 
 
 attributes #1 = { norecurse noimplicitfloat }

llvm/test/Transforms/RewriteStatepointsForGC/statepoint-calling-conventions.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate carry over
 ; the right calling conventions.
 
+target datalayout = "ni:1"
+
 define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke coldcc token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0
 entry:
   %ret_val = invoke coldcc i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
                to label %normal_return unwind label %exceptional_return
 

llvm/test/Transforms/RewriteStatepointsForGC/statepoint-coreclr.ll

 ; RUN: opt < %s -S -rewrite-statepoints-for-gc | FileCheck %s
 ; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
 ; Basic test to make sure that safepoints are placed
 ; for CoreCLR GC
 
+target datalayout = "ni:1"
+
 declare void @foo()
 
 define void @test_simple_call() gc "coreclr" {
 ; CHECK-LABEL: test_simple_call
 entry:
   br label %other
 other:
 ; CHECK-LABEL: other

llvm/test/Transforms/RewriteStatepointsForGC/statepoint-format.ll

 ; RUN: opt -rewrite-statepoints-for-gc -S < %s | FileCheck %s
 ; RUN: opt -passes=rewrite-statepoints-for-gc -S < %s | FileCheck %s
 
 ; Ensure that the gc.statepoint calls / invokes we generate have the
 ; set of arguments we expect it to have.
 
+target datalayout = "ni:1"
+
 define i64 addrspace(1)* @test_invoke_format(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality {
 ; CHECK-LABEL: @test_invoke_format(
 ; CHECK-LABEL: entry:
 ; CHECK: invoke token (i64, i32, i64 addrspace(1)* (i64 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 2882400000, i32 0, i64 addrspace(1)* (i64 addrspace(1)*)* @callee, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 0) [ "gc-live"(i64 addrspace(1)* %obj1, i64 addrspace(1)* %obj) ]
 entry:
   %ret_val = invoke i64 addrspace(1)* @callee(i64 addrspace(1)* %obj)
                to label %normal_return unwind label %exceptional_return
 

llvm/test/Transforms/RewriteStatepointsForGC/strip-invalid-attributes.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc  < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc  < %s | FileCheck %s
 
 
 ; Ensure we're stipping attributes from the function signatures which are invalid
 ; after inserting safepoints with explicit memory semantics
 
+target datalayout = "ni:1"
+
 declare void @f()
 
 define i8 addrspace(1)* @deref_arg(i8 addrspace(1)* dereferenceable(16) %arg) gc "statepoint-example" {
 ; CHECK: define i8 addrspace(1)* @deref_arg(i8 addrspace(1)* %arg)
   call void @f()
   ret i8 addrspace(1)* %arg
 }
 

llvm/test/Transforms/RewriteStatepointsForGC/two-invokes-one-landingpad.ll

 ; RUN: opt < %s -rewrite-statepoints-for-gc -S | FileCheck %s
 ; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S | FileCheck %s
 
+target datalayout = "ni:1"
+
 declare void @some_call(i64 addrspace(1)*)
 
 declare i32 @dummy_personality_function()
 
 define i64 addrspace(1)* @test(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
   gc "statepoint-example"
   personality i32 ()* @dummy_personality_function {
 entry:

llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy-no-deopt.ll

 ; RUN: opt -passes=rewrite-statepoints-for-gc -rs4gc-allow-statepoint-with-no-deopt-info=0 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-REQUIRE-DEOPT
 ; RUN: opt -passes=rewrite-statepoints-for-gc -rs4gc-allow-statepoint-with-no-deopt-info=1 -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NO-REQUIRE-DEOPT
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
 declare void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
 
 define void @test_memcpy_no_deopt(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: @test_memcpy_no_deopt
 ; CHECK-REQUIRE-DEOPT-NOT: @llvm.experimental.gc.statepoint

llvm/test/Transforms/RewriteStatepointsForGC/unordered-atomic-memcpy.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
 ; Use instcombine to cleanup offset computation.
 ; RUN: opt -passes=rewrite-statepoints-for-gc,instcombine -S < %s | FileCheck %s
 
-target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64"
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128-p1:64:64-ni:1"
 target triple = "x86_64-apple-macosx10.11.0"
 
 declare void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
 declare void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32 immarg)
 
 define void @test_memcpy_gc_leaf_function(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_gc_leaf_function
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
 ; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
-; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) [[ATTR2:#.*]]
-; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) [[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
 
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
   ret void
 }
 
 define void @test_memcpy_element_atomic_1(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_1
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
   ret void
 }
 
 define void @test_memcpy_element_atomic_2(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_2
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2)
   ret void
 }
 
 define void @test_memcpy_element_atomic_4(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_4
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4)
   ret void
 }
 
 define void @test_memcpy_element_atomic_8(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_8
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8)
   ret void
 }
 
 define void @test_memcpy_element_atomic_16(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memcpy_element_atomic_16
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memcpy_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memcpy.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16)
   ret void
 }
 
 define void @test_memmove_gc_leaf_function(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_gc_leaf_function
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
 ; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
-; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) [[ATTR2]]
-; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) [[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 1) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 2) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 4) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 8) #[[ATTR2]]
+; CHECK-NEXT:    call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 [[SRC_DERIVED]], i8 addrspace(1)* align 16 [[DEST_DERIVED]], i32 [[LEN]], i32 16) #[[ATTR2]]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
 
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1) "gc-leaf-function"
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2) "gc-leaf-function"
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4) "gc-leaf-function"
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8) "gc-leaf-function"
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16) "gc-leaf-function"
   ret void
 }
 
 define void @test_memmove_element_atomic_1(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_1
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_1, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 1)
   ret void
 }
 
 define void @test_memmove_element_atomic_2(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_2
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_2, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 2)
   ret void
 }
 
 define void @test_memmove_element_atomic_4(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_4
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_4, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 4)
   ret void
 }
 
 define void @test_memmove_element_atomic_8(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_8
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_8, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 8)
   ret void
 }
 
 define void @test_memmove_element_atomic_16(i8 addrspace(1)* %src, i64 %src_offset, i8 addrspace(1)* %dest, i64 %dest_offset, i32 %len) gc "statepoint-example" {
 ; CHECK-LABEL: define {{[^@]+}}@test_memmove_element_atomic_16
 ; CHECK-SAME: (i8 addrspace(1)* [[SRC:%.*]], i64 [[SRC_OFFSET:%.*]], i8 addrspace(1)* [[DEST:%.*]], i64 [[DEST_OFFSET:%.*]], i32 [[LEN:%.*]]) gc "statepoint-example" {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]], i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
+; CHECK-NEXT:    [[SRC_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[SRC]], i64 [[SRC_OFFSET]]
+; CHECK-NEXT:    [[DEST_DERIVED:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[DEST]], i64 [[DEST_OFFSET]]
+; CHECK-NEXT:    [[SRC_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC]] to i8*
+; CHECK-NEXT:    [[SRC_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[SRC_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP0:%.*]] = ptrtoint i8* [[SRC_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[SRC_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP2:%.*]] = sub i64 [[TMP1]], [[TMP0]]
+; CHECK-NEXT:    [[DEST_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST]] to i8*
+; CHECK-NEXT:    [[DEST_DERIVED_INTEGRAL:%.*]] = addrspacecast i8 addrspace(1)* [[DEST_DERIVED]] to i8*
+; CHECK-NEXT:    [[TMP3:%.*]] = ptrtoint i8* [[DEST_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP4:%.*]] = ptrtoint i8* [[DEST_DERIVED_INTEGRAL]] to i64
+; CHECK-NEXT:    [[TMP5:%.*]] = sub i64 [[TMP4]], [[TMP3]]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8i64p1i8i64i32f(i64 2882400000, i32 0, void (i8 addrspace(1)*, i64, i8 addrspace(1)*, i64, i32)* nonnull @__llvm_memmove_element_unordered_atomic_safepoint_16, i32 5, i32 0, i8 addrspace(1)* [[SRC]], i64 [[TMP2]], i8 addrspace(1)* [[DEST]], i64 [[TMP5]], i32 [[LEN]], i32 0, i32 0) [ "gc-live"() ]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %src_derived = getelementptr inbounds i8, i8 addrspace(1)* %src, i64 %src_offset
   %dest_derived = getelementptr inbounds i8, i8 addrspace(1)* %dest, i64 %dest_offset
   call void @llvm.memmove.element.unordered.atomic.p1i8.p1i8.i32(i8 addrspace(1)* align 16 %src_derived, i8 addrspace(1)* align 16 %dest_derived, i32 %len, i32 16)
   ret void
 }

llvm/test/Transforms/RewriteStatepointsForGC/unreachable-regression.ll

 ; RUN: opt -S -rewrite-statepoints-for-gc < %s | FileCheck %s
 ; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 ;
 ; Regression test:
 ;   After the rewritable callsite collection if any callsite was found
 ;   in a block that was reported unreachable by DominanceTree then
 ;   removeUnreachableBlocks() was called. But it is stronger than
 ;   DominatorTree::isReachableFromEntry(), i.e. removeUnreachableBlocks
 ;   can remove some blocks for which isReachableFromEntry() returns true.
 ;   This resulted in stale pointers to the collected but removed
 ;   callsites. Such stale pointers caused crash when accessed.
+target datalayout = "ni:1"
+
 declare void @f(i8 addrspace(1)* %obj)
 
 define void @test(i8 addrspace(1)* %arg) gc "statepoint-example" {
 ; CHECK-LABEL: test(
 ; CHECK-NEXT: @f
  call void @f(i8 addrspace(1)* %arg) #1
  br i1 true, label %not_zero, label %zero