From: Nikita Popov <npopov@redhat.com>
Date: Wed, 21 Jun 2023 10:40:23 +0000 (+0200)
Subject: [RewriteStatepointsForGC] Convert tests to opaque pointers (NFC)
X-Git-Tag: upstream/17.0.6~4347
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6f7c9d1e176362d4e9af46b808c36d786d1fc96c;p=platform%2Fupstream%2Fllvm.git

[RewriteStatepointsForGC] Convert tests to opaque pointers (NFC)
---

diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
index 9e03dbf..af2e96f 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-14.ll
@@ -1,5 +1,5 @@
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -opaque-pointers=0 -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
+; RUN: opt -S -passes=rewrite-statepoints-for-gc < %s | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
 target triple = "x86_64-unknown-linux-gnu"
@@ -8,50 +8,50 @@ declare void @foo() gc "statepoint-example"
 
 ; FIXME: In this test case %b6.base, which is inserted by RS4GC, is identical
 ; to %b6.
-define i8 addrspace(1)* @test1(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test1(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  left:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT:    [[B5:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5]], [[LOOP]] ]
 ; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 left:
   br i1 %c, label %loop, label %merge2
 
 loop:
-  %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
+  %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ]
   br i1 %c, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+  %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-define i8 addrspace(1)* @test2(i1 %c, i32 %n, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test2(i1 %c, i32 %n, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LEFT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT:    [[B5:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
 ; CHECK-NEXT:    switch i32 [[N:%.*]], label [[MERGE2]] [
 ; CHECK-NEXT:    i32 0, label [[LOOP]]
 ; CHECK-NEXT:    i32 1, label [[LOOP]]
 ; CHECK-NEXT:    i32 2, label [[LEFT]]
 ; CHECK-NEXT:    ]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 entry:
   br label %left
@@ -60,209 +60,203 @@ left:
   br i1 %c, label %loop, label %merge2
 
 loop:
-  %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
+  %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
   switch i32 %n, label %merge2 [ i32 0, label %loop
   i32 1, label %loop
   i32 2, label %left ]
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+  %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
 ; FIXME: In this test case %b5.base and %b6.base (inserted by RS4GC) are
 ; identical to %b5 and %b6 ; correspondingly.
-define i8 addrspace(1)* @test3(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test3(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:  left:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B5_BASE:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5_BASE]], [[LOOP]] ], [ [[B6_BASE_RELOCATED:%.*]], [[MERGE2]] ], !is_base_value !0
-; CHECK-NEXT:    [[B5:%.*]] = phi i8 addrspace(1)* [ [[B2]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B6_RELOCATED:%.*]], [[MERGE2]] ]
+; CHECK-NEXT:    [[B5_BASE:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5_BASE]], [[LOOP]] ], [ [[B6_BASE_RELOCATED:%.*]], [[MERGE2]] ], !is_base_value !0
+; CHECK-NEXT:    [[B5:%.*]] = phi ptr addrspace(1) [ [[B2]], [[LEFT]] ], [ [[B5]], [[LOOP]] ], [ [[B6_RELOCATED:%.*]], [[MERGE2]] ]
 ; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5_BASE]], [[LOOP]] ], !is_base_value !0
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6_BASE]], i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_BASE_RELOCATED]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    [[B6_RELOCATED]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
+; CHECK-NEXT:    [[B6_BASE:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B5_BASE]], [[LOOP]] ], !is_base_value !0
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6_BASE]], ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_BASE_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    [[B6_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 1)
 ; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[EXIT:%.*]]
 ; CHECK:       exit:
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 left:
   br i1 %c, label %loop, label %merge2
 
 loop:
-  %b5 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b6, %merge2 ]
+  %b5 = phi ptr addrspace(1) [ %b2, %left ], [ %b5, %loop ], [ %b6, %merge2 ]
   br i1 %c, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+  %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b5, %loop ]
   call void @foo() [ "deopt"() ]
   br i1 %c, label %loop, label %exit
 
 exit:
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-define i8 addrspace(1)* @test4(i1 %c, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %c, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test4(
 ; CHECK-NEXT:  left:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B5:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
-; CHECK-NEXT:    [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT:    [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT:%.*]] ], [ [[B3]], [[LOOP]] ]
 ; CHECK-NEXT:    br i1 [[C]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 left:
   br i1 %c, label %loop, label %merge2
 
 loop:
-  %b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ]
-  %b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)*
-  %b5 = bitcast i32 addrspace(1)* %b4 to i8 addrspace(1)*
+  %b3 = phi ptr addrspace(1) [ %b2, %left ], [ %b3, %loop ]
   br i1 %c, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+  %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b3, %loop ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-define i8 addrspace(1)* @test5(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ]
-; CHECK-NEXT:    [[B4:%.*]] = addrspacecast i8 addrspace(1)* [[B3]] to i8*
+; CHECK-NEXT:    [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B5:%.*]], [[LEFT:%.*]] ]
+; CHECK-NEXT:    [[B4:%.*]] = addrspacecast ptr addrspace(1) [[B3]] to ptr
 ; CHECK-NEXT:    br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
 ; CHECK:       left:
-; CHECK-NEXT:    [[B5]] = addrspacecast i8* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT:    [[B5]] = addrspacecast ptr [[B4]] to ptr addrspace(1)
 ; CHECK-NEXT:    br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B5]], [[LEFT]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 entry:
   br i1 %c1, label %loop, label %merge2
 
 loop:
-  %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b5, %left ]
-  %b4 = addrspacecast i8 addrspace(1)* %b3 to i8*
+  %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b5, %left ]
+  %b4 = addrspacecast ptr addrspace(1) %b3 to ptr
   br i1 %c1, label %left, label %merge2
 
 left:
-  %b5 = addrspacecast i8* %b4 to i8 addrspace(1)*
+  %b5 = addrspacecast ptr %b4 to ptr addrspace(1)
   br i1 %c2, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b5, %left ]
+  %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b5, %left ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-define i8 addrspace(1)* @test6(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test6(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test6(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ]
+; CHECK-NEXT:    [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B3]], [[LEFT:%.*]] ]
 ; CHECK-NEXT:    br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LEFT]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 entry:
   br i1 %c1, label %loop, label %merge2
 
 loop:
-  %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ]
+  %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b4, %left ]
   br i1 %c1, label %left, label %merge2
 
 left:
-  %b4 = phi i8 addrspace(1)* [ %b3, %loop ]
+  %b4 = phi ptr addrspace(1) [ %b3, %loop ]
   br i1 %c2, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
+  %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-declare i8 addrspace(1)* @returned_arg(i8 addrspace(1)* returned %p)
+declare ptr addrspace(1) @returned_arg(ptr addrspace(1) returned %p)
 
-define i8 addrspace(1)* @test7(i1 %c1, i1 %c2, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test7(i1 %c1, i1 %c2, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test7(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ]
+; CHECK-NEXT:    [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[ENTRY:%.*]] ], [ [[B41:%.*]], [[LEFT:%.*]] ]
 ; CHECK-NEXT:    br i1 [[C1]], label [[LEFT]], label [[MERGE2]]
 ; CHECK:       left:
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, i8 addrspace(1)* (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8p1i8f(i64 2882400000, i32 0, i8 addrspace(1)* (i8 addrspace(1)*)* elementtype(i8 addrspace(1)* (i8 addrspace(1)*)) @returned_arg, i32 1, i32 0, i8 addrspace(1)* [[B3]], i32 0, i32 0) [ "gc-live"(i8 addrspace(1)* [[B3]]) ]
-; CHECK-NEXT:    [[B41]] = call i8 addrspace(1)* @llvm.experimental.gc.result.p1i8(token [[STATEPOINT_TOKEN]])
-; CHECK-NEXT:    [[B3_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(ptr addrspace(1) (ptr addrspace(1))) @returned_arg, i32 1, i32 0, ptr addrspace(1) [[B3]], i32 0, i32 0) [ "gc-live"(ptr addrspace(1) [[B3]]) ]
+; CHECK-NEXT:    [[B41]] = call ptr addrspace(1) @llvm.experimental.gc.result.p1(token [[STATEPOINT_TOKEN]])
+; CHECK-NEXT:    [[B3_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
 ; CHECK-NEXT:    br i1 [[C2:%.*]], label [[LOOP]], label [[MERGE2]]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6_BASE:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]], i8 addrspace(1)* [[B6_BASE]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
-; CHECK-NEXT:    [[B6_BASE_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6_BASE:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ], !is_base_value !0
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1]], [[ENTRY]] ], [ [[B3]], [[LOOP]] ], [ [[B41]], [[LEFT]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN2:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]], ptr addrspace(1) [[B6_BASE]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 1, i32 0)
+; CHECK-NEXT:    [[B6_BASE_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN2]], i32 1, i32 1)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 entry:
   br i1 %c1, label %loop, label %merge2
 
 loop:
-  %b3 = phi i8 addrspace(1)* [ %b2, %entry ], [ %b4, %left ]
+  %b3 = phi ptr addrspace(1) [ %b2, %entry ], [ %b4, %left ]
   br i1 %c1, label %left, label %merge2
 
 left:
-  %b4 = call i8 addrspace(1)* @returned_arg(i8 addrspace(1)* %b3)
+  %b4 = call ptr addrspace(1) @returned_arg(ptr addrspace(1) %b3)
   br i1 %c2, label %loop, label %merge2
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
+  %b6 = phi ptr addrspace(1) [ %b1, %entry ], [ %b3, %loop ], [ %b4, %left ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
 
-define i8 addrspace(1)* @test8(i1 %c, i32 %n, i8 addrspace(1)* %b1, i8 addrspace(1)* %b2) gc "statepoint-example" {
+define ptr addrspace(1) @test8(i1 %c, i32 %n, ptr addrspace(1) %b1, ptr addrspace(1) %b2) gc "statepoint-example" {
 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[LEFT:%.*]]
 ; CHECK:       left:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[LOOP:%.*]], label [[MERGE2:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[B3:%.*]] = phi i8 addrspace(1)* [ [[B2:%.*]], [[LEFT]] ], [ [[B5:%.*]], [[LOOP]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[B4:%.*]] = bitcast i8 addrspace(1)* [[B3]] to i32 addrspace(1)*
-; CHECK-NEXT:    [[B5]] = bitcast i32 addrspace(1)* [[B4]] to i8 addrspace(1)*
+; CHECK-NEXT:    [[B3:%.*]] = phi ptr addrspace(1) [ [[B2:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ], [ [[B3]], [[LOOP]] ]
 ; CHECK-NEXT:    switch i32 [[N:%.*]], label [[MERGE2]] [
 ; CHECK-NEXT:    i32 0, label [[LOOP]]
 ; CHECK-NEXT:    i32 1, label [[LOOP]]
 ; CHECK-NEXT:    i32 2, label [[LEFT]]
 ; CHECK-NEXT:    ]
 ; CHECK:       merge2:
-; CHECK-NEXT:    [[B6:%.*]] = phi i8 addrspace(1)* [ [[B1:%.*]], [[LEFT]] ], [ [[B5]], [[LOOP]] ]
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* [[B6]]) ]
-; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
-; CHECK-NEXT:    ret i8 addrspace(1)* [[B6_RELOCATED]]
+; CHECK-NEXT:    [[B6:%.*]] = phi ptr addrspace(1) [ [[B1:%.*]], [[LEFT]] ], [ [[B3]], [[LOOP]] ]
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(ptr addrspace(1) [[B6]]) ]
+; CHECK-NEXT:    [[B6_RELOCATED:%.*]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 0, i32 0)
+; CHECK-NEXT:    ret ptr addrspace(1) [[B6_RELOCATED]]
 ;
 entry:
   br label %left
@@ -271,15 +265,13 @@ left:
   br i1 %c, label %loop, label %merge2
 
 loop:
-  %b3 = phi i8 addrspace(1)* [ %b2, %left ], [ %b5, %loop ], [ %b5, %loop ]
-  %b4 = bitcast i8 addrspace(1)* %b3 to i32 addrspace(1)*
-  %b5 = bitcast i32 addrspace(1)* %b4 to i8 addrspace(1)*
+  %b3 = phi ptr addrspace(1) [ %b2, %left ], [ %b3, %loop ], [ %b3, %loop ]
   switch i32 %n, label %merge2 [ i32 0, label %loop
   i32 1, label %loop
   i32 2, label %left ]
 
 merge2:
-  %b6 = phi i8 addrspace(1)* [ %b1, %left ], [ %b5, %loop ]
+  %b6 = phi ptr addrspace(1) [ %b1, %left ], [ %b3, %loop ]
   call void @foo() [ "deopt"() ]
-  ret i8 addrspace(1)* %b6
+  ret ptr addrspace(1) %b6
 }
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
index cb14854..50582ad 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll
@@ -1,35 +1,33 @@
 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -opaque-pointers=0 < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=rewrite-statepoints-for-gc -S 2>&1 | FileCheck %s
 
 ; derived %next.i64 base %base_obj
 
-define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
+define void @test(ptr 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:    [[OBJ:%.*]] = getelementptr i64, ptr addrspace(1) [[BASE_OBJ:%.*]], i32 1
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[DOT0:%.*]] = phi i64 addrspace(1)* [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    [[CURRENT:%.*]] = phi i64 addrspace(1)* [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_I64_RELOCATED_CASTED:%.*]], [[LOOP]] ]
-; CHECK-NEXT:    [[CURRENT_I32:%.*]] = bitcast i64 addrspace(1)* [[CURRENT]] to i32 addrspace(1)*
-; CHECK-NEXT:    [[NEXT_I32:%.*]] = getelementptr i32, i32 addrspace(1)* [[CURRENT_I32]], i32 1
-; CHECK-NEXT:    [[NEXT_I64:%.*]] = bitcast i32 addrspace(1)* [[NEXT_I32]] to i64 addrspace(1)*
-; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(i64 addrspace(1)* [[NEXT_I64]], i64 addrspace(1)* [[DOT0]]) ]
-; CHECK-NEXT:    [[NEXT_I64_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
-; CHECK-NEXT:    [[NEXT_I64_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[NEXT_I64_RELOCATED]] to i64 addrspace(1)*
-; CHECK-NEXT:    [[BASE_OBJ_RELOCATED:%.*]] = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
-; CHECK-NEXT:    [[BASE_OBJ_RELOCATED_CASTED]] = bitcast i8 addrspace(1)* [[BASE_OBJ_RELOCATED]] to i64 addrspace(1)*
+; CHECK-NEXT:    [[DOT0:%.*]] = phi ptr addrspace(1) [ [[BASE_OBJ]], [[ENTRY:%.*]] ], [ [[BASE_OBJ_RELOCATED:%.*]], [[LOOP]] ]
+; CHECK-NEXT:    [[CURRENT:%.*]] = phi ptr addrspace(1) [ [[OBJ]], [[ENTRY]] ], [ [[NEXT_I64_RELOCATED:%.*]], [[LOOP]] ]
+; CHECK-NEXT:    [[CURRENT_I32:%.*]] = bitcast ptr addrspace(1) [[CURRENT]] to ptr addrspace(1)
+; CHECK-NEXT:    [[NEXT_I32:%.*]] = getelementptr i32, ptr addrspace(1) [[CURRENT_I32]], i32 1
+; CHECK-NEXT:    [[NEXT_I64:%.*]] = bitcast ptr addrspace(1) [[NEXT_I32]] to ptr addrspace(1)
+; CHECK-NEXT:    [[STATEPOINT_TOKEN:%.*]] = call token (i64, i32, ptr, i32, i32, ...) @llvm.experimental.gc.statepoint.p0(i64 2882400000, i32 0, ptr elementtype(void ()) @do_safepoint, i32 0, i32 0, i32 0, i32 0) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0), "gc-live"(ptr addrspace(1) [[NEXT_I64]], ptr addrspace(1) [[DOT0]]) ]
+; CHECK-NEXT:    [[NEXT_I64_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 0)
+; CHECK-NEXT:    [[BASE_OBJ_RELOCATED]] = call coldcc ptr addrspace(1) @llvm.experimental.gc.relocate.p1(token [[STATEPOINT_TOKEN]], i32 1, i32 1)
 ; CHECK-NEXT:    br label [[LOOP]]
 ;
 entry:
-  %obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
+  %obj = getelementptr i64, ptr addrspace(1) %base_obj, i32 1
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
-  %current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next.i64, %loop ]
-  %current.i32 = bitcast i64 addrspace(1)* %current to i32 addrspace(1)*
-  %next.i32 = getelementptr i32, i32 addrspace(1)* %current.i32, i32 1
-  %next.i64 = bitcast i32 addrspace(1)* %next.i32 to i64 addrspace(1)*
+  %current = phi ptr addrspace(1) [ %obj, %entry ], [ %next.i64, %loop ]
+  %current.i32 = bitcast ptr addrspace(1) %current to ptr addrspace(1)
+  %next.i32 = getelementptr i32, ptr addrspace(1) %current.i32, i32 1
+  %next.i64 = bitcast ptr addrspace(1) %next.i32 to ptr addrspace(1)
   call void @do_safepoint() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   br label %loop
 }
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll b/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
index a7ad6ce..c7057c8 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/invokes.ll
@@ -1,67 +1,67 @@
-; RUN: opt -opaque-pointers=0 < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
+; RUN: opt < %s -S -passes=rewrite-statepoints-for-gc | FileCheck %s
 
-declare i64 addrspace(1)* @some_call(i64 addrspace(1)*)
+declare ptr addrspace(1) @some_call(ptr 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 {
+define ptr addrspace(1) @test_basic(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality_function {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke
   ; CHECK: statepoint
   ; CHECK: some_call
-  %ret_val = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+  %ret_val = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
                to label %normal_return unwind label %exceptional_return
 
 ; CHECK-LABEL: normal_return:
 ; CHECK: gc.result
-; CHECK: ret i64
+; CHECK: ret ptr
 
 normal_return:
-  ret i64 addrspace(1)* %ret_val
+  ret ptr addrspace(1) %ret_val
 
 ; CHECK-LABEL: exceptional_return:
 ; CHECK: landingpad
-; CHECK: ret i64
+; CHECK: ret ptr
 
 exceptional_return:
   %landing_pad4 = landingpad token
           cleanup
-  ret i64 addrspace(1)* %obj1
+  ret ptr addrspace(1) %obj1
 }
 
-declare <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*>)
+declare <4 x ptr addrspace(1)> @some_vector_call(<4 x ptr addrspace(1)>)
 
-define <4 x i64 addrspace(1)*> @test_basic_vector(<4 x i64 addrspace(1)*> %objs, <4 x i64 addrspace(1)*> %objs1) gc "statepoint-example" personality i32 ()* @personality_function {
+define <4 x ptr addrspace(1)> @test_basic_vector(<4 x ptr addrspace(1)> %objs, <4 x ptr addrspace(1)> %objs1) gc "statepoint-example" personality ptr @personality_function {
 ; CHECK-LABEL: @test_basic_vector
 entry:
 ; CHECK: invoke{{.*}}llvm.experimental.gc.statepoint{{.*}}some_vector_call
-  %ret_val = invoke <4 x i64 addrspace(1)*> @some_vector_call(<4 x i64 addrspace(1)*> %objs)
+  %ret_val = invoke <4 x ptr addrspace(1)> @some_vector_call(<4 x ptr addrspace(1)> %objs)
                to label %normal_return unwind label %exceptional_return
 
 ; CHECK-LABEL: normal_return:
 ; CHECK: gc.result
-; CHECK: ret <4 x i64 addrspace(1)*>
+; CHECK: ret <4 x ptr addrspace(1)>
 
 normal_return:
-  ret <4 x i64 addrspace(1)*> %ret_val
+  ret <4 x ptr addrspace(1)> %ret_val
 
 ; CHECK-LABEL: exceptional_return:
 ; CHECK: landingpad
-; CHECK: ret <4 x i64 addrspace(1)*>
+; CHECK: ret <4 x ptr addrspace(1)>
 
 exceptional_return:
   %landing_pad4 = landingpad token
           cleanup
-  ret <4 x i64 addrspace(1)*> %objs1
+  ret <4 x ptr addrspace(1)> %objs1
 }
 
-define i64 addrspace(1)* @test_two_invokes(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1) gc "statepoint-example" personality i32 ()* @personality_function {
+define ptr addrspace(1) @test_two_invokes(ptr addrspace(1) %obj, ptr addrspace(1) %obj1) gc "statepoint-example" personality ptr @personality_function {
 ; CHECK-LABEL: entry:
 entry:
   ; CHECK: invoke
   ; CHECK: statepoint
   ; CHECK: some_call
-  %ret_val1 = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+  %ret_val1 = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
                to label %second_invoke unwind label %exceptional_return
 
 ; CHECK-LABEL: second_invoke:
@@ -69,36 +69,36 @@ second_invoke:
   ; CHECK: invoke
   ; CHECK: statepoint
   ; CHECK: some_call
-  %ret_val2 = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %ret_val1)
+  %ret_val2 = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %ret_val1)
                 to label %normal_return unwind label %exceptional_return
 
 ; CHECK-LABEL: normal_return:
 normal_return:
   ; CHECK: gc.result
-  ; CHECK: ret i64
-  ret i64 addrspace(1)* %ret_val2
+  ; CHECK: ret ptr
+  ret ptr addrspace(1) %ret_val2
 
 ; CHECK: exceptional_return:
-; CHECK: ret i64
+; CHECK: ret ptr
 
 exceptional_return:
   %landing_pad4 = landingpad token
           cleanup
-  ret i64 addrspace(1)* %obj1
+  ret ptr addrspace(1) %obj1
 }
 
-define i64 addrspace(1)* @test_phi_node(i1 %cond, i64 addrspace(1)* %obj) gc "statepoint-example" personality i32 ()* @personality_function {
+define ptr addrspace(1) @test_phi_node(i1 %cond, ptr addrspace(1) %obj) gc "statepoint-example" personality ptr @personality_function {
 ; CHECK-LABEL: @test_phi_node
 ; CHECK-LABEL: entry:
 entry:
   br i1 %cond, label %left, label %right
 
 left:
-  %ret_val_left = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+  %ret_val_left = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
                     to label %merge unwind label %exceptional_return
 
 right:
-  %ret_val_right = invoke i64 addrspace(1)* @some_call(i64 addrspace(1)* %obj)
+  %ret_val_right = invoke ptr addrspace(1) @some_call(ptr addrspace(1) %obj)
                      to label %merge unwind label %exceptional_return
 
 ; CHECK: merge[[A:[0-9]]]:
@@ -111,18 +111,18 @@ right:
 
 ; CHECK: [[with_phi]]:
 ; CHECK: phi
-; CHECK: ret i64 addrspace(1)* %ret_val
+; CHECK: ret ptr addrspace(1) %ret_val
 merge:
-  %ret_val = phi i64 addrspace(1)* [%ret_val_left, %left], [%ret_val_right, %right]
-  ret i64 addrspace(1)* %ret_val
+  %ret_val = phi ptr addrspace(1) [%ret_val_left, %left], [%ret_val_right, %right]
+  ret ptr addrspace(1) %ret_val
 
 ; CHECK-LABEL: exceptional_return:
-; CHECK: ret i64 addrspace(1)*
+; CHECK: ret ptr addrspace(1)
 
 exceptional_return:
   %landing_pad4 = landingpad token
           cleanup
-  ret i64 addrspace(1)* %obj
+  ret ptr addrspace(1) %obj
 }
 
 declare void @do_safepoint()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll b/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
index c9397d1..e827ff6e 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll
@@ -1,11 +1,11 @@
 ; A collection of liveness test cases to ensure we're reporting the
 ; correct live values at statepoints
-; RUN: opt -opaque-pointers=0 -passes=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.
 
-define i64 addrspace(1)* @test1(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test1(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 entry:
   br i1 %cmp, label %taken, label %untaken
@@ -13,8 +13,7 @@ entry:
 taken:                                            ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
 ; CHECK-NEXT: br label %merge
   call void @foo() [ "deopt"() ]
   br label %merge
@@ -22,21 +21,20 @@ taken:                                            ; preds = %entry
 untaken:                                          ; preds = %entry
 ; CHECK-LABEL: untaken:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated2 = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated2 = call coldcc ptr addrspace(1)
 ; CHECK-NEXT: br label %merge
   call void @foo() [ "deopt"() ]
   br label %merge
 
 merge:                                            ; preds = %untaken, %taken
 ; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated2.casted, %untaken ]
-; CHECK-NEXT: ret i64 addrspace(1)* %.0
+; CHECK-NEXT: %.0 = phi ptr addrspace(1) [ %obj.relocated, %taken ], [ %obj.relocated2, %untaken ]
+; CHECK-NEXT: ret ptr addrspace(1) %.0
 ; A local kill should not effect liveness in predecessor block
-  ret i64 addrspace(1)* %obj
+  ret ptr addrspace(1) %obj
 }
 
-define i64 addrspace(1)* @test2(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
+define ptr addrspace(1) @test2(i1 %cmp, ptr %loc) gc "statepoint-example" {
 ; CHECK-LABEL: @test2
 entry:
 ; CHECK-LABEL: entry:
@@ -50,19 +48,18 @@ taken:                                            ; preds = %entry
 ; CHECK-NEXT:  %obj = load
 ; CHECK-NEXT:  gc.statepoint
 ; CHECK-NEXT:  gc.relocate
-; CHECK-NEXT: bitcast
-; CHECK-NEXT:  ret i64 addrspace(1)* %obj.relocated.casted
+; CHECK-NEXT:  ret ptr addrspace(1) %obj.relocated
 ; A local kill should effect values live from a successor phi.  Also, we
 ; should only propagate liveness from a phi to the appropriate predecessors.
-  %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
+  %obj = load ptr addrspace(1), ptr %loc
   call void @foo() [ "deopt"() ]
-  ret i64 addrspace(1)* %obj
+  ret ptr addrspace(1) %obj
 
 untaken:                                          ; preds = %entry
-  ret i64 addrspace(1)* null
+  ret ptr addrspace(1) null
 }
 
-define i64 addrspace(1)* @test3(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
+define ptr addrspace(1) @test3(i1 %cmp, ptr %loc) gc "statepoint-example" {
 ; CHECK-LABEL: @test3
 entry:
   br i1 %cmp, label %taken, label %untaken
@@ -72,11 +69,10 @@ taken:                                            ; preds = %entry
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: %obj = load
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
 ; CHECK-NEXT: br label %merge
   call void @foo() [ "deopt"() ]
-  %obj = load i64 addrspace(1)*, i64 addrspace(1)** %loc
+  %obj = load ptr addrspace(1), ptr %loc
   call void @foo() [ "deopt"() ]
   br label %merge
 
@@ -90,41 +86,37 @@ untaken:                                          ; preds = %entry
   br label %merge
 
 merge:                                            ; preds = %untaken, %taken
-  %phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
-  ret i64 addrspace(1)* %phi
+  %phi = phi ptr addrspace(1) [ %obj, %taken ], [ null, %untaken ]
+  ret ptr addrspace(1) %phi
 }
 
-define i64 addrspace(1)* @test4(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test4(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test4
 entry:
 ; CHECK-LABEL: entry:
 ; CHECK-NEXT:  %derived = getelementptr
 ; CHECK-NEXT:  gc.statepoint
 ; CHECK-NEXT:  %derived.relocated =
-; CHECK-NEXT:  bitcast
 ; CHECK-NEXT:  %obj.relocated =
-; CHECK-NEXT:  bitcast
 ; CHECK-NEXT:  gc.statepoint
 ; CHECK-NEXT:  %derived.relocated2 =
-; CHECK-NEXT:  bitcast
 
 ; Note: It's legal to relocate obj again, but not strictly needed
 ; CHECK-NEXT:  %obj.relocated3 =
-; CHECK-NEXT:  bitcast
-; CHECK-NEXT:  ret i64 addrspace(1)* %derived.relocated2.casted
+; CHECK-NEXT:  ret ptr addrspace(1) %derived.relocated2
 ;
 ; Make sure that a phi def visited during iteration is considered a kill.
 ; Also, liveness after base pointer analysis can change based on new uses,
 ; not just new defs.
-  %derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
+  %derived = getelementptr i64, ptr addrspace(1) %obj, i64 8
   call void @foo() [ "deopt"() ]
   call void @foo() [ "deopt"() ]
-  ret i64 addrspace(1)* %derived
+  ret ptr addrspace(1) %derived
 }
 
 declare void @consume(...) readonly "gc-leaf-function"
 
-define i64 addrspace(1)* @test5(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
+define ptr addrspace(1) @test5(i1 %cmp, ptr addrspace(1) %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test5
 entry:
   br i1 %cmp, label %taken, label %untaken
@@ -132,8 +124,7 @@ entry:
 taken:                                            ; preds = %entry
 ; CHECK-LABEL: taken:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
 ; CHECK-NEXT: br label %merge
   call void @foo() [ "deopt"() ]
   br label %merge
@@ -145,20 +136,20 @@ untaken:                                          ; preds = %entry
 
 merge:                                            ; preds = %untaken, %taken
 ; CHECK-LABEL: merge:
-; CHECK-NEXT: %.0 = phi i64 addrspace(1)*
+; CHECK-NEXT: %.0 = phi ptr addrspace(1)
 ; CHECK-NEXT: %obj2a = phi
 ; CHECK-NEXT: @consume
 ; CHECK-NEXT: br label %final
-  %obj2a = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
-  call void (...) @consume(i64 addrspace(1)* %obj2a)
+  %obj2a = phi ptr addrspace(1) [ %obj, %taken ], [ null, %untaken ]
+  call void (...) @consume(ptr addrspace(1) %obj2a)
   br label %final
 
 final:                                            ; preds = %merge
 ; CHECK-LABEL: final:
 ; CHECK-NEXT: @consume
-; CHECK-NEXT: ret i64 addrspace(1)* %.0
-  call void (...) @consume(i64 addrspace(1)* %obj2a)
-  ret i64 addrspace(1)* %obj
+; CHECK-NEXT: ret ptr addrspace(1) %.0
+  call void (...) @consume(ptr addrspace(1) %obj2a)
+  ret ptr addrspace(1) %obj
 }
 
 declare void @foo()
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll b/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
index 7928b30..4c7f9d6 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/preprocess.ll
@@ -1,11 +1,11 @@
-; RUN: opt -opaque-pointers=0 -passes=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
 
 declare void @consume(...) "gc-leaf-function"
 
-define void @test6(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test6(ptr addrspace(1) %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test6
 entry:
   br label %next
@@ -14,14 +14,13 @@ next:                                             ; preds = %entry
 ; CHECK-LABEL: next:
 ; CHECK-NEXT: gc.statepoint
 ; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
-; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
-; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
+; CHECK-NEXT: @consume(ptr addrspace(1) %obj.relocated)
+; CHECK-NEXT: @consume(ptr addrspace(1) %obj.relocated)
 ; Need to delete unreachable gc.statepoint call
-  %obj2 = phi i64 addrspace(1)* [ %obj, %entry ]
+  %obj2 = phi ptr addrspace(1) [ %obj, %entry ]
   call void @foo() [ "deopt"() ]
-  call void (...) @consume(i64 addrspace(1)* %obj2)
-  call void (...) @consume(i64 addrspace(1)* %obj)
+  call void (...) @consume(ptr addrspace(1) %obj2)
+  call void (...) @consume(ptr addrspace(1) %obj)
   ret void
 }
 
@@ -33,13 +32,13 @@ define void @test7() gc "statepoint-example" {
   ret void
 
 unreached:                                        ; preds = %unreached
-  %obj = phi i64 addrspace(1)* [ null, %unreached ]
+  %obj = phi ptr addrspace(1) [ null, %unreached ]
   call void @foo() [ "deopt"() ]
-  call void (...) @consume(i64 addrspace(1)* %obj)
+  call void (...) @consume(ptr addrspace(1) %obj)
   br label %unreached
 }
 
-define void @test8() gc "statepoint-example" personality i32 ()* undef {
+define void @test8() gc "statepoint-example" personality ptr undef {
 ; CHECK-LABEL: test8
 ; CHECK-NOT: gc.statepoint
 ; Bound the last check-not
@@ -54,7 +53,7 @@ normal_return:                                    ; preds = %unreached
   ret void
 
 exceptional_return:                               ; preds = %unreached
-  %landing_pad4 = landingpad { i8*, i32 }
+  %landing_pad4 = landingpad { ptr, i32 }
           cleanup
   ret void
 }
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll b/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
index 4310aa4..834e8c7 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/relocate-invoke-result.ll
@@ -1,31 +1,30 @@
-;; RUN: opt -opaque-pointers=0 -passes=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.
 
-declare i64* addrspace(1)* @non_gc_call() "gc-leaf-function"
+declare ptr addrspace(1) @non_gc_call() "gc-leaf-function"
 
 declare void @gc_call()
 
-declare i32* @fake_personality_function()
+declare ptr @fake_personality_function()
 
-define i64* addrspace(1)* @test() gc "statepoint-example" personality i32* ()* @fake_personality_function {
+define ptr addrspace(1) @test() gc "statepoint-example" personality ptr @fake_personality_function {
 ; CHECK-LABEL: @test(
 
 entry:
-  %obj = invoke i64* addrspace(1)* @non_gc_call()
+  %obj = invoke ptr addrspace(1) @non_gc_call()
           to label %normal_dest unwind label %unwind_dest
 
 unwind_dest:                                      ; preds = %entry
-  %lpad = landingpad { i8*, i32 }
+  %lpad = landingpad { ptr, i32 }
           cleanup
-  resume { i8*, i32 } undef
+  resume { ptr, i32 } undef
 
 normal_dest:                                      ; preds = %entry
 ; CHECK: normal_dest:
 ; CHECK-NEXT: gc.statepoint
-; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
-; CHECK-NEXT: bitcast
+; CHECK-NEXT: %obj.relocated = call coldcc ptr addrspace(1)
 
   call void @gc_call() [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  ret i64* addrspace(1)* %obj
+  ret ptr addrspace(1) %obj
 }
diff --git a/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll b/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
index 4fa5f54..249b3c1 100644
--- a/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
+++ b/llvm/test/Transforms/RewriteStatepointsForGC/relocation.ll
@@ -1,11 +1,11 @@
-; RUN: opt -opaque-pointers=0 < %s -passes=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
 
 
 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" {
+define ptr addrspace(1) @test1(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test1
 ; CHECK-DAG: %obj.relocated
 ; CHECK-DAG: %obj2.relocated
@@ -15,8 +15,8 @@ entry:
 
 joint:                                            ; preds = %joint2, %entry
 ; CHECK-LABEL: joint:
-; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]
-  %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]
+; CHECK: %phi1 = phi ptr addrspace(1) [ %obj.relocated, %entry ], [ %obj3, %joint2 ]
+  %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj3, %joint2 ]
   br i1 %condition, label %use, label %joint2
 
 use:                                              ; preds = %joint
@@ -24,36 +24,36 @@ use:                                              ; preds = %joint
 
 joint2:                                           ; preds = %use, %joint
 ; CHECK-LABEL: joint2:
-; CHECK: %phi2 = phi i64 addrspace(1)* [ %obj.relocated.casted, %use ], [ %obj2.relocated.casted, %joint ]
-; CHECK: %obj3 = getelementptr i64, i64 addrspace(1)* %obj2.relocated.casted, i32 1
-  %phi2 = phi i64 addrspace(1)* [ %obj, %use ], [ %obj2, %joint ]
-  %obj3 = getelementptr i64, i64 addrspace(1)* %obj2, i32 1
+; CHECK: %phi2 = phi ptr addrspace(1) [ %obj.relocated, %use ], [ %obj2.relocated, %joint ]
+; CHECK: %obj3 = getelementptr i64, ptr addrspace(1) %obj2.relocated, i32 1
+  %phi2 = phi ptr addrspace(1) [ %obj, %use ], [ %obj2, %joint ]
+  %obj3 = getelementptr i64, ptr addrspace(1) %obj2, i32 1
   br label %joint
 }
 
-declare i64 addrspace(1)* @generate_obj() "gc-leaf-function"
+declare ptr addrspace(1) @generate_obj() "gc-leaf-function"
 
-declare void @consume_obj(i64 addrspace(1)*) "gc-leaf-function"
+declare void @consume_obj(ptr addrspace(1)) "gc-leaf-function"
 
 declare i1 @rt() "gc-leaf-function"
 
 define void @test2() gc "statepoint-example" {
 ; CHECK-LABEL: @test2
 entry:
-  %obj_init = call i64 addrspace(1)* @generate_obj()
-  %obj = getelementptr i64, i64 addrspace(1)* %obj_init, i32 42
+  %obj_init = call ptr addrspace(1) @generate_obj()
+  %obj = getelementptr i64, ptr addrspace(1) %obj_init, i32 42
   br label %loop
 
 loop:                                             ; preds = %loop.backedge, %entry
 ; CHECK: loop:
-; CHECK-DAG: [ %obj_init.relocated.casted, %loop.backedge ]
+; CHECK-DAG: [ %obj_init.relocated, %loop.backedge ]
 ; CHECK-DAG: [ %obj_init, %entry ]
-; CHECK-DAG: [ %obj.relocated.casted, %loop.backedge ]
+; CHECK-DAG: [ %obj.relocated, %loop.backedge ]
 ; CHECK-DAG: [ %obj, %entry ]
-; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
+; CHECK-NOT: %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index
   %index = phi i32 [ 0, %entry ], [ %index.inc, %loop.backedge ]
-  %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
-  call void @consume_obj(i64 addrspace(1)* %location)
+  %location = getelementptr i64, ptr addrspace(1) %obj, i32 %index
+  call void @consume_obj(ptr addrspace(1) %location)
   %index.inc = add i32 %index, 1
   %condition = call i1 @rt()
   br i1 %condition, label %loop_x, label %loop_y
@@ -69,9 +69,9 @@ loop_y:                                           ; preds = %loop
   br label %loop.backedge
 }
 
-declare void @some_call(i8 addrspace(1)*) "gc-leaf-function"
+declare void @some_call(ptr addrspace(1)) "gc-leaf-function"
 
-define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @relocate_merge(i1 %cnd, ptr addrspace(1) %arg) gc "statepoint-example" {
 ; CHECK-LABEL: @relocate_merge
 
 bci_0:
@@ -94,34 +94,33 @@ else_branch:                                      ; preds = %bci_0
 
 join:                                             ; preds = %else_branch, %if_branch
 ; CHECK-LABEL: join:
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: [ %arg.relocated, %if_branch ]
 ; CHECK-DAG: [ %arg.relocated2, %else_branch ]
 ; CHECK-NOT: phi
-  call void @some_call(i8 addrspace(1)* %arg)
+  call void @some_call(ptr addrspace(1) %arg)
   ret void
 }
 
 declare void @goo(i64)
 
-declare i32 @moo(i64 addrspace(1)*)
+declare i32 @moo(ptr addrspace(1))
 
 ; Make sure a use in a statepoint gets properly relocated at a previous one.
 ; This is basically just making sure that statepoints aren't accidentally
 ; treated specially.
-define void @test3(i64 addrspace(1)* %obj) gc "statepoint-example" {
+define void @test3(ptr addrspace(1) %obj) gc "statepoint-example" {
 ; CHECK-LABEL: @test3
 ; CHECK: gc.statepoint
 ; CHECK-NEXT: gc.relocate
-; CHECK-NEXT: bitcast
 ; CHECK-NEXT: gc.statepoint
 entry:
   call void @goo(i64 undef) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
-  %0 = call i32 @moo(i64 addrspace(1)* %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
+  %0 = call i32 @moo(ptr addrspace(1) %obj) [ "deopt"(i32 0, i32 -1, i32 0, i32 0, i32 0) ]
   ret void
 }
 
-declare i8 addrspace(1)* @boo()
+declare ptr addrspace(1) @boo()
 
 ; Check specifically for the case where the result of a statepoint needs to
 ; be relocated itself
@@ -131,18 +130,18 @@ define void @test4() gc "statepoint-example" {
 ; CHECK: gc.result
 ; CHECK: gc.statepoint
 ; CHECK: [[RELOCATED:%[^ ]+]] = call {{.*}}gc.relocate
-; CHECK: @use(i8 addrspace(1)* [[RELOCATED]])
-  %1 = call i8 addrspace(1)* @boo() [ "deopt"() ]
-  %2 = call i8 addrspace(1)* @boo() [ "deopt"() ]
-  call void (...) @use(i8 addrspace(1)* %1)
+; CHECK: @use(ptr addrspace(1) [[RELOCATED]])
+  %1 = call ptr addrspace(1) @boo() [ "deopt"() ]
+  %2 = call ptr addrspace(1) @boo() [ "deopt"() ]
+  call void (...) @use(ptr addrspace(1) %1)
   ret void
 }
 
 ; Test updating a phi where not all inputs are live to begin with
-define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {
+define void @test5(ptr addrspace(1) %arg) gc "statepoint-example" {
 ; CHECK-LABEL: test5
 entry:
-  %0 = call i8 addrspace(1)* @boo() [ "deopt"() ]
+  %0 = call ptr addrspace(1) @boo() [ "deopt"() ]
   switch i32 undef, label %kill [
     i32 10, label %merge
     i32 13, label %merge
@@ -153,17 +152,17 @@ kill:                                             ; preds = %entry
 
 merge:                                            ; preds = %kill, %entry, %entry
 ; CHECK: merge:
-; CHECK: %test = phi i8 addrspace(1)
+; CHECK: %test = phi ptr addrspace(1)
 ; CHECK-DAG: [ null, %kill ]
 ; CHECK-DAG: [ %arg.relocated, %entry ]
 ; CHECK-DAG: [ %arg.relocated, %entry ]
-  %test = phi i8 addrspace(1)* [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ]
-  call void (...) @use(i8 addrspace(1)* %test)
+  %test = phi ptr addrspace(1) [ null, %kill ], [ %arg, %entry ], [ %arg, %entry ]
+  call void (...) @use(ptr addrspace(1) %test)
   ret void
 }
 
 ; Check to make sure we handle values live over an entry statepoint
-define void @test6(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3, i1 %c) gc "statepoint-example" {
+define void @test6(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3, i1 %c) gc "statepoint-example" {
 ; CHECK-LABEL: @test6
 entry:
   br i1 %c, label %gc.safepoint_poll.exit2, label %do_safepoint
@@ -174,27 +173,27 @@ do_safepoint:                                     ; preds = %entry
 ; CHECK: arg1.relocated =
 ; CHECK: arg2.relocated =
 ; CHECK: arg3.relocated =
-  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3) ]
+  call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3) ]
   br label %gc.safepoint_poll.exit2
 
 gc.safepoint_poll.exit2:                          ; preds = %do_safepoint, %entry
 ; CHECK-LABEL: gc.safepoint_poll.exit2:
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: [ %arg3, %entry ]
 ; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: [ %arg2, %entry ]
 ; CHECK-DAG: [ %arg2.relocated, %do_safepoint ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: [ %arg1, %entry ]
 ; CHECK-DAG:  [ %arg1.relocated, %do_safepoint ]
-  call void (...) @use(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)
+  call void (...) @use(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, ptr addrspace(1) %arg3)
   ret void
 }
 
 ; Check relocation in a loop nest where a relocation happens in the outer
 ; but not the inner loop
-define void @test_outer_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
+define void @test_outer_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" {
 ; CHECK-LABEL: @test_outer_loop
 
 bci_0:
@@ -202,8 +201,8 @@ bci_0:
 
 outer-loop:                                       ; preds = %outer-inc, %bci_0
 ; CHECK-LABEL: outer-loop:
-; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
-; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
   br label %inner-loop
 
 inner-loop:                                       ; preds = %inner-loop, %outer-loop
@@ -213,13 +212,13 @@ outer-inc:                                        ; preds = %inner-loop
 ; CHECK-LABEL: outer-inc:
 ; CHECK: %arg1.relocated
 ; CHECK: %arg2.relocated
-  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
+  call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ]
   br label %outer-loop
 }
 
 ; Check that both inner and outer loops get phis when relocation is in
 ;  inner loop
-define void @test_inner_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i1 %cmp) gc "statepoint-example" {
+define void @test_inner_loop(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2, i1 %cmp) gc "statepoint-example" {
 ; CHECK-LABEL: @test_inner_loop
 
 bci_0:
@@ -227,14 +226,14 @@ bci_0:
 
 outer-loop:                                       ; preds = %outer-inc, %bci_0
 ; CHECK-LABEL: outer-loop:
-; CHECK: phi i8 addrspace(1)* [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
-; CHECK: phi i8 addrspace(1)* [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg2, %bci_0 ], [ %arg2.relocated, %outer-inc ]
+; CHECK: phi ptr addrspace(1) [ %arg1, %bci_0 ], [ %arg1.relocated, %outer-inc ]
   br label %inner-loop
 ; CHECK-LABEL: inner-loop
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: %outer-loop ]
 ; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
-; CHECK: phi i8 addrspace(1)*
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: %outer-loop ]
 ; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
 ; CHECK: gc.statepoint
@@ -242,7 +241,7 @@ outer-loop:                                       ; preds = %outer-inc, %bci_0
 ; CHECK: %arg2.relocated
 
 inner-loop:                                       ; preds = %inner-loop, %outer-loop
-  call void @foo() [ "deopt"(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2) ]
+  call void @foo() [ "deopt"(ptr addrspace(1) %arg1, ptr addrspace(1) %arg2) ]
   br i1 %cmp, label %inner-loop, label %outer-inc
 
 outer-inc:                                        ; preds = %inner-loop
@@ -252,7 +251,7 @@ outer-inc:                                        ; preds = %inner-loop
   br label %outer-loop
 }
 
-define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
+define ptr addrspace(1) @test7(ptr addrspace(1) %obj, ptr addrspace(1) %obj2, i1 %condition) gc "statepoint-example" {
 ; CHECK-LABEL: @test7
 entry:
   br i1 %condition, label %branch2, label %join
@@ -266,20 +265,20 @@ callbb:                                           ; preds = %branch2
 
 join:                                             ; preds = %callbb, %entry
 ; CHECK-LABEL: join:
-; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]
-; CHECK: phi i64 addrspace(1)*
+; CHECK: phi ptr addrspace(1) [ %obj.relocated, %callbb ], [ %obj, %entry ]
+; CHECK: phi ptr addrspace(1)
 ; CHECK-DAG: [ %obj, %entry ]
-; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]
-  %phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj2, %callbb ]
+; CHECK-DAG: [ %obj2.relocated, %callbb ]
+  %phi1 = phi ptr addrspace(1) [ %obj, %entry ], [ %obj2, %callbb ]
   br label %join2
 
 join2:                                            ; preds = %join, %branch2
 ; CHECK-LABEL: join2:
-; CHECK: phi2 = phi i64 addrspace(1)*
+; CHECK: phi2 = phi ptr addrspace(1)
 ; CHECK-DAG: %join ]
 ; CHECK-DAG:  [ %obj2, %branch2 ]
-  %phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]
-  ret i64 addrspace(1)* %phi2
+  %phi2 = phi ptr addrspace(1) [ %obj, %join ], [ %obj2, %branch2 ]
+  ret ptr addrspace(1) %phi2
 }
 
 declare void @do_safepoint()