diff --git a/llvm/test/Transforms/FunctionSpecialization/bug52821-use-after-free.ll b/llvm/test/Transforms/FunctionSpecialization/bug52821-use-after-free.ll
index 32bd29f167fce6..d7528412796448 100644
--- a/llvm/test/Transforms/FunctionSpecialization/bug52821-use-after-free.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/bug52821-use-after-free.ll
@@ -3,56 +3,56 @@
 
 %mystruct = type { i32, [2 x i64] }
 
-define internal %mystruct* @myfunc(%mystruct* %arg) {
+define internal ptr @myfunc(ptr %arg) {
 ; CHECK-LABEL: @myfunc(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:
 ; CHECK-NEXT:    br i1 true, label [[FOR_COND2:%.*]], label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
-; CHECK-NEXT:    call void @callee(%mystruct* nonnull null)
+; CHECK-NEXT:    call void @callee(ptr nonnull null)
 ; CHECK-NEXT:    br label [[FOR_COND]]
 ; CHECK:       for.cond2:
 ; CHECK-NEXT:    br i1 false, label [[FOR_END:%.*]], label [[FOR_BODY2:%.*]]
 ; CHECK:       for.body2:
-; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[MYSTRUCT:%.*]], %mystruct* null, i64 0, i32 1, i64 3
+; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds [[MYSTRUCT:%.*]], ptr null, i64 0, i32 1, i64 3
 ; CHECK-NEXT:    br label [[FOR_COND2]]
 ; CHECK:       for.end:
-; CHECK-NEXT:    ret %mystruct* [[ARG:%.*]]
+; CHECK-NEXT:    ret ptr [[ARG:%.*]]
 ;
 entry:
   br label %for.cond
 
 for.cond:                                     ; preds = %for.body, %entry
-  %phi = phi %mystruct* [ undef, %for.body ], [ null, %entry ]
-  %cond = icmp eq %mystruct* %phi, null
+  %phi = phi ptr [ undef, %for.body ], [ null, %entry ]
+  %cond = icmp eq ptr %phi, null
   br i1 %cond, label %for.cond2, label %for.body
 
 for.body:                                     ; preds = %for.cond
-  call void @callee(%mystruct* nonnull %phi)
+  call void @callee(ptr nonnull %phi)
   br label %for.cond
 
 for.cond2:                                     ; preds = %for.body2, %for.cond
-  %phi2 = phi %mystruct* [ undef, %for.body2 ], [ null, %for.cond ]
+  %phi2 = phi ptr [ undef, %for.body2 ], [ null, %for.cond ]
   br i1 false, label %for.end, label %for.body2
 
 for.body2:                                     ; preds = %for.cond2
-  %arrayidx = getelementptr inbounds %mystruct, %mystruct* %phi2, i64 0, i32 1, i64 3
+  %arrayidx = getelementptr inbounds %mystruct, ptr %phi2, i64 0, i32 1, i64 3
   br label %for.cond2
 
 for.end:                                      ; preds = %for.cond2
-  ret %mystruct* %arg
+  ret ptr %arg
 }
 
-define %mystruct* @caller() {
+define ptr @caller() {
 ; CHECK-LABEL: @caller(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = call %mystruct* @myfunc(%mystruct* undef)
-; CHECK-NEXT:    ret %mystruct* [[CALL]]
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @myfunc(ptr undef)
+; CHECK-NEXT:    ret ptr [[CALL]]
 ;
 entry:
-  %call = call %mystruct* @myfunc(%mystruct* undef)
-  ret %mystruct* %call
+  %call = call ptr @myfunc(ptr undef)
+  ret ptr %call
 }
 
-declare void @callee(%mystruct*)
+declare void @callee(ptr)
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-always-inline.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-always-inline.ll
index ff5816c3e10081..f93b4cdf5f23e7 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-always-inline.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-always-inline.ll
@@ -13,7 +13,7 @@ declare i1 @cond_begin()
 declare i1 @cond_end()
 declare i1 @getCond()
 
-define internal i32 @foo(i32 %x, i32* %b, i32* %c) alwaysinline {
+define internal i32 @foo(i32 %x, ptr %b, ptr %c) alwaysinline {
 entry:
   br label %loop.entry
 
@@ -24,8 +24,8 @@ loop2.entry:
   br label %loop2.body
 
 loop2.body:
-  %0 = load i32, i32* %b, align 4
-  %1 = load i32, i32* %c, align 4
+  %0 = load i32, ptr %b, align 4
+  %1 = load i32, ptr %c, align 4
   %add.0 = add nsw i32 %0, %1
   %add = add nsw i32 %add.0, %x
   br label %loop2.end
@@ -48,11 +48,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A, i32* @C)
+  %call = call i32 @foo(i32 %x, ptr @A, ptr @C)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B, i32* @D)
+  %call1 = call i32 @foo(i32 %y, ptr @B, ptr @D)
   br label %return
 
 return:
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll
index 94a7c864222d64..0bb253b2215cbf 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression.ll
@@ -9,20 +9,20 @@
 %struct = type { i8, i16, i32, i64, i64}
 @Global = internal constant %struct {i8 0, i16 1, i32 2, i64 3, i64 4}
 
-define internal i64 @func2(i64 *%x) {
+define internal i64 @func2(ptr %x) {
 entry:
-  %val = ptrtoint i64* %x to i64
+  %val = ptrtoint ptr %x to i64
   ret i64 %val
 }
 
-define internal i64 @func(i64 *%x, i64 (i64*)* %binop) {
+define internal i64 @func(ptr %x, ptr %binop) {
 ; CHECK-LABEL: @func(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = call i64 [[BINOP:%.*]](i64* [[X:%.*]])
+; CHECK-NEXT:    [[TMP0:%.*]] = call i64 [[BINOP:%.*]](ptr [[X:%.*]])
 ; CHECK-NEXT:    ret i64 [[TMP0]]
 ;
 entry:
-  %tmp0 = call i64 %binop(i64* %x)
+  %tmp0 = call i64 %binop(ptr %x)
   ret i64 %tmp0
 }
 
@@ -31,10 +31,10 @@ define internal i64 @zoo(i1 %flag) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; CHECK:       plus:
-; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @func2.2(i64* getelementptr inbounds ([[STRUCT:%.*]], %struct* @Global, i32 0, i32 3))
+; CHECK-NEXT:    [[TMP0:%.*]] = call i64 @func2.2(ptr getelementptr inbounds ([[STRUCT:%.*]], ptr @Global, i32 0, i32 3))
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       minus:
-; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @func2.1(i64* getelementptr inbounds ([[STRUCT]], %struct* @Global, i32 0, i32 4))
+; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @func2.1(ptr getelementptr inbounds ([[STRUCT]], ptr @Global, i32 0, i32 4))
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; CHECK-NEXT:    [[TMP2:%.*]] = phi i64 [ [[TMP0]], [[PLUS]] ], [ [[TMP1]], [[MINUS]] ]
@@ -44,13 +44,13 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %arg = getelementptr %struct, %struct* @Global, i32 0, i32 3
-  %tmp0 = call i64 @func2(i64* %arg)
+  %arg = getelementptr %struct, ptr @Global, i32 0, i32 3
+  %tmp0 = call i64 @func2(ptr %arg)
   br label %merge
 
 minus:
-  %arg2 = getelementptr %struct, %struct* @Global, i32 0, i32 4
-  %tmp1 = call i64 @func2(i64* %arg2)
+  %arg2 = getelementptr %struct, ptr @Global, i32 0, i32 4
+  %tmp1 = call i64 @func2(ptr %arg2)
   br label %merge
 
 merge:
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression2.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression2.ll
index 0f3c79cb8e9f1e..07bd690ed1ccc4 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression2.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression2.ll
@@ -10,25 +10,23 @@
 @global.5 = external dso_local global [4 x %struct.pluto], align 1
 @global.12 = external global %struct.quux, align 1
 
-define internal i16 @wobble.972(%struct.quux* byval(%struct.quux) align 1 %arg, i16 %arg1, %struct.spam* byval(%struct.spam) align 1 %arg2, %struct.quux* byval(%struct.quux) align 1 %arg3) #4 {
+define internal i16 @wobble.972(ptr byval(%struct.quux) align 1 %arg, i16 %arg1, ptr byval(%struct.spam) align 1 %arg2, ptr byval(%struct.quux) align 1 %arg3) #4 {
 ; CHECK-LABEL: @wobble.972(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[TMP34:%.*]] = bitcast %struct.spam* [[ARG2:%.*]] to i16*
 ; CHECK-NEXT:    unreachable
 ;
 bb:
-  %tmp34 = bitcast %struct.spam* %arg2 to i16*
   unreachable
 }
 
 define internal i16 @snork() {
 ; CHECK-LABEL: @snork(
 ; CHECK-NEXT:  bb4:
-; CHECK-NEXT:    [[TMP:%.*]] = call i16 @wobble.972(%struct.quux* byval([[STRUCT_QUUX:%.*]]) align 1 undef, i16 undef, %struct.spam* byval([[STRUCT_SPAM:%.*]]) align 1 getelementptr inbounds ([4 x %struct.pluto], [4 x %struct.pluto]* @global.5, i32 0, i32 3, i32 0), %struct.quux* byval([[STRUCT_QUUX]]) align 1 @global.12)
+; CHECK-NEXT:    [[TMP:%.*]] = call i16 @wobble.972(ptr byval([[STRUCT_QUUX:%.*]]) align 1 undef, i16 undef, ptr byval([[STRUCT_SPAM:%.*]]) align 1 getelementptr inbounds ([4 x %struct.pluto], ptr @global.5, i32 0, i32 3, i32 0), ptr byval([[STRUCT_QUUX]]) align 1 @global.12)
 ; CHECK-NEXT:    unreachable
 ;
 bb4:
-  %tmp = call i16 @wobble.972(%struct.quux* byval(%struct.quux) align 1 undef, i16 undef, %struct.spam* byval(%struct.spam) align 1 getelementptr inbounds ([4 x %struct.pluto], [4 x %struct.pluto]* @global.5, i32 0, i32 3, i32 0), %struct.quux* byval(%struct.quux) align 1 @global.12)
+  %tmp = call i16 @wobble.972(ptr byval(%struct.quux) align 1 undef, i16 undef, ptr byval(%struct.spam) align 1 getelementptr inbounds ([4 x %struct.pluto], ptr @global.5, i32 0, i32 3, i32 0), ptr byval(%struct.quux) align 1 @global.12)
   unreachable
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression3.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression3.ll
index 3f691839a3df8c..d8924c2489e8a4 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression3.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression3.ll
@@ -4,21 +4,21 @@
 define i32 @main() {
 ; CHECK-LABEL: @main(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    tail call void @wombat.1(i8* undef, i64 undef, i64 undef, i32 (i8*, i8*)* bitcast (i32 ()* @quux to i32 (i8*, i8*)*))
-; CHECK-NEXT:    tail call void @wombat.2(i8* undef, i64 undef, i64 undef, i32 (i8*, i8*)* bitcast (i32 ()* @eggs to i32 (i8*, i8*)*))
+; CHECK-NEXT:    tail call void @wombat.1(ptr undef, i64 undef, i64 undef, ptr @quux)
+; CHECK-NEXT:    tail call void @wombat.2(ptr undef, i64 undef, i64 undef, ptr @eggs)
 ; CHECK-NEXT:    ret i32 undef
 ;
 bb:
-  tail call void @wombat(i8* undef, i64 undef, i64 undef, i32 (i8*, i8*)* bitcast (i32 ()* @quux to i32 (i8*, i8*)*))
-  tail call void @wombat(i8* undef, i64 undef, i64 undef, i32 (i8*, i8*)* bitcast (i32 ()* @eggs to i32 (i8*, i8*)*))
+  tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr @quux)
+  tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr @eggs)
   ret i32 undef
 }
 
 declare i32 @quux()
 declare i32 @eggs()
 
-define internal void @wombat(i8* %arg, i64 %arg1, i64 %arg2, i32 (i8*, i8*)* %arg3) {
+define internal void @wombat(ptr %arg, i64 %arg1, i64 %arg2, ptr %arg3) {
 bb4:
-  %tmp = tail call i32 %arg3(i8* undef, i8* undef)
+  %tmp = tail call i32 %arg3(ptr undef, ptr undef)
   ret void
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression4.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression4.ll
index 93f695d14f6cfe..a7df6cbde05a5f 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression4.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression4.ll
@@ -4,29 +4,27 @@
 
 ; CHECK-NOT: wombat.{{[0-9]+}}
 
-declare i32* @quux()
-declare i32* @eggs()
+declare ptr @quux()
+declare ptr @eggs()
 
 define i32 @main() {
 ; CHECK:       bb:
-; CHECK-NEXT:    tail call void @wombat(i8* undef, i64 undef, i64 undef, i32* byval(i32) bitcast (i32* ()* @quux to i32*))
-; CHECK-NEXT:    tail call void @wombat(i8* undef, i64 undef, i64 undef, i32* byval(i32) bitcast (i32* ()* @eggs to i32*))
+; CHECK-NEXT:    tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr byval(i32) @quux)
+; CHECK-NEXT:    tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr byval(i32) @eggs)
 ; CHECK-NEXT:    ret i32 undef
 ;
 bb:
-  tail call void @wombat(i8* undef, i64 undef, i64 undef, i32* byval(i32) bitcast (i32* ()* @quux to i32*))
-  tail call void @wombat(i8* undef, i64 undef, i64 undef, i32* byval(i32) bitcast (i32* ()* @eggs to i32*))
+  tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr byval(i32) @quux)
+  tail call void @wombat(ptr undef, i64 undef, i64 undef, ptr byval(i32) @eggs)
   ret i32 undef
 }
 
-define internal void @wombat(i8* %arg, i64 %arg1, i64 %arg2, i32* byval(i32) %func) {
+define internal void @wombat(ptr %arg, i64 %arg1, i64 %arg2, ptr byval(i32) %func) {
 ; CHECK:       bb2:
-; CHECK-NEXT:    [[FUNPTR:%.*]] = bitcast i32* %func to i32* (i8*, i8*)*
-; CHECK-NEXT:    [[TMP:%.*]] = tail call i32* [[FUNPTR]](i8* undef, i8* undef)
+; CHECK-NEXT:    [[TMP:%.*]] = tail call ptr %func(ptr undef, ptr undef)
 ; CHECK-NEXT:    ret void
 ;
 bb2:
-  %mycall = bitcast i32* %func to i32* (i8*, i8*)*
-  %tmp = tail call i32* %mycall(i8* undef, i8* undef)
+  %tmp = tail call ptr %func(ptr undef, ptr undef)
   ret void
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression5.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression5.ll
index 01228984842f5c..1a3a2c0fbac8a6 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression5.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-constant-expression5.ll
@@ -12,25 +12,23 @@
 @global.5 = external dso_local global i128
 @global.12 = external global %struct.quux
 
-define internal i16 @wobble(%struct.quux* %arg, i16 %arg1, i128* byval(i128) %arg2, %struct.quux* %arg3) {
+define internal i16 @wobble(ptr %arg, i16 %arg1, ptr byval(i128) %arg2, ptr %arg3) {
 ; CHECK-LABEL: @wobble(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[TMP34:%.*]] = bitcast i128* [[ARG2:%.*]] to i16*
 ; CHECK-NEXT:    unreachable
 ;
 bb:
-  %tmp34 = bitcast i128* %arg2 to i16*
   unreachable
 }
 
 define internal i16 @snork() {
 ; CHECK-LABEL: @snork(
 ; CHECK-NEXT:  bb4:
-; CHECK-NEXT:    [[TMP35:%.*]] = call i16 @wobble(%struct.quux* undef, i16 2, i128* byval(i128) @global.5, %struct.quux* @global.12)
+; CHECK-NEXT:    [[TMP35:%.*]] = call i16 @wobble(ptr undef, i16 2, ptr byval(i128) @global.5, ptr @global.12)
 ; CHECK-NEXT:    unreachable
 ;
 bb4:
-  %tmp35 = call i16 @wobble(%struct.quux* undef, i16 2, i128* byval(i128) @global.5, %struct.quux* @global.12)
+  %tmp35 = call i16 @wobble(ptr undef, i16 2, ptr byval(i128) @global.5, ptr @global.12)
   unreachable
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll
index 919f583b27a836..d3af3c44e6a58c 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-loop.ll
@@ -15,7 +15,7 @@ declare i1 @cond_begin()
 declare i1 @cond_end()
 declare i1 @getCond()
 
-define internal i32 @foo(i32 %x, i32* %b, i32* %c) {
+define internal i32 @foo(i32 %x, ptr %b, ptr %c) {
 entry:
   br label %loop.entry
 
@@ -26,8 +26,8 @@ loop2.entry:
   br label %loop2.body
 
 loop2.body:
-  %0 = load i32, i32* %b, align 4
-  %1 = load i32, i32* %c, align 4
+  %0 = load i32, ptr %b, align 4
+  %1 = load i32, ptr %c, align 4
   %add.0 = add nsw i32 %0, %1
   %add = add nsw i32 %add.0, %x
   br label %loop2.end
@@ -50,11 +50,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A, i32* @C)
+  %call = call i32 @foo(i32 %x, ptr @A, ptr @C)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B, i32* @D)
+  %call1 = call i32 @foo(i32 %y, ptr @B, ptr @D)
   br label %return
 
 return:
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize.ll
index 8fc5438b2e42c3..7df997c6e93bfa 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize.ll
@@ -8,11 +8,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus)
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus)
   br label %merge
 
 merge:
@@ -20,7 +20,7 @@ merge:
   ret i64 %tmp2
 }
 
-define internal i64 @compute(i64 %x, i64 (i64)* %binop) minsize {
+define internal i64 @compute(i64 %x, ptr %binop) minsize {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize2.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize2.ll
index 80ea1a47954e58..cc6661da59d3b1 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize2.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize2.ll
@@ -11,11 +11,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus) #0
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus) #0
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus) #0
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus) #0
   br label %merge
 
 merge:
@@ -23,7 +23,7 @@ merge:
   ret i64 %tmp2
 }
 
-define internal i64 @compute(i64 %x, i64 (i64)* %binop) {
+define internal i64 @compute(i64 %x, ptr %binop) {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize3.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize3.ll
index 4321b2fecc3cd6..32f452e29fb5cd 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize3.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-minsize3.ll
@@ -4,10 +4,10 @@
 ; specialisation for the call that does not have the attribute:
 ;
 ; CHECK: plus:
-; CHECK:   %tmp0 = call i64 @compute.1(i64 %x, i64 (i64)* @plus)
+; CHECK:   %tmp0 = call i64 @compute.1(i64 %x, ptr @plus)
 ; CHECK:   br label %merge
 ; CHECK: minus:
-; CHECK:   %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus) #0
+; CHECK:   %tmp1 = call i64 @compute(i64 %x, ptr @minus) #0
 ; CHECK:   br label %merge
 ;
 define i64 @main(i64 %x, i1 %flag) {
@@ -15,11 +15,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus) #0
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus) #0
   br label %merge
 
 merge:
@@ -27,7 +27,7 @@ merge:
   ret i64 %tmp2
 }
 
-define internal i64 @compute(i64 %x, i64 (i64)* %binop) {
+define internal i64 @compute(i64 %x, ptr %binop) {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup.ll
index fa726b66fe596c..60ec256d90a668 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup.ll
@@ -17,11 +17,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A)
+  %call = call i32 @foo(i32 %x, ptr @A)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B)
+  %call1 = call i32 @foo(i32 %y, ptr @B)
   br label %return
 
 return:
@@ -29,9 +29,9 @@ return:
   ret i32 %retval.0
 }
 
-define internal i32 @foo(i32 %x, i32* %b) #0 {
+define internal i32 @foo(i32 %x, ptr %b) #0 {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
   ret i32 %add
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup2.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup2.ll
index 84d5dd81bf3c22..22a31b0bf886ea 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup2.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nodup2.ll
@@ -19,11 +19,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A)
+  %call = call i32 @foo(i32 %x, ptr @A)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B)
+  %call1 = call i32 @foo(i32 %y, ptr @B)
   br label %return
 
 return:
@@ -31,9 +31,9 @@ return:
   ret i32 %retval.0
 }
 
-define internal i32 @foo(i32 %x, i32* %b) {
+define internal i32 @foo(i32 %x, ptr %b) {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
   %cmp = call i1 @llvm.test.set.loop.iterations.i32(i32 42)
   ret i32 %add
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-noexec.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-noexec.ll
index 8e205965f4bc35..3b39b35d825cb9 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-noexec.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-noexec.ll
@@ -16,11 +16,11 @@ entry:
   br i1 false, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A)
+  %call = call i32 @foo(i32 %x, ptr @A)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B)
+  %call1 = call i32 @foo(i32 %y, ptr @B)
   br label %return
 
 return:
@@ -28,9 +28,9 @@ return:
   ret i32 %retval.0
 }
 
-define internal i32 @foo(i32 %x, i32* %b) {
+define internal i32 @foo(i32 %x, ptr %b) {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
   ret i32 %add
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nonconst-glob.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nonconst-glob.ll
index 42a7dc6f5af03a..7879b414fe530c 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nonconst-glob.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nonconst-glob.ll
@@ -7,8 +7,8 @@
 ; Global B is not constant. We do not specialise on addresses unless we
 ; enable that:
 
-; ON-ADDRESS: call i32 @foo.1(i32 %x, i32* @A)
-; ON-ADDRESS: call i32 @foo.2(i32 %y, i32* @B)
+; ON-ADDRESS: call i32 @foo.1(i32 %x, ptr @A)
+; ON-ADDRESS: call i32 @foo.2(i32 %y, ptr @B)
 
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
@@ -21,10 +21,10 @@ define dso_local i32 @bar(i32 %x, i32 %y) {
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo.1(i32 [[X]], i32* @A)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo.1(i32 [[X]], ptr @A)
 ; CHECK-NEXT:    br label [[RETURN:%.*]]
 ; CHECK:       if.else:
-; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @foo(i32 [[Y:%.*]], i32* @B)
+; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @foo(i32 [[Y:%.*]], ptr @B)
 ; CHECK-NEXT:    br label [[RETURN]]
 ; CHECK:       return:
 ; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi i32 [ [[CALL]], [[IF_THEN]] ], [ [[CALL1]], [[IF_ELSE]] ]
@@ -35,11 +35,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A)
+  %call = call i32 @foo(i32 %x, ptr @A)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B)
+  %call1 = call i32 @foo(i32 %y, ptr @B)
   br label %return
 
 return:
@@ -47,22 +47,22 @@ return:
   ret i32 %retval.0
 }
 
-define internal i32 @foo(i32 %x, i32* %b) {
+define internal i32 @foo(i32 %x, ptr %b) {
 ; CHECK-LABEL: define internal i32 @foo(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[B:%.*]], align 4
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[B:%.*]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[X:%.*]], [[TMP0]]
 ; CHECK-NEXT:    ret i32 [[ADD]]
 ;
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
   ret i32 %add
 }
 
-; CHECK-LABEL: define internal i32 @foo.1(i32 %x, i32* %b) {
+; CHECK-LABEL: define internal i32 @foo.1(i32 %x, ptr %b) {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    %0 = load i32, i32* @A, align 4
+; CHECK-NEXT:    %0 = load i32, ptr @A, align 4
 ; CHECK-NEXT:    %add = add nsw i32 %x, %0
 ; CHECK-NEXT:    ret i32 %add
 ; CHECK-NEXT:  }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nothing-todo.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nothing-todo.ll
index b707eca22360d0..22cacb136a1ed1 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-nothing-todo.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-nothing-todo.ll
@@ -22,8 +22,8 @@
 ; CHECK-NOT:   call i32 @llvm.ssa.copy.i32
 
 @N = external dso_local global i32, align 4
-@B = external dso_local global i32*, align 8
-@A = external dso_local global i32*, align 8
+@B = external dso_local global ptr, align 8
+@A = external dso_local global ptr, align 8
 
 define dso_local i32 @foo() {
 entry:
@@ -31,7 +31,7 @@ entry:
 
 for.cond:
   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
-  %0 = load i32, i32* @N, align 4
+  %0 = load i32, ptr @N, align 4
   %cmp = icmp slt i32 %i.0, %0
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 
@@ -39,13 +39,13 @@ for.cond.cleanup:
   ret i32 undef
 
 for.body:
-  %1 = load i32*, i32** @B, align 8
+  %1 = load ptr, ptr @B, align 8
   %idxprom = sext i32 %i.0 to i64
-  %arrayidx = getelementptr inbounds i32, i32* %1, i64 %idxprom
-  %2 = load i32, i32* %arrayidx, align 4
-  %3 = load i32*, i32** @A, align 8
-  %arrayidx2 = getelementptr inbounds i32, i32* %3, i64 %idxprom
-  store i32 %2, i32* %arrayidx2, align 4
+  %arrayidx = getelementptr inbounds i32, ptr %1, i64 %idxprom
+  %2 = load i32, ptr %arrayidx, align 4
+  %3 = load ptr, ptr @A, align 8
+  %arrayidx2 = getelementptr inbounds i32, ptr %3, i64 %idxprom
+  store i32 %2, ptr %arrayidx2, align 4
   %inc = add nsw i32 %i.0, 1
   br label %for.cond
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-poison.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-poison.ll
index d359deedcc496b..e605e0fbbaef27 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-poison.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-poison.ll
@@ -8,25 +8,23 @@
 
 @global.12 = external global %struct.quux, align 1
 
-define internal i16 @wobble(%struct.spam* byval(%struct.spam) %arg2) {
+define internal i16 @wobble(ptr byval(%struct.spam) %arg2) {
 ; CHECK-LABEL: @wobble(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[C:%.*]] = bitcast %struct.spam* [[ARG2:%.*]] to i16*
 ; CHECK-NEXT:    unreachable
 ;
 bb:
-  %C = bitcast %struct.spam* %arg2 to i16*
   unreachable
 }
 
 define internal i16 @snork() {
 ; CHECK-LABEL: @snork(
 ; CHECK-NEXT:  bb4:
-; CHECK-NEXT:    [[B:%.*]] = call i16 @wobble(%struct.spam* poison)
+; CHECK-NEXT:    [[B:%.*]] = call i16 @wobble(ptr poison)
 ; CHECK-NEXT:    unreachable
 ;
 bb4:
-  %B = call i16 @wobble(%struct.spam* poison)
+  %B = call i16 @wobble(ptr poison)
   unreachable
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll
index 82020edec442fc..5cea9f1d62f244 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive.ll
@@ -5,11 +5,11 @@
 @low = internal constant i32 0, align 4
 @high = internal constant i32 6, align 4
 
-define internal void @recursiveFunc(i32* nocapture readonly %lo, i32 %step, i32* nocapture readonly %hi) {
+define internal void @recursiveFunc(ptr nocapture readonly %lo, i32 %step, ptr nocapture readonly %hi) {
   %lo.temp = alloca i32, align 4
   %hi.temp = alloca i32, align 4
-  %lo.load = load i32, i32* %lo, align 4
-  %hi.load = load i32, i32* %hi, align 4
+  %lo.load = load i32, ptr %lo, align 4
+  %hi.load = load i32, ptr %hi, align 4
   %cmp = icmp ne i32 %lo.load, %hi.load
   br i1 %cmp, label %block6, label %ret.block
 
@@ -17,9 +17,9 @@ block6:
   call void @print_val(i32 %lo.load, i32 %hi.load)
   %add = add nsw i32 %lo.load, %step
   %sub = sub nsw i32 %hi.load, %step
-  store i32 %add, i32* %lo.temp, align 4
-  store i32 %sub, i32* %hi.temp, align 4
-  call void @recursiveFunc(i32* nonnull %lo.temp, i32 %step, i32* nonnull %hi.temp)
+  store i32 %add, ptr %lo.temp, align 4
+  store i32 %sub, ptr %hi.temp, align 4
+  call void @recursiveFunc(ptr nonnull %lo.temp, i32 %step, ptr nonnull %hi.temp)
   br label %ret.block
 
 ret.block:
@@ -36,14 +36,14 @@ define i32 @main() {
 ; ITERS2-LABEL: @main(
 ; ITERS2-NEXT:    call void @print_val(i32 0, i32 6)
 ; ITERS2-NEXT:    call void @print_val(i32 1, i32 5)
-; ITERS2-NEXT:    call void @recursiveFunc(i32* nonnull @funcspec.arg.4, i32 1, i32* nonnull @funcspec.arg.5)
+; ITERS2-NEXT:    call void @recursiveFunc(ptr nonnull @funcspec.arg.4, i32 1, ptr nonnull @funcspec.arg.5)
 ; ITERS2-NEXT:    ret i32 0
 ;
 ; ITERS3-LABEL: @main(
 ; ITERS3-NEXT:    call void @print_val(i32 0, i32 6)
 ; ITERS3-NEXT:    call void @print_val(i32 1, i32 5)
 ; ITERS3-NEXT:    call void @print_val(i32 2, i32 4)
-; ITERS3-NEXT:    call void @recursiveFunc(i32* nonnull @funcspec.arg.7, i32 1, i32* nonnull @funcspec.arg.8)
+; ITERS3-NEXT:    call void @recursiveFunc(ptr nonnull @funcspec.arg.7, i32 1, ptr nonnull @funcspec.arg.8)
 ; ITERS3-NEXT:    ret i32 0
 ;
 ; ITERS4-LABEL: @main(
@@ -52,7 +52,7 @@ define i32 @main() {
 ; ITERS4-NEXT:    call void @print_val(i32 2, i32 4)
 ; ITERS4-NEXT:    ret i32 0
 ;
-  call void @recursiveFunc(i32* nonnull @low, i32 1, i32* nonnull @high)
+  call void @recursiveFunc(ptr nonnull @low, i32 1, ptr nonnull @high)
   ret i32 0
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive2.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive2.ll
index 8bac3cf26f4bd3..d62cc6fb3fa2e2 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive2.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive2.ll
@@ -7,17 +7,17 @@
 
 @Global = internal constant i32 1, align 4
 
-define internal void @recursiveFunc(i32* nocapture readonly %arg) {
+define internal void @recursiveFunc(ptr nocapture readonly %arg) {
   %temp = alloca i32, align 4
-  %arg.load = load i32, i32* %arg, align 4
+  %arg.load = load i32, ptr %arg, align 4
   %arg.cmp = icmp slt i32 %arg.load, 4
   br i1 %arg.cmp, label %block6, label %ret.block
 
 block6:
   call void @print_val(i32 %arg.load)
   %arg.add = add nsw i32 %arg.load, 1
-  store volatile i32 %arg.add, i32* %temp, align 4
-  call void @recursiveFunc(i32* nonnull %temp)
+  store volatile i32 %arg.add, ptr %temp, align 4
+  call void @recursiveFunc(ptr nonnull %temp)
   br label %ret.block
 
 ret.block:
@@ -25,7 +25,7 @@ ret.block:
 }
 
 define i32 @main() {
-  call void @recursiveFunc(i32* nonnull @Global)
+  call void @recursiveFunc(ptr nonnull @Global)
   ret i32 0
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive3.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive3.ll
index 46b7761e9d7079..e234b003d2d44c 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive3.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive3.ll
@@ -7,18 +7,18 @@
 
 @Global = internal constant i32 1, align 4
 
-define internal void @recursiveFunc(i32* nocapture readonly %arg) {
+define internal void @recursiveFunc(ptr nocapture readonly %arg) {
   %temp = alloca i32, align 4
-  %arg.load = load i32, i32* %arg, align 4
+  %arg.load = load i32, ptr %arg, align 4
   %arg.cmp = icmp slt i32 %arg.load, 4
   br i1 %arg.cmp, label %block6, label %ret.block
 
 block6:
   call void @print_val(i32 %arg.load)
   %arg.add = add nsw i32 %arg.load, 1
-  store i32 %arg.add, i32* %temp, align 4
-  store i32 %arg.add, i32* %temp, align 4
-  call void @recursiveFunc(i32* nonnull %temp)
+  store i32 %arg.add, ptr %temp, align 4
+  store i32 %arg.add, ptr %temp, align 4
+  call void @recursiveFunc(ptr nonnull %temp)
   br label %ret.block
 
 ret.block:
@@ -27,7 +27,7 @@ ret.block:
 
 
 define i32 @main() {
-  call void @recursiveFunc(i32* nonnull @Global)
+  call void @recursiveFunc(ptr nonnull @Global)
   ret i32 0
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive4.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive4.ll
index 294c6e00f38a9b..d46b12153ea436 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive4.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-recursive4.ll
@@ -7,17 +7,16 @@
 
 @Global = internal constant i32 1, align 4
 
-define internal void @recursiveFunc(i32* nocapture readonly %arg) {
+define internal void @recursiveFunc(ptr nocapture readonly %arg) {
   %temp = alloca float, align 4
-  %arg.load = load i32, i32* %arg, align 4
+  %arg.load = load i32, ptr %arg, align 4
   %arg.cmp = icmp slt i32 %arg.load, 4
   br i1 %arg.cmp, label %block6, label %ret.block
 
 block6:
   call void @print_val(i32 %arg.load)
   %arg.add = add nsw i32 %arg.load, 1
-  %bc = bitcast float* %temp to i32*
-  call void @recursiveFunc(i32* nonnull %bc)
+  call void @recursiveFunc(ptr nonnull %temp)
   br label %ret.block
 
 ret.block:
@@ -25,7 +24,7 @@ ret.block:
 }
 
 define i32 @main() {
-  call void @recursiveFunc(i32* nonnull @Global)
+  call void @recursiveFunc(ptr nonnull @Global)
   ret i32 0
 }
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll
index a3959561dc1518..9dd7ed0a2ab9aa 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization-stats.ll
@@ -8,11 +8,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus)
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus)
   br label %merge
 
 merge:
@@ -20,7 +20,7 @@ merge:
   ret i64 %tmp2
 }
 
-define internal i64 @compute(i64 %x, i64 (i64)* %binop) {
+define internal i64 @compute(i64 %x, ptr %binop) {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization.ll
index 17349172be7b30..ae0c530a612f2c 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization.ll
@@ -6,10 +6,10 @@ define i64 @main(i64 %x, i1 %flag) {
 ; CHECK:      entry:
 ; CHECK-NEXT:   br i1 %flag, label %plus, label %minus
 ; CHECK:      plus:
-; CHECK-NEXT:   [[TMP0:%.+]] = call i64 @compute.1(i64 %x, i64 (i64)* @plus)
+; CHECK-NEXT:   [[TMP0:%.+]] = call i64 @compute.1(i64 %x, ptr @plus)
 ; CHECK-NEXT:   br label %merge
 ; CHECK:      minus:
-; CHECK-NEXT:   [[TMP1:%.+]] = call i64 @compute.2(i64 %x, i64 (i64)* @minus)
+; CHECK-NEXT:   [[TMP1:%.+]] = call i64 @compute.2(i64 %x, ptr @minus)
 ; CHECK-NEXT:   br label %merge
 ; CHECK:      merge:
 ; CHECK-NEXT:   [[TMP2:%.+]] = phi i64 [ [[TMP0]], %plus ], [ [[TMP1]], %minus ]
@@ -20,11 +20,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus)
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus)
   br label %merge
 
 merge:
@@ -34,19 +34,19 @@ merge:
 
 ; CHECK-NOT: define internal i64 @compute(
 ;
-; CHECK-LABEL: define internal i64 @compute.1(i64 %x, i64 (i64)* %binop) {
+; CHECK-LABEL: define internal i64 @compute.1(i64 %x, ptr %binop) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.+]] = call i64 @plus(i64 %x)
 ; CHECK-NEXT:    ret i64 [[TMP0]]
 ; CHECK-NEXT:  }
 ;
-; CHECK-LABEL: define internal i64 @compute.2(i64 %x, i64 (i64)* %binop) {
+; CHECK-LABEL: define internal i64 @compute.2(i64 %x, ptr %binop) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.+]] = call i64 @minus(i64 %x)
 ; CHECK-NEXT:    ret i64 [[TMP0]]
 ; CHECK-NEXT:  }
 ;
-define internal i64 @compute(i64 %x, i64 (i64)* %binop) {
+define internal i64 @compute(i64 %x, ptr %binop) {
 entry:
   %tmp0 = call i64 %binop(i64 %x)
   ret i64 %tmp0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll
index c7bceed3bd91c8..c80e3f702ab376 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization2.ll
@@ -7,63 +7,63 @@
 ; DISABLED-NOT: @func.1(
 ; DISABLED-NOT: @func.2(
 
-define internal i32 @func(i32* %0, i32 %1, void (i32*)* nocapture %2) {
+define internal i32 @func(ptr %0, i32 %1, ptr nocapture %2) {
   %4 = alloca i32, align 4
-  store i32 %1, i32* %4, align 4
-  %5 = load i32, i32* %4, align 4
+  store i32 %1, ptr %4, align 4
+  %5 = load i32, ptr %4, align 4
   %6 = icmp slt i32 %5, 1
   br i1 %6, label %14, label %7
 
 7:                                                ; preds = %3
-  %8 = load i32, i32* %4, align 4
+  %8 = load i32, ptr %4, align 4
   %9 = sext i32 %8 to i64
-  %10 = getelementptr inbounds i32, i32* %0, i64 %9
-  call void %2(i32* %10)
-  %11 = load i32, i32* %4, align 4
+  %10 = getelementptr inbounds i32, ptr %0, i64 %9
+  call void %2(ptr %10)
+  %11 = load i32, ptr %4, align 4
   %12 = add nsw i32 %11, -1
-  %13 = call i32 @func(i32* %0, i32 %12, void (i32*)* %2)
+  %13 = call i32 @func(ptr %0, i32 %12, ptr %2)
   br label %14
 
 14:                                               ; preds = %3, %7
   ret i32 0
 }
 
-define internal void @increment(i32* nocapture %0) {
-  %2 = load i32, i32* %0, align 4
+define internal void @increment(ptr nocapture %0) {
+  %2 = load i32, ptr %0, align 4
   %3 = add nsw i32 %2, 1
-  store i32 %3, i32* %0, align 4
+  store i32 %3, ptr %0, align 4
   ret void
 }
 
-define internal void @decrement(i32* nocapture %0) {
-  %2 = load i32, i32* %0, align 4
+define internal void @decrement(ptr nocapture %0) {
+  %2 = load i32, ptr %0, align 4
   %3 = add nsw i32 %2, -1
-  store i32 %3, i32* %0, align 4
+  store i32 %3, ptr %0, align 4
   ret void
 }
 
-define i32 @main(i32* %0, i32 %1) {
-; CHECK:    [[TMP3:%.*]] = call i32 @func.2(i32* [[TMP0:%.*]], i32 [[TMP1:%.*]])
-  %3 = call i32 @func(i32* %0, i32 %1, void (i32*)* nonnull @increment)
-; CHECK:    [[TMP4:%.*]] = call i32 @func.1(i32* [[TMP0]], i32 [[TMP3]])
-  %4 = call i32 @func(i32* %0, i32 %3, void (i32*)* nonnull @decrement)
+define i32 @main(ptr %0, i32 %1) {
+; CHECK:    [[TMP3:%.*]] = call i32 @func.2(ptr [[TMP0:%.*]], i32 [[TMP1:%.*]])
+  %3 = call i32 @func(ptr %0, i32 %1, ptr nonnull @increment)
+; CHECK:    [[TMP4:%.*]] = call i32 @func.1(ptr [[TMP0]], i32 [[TMP3]])
+  %4 = call i32 @func(ptr %0, i32 %3, ptr nonnull @decrement)
   ret i32 %4
 }
 
 ; CHECK: @func.1(
 ; CHECK:    [[TMP3:%.*]] = alloca i32, align 4
-; CHECK:    store i32 [[TMP1:%.*]], i32* [[TMP3]], align 4
-; CHECK:    [[TMP4:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    store i32 [[TMP1:%.*]], ptr [[TMP3]], align 4
+; CHECK:    [[TMP4:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP5:%.*]] = icmp slt i32 [[TMP4]], 1
 ; CHECK:    br i1 [[TMP5]], label [[TMP13:%.*]], label [[TMP6:%.*]]
 ; CHECK:       6:
-; CHECK:    [[TMP7:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    [[TMP7:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP8:%.*]] = sext i32 [[TMP7]] to i64
-; CHECK:    [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP0:%.*]], i64 [[TMP8]]
-; CHECK:    call void @decrement(i32* [[TMP9]])
-; CHECK:    [[TMP10:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    [[TMP9:%.*]] = getelementptr inbounds i32, ptr [[TMP0:%.*]], i64 [[TMP8]]
+; CHECK:    call void @decrement(ptr [[TMP9]])
+; CHECK:    [[TMP10:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP11:%.*]] = add nsw i32 [[TMP10]], -1
-; CHECK:    [[TMP12:%.*]] = call i32 @func.1(i32* [[TMP0]], i32 [[TMP11]])
+; CHECK:    [[TMP12:%.*]] = call i32 @func.1(ptr [[TMP0]], i32 [[TMP11]])
 ; CHECK:    br label [[TMP13]]
 ; CHECK:       13:
 ; CHECK:    ret i32 0
@@ -71,17 +71,17 @@ define i32 @main(i32* %0, i32 %1) {
 ;
 ; CHECK: @func.2(
 ; CHECK:    [[TMP3:%.*]] = alloca i32, align 4
-; CHECK:    store i32 [[TMP1:%.*]], i32* [[TMP3]], align 4
-; CHECK:    [[TMP4:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    store i32 [[TMP1:%.*]], ptr [[TMP3]], align 4
+; CHECK:    [[TMP4:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP5:%.*]] = icmp slt i32 [[TMP4]], 1
 ; CHECK:    br i1 [[TMP5]], label [[TMP13:%.*]], label [[TMP6:%.*]]
 ; CHECK:       6:
-; CHECK:    [[TMP7:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    [[TMP7:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP8:%.*]] = sext i32 [[TMP7]] to i64
-; CHECK:    [[TMP9:%.*]] = getelementptr inbounds i32, i32* [[TMP0:%.*]], i64 [[TMP8]]
-; CHECK:    call void @increment(i32* [[TMP9]])
-; CHECK:    [[TMP10:%.*]] = load i32, i32* [[TMP3]], align 4
+; CHECK:    [[TMP9:%.*]] = getelementptr inbounds i32, ptr [[TMP0:%.*]], i64 [[TMP8]]
+; CHECK:    call void @increment(ptr [[TMP9]])
+; CHECK:    [[TMP10:%.*]] = load i32, ptr [[TMP3]], align 4
 ; CHECK:    [[TMP11:%.*]] = add nsw i32 [[TMP10]], -1
-; CHECK:    [[TMP12:%.*]] = call i32 @func.2(i32* [[TMP0]], i32 [[TMP11]])
+; CHECK:    [[TMP12:%.*]] = call i32 @func.2(ptr [[TMP0]], i32 [[TMP11]])
 ; CHECK:    br label [[TMP13]]
 ; CHECK:    ret i32 0
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll
index 6b65e66697c6cc..f20fd6c7acd0cc 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization3.ll
@@ -14,19 +14,19 @@ target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 define dso_local i32 @bar(i32 %x, i32 %y) {
 ; COMMON-LABEL: @bar
-; FORCE:        %call = call i32 @foo.1(i32 %x, i32* @A)
-; FORCE:        %call1 = call i32 @foo.2(i32 %y, i32* @B)
+; FORCE:        %call = call i32 @foo.1(i32 %x, ptr @A)
+; FORCE:        %call1 = call i32 @foo.2(i32 %y, ptr @B)
 ; DISABLED-NOT: %call1 = call i32 @foo.1(
 entry:
   %tobool = icmp ne i32 %x, 0
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A)
+  %call = call i32 @foo(i32 %x, ptr @A)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B)
+  %call1 = call i32 @foo(i32 %y, ptr @B)
   br label %return
 
 return:
@@ -36,23 +36,23 @@ return:
 
 ; FORCE-NOT: define internal i32 @foo(
 ;
-; FORCE:      define internal i32 @foo.1(i32 %x, i32* %b) {
+; FORCE:      define internal i32 @foo.1(i32 %x, ptr %b) {
 ; FORCE-NEXT: entry:
-; FORCE-NEXT:   %0 = load i32, i32* @A, align 4
+; FORCE-NEXT:   %0 = load i32, ptr @A, align 4
 ; FORCE-NEXT:   %add = add nsw i32 %x, %0
 ; FORCE-NEXT:   ret i32 %add
 ; FORCE-NEXT: }
 ;
-; FORCE:      define internal i32 @foo.2(i32 %x, i32* %b) {
+; FORCE:      define internal i32 @foo.2(i32 %x, ptr %b) {
 ; FORCE-NEXT: entry:
-; FORCE-NEXT:   %0 = load i32, i32* @B, align 4
+; FORCE-NEXT:   %0 = load i32, ptr @B, align 4
 ; FORCE-NEXT:   %add = add nsw i32 %x, %0
 ; FORCE-NEXT:   ret i32 %add
 ; FORCE-NEXT: }
 ;
-define internal i32 @foo(i32 %x, i32* %b) {
+define internal i32 @foo(i32 %x, ptr %b) {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
   ret i32 %add
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll
index 787e6e6c87d536..4348fe32a771f5 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization4.ll
@@ -17,11 +17,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A, i32* @C)
+  %call = call i32 @foo(i32 %x, ptr @A, ptr @C)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @B, i32* @D)
+  %call1 = call i32 @foo(i32 %y, ptr @B, ptr @D)
   br label %return
 
 return:
@@ -30,32 +30,32 @@ return:
 }
 
 ; CHECK-NOT: define internal i32 @foo(
-define internal i32 @foo(i32 %x, i32* %b, i32* %c) {
+define internal i32 @foo(i32 %x, ptr %b, ptr %c) {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
-  %1 = load i32, i32* %c, align 4
+  %1 = load i32, ptr %c, align 4
   %add1 = add nsw i32 %add, %1
   ret i32 %add1
 }
 
-; CONST1:     define internal i32 @foo.1(i32 %x, i32* %b, i32* %c)
-; CONST1-NOT: define internal i32 @foo.2(i32 %x, i32* %b, i32* %c)
+; CONST1:     define internal i32 @foo.1(i32 %x, ptr %b, ptr %c)
+; CONST1-NOT: define internal i32 @foo.2(i32 %x, ptr %b, ptr %c)
 
-; CHECK:        define internal i32 @foo.1(i32 %x, i32* %b, i32* %c) {
+; CHECK:        define internal i32 @foo.1(i32 %x, ptr %b, ptr %c) {
 ; CHECK-NEXT:   entry:
-; CHECK-NEXT:     %0 = load i32, i32* @A, align 4
+; CHECK-NEXT:     %0 = load i32, ptr @A, align 4
 ; CHECK-NEXT:     %add = add nsw i32 %x, %0
-; CHECK-NEXT:     %1 = load i32, i32* @C, align 4
+; CHECK-NEXT:     %1 = load i32, ptr @C, align 4
 ; CHECK-NEXT:     %add1 = add nsw i32 %add, %1
 ; CHECK-NEXT:     ret i32 %add1
 ; CHECK-NEXT:   }
 
-; CHECK: define internal i32 @foo.2(i32 %x, i32* %b, i32* %c) {
+; CHECK: define internal i32 @foo.2(i32 %x, ptr %b, ptr %c) {
 ; CHECK-NEXT:   entry:
-; CHECK-NEXT:     %0 = load i32, i32* @B, align 4
+; CHECK-NEXT:     %0 = load i32, ptr @B, align 4
 ; CHECK-NEXT:     %add = add nsw i32 %x, %0
-; CHECK-NEXT:     %1 = load i32, i32* @D, align 4
+; CHECK-NEXT:     %1 = load i32, ptr @D, align 4
 ; CHECK-NEXT:     %add1 = add nsw i32 %add, %1
 ; CHECK-NEXT:     ret i32 %add1
 ; CHECK-NEXT:   }
diff --git a/llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll b/llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll
index a18a9a0fa5c341..f4e09b3fa5f3fd 100644
--- a/llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/function-specialization5.ll
@@ -18,11 +18,11 @@ entry:
   br i1 %tobool, label %if.then, label %if.else
 
 if.then:
-  %call = call i32 @foo(i32 %x, i32* @A, i32* @C)
+  %call = call i32 @foo(i32 %x, ptr @A, ptr @C)
   br label %return
 
 if.else:
-  %call1 = call i32 @foo(i32 %y, i32* @A, i32* @C)
+  %call1 = call i32 @foo(i32 %y, ptr @A, ptr @C)
   br label %return
 
 return:
@@ -30,11 +30,11 @@ return:
   ret i32 %retval.0
 }
 
-define internal i32 @foo(i32 %x, i32* %b, i32* %c) {
+define internal i32 @foo(i32 %x, ptr %b, ptr %c) {
 entry:
-  %0 = load i32, i32* %b, align 4
+  %0 = load i32, ptr %b, align 4
   %add = add nsw i32 %x, %0
-  %1 = load i32, i32* %c, align 4
+  %1 = load i32, ptr %c, align 4
   %add1 = add nsw i32 %add, %1
   ret i32 %add1
 }
diff --git a/llvm/test/Transforms/FunctionSpecialization/identical-specializations.ll b/llvm/test/Transforms/FunctionSpecialization/identical-specializations.ll
index 711248ba041022..e67f9d68b7b6ca 100644
--- a/llvm/test/Transforms/FunctionSpecialization/identical-specializations.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/identical-specializations.ll
@@ -6,38 +6,38 @@ define i64 @main(i64 %x, i64 %y, i1 %flag) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; CHECK:       plus:
-; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @compute.1(i64 [[X:%.*]], i64 [[Y:%.*]], i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @compute.1(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @plus, ptr @minus)
 ; CHECK-NEXT:    br label [[MERGE:%.*]]
 ; CHECK:       minus:
-; CHECK-NEXT:    [[CMP1:%.*]] = call i64 @compute.2(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @minus, i64 (i64, i64)* @plus)
+; CHECK-NEXT:    [[CMP1:%.*]] = call i64 @compute.2(i64 [[X]], i64 [[Y]], ptr @minus, ptr @plus)
 ; CHECK-NEXT:    br label [[MERGE]]
 ; CHECK:       merge:
 ; CHECK-NEXT:    [[PH:%.*]] = phi i64 [ [[CMP0]], [[PLUS]] ], [ [[CMP1]], [[MINUS]] ]
-; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute.1(i64 [[PH]], i64 42, i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute.1(i64 [[PH]], i64 42, ptr @plus, ptr @minus)
 ; CHECK-NEXT:    ret i64 [[CMP2]]
 ;
 entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %cmp0 = call i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+  %cmp0 = call i64 @compute(i64 %x, i64 %y, ptr @plus, ptr @minus)
   br label %merge
 
 minus:
-  %cmp1 = call i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* @minus, i64 (i64, i64)* @plus)
+  %cmp1 = call i64 @compute(i64 %x, i64 %y, ptr @minus, ptr @plus)
   br label %merge
 
 merge:
   %ph = phi i64 [ %cmp0, %plus ], [ %cmp1, %minus]
-  %cmp2 = call i64 @compute(i64 %ph, i64 42, i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+  %cmp2 = call i64 @compute(i64 %ph, i64 42, ptr @plus, ptr @minus)
   ret i64 %cmp2
 }
 
-define internal i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* %binop2) {
+define internal i64 @compute(i64 %x, i64 %y, ptr %binop1, ptr %binop2) {
 entry:
   %op0 = call i64 %binop1(i64 %x, i64 %y)
   %op1 = call i64 %binop2(i64 %x, i64 %y)
-  %op2 = call i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* @plus)
+  %op2 = call i64 @compute(i64 %x, i64 %y, ptr %binop1, ptr @plus)
   %add0 = add i64 %op0, %op1
   %add1 = add i64 %add0, %op2
   %div = sdiv i64 %add1, %x
@@ -64,16 +64,16 @@ entry:
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @plus(i64 [[X:%.*]], i64 [[Y:%.*]])
 ; CHECK-NEXT:    [[CMP1:%.*]] = call i64 @minus(i64 [[X]], i64 [[Y]])
-; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @plus)
+; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], ptr @plus, ptr @plus)
 
 ; CHECK-LABEL: @compute.2
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @minus(i64 [[X:%.*]], i64 [[Y:%.*]])
 ; CHECK-NEXT:    [[CMP1:%.*]] = call i64 @plus(i64 [[X]], i64 [[Y]])
-; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @minus, i64 (i64, i64)* @plus)
+; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], ptr @minus, ptr @plus)
 
 ; CHECK-LABEL: @compute.3
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP0:%.*]] = call i64 @plus(i64 [[X:%.*]], i64 [[Y:%.*]])
 ; CHECK-NEXT:    [[CMP1:%.*]] = call i64 @minus(i64 [[X]], i64 [[Y]])
-; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @plus)
+; CHECK-NEXT:    [[CMP2:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], ptr @plus, ptr @plus)
diff --git a/llvm/test/Transforms/FunctionSpecialization/remove-dead-recursive-function.ll b/llvm/test/Transforms/FunctionSpecialization/remove-dead-recursive-function.ll
index a3fcd5819f99c4..50a95a94c6f625 100644
--- a/llvm/test/Transforms/FunctionSpecialization/remove-dead-recursive-function.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/remove-dead-recursive-function.ll
@@ -5,11 +5,11 @@ entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 (i64)* @plus)
+  %tmp0 = call i64 @compute(i64 %x, ptr @plus)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 (i64)* @minus)
+  %tmp1 = call i64 @compute(i64 %x, ptr @minus)
   br label %merge
 
 merge:
@@ -19,17 +19,17 @@ merge:
 
 ; CHECK-NOT: define internal i64 @compute(
 ;
-; CHECK-LABEL: define internal i64 @compute.1(i64 %n, i64 (i64)* %binop) {
+; CHECK-LABEL: define internal i64 @compute.1(i64 %n, ptr %binop) {
 ; CHECK:  [[TMP0:%.+]] = call i64 @plus(i64 %n)
-; CHECK:  [[TMP1:%.+]] = call i64 @compute.1(i64 [[TMP2:%.+]], i64 (i64)* @plus)
+; CHECK:  [[TMP1:%.+]] = call i64 @compute.1(i64 [[TMP2:%.+]], ptr @plus)
 ; CHECK:  add nsw i64 [[TMP1]], [[TMP0]]
 ;
-; CHECK-LABEL: define internal i64 @compute.2(i64 %n, i64 (i64)* %binop) {
+; CHECK-LABEL: define internal i64 @compute.2(i64 %n, ptr %binop) {
 ; CHECK:  [[TMP0:%.+]] = call i64 @minus(i64 %n)
-; CHECK:  [[TMP1:%.+]] = call i64 @compute.2(i64 [[TMP2:%.+]], i64 (i64)* @minus)
+; CHECK:  [[TMP1:%.+]] = call i64 @compute.2(i64 [[TMP2:%.+]], ptr @minus)
 ; CHECK:  add nsw i64 [[TMP1]], [[TMP0]]
 ;
-define internal i64 @compute(i64 %n, i64 (i64)* %binop) {
+define internal i64 @compute(i64 %n, ptr %binop) {
 entry:
   %cmp = icmp sgt i64 %n, 0
   br i1 %cmp, label %if.then, label %if.end
@@ -37,7 +37,7 @@ entry:
 if.then:
   %call = call i64 %binop(i64 %n)
   %sub = add nsw i64 %n, -1
-  %call1 = call i64 @compute(i64 %sub, i64 (i64)* %binop)
+  %call1 = call i64 @compute(i64 %sub, ptr %binop)
   %add2 = add nsw i64 %call1, %call
   br label %if.end
 
diff --git a/llvm/test/Transforms/FunctionSpecialization/specialize-multiple-arguments.ll b/llvm/test/Transforms/FunctionSpecialization/specialize-multiple-arguments.ll
index b4f28fd2b24465..518e78ce2f0234 100644
--- a/llvm/test/Transforms/FunctionSpecialization/specialize-multiple-arguments.ll
+++ b/llvm/test/Transforms/FunctionSpecialization/specialize-multiple-arguments.ll
@@ -21,78 +21,78 @@ define i64 @main(i64 %x, i64 %y, i1 %flag) {
 ; NONE-NEXT:  entry:
 ; NONE-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; NONE:       plus:
-; NONE-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], i64 (i64, i64)* @power, i64 (i64, i64)* @mul)
+; NONE-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @power, ptr @mul)
 ; NONE-NEXT:    br label [[MERGE:%.*]]
 ; NONE:       minus:
-; NONE-NEXT:    [[TMP1:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; NONE-NEXT:    [[TMP1:%.*]] = call i64 @compute(i64 [[X]], i64 [[Y]], ptr @plus, ptr @minus)
 ; NONE-NEXT:    br label [[MERGE]]
 ; NONE:       merge:
 ; NONE-NEXT:    [[TMP2:%.*]] = phi i64 [ [[TMP0]], [[PLUS]] ], [ [[TMP1]], [[MINUS]] ]
-; NONE-NEXT:    [[TMP3:%.*]] = call i64 @compute(i64 [[TMP2]], i64 42, i64 (i64, i64)* @minus, i64 (i64, i64)* @power)
+; NONE-NEXT:    [[TMP3:%.*]] = call i64 @compute(i64 [[TMP2]], i64 42, ptr @minus, ptr @power)
 ; NONE-NEXT:    ret i64 [[TMP3]]
 ;
 ; ONE-LABEL: @main(
 ; ONE-NEXT:  entry:
 ; ONE-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; ONE:       plus:
-; ONE-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], i64 (i64, i64)* @power, i64 (i64, i64)* @mul)
+; ONE-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @power, ptr @mul)
 ; ONE-NEXT:    br label [[MERGE:%.*]]
 ; ONE:       minus:
-; ONE-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; ONE-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], ptr @plus, ptr @minus)
 ; ONE-NEXT:    br label [[MERGE]]
 ; ONE:       merge:
 ; ONE-NEXT:    [[TMP2:%.*]] = phi i64 [ [[TMP0]], [[PLUS]] ], [ [[TMP1]], [[MINUS]] ]
-; ONE-NEXT:    [[TMP3:%.*]] = call i64 @compute(i64 [[TMP2]], i64 42, i64 (i64, i64)* @minus, i64 (i64, i64)* @power)
+; ONE-NEXT:    [[TMP3:%.*]] = call i64 @compute(i64 [[TMP2]], i64 42, ptr @minus, ptr @power)
 ; ONE-NEXT:    ret i64 [[TMP3]]
 ;
 ; TWO-LABEL: @main(
 ; TWO-NEXT:  entry:
 ; TWO-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; TWO:       plus:
-; TWO-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], i64 (i64, i64)* @power, i64 (i64, i64)* @mul)
+; TWO-NEXT:    [[TMP0:%.*]] = call i64 @compute(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @power, ptr @mul)
 ; TWO-NEXT:    br label [[MERGE:%.*]]
 ; TWO:       minus:
-; TWO-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; TWO-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], ptr @plus, ptr @minus)
 ; TWO-NEXT:    br label [[MERGE]]
 ; TWO:       merge:
 ; TWO-NEXT:    [[TMP2:%.*]] = phi i64 [ [[TMP0]], [[PLUS]] ], [ [[TMP1]], [[MINUS]] ]
-; TWO-NEXT:    [[TMP3:%.*]] = call i64 @compute.2(i64 [[TMP2]], i64 42, i64 (i64, i64)* @minus, i64 (i64, i64)* @power)
+; TWO-NEXT:    [[TMP3:%.*]] = call i64 @compute.2(i64 [[TMP2]], i64 42, ptr @minus, ptr @power)
 ; TWO-NEXT:    ret i64 [[TMP3]]
 ;
 ; THREE-LABEL: @main(
 ; THREE-NEXT:  entry:
 ; THREE-NEXT:    br i1 [[FLAG:%.*]], label [[PLUS:%.*]], label [[MINUS:%.*]]
 ; THREE:       plus:
-; THREE-NEXT:    [[TMP0:%.*]] = call i64 @compute.3(i64 [[X:%.*]], i64 [[Y:%.*]], i64 (i64, i64)* @power, i64 (i64, i64)* @mul)
+; THREE-NEXT:    [[TMP0:%.*]] = call i64 @compute.3(i64 [[X:%.*]], i64 [[Y:%.*]], ptr @power, ptr @mul)
 ; THREE-NEXT:    br label [[MERGE:%.*]]
 ; THREE:       minus:
-; THREE-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+; THREE-NEXT:    [[TMP1:%.*]] = call i64 @compute.1(i64 [[X]], i64 [[Y]], ptr @plus, ptr @minus)
 ; THREE-NEXT:    br label [[MERGE]]
 ; THREE:       merge:
 ; THREE-NEXT:    [[TMP2:%.*]] = phi i64 [ [[TMP0]], [[PLUS]] ], [ [[TMP1]], [[MINUS]] ]
-; THREE-NEXT:    [[TMP3:%.*]] = call i64 @compute.2(i64 [[TMP2]], i64 42, i64 (i64, i64)* @minus, i64 (i64, i64)* @power)
+; THREE-NEXT:    [[TMP3:%.*]] = call i64 @compute.2(i64 [[TMP2]], i64 42, ptr @minus, ptr @power)
 ; THREE-NEXT:    ret i64 [[TMP3]]
 ;
 entry:
   br i1 %flag, label %plus, label %minus
 
 plus:
-  %tmp0 = call i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* @power, i64 (i64, i64)* @mul)
+  %tmp0 = call i64 @compute(i64 %x, i64 %y, ptr @power, ptr @mul)
   br label %merge
 
 minus:
-  %tmp1 = call i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* @plus, i64 (i64, i64)* @minus)
+  %tmp1 = call i64 @compute(i64 %x, i64 %y, ptr @plus, ptr @minus)
   br label %merge
 
 merge:
   %tmp2 = phi i64 [ %tmp0, %plus ], [ %tmp1, %minus]
-  %tmp3 = call i64 @compute(i64 %tmp2, i64 42, i64 (i64, i64)* @minus, i64 (i64, i64)* @power)
+  %tmp3 = call i64 @compute(i64 %tmp2, i64 42, ptr @minus, ptr @power)
   ret i64 %tmp3
 }
 
 ; THREE-NOT: define internal i64 @compute
 ;
-; THREE-LABEL: define internal i64 @compute.1(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* %binop2) {
+; THREE-LABEL: define internal i64 @compute.1(i64 %x, i64 %y, ptr %binop1, ptr %binop2) {
 ; THREE-NEXT:  entry:
 ; THREE-NEXT:    [[TMP0:%.+]] = call i64 @plus(i64 %x, i64 %y)
 ; THREE-NEXT:    [[TMP1:%.+]] = call i64 @minus(i64 %x, i64 %y)
@@ -103,7 +103,7 @@ merge:
 ; THREE-NEXT:    ret i64 [[TMP5]]
 ; THREE-NEXT:  }
 ;
-; THREE-LABEL: define internal i64 @compute.2(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* %binop2) {
+; THREE-LABEL: define internal i64 @compute.2(i64 %x, i64 %y, ptr %binop1, ptr %binop2) {
 ; THREE-NEXT:  entry:
 ; THREE-NEXT:    [[TMP0:%.+]] = call i64 @minus(i64 %x, i64 %y)
 ; THREE-NEXT:    [[TMP1:%.+]] = call i64 @power(i64 %x, i64 %y)
@@ -114,7 +114,7 @@ merge:
 ; THREE-NEXT:    ret i64 [[TMP5]]
 ; THREE-NEXT:  }
 ;
-; THREE-LABEL: define internal i64 @compute.3(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* %binop2) {
+; THREE-LABEL: define internal i64 @compute.3(i64 %x, i64 %y, ptr %binop1, ptr %binop2) {
 ; THREE-NEXT:  entry:
 ; THREE-NEXT:    [[TMP0:%.+]] = call i64 @power(i64 %x, i64 %y)
 ; THREE-NEXT:    [[TMP1:%.+]] = call i64 @mul(i64 %x, i64 %y)
@@ -125,7 +125,7 @@ merge:
 ; THREE-NEXT:    ret i64 [[TMP5]]
 ; THREE-NEXT:  }
 ;
-define internal i64 @compute(i64 %x, i64 %y, i64 (i64, i64)* %binop1, i64 (i64, i64)* %binop2) {
+define internal i64 @compute(i64 %x, i64 %y, ptr %binop1, ptr %binop2) {
 entry:
   %tmp0 = call i64 %binop1(i64 %x, i64 %y)
   %tmp1 = call i64 %binop2(i64 %x, i64 %y)