[llvm] f4b925e - IROutliner: Convert tests to opaque pointers
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Fri Dec 30 05:44:54 PST 2022
Author: Matt Arsenault
Date: 2022-12-30T08:44:49-05:00
New Revision: f4b925ee7078f058602fd323e25f45f1ae91ca34
URL: https://github.com/llvm/llvm-project/commit/f4b925ee7078f058602fd323e25f45f1ae91ca34
DIFF: https://github.com/llvm/llvm-project/commit/f4b925ee7078f058602fd323e25f45f1ae91ca34.diff
LOG: IROutliner: Convert tests to opaque pointers
Some of these show improvements. outlining-bitcasts.ll might not be
relevant anymore (or should be rewritten to test some other type of
non-pointer bitcast).
Added:
Modified:
llvm/test/Transforms/IROutliner/different-intrinsics.ll
llvm/test/Transforms/IROutliner/extraction.ll
llvm/test/Transforms/IROutliner/gvn-output-set-overload.ll
llvm/test/Transforms/IROutliner/illegal-assumes.ll
llvm/test/Transforms/IROutliner/illegal-branches.ll
llvm/test/Transforms/IROutliner/illegal-catchpad.ll
llvm/test/Transforms/IROutliner/illegal-cleanup.ll
llvm/test/Transforms/IROutliner/illegal-frozen.ll
llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
llvm/test/Transforms/IROutliner/illegal-invoke.ll
llvm/test/Transforms/IROutliner/illegal-landingpad.ll
llvm/test/Transforms/IROutliner/illegal-memcpy.ll
llvm/test/Transforms/IROutliner/illegal-memmove.ll
llvm/test/Transforms/IROutliner/illegal-memset.ll
llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll
llvm/test/Transforms/IROutliner/illegal-returns-twice.ll
llvm/test/Transforms/IROutliner/illegal-vaarg.ll
llvm/test/Transforms/IROutliner/included-phi-nodes-begin.ll
llvm/test/Transforms/IROutliner/included-phi-nodes-end.ll
llvm/test/Transforms/IROutliner/legal-debug.ll
llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
llvm/test/Transforms/IROutliner/mismatched-phi-exits-not-in-first-outlined.ll
llvm/test/Transforms/IROutliner/mismatched-phi-exits.ll
llvm/test/Transforms/IROutliner/mismatched-phi-outputs-ordering.ll
llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-begin.ll
llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-end.ll
llvm/test/Transforms/IROutliner/no-outlining-optnone.ll
llvm/test/Transforms/IROutliner/opt-remarks.ll
llvm/test/Transforms/IROutliner/outline-memcpy.ll
llvm/test/Transforms/IROutliner/outline-memmove.ll
llvm/test/Transforms/IROutliner/outline-memset.ll
llvm/test/Transforms/IROutliner/outline-vaarg-intrinsic.ll
llvm/test/Transforms/IROutliner/outlining-across-branch.ll
llvm/test/Transforms/IROutliner/outlining-address-taken.ll
llvm/test/Transforms/IROutliner/outlining-bitcasts.ll
llvm/test/Transforms/IROutliner/outlining-branches-phi-nodes.ll
llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
llvm/test/Transforms/IROutliner/outlining-calls.ll
llvm/test/Transforms/IROutliner/outlining-commutative-fp.ll
llvm/test/Transforms/IROutliner/outlining-commutative.ll
llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll
llvm/test/Transforms/IROutliner/outlining-compatible-or-attribute-transfer.ll
llvm/test/Transforms/IROutliner/outlining-constants-vs-registers.ll
llvm/test/Transforms/IROutliner/outlining-cost-model.ll
llvm/test/Transforms/IROutliner/outlining-debug-statements.ll
llvm/test/Transforms/IROutliner/outlining-different-constants.ll
llvm/test/Transforms/IROutliner/outlining-different-globals.ll
llvm/test/Transforms/IROutliner/outlining-different-output-blocks.ll
llvm/test/Transforms/IROutliner/outlining-different-structure.ll
llvm/test/Transforms/IROutliner/outlining-exits-to-phi-node.ll
llvm/test/Transforms/IROutliner/outlining-gep.ll
llvm/test/Transforms/IROutliner/outlining-isomorphic-predicates.ll
llvm/test/Transforms/IROutliner/outlining-multiple-exits-diff-outputs.ll
llvm/test/Transforms/IROutliner/outlining-multiple-exits-one-output-set.ll
llvm/test/Transforms/IROutliner/outlining-multiple-exits.ll
llvm/test/Transforms/IROutliner/outlining-musttail.ll
llvm/test/Transforms/IROutliner/outlining-odr.ll
llvm/test/Transforms/IROutliner/outlining-remapped-outputs.ll
llvm/test/Transforms/IROutliner/outlining-same-constants.ll
llvm/test/Transforms/IROutliner/outlining-same-globals.ll
llvm/test/Transforms/IROutliner/outlining-same-output-blocks.ll
llvm/test/Transforms/IROutliner/outlining-swift-error.ll
llvm/test/Transforms/IROutliner/outlining-swifttailcc.ll
llvm/test/Transforms/IROutliner/outlining-tailcc.ll
llvm/test/Transforms/IROutliner/phi-nodes-non-constant.ll
llvm/test/Transforms/IROutliner/phi-nodes-output-overload.ll
llvm/test/Transforms/IROutliner/phi-nodes-parent-block-referential.ll
llvm/test/Transforms/IROutliner/phi-nodes-simple.ll
llvm/test/Transforms/IROutliner/region-end-of-module.ll
llvm/test/Transforms/IROutliner/region-inputs-in-phi-nodes.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/IROutliner/
diff erent-intrinsics.ll b/llvm/test/Transforms/IROutliner/
diff erent-intrinsics.ll
index 0d2b550b4ec03..5fb22c3101d82 100644
--- a/llvm/test/Transforms/IROutliner/
diff erent-intrinsics.ll
+++ b/llvm/test/Transforms/IROutliner/
diff erent-intrinsics.ll
@@ -4,26 +4,26 @@
; This test checks that we do not outline
diff erent intrinsics as the same
; function or as a value like we would for non-intrinsic functions.
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
-declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
+declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
-define i8 @function1(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function1(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
-define i8 @function2(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function2(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
; CHECK-LABEL: @function1(
@@ -31,18 +31,18 @@ entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
@@ -51,18 +51,18 @@ entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memmove.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
@@ -71,10 +71,10 @@ entry:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
; CHECK-NEXT: [[C:%.*]] = add i8 [[TMP0:%.*]], [[TMP1:%.*]]
-; CHECK-NEXT: [[RET:%.*]] = load i8, i8* [[TMP2:%.*]], align 1
+; CHECK-NEXT: [[RET:%.*]] = load i8, ptr [[TMP2:%.*]], align 1
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
-; CHECK-NEXT: store i8 [[RET]], i8* [[TMP3:%.*]], align 1
+; CHECK-NEXT: store i8 [[RET]], ptr [[TMP3:%.*]], align 1
; CHECK-NEXT: ret void
;
;
@@ -82,11 +82,11 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[A:%.*]] = load i8, i8* [[TMP0:%.*]], align 1
-; CHECK-NEXT: [[B:%.*]] = load i8, i8* [[TMP1:%.*]], align 1
+; CHECK-NEXT: [[A:%.*]] = load i8, ptr [[TMP0:%.*]], align 1
+; CHECK-NEXT: [[B:%.*]] = load i8, ptr [[TMP1:%.*]], align 1
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
-; CHECK-NEXT: store i8 [[A]], i8* [[TMP2:%.*]], align 1
-; CHECK-NEXT: store i8 [[B]], i8* [[TMP3:%.*]], align 1
+; CHECK-NEXT: store i8 [[A]], ptr [[TMP2:%.*]], align 1
+; CHECK-NEXT: store i8 [[B]], ptr [[TMP3:%.*]], align 1
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/extraction.ll b/llvm/test/Transforms/IROutliner/extraction.ll
index 9e48ca6098fee..1eca4ea2f135e 100644
--- a/llvm/test/Transforms/IROutliner/extraction.ll
+++ b/llvm/test/Transforms/IROutliner/extraction.ll
@@ -10,19 +10,19 @@ define void @extract1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -32,19 +32,19 @@ define void @extract2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -59,17 +59,15 @@ define void @extract_outs1() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; CHECK-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -77,16 +75,16 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -101,16 +99,14 @@ define void @extract_outs2() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -118,14 +114,14 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/gvn-output-set-overload.ll b/llvm/test/Transforms/IROutliner/gvn-output-set-overload.ll
index 03b514c402054..1184b4a3d64fd 100644
--- a/llvm/test/Transforms/IROutliner/gvn-output-set-overload.ll
+++ b/llvm/test/Transforms/IROutliner/gvn-output-set-overload.ll
@@ -4,16 +4,16 @@
; Show that we do
diff erentiate between outputs of the region stored in PHINodes
; versus those stored outside of PHINodes.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
@@ -22,16 +22,16 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
ret void
@@ -44,11 +44,10 @@ next:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]], i32* null, i32 0)
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]], ptr null, i32 0)
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[DOTCE_RELOAD]], [[ENTRY:%.*]] ]
@@ -62,15 +61,13 @@ next:
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[C_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[C_LOC]], i32* [[E_LOC]], i32 1)
-; CHECK-NEXT: [[C_RELOAD:%.*]] = load i32, i32* [[C_LOC]], align 4
-; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[C_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[C_LOC]], ptr [[E_LOC]], i32 1)
+; CHECK-NEXT: [[C_RELOAD:%.*]] = load i32, ptr [[C_LOC]], align 4
+; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[C_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -84,13 +81,13 @@ next:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT:%.*]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT]], label [[NEXT_EXITSTUB:%.*]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[C]], [[TEST]] ], [ [[E]], [[TEST1]] ]
@@ -105,15 +102,15 @@ next:
; CHECK-NEXT: i32 0, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_0_1:
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[C]], i32* [[TMP1]], align 4
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[C]], ptr [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_1_1:
-; CHECK-NEXT: store i32 [[C]], i32* [[TMP1]], align 4
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[C]], ptr [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: final_block_0:
; CHECK-NEXT: ret i1 false
diff --git a/llvm/test/Transforms/IROutliner/illegal-assumes.ll b/llvm/test/Transforms/IROutliner/illegal-assumes.ll
index dcec3210111f7..b91f8ec92200e 100644
--- a/llvm/test/Transforms/IROutliner/illegal-assumes.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-assumes.ll
@@ -12,15 +12,14 @@ define void @outline_assumes() {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[D:%.*]] = alloca i1, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i1* [[DL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_3(i1 true, i1* [[D]], i1* [[DL_LOC]])
-; CHECK-NEXT: [[DL_RELOAD:%.*]] = load i1, i1* [[DL_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DL_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_3(i1 true, ptr [[D]], ptr [[DL_LOC]])
+; CHECK-NEXT: [[DL_RELOAD:%.*]] = load i1, ptr [[DL_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DL_LOC]])
; CHECK-NEXT: [[SPLIT_INST:%.*]] = sub i1 [[DL_RELOAD]], [[DL_RELOAD]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void @llvm.assume(i1 [[DL_RELOAD]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
@@ -28,16 +27,16 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i1, align 4
- store i1 1, i1* %d, align 4
- %dl = load i1, i1* %d
+ store i1 1, ptr %d, align 4
+ %dl = load i1, ptr %d
%split_inst = sub i1 %dl, %dl
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void @llvm.assume(i1 %dl)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -49,14 +48,13 @@ define void @outline_assumes2() {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[D:%.*]] = alloca i1, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i1* [[DL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_3(i1 false, i1* [[D]], i1* [[DL_LOC]])
-; CHECK-NEXT: [[DL_RELOAD:%.*]] = load i1, i1* [[DL_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DL_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_3(i1 false, ptr [[D]], ptr [[DL_LOC]])
+; CHECK-NEXT: [[DL_RELOAD:%.*]] = load i1, ptr [[DL_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DL_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void @llvm.assume(i1 [[DL_RELOAD]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
@@ -64,15 +62,15 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i1, align 4
- store i1 0, i1* %d, align 4
- %dl = load i1, i1* %d
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i1 0, ptr %d, align 4
+ %dl = load i1, ptr %d
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void @llvm.assume(i1 %dl)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -83,12 +81,12 @@ define void @outline_assumes3() {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[D:%.*]] = alloca i1, align 4
-; CHECK-NEXT: store i1 true, i1* [[D]], align 4
-; CHECK-NEXT: [[DL:%.*]] = load i1, i1* [[D]], align 1
+; CHECK-NEXT: store i1 true, ptr [[D]], align 4
+; CHECK-NEXT: [[DL:%.*]] = load i1, ptr [[D]], align 1
; CHECK-NEXT: [[SPLIT_INST:%.*]] = add i1 [[DL]], [[DL]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT: call void @outlined_ir_func_2(i32* [[A]])
+; CHECK-NEXT: call void @outlined_ir_func_2(ptr [[A]])
; CHECK-NEXT: ret void
;
entry:
@@ -96,14 +94,14 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i1, align 4
- store i1 1, i1* %d, align 4
- %dl = load i1, i1* %d
+ store i1 1, ptr %d, align 4
+ %dl = load i1, ptr %d
%split_inst = add i1 %dl, %dl
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void @llvm.assume(i1 %dl)
- %al = load i32, i32* %a
+ %al = load i32, ptr %a
%bl = add i32 %al, %al
ret void
}
@@ -115,12 +113,12 @@ define void @outline_assumes4() {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[D:%.*]] = alloca i1, align 4
-; CHECK-NEXT: store i1 false, i1* [[D]], align 4
-; CHECK-NEXT: [[DL:%.*]] = load i1, i1* [[D]], align 1
+; CHECK-NEXT: store i1 false, ptr [[D]], align 4
+; CHECK-NEXT: [[DL:%.*]] = load i1, ptr [[D]], align 1
; CHECK-NEXT: [[SPLIT_INST:%.*]] = add i1 [[DL]], [[DL]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT: call void @outlined_ir_func_2(i32* [[A]])
+; CHECK-NEXT: call void @outlined_ir_func_2(ptr [[A]])
; CHECK-NEXT: ret void
;
entry:
@@ -128,14 +126,14 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i1, align 4
- store i1 0, i1* %d, align 4
- %dl = load i1, i1* %d
+ store i1 0, ptr %d, align 4
+ %dl = load i1, ptr %d
%split_inst = add i1 %dl, %dl
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void @llvm.assume(i1 %dl)
- %al = load i32, i32* %a
+ %al = load i32, ptr %a
%bl = add i32 %al, %al
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-branches.ll b/llvm/test/Transforms/IROutliner/illegal-branches.ll
index 38939b32c8505..b70d22ab82d90 100644
--- a/llvm/test/Transforms/IROutliner/illegal-branches.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-branches.ll
@@ -10,7 +10,7 @@ define void @function1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: br label [[NEXT:%.*]]
; CHECK: next:
; CHECK-NEXT: ret void
@@ -19,9 +19,9 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
br label %next
next:
ret void
@@ -33,7 +33,7 @@ define void @function2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: br label [[NEXT:%.*]]
; CHECK: next:
; CHECK-NEXT: ret void
@@ -42,9 +42,9 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
br label %next
next:
ret void
diff --git a/llvm/test/Transforms/IROutliner/illegal-catchpad.ll b/llvm/test/Transforms/IROutliner/illegal-catchpad.ll
index c3ff3c344a478..a25007fd8034d 100644
--- a/llvm/test/Transforms/IROutliner/illegal-catchpad.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-catchpad.ll
@@ -18,7 +18,7 @@ define void @function1() personality i8 3 {
; CHECK-NEXT: [[CS1:%.*]] = catchswitch within none [label %catchpad1] unwind to caller
; CHECK: catchpad1:
; CHECK-NEXT: [[TMP0:%.*]] = catchpad within [[CS1]] []
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -31,8 +31,8 @@ exception:
%cs1 = catchswitch within none [label %catchpad1] unwind to caller
catchpad1:
catchpad within %cs1 []
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
@@ -49,7 +49,7 @@ define void @function2() personality i8 3 {
; CHECK-NEXT: [[CS1:%.*]] = catchswitch within none [label %catchpad1] unwind to caller
; CHECK: catchpad1:
; CHECK-NEXT: [[TMP0:%.*]] = catchpad within [[CS1]] []
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -62,8 +62,8 @@ exception:
%cs1 = catchswitch within none [label %catchpad1] unwind to caller
catchpad1:
catchpad within %cs1 []
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
diff --git a/llvm/test/Transforms/IROutliner/illegal-cleanup.ll b/llvm/test/Transforms/IROutliner/illegal-cleanup.ll
index 9d6509979b459..b9eeba911f578 100644
--- a/llvm/test/Transforms/IROutliner/illegal-cleanup.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-cleanup.ll
@@ -16,7 +16,7 @@ define void @function1() personality i8 3 {
; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
; CHECK: exception:
; CHECK-NEXT: [[CLEAN:%.*]] = cleanuppad within none []
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -27,8 +27,8 @@ entry:
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%clean = cleanuppad within none []
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
@@ -43,7 +43,7 @@ define void @function2() personality i8 3 {
; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
; CHECK: exception:
; CHECK-NEXT: [[CLEAN:%.*]] = cleanuppad within none []
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -54,8 +54,8 @@ entry:
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%clean = cleanuppad within none []
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
diff --git a/llvm/test/Transforms/IROutliner/illegal-frozen.ll b/llvm/test/Transforms/IROutliner/illegal-frozen.ll
index 6b86922b68bb0..293f433317bd3 100644
--- a/llvm/test/Transforms/IROutliner/illegal-frozen.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-frozen.ll
@@ -4,13 +4,13 @@
; Show that we do not extract freeze instructions, since extra handling is
; required to mark any outputs used with freeze.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
-; CHECK-NEXT: [[C:%.*]] = freeze i32* [[A:%.*]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[C]], i32* [[B:%.*]])
+; CHECK-NEXT: [[C:%.*]] = freeze ptr [[A:%.*]]
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[C]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
; CHECK: next:
; CHECK-NEXT: br label [[FIRST]]
@@ -18,21 +18,21 @@ define void @function1(i32* %a, i32* %b) {
entry:
br label %first
first:
- %c = freeze i32* %a
- store i32 2, i32* %c, align 4
- store i32 3, i32* %b, align 4
+ %c = freeze ptr %a
+ store i32 2, ptr %c, align 4
+ store i32 3, ptr %b, align 4
ret void
next:
br label %first
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
-; CHECK-NEXT: [[C:%.*]] = freeze i32* [[A:%.*]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[C]], i32* [[B:%.*]])
+; CHECK-NEXT: [[C:%.*]] = freeze ptr [[A:%.*]]
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[C]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
; CHECK: next:
; CHECK-NEXT: br label [[FIRST]]
@@ -40,9 +40,9 @@ define void @function2(i32* %a, i32* %b) {
entry:
br label %first
first:
- %c = freeze i32* %a
- store i32 2, i32* %c, align 4
- store i32 3, i32* %b, align 4
+ %c = freeze ptr %a
+ store i32 2, ptr %c, align 4
+ store i32 3, ptr %b, align 4
ret void
next:
br label %first
diff --git a/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll b/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
index e9052bd1c76ad..76338569707a6 100644
--- a/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-indirect-calls.ll
@@ -4,55 +4,55 @@
; This test checks that we do not outline indirect calls when it is specified
; that we should not.
-declare void @f1(i32*, i32*);
-declare void @f2(i32*, i32*);
+declare void @f1(ptr, ptr);
+declare void @f2(ptr, ptr);
-define void @function1(void()* %func) {
+define void @function1(ptr %func) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void [[FUNC:%.*]]()
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void %func()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-define void @function2(void()* %func) {
+define void @function2(ptr %func) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: call void [[FUNC:%.*]]()
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void %func()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-invoke.ll b/llvm/test/Transforms/IROutliner/illegal-invoke.ll
index 57c43158578b6..82d62b928a3f8 100644
--- a/llvm/test/Transforms/IROutliner/illegal-invoke.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-invoke.ll
@@ -12,7 +12,7 @@ define void @function1() personality i8 3 {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: invoke void @llvm.donothing()
; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
; CHECK: exception:
@@ -25,8 +25,8 @@ define void @function1() personality i8 3 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%cleanup = landingpad i8 cleanup
@@ -40,7 +40,7 @@ define void @function2() personality i8 3 {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: invoke void @llvm.donothing()
; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
; CHECK: exception:
@@ -53,8 +53,8 @@ define void @function2() personality i8 3 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%cleanup = landingpad i8 cleanup
diff --git a/llvm/test/Transforms/IROutliner/illegal-landingpad.ll b/llvm/test/Transforms/IROutliner/illegal-landingpad.ll
index 27e8987d2d5bb..5d70d55ab6e4e 100644
--- a/llvm/test/Transforms/IROutliner/illegal-landingpad.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-landingpad.ll
@@ -17,7 +17,7 @@ define void @function1() personality i8 3 {
; CHECK: exception:
; CHECK-NEXT: [[CLEANUP:%.*]] = landingpad i8
; CHECK-NEXT: cleanup
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -28,8 +28,8 @@ entry:
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%cleanup = landingpad i8 cleanup
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
@@ -45,7 +45,7 @@ define void @function2() personality i8 3 {
; CHECK: exception:
; CHECK-NEXT: [[CLEANUP:%.*]] = landingpad i8
; CHECK-NEXT: cleanup
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: br label [[NORMAL]]
; CHECK: normal:
; CHECK-NEXT: ret void
@@ -56,8 +56,8 @@ entry:
invoke void @llvm.donothing() to label %normal unwind label %exception
exception:
%cleanup = landingpad i8 cleanup
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %normal
normal:
ret void
diff --git a/llvm/test/Transforms/IROutliner/illegal-memcpy.ll b/llvm/test/Transforms/IROutliner/illegal-memcpy.ll
index 1b299d92f85cb..20e009aa32721 100644
--- a/llvm/test/Transforms/IROutliner/illegal-memcpy.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-memcpy.ll
@@ -4,62 +4,62 @@
; This test checks that we do not outline memcpy intrinsics since it may require
; extra address space checks.
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
-define i8 @function1(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function1(ptr noalias %s, ptr noalias %d, i64 %len) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
-define i8 @function2(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function2(ptr noalias %s, ptr noalias %d, i64 %len) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-memmove.ll b/llvm/test/Transforms/IROutliner/illegal-memmove.ll
index ebf0ae8457ab6..06480c8adb653 100644
--- a/llvm/test/Transforms/IROutliner/illegal-memmove.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-memmove.ll
@@ -4,62 +4,62 @@
; This test checks that we do not outline memcpy intrinsics since it may require
; extra address space checks.
-declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
-define i8 @function1(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function1(ptr noalias %s, ptr noalias %d, i64 %len) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memmove.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
-define i8 @function2(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function2(ptr noalias %s, ptr noalias %d, i64 %len) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[B_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[A_LOC:%.*]] = alloca i8, align 1
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i8* [[S:%.*]], i8* [[D:%.*]], i8* [[A_LOC]], i8* [[B_LOC]])
-; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, i8* [[A_LOC]], align 1
-; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, i8* [[B_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[A_LOC]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[B_LOC]])
-; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[D]], i8* [[S]], i64 [[LEN:%.*]], i1 false)
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], i8* [[S]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[S:%.*]], ptr [[D:%.*]], ptr [[A_LOC]], ptr [[B_LOC]])
+; CHECK-NEXT: [[A_RELOAD:%.*]] = load i8, ptr [[A_LOC]], align 1
+; CHECK-NEXT: [[B_RELOAD:%.*]] = load i8, ptr [[B_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B_LOC]])
+; CHECK-NEXT: call void @llvm.memmove.p0.p0.i64(ptr [[D]], ptr [[S]], i64 [[LEN:%.*]], i1 false)
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i8 [[A_RELOAD]], i8 [[B_RELOAD]], ptr [[S]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-memset.ll b/llvm/test/Transforms/IROutliner/illegal-memset.ll
index 91c73e905d9c9..34658ec85fa5e 100644
--- a/llvm/test/Transforms/IROutliner/illegal-memset.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-memset.ll
@@ -4,21 +4,19 @@
; This test checks that we do not outline memset intrinsics since it requires
; extra address space checks.
-declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1)
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1)
define i64 @function1(i64 %x, i64 %z, i64 %n) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[POOL:%.*]] = alloca [59 x i64], align 4
-; CHECK-NEXT: [[TMP:%.*]] = bitcast [59 x i64]* [[POOL]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 4 [[TMP]], i8 0, i64 236, i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr nonnull align 4 [[POOL]], i8 0, i64 236, i1 false)
; CHECK-NEXT: call void @outlined_ir_func_0(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
; CHECK-NEXT: ret i64 0
;
entry:
%pool = alloca [59 x i64], align 4
- %tmp = bitcast [59 x i64]* %pool to i8*
- call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
+ call void @llvm.memset.p0.i64(ptr nonnull %pool, i8 0, i64 236, i32 4, i1 false)
%cmp3 = icmp eq i64 %n, 0
%a = add i64 %x, %z
%c = add i64 %x, %z
@@ -29,15 +27,13 @@ define i64 @function2(i64 %x, i64 %z, i64 %n) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[POOL:%.*]] = alloca [59 x i64], align 4
-; CHECK-NEXT: [[TMP:%.*]] = bitcast [59 x i64]* [[POOL]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 4 [[TMP]], i8 0, i64 236, i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr nonnull align 4 [[POOL]], i8 0, i64 236, i1 false)
; CHECK-NEXT: call void @outlined_ir_func_0(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
; CHECK-NEXT: ret i64 0
;
entry:
%pool = alloca [59 x i64], align 4
- %tmp = bitcast [59 x i64]* %pool to i8*
- call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
+ call void @llvm.memset.p0.i64(ptr nonnull %pool, i8 0, i64 236, i32 4, i1 false)
%cmp3 = icmp eq i64 %n, 0
%a = add i64 %x, %z
%c = add i64 %x, %z
diff --git a/llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll b/llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll
index 4a68c2cc7105d..46d069d5afcc0 100644
--- a/llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll
@@ -4,13 +4,13 @@
; Show that we do not extract phi nodes as it would require extra label and
; control flow checking.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 3, [[NEXT:%.*]] ]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
; CHECK: next:
; CHECK-NEXT: br label [[FIRST]]
@@ -19,20 +19,20 @@ entry:
br label %first
first:
%0 = phi i32 [ 0, %entry ], [ 3, %next ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
next:
br label %first
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 3, [[NEXT:%.*]] ]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
; CHECK: next:
; CHECK-NEXT: br label [[FIRST]]
@@ -41,8 +41,8 @@ entry:
br label %first
first:
%0 = phi i32 [ 0, %entry ], [ 3, %next ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
next:
br label %first
diff --git a/llvm/test/Transforms/IROutliner/illegal-returns-twice.ll b/llvm/test/Transforms/IROutliner/illegal-returns-twice.ll
index e30f14e443ced..a520cb1b54cef 100644
--- a/llvm/test/Transforms/IROutliner/illegal-returns-twice.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-returns-twice.ll
@@ -6,7 +6,7 @@
; outliner behaves, causing miscompiles.
; Function Attrs: optsize returns_twice
-declare i32 @setjmp(i32*) local_unnamed_addr #1
+declare i32 @setjmp(ptr) local_unnamed_addr #1
@tmp_jmpb = global [37 x i32] zeroinitializer, align 16
define void @function1() {
@@ -15,24 +15,24 @@ define void @function1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[CALL:%.*]] = call i32 @setjmp(i32* getelementptr inbounds ([37 x i32], [37 x i32]* @tmp_jmpb, i64 0, i64 0))
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[CALL:%.*]] = call i32 @setjmp(ptr @tmp_jmpb)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %call = call i32 @setjmp(i32* getelementptr inbounds ([37 x i32], [37 x i32]* @tmp_jmpb, i64 0, i64 0))
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %call = call i32 @setjmp(ptr @tmp_jmpb)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -42,24 +42,24 @@ define void @function2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[CALL:%.*]] = call i32 @setjmp(i32* getelementptr inbounds ([37 x i32], [37 x i32]* @tmp_jmpb, i64 0, i64 0))
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[CALL:%.*]] = call i32 @setjmp(ptr @tmp_jmpb)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %call = call i32 @setjmp(i32* getelementptr inbounds ([37 x i32], [37 x i32]* @tmp_jmpb, i64 0, i64 0))
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %call = call i32 @setjmp(ptr @tmp_jmpb)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/illegal-vaarg.ll b/llvm/test/Transforms/IROutliner/illegal-vaarg.ll
index 2eab1ad3244c4..ef365d6eaddb5 100644
--- a/llvm/test/Transforms/IROutliner/illegal-vaarg.ll
+++ b/llvm/test/Transforms/IROutliner/illegal-vaarg.ll
@@ -4,84 +4,76 @@
; This test ensures that we do not outline vararg instructions or intrinsics, as
; they may cause inconsistencies when outlining.
-declare void @llvm.va_start(i8*)
-declare void @llvm.va_copy(i8*, i8*)
-declare void @llvm.va_end(i8*)
+declare void @llvm.va_start(ptr)
+declare void @llvm.va_copy(ptr, ptr)
+declare void @llvm.va_end(ptr)
-define i32 @func1(i32 %a, double %b, i8* %v, ...) nounwind {
+define i32 @func1(i32 %a, double %b, ptr %v, ...) nounwind {
; CHECK-LABEL: @func1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[AP1_LOC:%.*]] = alloca i8*, align 8
+; CHECK-NEXT: [[TMP_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_ADDR:%.*]] = alloca double, align 8
-; CHECK-NEXT: [[AP:%.*]] = alloca i8*, align 4
+; CHECK-NEXT: [[AP:%.*]] = alloca ptr, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i8** [[AP1_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[A:%.*]], i32* [[A_ADDR]], double [[B:%.*]], double* [[B_ADDR]], i8** [[AP]], i8** [[AP1_LOC]])
-; CHECK-NEXT: [[AP1_RELOAD:%.*]] = load i8*, i8** [[AP1_LOC]], align 8
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.va_start(i8* [[AP1_RELOAD]])
-; CHECK-NEXT: [[TMP0:%.*]] = va_arg i8** [[AP]], i32
-; CHECK-NEXT: call void @llvm.va_copy(i8* [[V:%.*]], i8* [[AP1_RELOAD]])
-; CHECK-NEXT: call void @llvm.va_end(i8* [[AP1_RELOAD]])
-; CHECK-NEXT: store i32 [[TMP0]], i32* [[C]], align 4
-; CHECK-NEXT: [[TMP:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: ret i32 [[TMP]]
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[A:%.*]], ptr [[A_ADDR]], double [[B:%.*]], ptr [[B_ADDR]])
+; CHECK-NEXT: call void @llvm.va_start(ptr [[AP]])
+; CHECK-NEXT: [[TMP0:%.*]] = va_arg ptr [[AP]], i32
+; CHECK-NEXT: call void @llvm.va_copy(ptr [[V:%.*]], ptr [[AP]])
+; CHECK-NEXT: call void @llvm.va_end(ptr [[AP]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[TMP0]], ptr [[C]], ptr [[TMP_LOC]])
+; CHECK-NEXT: [[TMP_RELOAD:%.*]] = load i32, ptr [[TMP_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: ret i32 [[TMP_RELOAD]]
;
entry:
%a.addr = alloca i32, align 4
%b.addr = alloca double, align 8
- %ap = alloca i8*, align 4
+ %ap = alloca ptr, align 4
%c = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- store double %b, double* %b.addr, align 8
- %ap1 = bitcast i8** %ap to i8*
- call void @llvm.va_start(i8* %ap1)
- %0 = va_arg i8** %ap, i32
- call void @llvm.va_copy(i8* %v, i8* %ap1)
- call void @llvm.va_end(i8* %ap1)
- store i32 %0, i32* %c, align 4
- %tmp = load i32, i32* %c, align 4
+ store i32 %a, ptr %a.addr, align 4
+ store double %b, ptr %b.addr, align 8
+ call void @llvm.va_start(ptr %ap)
+ %0 = va_arg ptr %ap, i32
+ call void @llvm.va_copy(ptr %v, ptr %ap)
+ call void @llvm.va_end(ptr %ap)
+ store i32 %0, ptr %c, align 4
+ %tmp = load i32, ptr %c, align 4
ret i32 %tmp
}
-define i32 @func2(i32 %a, double %b, i8* %v, ...) nounwind {
+define i32 @func2(i32 %a, double %b, ptr %v, ...) nounwind {
; CHECK-LABEL: @func2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[AP1_LOC:%.*]] = alloca i8*, align 8
+; CHECK-NEXT: [[TMP_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_ADDR:%.*]] = alloca double, align 8
-; CHECK-NEXT: [[AP:%.*]] = alloca i8*, align 4
+; CHECK-NEXT: [[AP:%.*]] = alloca ptr, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i8** [[AP1_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[A:%.*]], i32* [[A_ADDR]], double [[B:%.*]], double* [[B_ADDR]], i8** [[AP]], i8** [[AP1_LOC]])
-; CHECK-NEXT: [[AP1_RELOAD:%.*]] = load i8*, i8** [[AP1_LOC]], align 8
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.va_start(i8* [[AP1_RELOAD]])
-; CHECK-NEXT: [[TMP0:%.*]] = va_arg i8** [[AP]], i32
-; CHECK-NEXT: call void @llvm.va_copy(i8* [[V:%.*]], i8* [[AP1_RELOAD]])
-; CHECK-NEXT: call void @llvm.va_end(i8* [[AP1_RELOAD]])
-; CHECK-NEXT: store i32 [[TMP0]], i32* [[C]], align 4
-; CHECK-NEXT: [[AP2:%.*]] = bitcast i8** [[AP]] to i8*
-; CHECK-NEXT: [[TMP:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: ret i32 [[TMP]]
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[A:%.*]], ptr [[A_ADDR]], double [[B:%.*]], ptr [[B_ADDR]])
+; CHECK-NEXT: call void @llvm.va_start(ptr [[AP]])
+; CHECK-NEXT: [[TMP0:%.*]] = va_arg ptr [[AP]], i32
+; CHECK-NEXT: call void @llvm.va_copy(ptr [[V:%.*]], ptr [[AP]])
+; CHECK-NEXT: call void @llvm.va_end(ptr [[AP]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[TMP0]], ptr [[C]], ptr [[TMP_LOC]])
+; CHECK-NEXT: [[TMP_RELOAD:%.*]] = load i32, ptr [[TMP_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: ret i32 [[TMP_RELOAD]]
;
entry:
%a.addr = alloca i32, align 4
%b.addr = alloca double, align 8
- %ap = alloca i8*, align 4
+ %ap = alloca ptr, align 4
%c = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- store double %b, double* %b.addr, align 8
- %ap1 = bitcast i8** %ap to i8*
- call void @llvm.va_start(i8* %ap1)
- %0 = va_arg i8** %ap, i32
- call void @llvm.va_copy(i8* %v, i8* %ap1)
- call void @llvm.va_end(i8* %ap1)
- store i32 %0, i32* %c, align 4
- %ap2 = bitcast i8** %ap to i8*
- %tmp = load i32, i32* %c, align 4
+ store i32 %a, ptr %a.addr, align 4
+ store double %b, ptr %b.addr, align 8
+ call void @llvm.va_start(ptr %ap)
+ %0 = va_arg ptr %ap, i32
+ call void @llvm.va_copy(ptr %v, ptr %ap)
+ call void @llvm.va_end(ptr %ap)
+ store i32 %0, ptr %c, align 4
+ %tmp = load i32, ptr %c, align 4
ret i32 %tmp
}
diff --git a/llvm/test/Transforms/IROutliner/included-phi-nodes-begin.ll b/llvm/test/Transforms/IROutliner/included-phi-nodes-begin.ll
index 8dd018f06f386..c788b61d18989 100644
--- a/llvm/test/Transforms/IROutliner/included-phi-nodes-begin.ll
+++ b/llvm/test/Transforms/IROutliner/included-phi-nodes-begin.ll
@@ -5,10 +5,10 @@
; block are included in the region and there is no more than one predecessor
; into those phi nodes from outside of the region.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = add i32 %c, %c
br label %test1
dummy:
@@ -16,20 +16,20 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %e, %test1 ], [ %y, %entry ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
br i1 true, label %test, label %test1
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = mul i32 %c, %c
br label %test1
dummy:
@@ -37,11 +37,11 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %e, %test1 ], [ %y, %entry ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
br i1 true, label %test, label %test1
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
@@ -49,13 +49,13 @@ first:
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
; CHECK: test1:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[Y]], i32* [[TMP0]], i32 [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[Y]], ptr [[TMP0]], i32 [[C]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -64,13 +64,13 @@ first:
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = mul i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
; CHECK: test1:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[Y]], i32* [[TMP0]], i32 [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[Y]], ptr [[TMP0]], i32 [[C]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -82,11 +82,11 @@ first:
; CHECK: test1_to_outline:
; CHECK-NEXT: [[TMP3:%.*]] = phi i32 [ [[E:%.*]], [[TEST1_TO_OUTLINE]] ], [ [[TMP0:%.*]], [[NEWFUNCROOT:%.*]] ]
; CHECK-NEXT: [[TMP4:%.*]] = phi i32 [ [[E]], [[TEST1_TO_OUTLINE]] ], [ [[TMP0]], [[NEWFUNCROOT]] ]
-; CHECK-NEXT: [[E]] = load i32, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: [[E]] = load i32, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: [[TMP5:%.*]] = add i32 [[TMP2:%.*]], [[TMP2]]
; CHECK-NEXT: br i1 true, label [[TEST:%.*]], label [[TEST1_TO_OUTLINE]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: br label [[FIRST_EXITSTUB:%.*]]
; CHECK: first.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/included-phi-nodes-end.ll b/llvm/test/Transforms/IROutliner/included-phi-nodes-end.ll
index 79db03486ade2..0d59a0bec11d8 100644
--- a/llvm/test/Transforms/IROutliner/included-phi-nodes-end.ll
+++ b/llvm/test/Transforms/IROutliner/included-phi-nodes-end.ll
@@ -4,18 +4,18 @@
; Show that we are able to propogate inputs to the region into the split PHINode
; outside of the region if necessary.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = add i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%2 = phi i32 [ %d, %test ], [ %e, %test1 ], [ %c, %entry ]
@@ -25,18 +25,18 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = mul i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%2 = phi i32 [ %d, %test ], [ %e, %test1 ], [ %c, %entry ]
@@ -48,9 +48,9 @@ next:
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = add i32 [[C]], [[C]]
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[NEXT:%.*]], label [[ENTRY_AFTER_OUTLINE:%.*]]
; CHECK: entry_after_outline:
; CHECK-NEXT: ret void
@@ -61,9 +61,9 @@ next:
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = mul i32 [[C]], [[C]]
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[NEXT:%.*]], label [[ENTRY_AFTER_OUTLINE:%.*]]
; CHECK: entry_after_outline:
; CHECK-NEXT: ret void
@@ -77,11 +77,11 @@ next:
; CHECK: entry_to_outline:
; CHECK-NEXT: br i1 true, label [[TEST1:%.*]], label [[FIRST:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP1:%.*]], [[TMP1]]
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[NEXT_EXITSTUB:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP3:%.*]] = phi i32 [ [[D]], [[TEST]] ], [ [[E]], [[TEST1]] ], [ [[TMP1]], [[ENTRY_TO_OUTLINE]] ]
diff --git a/llvm/test/Transforms/IROutliner/legal-debug.ll b/llvm/test/Transforms/IROutliner/legal-debug.ll
index 810fe2d3a23a4..b7b472fa20b3e 100644
--- a/llvm/test/Transforms/IROutliner/legal-debug.ll
+++ b/llvm/test/Transforms/IROutliner/legal-debug.ll
@@ -7,19 +7,19 @@
define void @function1() !dbg !6 {
entry:
%a = alloca i32, align 4, !dbg !17
- call void @llvm.dbg.value(metadata i32* %a, metadata !9, metadata !DIExpression()), !dbg !17
+ call void @llvm.dbg.value(metadata ptr %a, metadata !9, metadata !DIExpression()), !dbg !17
%b = alloca i32, align 4, !dbg !18
- call void @llvm.dbg.value(metadata i32* %b, metadata !11, metadata !DIExpression()), !dbg !18
+ call void @llvm.dbg.value(metadata ptr %b, metadata !11, metadata !DIExpression()), !dbg !18
%c = alloca i32, align 4, !dbg !19
- call void @llvm.dbg.value(metadata i32* %c, metadata !12, metadata !DIExpression()), !dbg !19
- store i32 2, i32* %a, align 4, !dbg !20
- store i32 3, i32* %b, align 4, !dbg !21
- store i32 4, i32* %c, align 4, !dbg !22
- %al = load i32, i32* %a, align 4, !dbg !23
+ call void @llvm.dbg.value(metadata ptr %c, metadata !12, metadata !DIExpression()), !dbg !19
+ store i32 2, ptr %a, align 4, !dbg !20
+ store i32 3, ptr %b, align 4, !dbg !21
+ store i32 4, ptr %c, align 4, !dbg !22
+ %al = load i32, ptr %a, align 4, !dbg !23
call void @llvm.dbg.value(metadata i32 %al, metadata !13, metadata !DIExpression()), !dbg !23
- %bl = load i32, i32* %b, align 4, !dbg !24
+ %bl = load i32, ptr %b, align 4, !dbg !24
call void @llvm.dbg.value(metadata i32 %bl, metadata !15, metadata !DIExpression()), !dbg !24
- %cl = load i32, i32* %c, align 4, !dbg !25
+ %cl = load i32, ptr %c, align 4, !dbg !25
call void @llvm.dbg.value(metadata i32 %cl, metadata !16, metadata !DIExpression()), !dbg !25
ret void, !dbg !26
}
@@ -27,19 +27,19 @@ entry:
define void @function2() !dbg !27 {
entry:
%a = alloca i32, align 4, !dbg !35
- call void @llvm.dbg.value(metadata i32* %a, metadata !29, metadata !DIExpression()), !dbg !35
+ call void @llvm.dbg.value(metadata ptr %a, metadata !29, metadata !DIExpression()), !dbg !35
%b = alloca i32, align 4, !dbg !36
- call void @llvm.dbg.value(metadata i32* %b, metadata !30, metadata !DIExpression()), !dbg !36
+ call void @llvm.dbg.value(metadata ptr %b, metadata !30, metadata !DIExpression()), !dbg !36
%c = alloca i32, align 4, !dbg !37
- call void @llvm.dbg.value(metadata i32* %c, metadata !31, metadata !DIExpression()), !dbg !37
- store i32 2, i32* %a, align 4, !dbg !38
- store i32 3, i32* %b, align 4, !dbg !39
- store i32 4, i32* %c, align 4, !dbg !40
- %al = load i32, i32* %a, align 4, !dbg !41
+ call void @llvm.dbg.value(metadata ptr %c, metadata !31, metadata !DIExpression()), !dbg !37
+ store i32 2, ptr %a, align 4, !dbg !38
+ store i32 3, ptr %b, align 4, !dbg !39
+ store i32 4, ptr %c, align 4, !dbg !40
+ %al = load i32, ptr %a, align 4, !dbg !41
call void @llvm.dbg.value(metadata i32 %al, metadata !32, metadata !DIExpression()), !dbg !41
- %bl = load i32, i32* %b, align 4, !dbg !42
+ %bl = load i32, ptr %b, align 4, !dbg !42
call void @llvm.dbg.value(metadata i32 %bl, metadata !33, metadata !DIExpression()), !dbg !42
- %cl = load i32, i32* %c, align 4, !dbg !43
+ %cl = load i32, ptr %c, align 4, !dbg !43
call void @llvm.dbg.value(metadata i32 %cl, metadata !34, metadata !DIExpression()), !dbg !43
ret void, !dbg !44
}
@@ -102,34 +102,34 @@ attributes #0 = { nounwind readnone speculatable willreturn }
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4, !dbg [[DBG17:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META9:![0-9]+]], metadata !DIExpression()), !dbg [[DBG17]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[A]], metadata [[META9:![0-9]+]], metadata !DIExpression()), !dbg [[DBG17]]
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4, !dbg [[DBG18:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META11:![0-9]+]], metadata !DIExpression()), !dbg [[DBG18]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[B]], metadata [[META11:![0-9]+]], metadata !DIExpression()), !dbg [[DBG18]]
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4, !dbg [[DBG19:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META12:![0-9]+]], metadata !DIExpression()), !dbg [[DBG19]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG20:![0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[C]], metadata [[META12:![0-9]+]], metadata !DIExpression()), !dbg [[DBG19]]
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]]), !dbg [[DBG20:![0-9]+]]
; CHECK-NEXT: ret void, !dbg [[DBG21:![0-9]+]]
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4, !dbg [[DBG30:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META24:![0-9]+]], metadata !DIExpression()), !dbg [[DBG30]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[A]], metadata [[META24:![0-9]+]], metadata !DIExpression()), !dbg [[DBG30]]
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4, !dbg [[DBG31:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META25:![0-9]+]], metadata !DIExpression()), !dbg [[DBG31]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[B]], metadata [[META25:![0-9]+]], metadata !DIExpression()), !dbg [[DBG31]]
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4, !dbg [[DBG32:![0-9]+]]
-; CHECK-NEXT: call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META26:![0-9]+]], metadata !DIExpression()), !dbg [[DBG32]]
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG33:![0-9]+]]
+; CHECK-NEXT: call void @llvm.dbg.value(metadata ptr [[C]], metadata [[META26:![0-9]+]], metadata !DIExpression()), !dbg [[DBG32]]
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]]), !dbg [[DBG33:![0-9]+]]
; CHECK-NEXT: ret void, !dbg [[DBG34:![0-9]+]]
;
;
-; CHECK: @outlined_ir_func_0(i32* [[TMP0:%.*]], i32* [[TMP1:%.*]], i32* [[TMP2:%.*]])
+; CHECK: @outlined_ir_func_0(ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], ptr [[TMP2:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[TMP2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
;
diff --git a/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll b/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
index cbe6b7e1b196d..1733bdb508565 100644
--- a/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
+++ b/llvm/test/Transforms/IROutliner/legal-indirect-calls.ll
@@ -4,36 +4,36 @@
; This test checks that we do outline indirect calls when it is not specified
; that we should not.
-declare void @f1(i32*, i32*);
-declare void @f2(i32*, i32*);
+declare void @f1(ptr, ptr);
+declare void @f2(ptr, ptr);
-define void @function1(void()* %func) {
+define void @function1(ptr %func) {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void %func()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-define void @function2(void()* %func) {
+define void @function2(ptr %func) {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void %func()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
; CHECK-LABEL: @function1(
@@ -41,7 +41,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr [[FUNC:%.*]])
; CHECK-NEXT: ret void
;
;
@@ -50,7 +50,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr [[FUNC:%.*]])
; CHECK-NEXT: ret void
;
;
@@ -58,13 +58,13 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: call void [[TMP3:%.*]]()
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/mismatched-phi-exits-not-in-first-outlined.ll b/llvm/test/Transforms/IROutliner/mismatched-phi-exits-not-in-first-outlined.ll
index 42518d7c236ea..24ad86f8e9c48 100644
--- a/llvm/test/Transforms/IROutliner/mismatched-phi-exits-not-in-first-outlined.ll
+++ b/llvm/test/Transforms/IROutliner/mismatched-phi-exits-not-in-first-outlined.ll
@@ -4,31 +4,31 @@
; Show that we are able to extract blocks that contain PHINodes, and selectively
; store into it's respective block, creating a new block if needed.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
@@ -37,7 +37,7 @@ first:
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* null, i32 -1)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr null, i32 -1)
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -47,11 +47,10 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]], i32 0)
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]], i32 0)
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[DOTCE_RELOAD]], [[ENTRY:%.*]] ]
@@ -62,20 +61,20 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[PHI_BLOCK:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[PHI_BLOCK]]
; CHECK: first.exitStub:
; CHECK-NEXT: switch i32 [[TMP2:%.*]], label [[FINAL_BLOCK_0:%.*]] [
; CHECK-NEXT: i32 0, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[TMP3:%.*]], i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[TMP3:%.*]], ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: phi_block:
; CHECK-NEXT: [[TMP3]] = phi i32 [ [[C]], [[TEST:%.*]] ], [ [[E]], [[TEST1]] ]
diff --git a/llvm/test/Transforms/IROutliner/mismatched-phi-exits.ll b/llvm/test/Transforms/IROutliner/mismatched-phi-exits.ll
index 443a625c46c5b..6b50e99e2cf25 100644
--- a/llvm/test/Transforms/IROutliner/mismatched-phi-exits.ll
+++ b/llvm/test/Transforms/IROutliner/mismatched-phi-exits.ll
@@ -4,32 +4,32 @@
; Show that we are able to extract blocks that contain PHINodes, and selectively
; store into it's respective block, only using if needed.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
@@ -38,11 +38,10 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]], i32 0)
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]], i32 0)
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[DOTCE_RELOAD]], [[ENTRY:%.*]] ]
@@ -52,7 +51,7 @@ first:
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* null, i32 -1)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr null, i32 -1)
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -62,13 +61,13 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST_SPLIT:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST_SPLIT]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[C]], [[TEST:%.*]] ], [ [[E]], [[TEST1]] ]
@@ -78,7 +77,7 @@ first:
; CHECK-NEXT: i32 0, label [[OUTPUT_BLOCK_0_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_0_0:
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: final_block_0:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/mismatched-phi-outputs-ordering.ll b/llvm/test/Transforms/IROutliner/mismatched-phi-outputs-ordering.ll
index f05e88620c255..ab1836f7a4d28 100644
--- a/llvm/test/Transforms/IROutliner/mismatched-phi-outputs-ordering.ll
+++ b/llvm/test/Transforms/IROutliner/mismatched-phi-outputs-ordering.ll
@@ -4,16 +4,16 @@
; Show that we do not extract similar regions that would involve the splitting
; of phi nodes on exit.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
@@ -24,16 +24,16 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
ret void
@@ -48,19 +48,16 @@ next:
; CHECK-NEXT: [[D_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[D_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[E_LOC]], i32* [[D_LOC]], i32* [[DOTCE_LOC]], i32 0)
-; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: [[D_RELOAD:%.*]] = load i32, i32* [[D_LOC]], align 4
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[D_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[E_LOC]], ptr [[D_LOC]], ptr [[DOTCE_LOC]], i32 0)
+; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: [[D_RELOAD:%.*]] = load i32, ptr [[D_LOC]], align 4
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[D_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[DOTCE_RELOAD]], [[ENTRY:%.*]] ]
@@ -75,15 +72,13 @@ next:
; CHECK-NEXT: [[D_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[D_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[E_LOC]], i32* [[D_LOC]], i32* null, i32 1)
-; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: [[D_RELOAD:%.*]] = load i32, i32* [[D_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[D_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[E_LOC]], ptr [[D_LOC]], ptr null, i32 1)
+; CHECK-NEXT: [[E_RELOAD:%.*]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: [[D_RELOAD:%.*]] = load i32, ptr [[D_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[D_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -96,13 +91,13 @@ next:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT:%.*]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT]], label [[NEXT_EXITSTUB:%.*]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[C]], [[TEST]] ], [ [[E]], [[TEST1]] ]
@@ -118,19 +113,19 @@ next:
; CHECK-NEXT: i32 1, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_0_0:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 [[D]], i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[D]], ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_0_1:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP1]], align 4
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP1]], align 4
-; CHECK-NEXT: store i32 [[D]], i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[D]], ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_1_1:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP1]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: final_block_0:
; CHECK-NEXT: ret i1 false
diff --git a/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-begin.ll b/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-begin.ll
index 3a39360ce65cb..32973ea3530dd 100644
--- a/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-begin.ll
+++ b/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-begin.ll
@@ -4,10 +4,10 @@
; Show that we do not outline when all of the phi nodes in the beginning
; block are included not in the region.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = add i32 %c, %c
br label %test1
dummy:
@@ -15,20 +15,20 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %e, %test1 ], [ %y, %entry ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
br i1 true, label %test, label %test1
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = mul i32 %c, %c
br label %test1
dummy:
@@ -36,11 +36,11 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %y, %entry ], [ %e, %test1 ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
br i1 true, label %test, label %test1
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
ret void
@@ -49,7 +49,7 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
@@ -57,11 +57,10 @@ first:
; CHECK: test1:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[E_RELOAD:%.*]], [[TEST1]] ], [ [[Y]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[E_RELOAD]], [[TEST1]] ], [ [[Y]], [[ENTRY]] ]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[E_LOC]])
-; CHECK-NEXT: [[E_RELOAD]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[E_LOC]])
+; CHECK-NEXT: [[E_RELOAD]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[TEST1]], label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -71,7 +70,7 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = mul i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
@@ -79,11 +78,10 @@ first:
; CHECK: test1:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[E_RELOAD:%.*]], [[TEST1]] ], [ [[Y]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[Y]], [[ENTRY]] ], [ [[E_RELOAD]], [[TEST1]] ]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[E_LOC]])
-; CHECK-NEXT: [[E_RELOAD]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[E_LOC]])
+; CHECK-NEXT: [[E_RELOAD]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[TEST1]], label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -93,16 +91,16 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[TEST1_TO_OUTLINE:%.*]]
; CHECK: test1_to_outline:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[TMP1:%.*]], [[TMP1]]
; CHECK-NEXT: br i1 true, label [[TEST:%.*]], label [[TEST1_EXITSTUB:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST_EXITSTUB:%.*]]
; CHECK: test1.exitStub:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: ret i1 true
; CHECK: first.exitStub:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP2]], align 4
; CHECK-NEXT: ret i1 false
;
diff --git a/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-end.ll b/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-end.ll
index ddffeb8f5d3e1..6f64414640d4c 100644
--- a/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-end.ll
+++ b/llvm/test/Transforms/IROutliner/must-capture-all-phi-nodes-end.ll
@@ -4,18 +4,18 @@
; Show that we do not outline when all of the phi nodes in the end
; block are not included in the region.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = add i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%2 = phi i32 [ %d, %test ], [ %e, %test1 ], [ %c, %entry ]
@@ -25,18 +25,18 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = mul i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%2 = phi i32 [ %d, %test ], [ %e, %test1 ], [ %c, %entry ]
@@ -48,15 +48,15 @@ next:
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[TEST1:%.*]], label [[FIRST:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[D]], [[TEST]] ], [ [[E]], [[TEST1]] ], [ [[C]], [[ENTRY:%.*]] ]
@@ -69,15 +69,15 @@ next:
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = mul i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[TEST1:%.*]], label [[FIRST:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[D]], [[TEST]] ], [ [[E]], [[TEST1]] ], [ [[C]], [[ENTRY:%.*]] ]
diff --git a/llvm/test/Transforms/IROutliner/no-outlining-optnone.ll b/llvm/test/Transforms/IROutliner/no-outlining-optnone.ll
index 8a9f2b31125b1..4d1836b544c1e 100644
--- a/llvm/test/Transforms/IROutliner/no-outlining-optnone.ll
+++ b/llvm/test/Transforms/IROutliner/no-outlining-optnone.ll
@@ -9,12 +9,12 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 3, i32* %a, align 4
- store i32 4, i32* %b, align 4
- store i32 5, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 3, ptr %a, align 4
+ store i32 4, ptr %b, align 4
+ store i32 5, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -23,12 +23,12 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -37,12 +37,12 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 3, i32* [[A]], align 4
-; CHECK-NEXT: store i32 4, i32* [[B]], align 4
-; CHECK-NEXT: store i32 5, i32* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 3, ptr [[A]], align 4
+; CHECK-NEXT: store i32 4, ptr [[B]], align 4
+; CHECK-NEXT: store i32 5, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: ret void
;
;
@@ -51,11 +51,11 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/opt-remarks.ll b/llvm/test/Transforms/IROutliner/opt-remarks.ll
index 6e58829c613e9..e0dc72bf8df59 100644
--- a/llvm/test/Transforms/IROutliner/opt-remarks.ll
+++ b/llvm/test/Transforms/IROutliner/opt-remarks.ll
@@ -328,16 +328,16 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -347,16 +347,16 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -364,8 +364,8 @@ define void @function3() #0 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%mul = mul i32 %0, %1
%sub = sub i32 %0, %1
@@ -386,8 +386,8 @@ define void @function4() #0 {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%mul = mul i32 %0, %1
%sub = sub i32 %0, %1
diff --git a/llvm/test/Transforms/IROutliner/outline-memcpy.ll b/llvm/test/Transforms/IROutliner/outline-memcpy.ll
index 7cac8cf32f856..0cf4f34d23212 100644
--- a/llvm/test/Transforms/IROutliner/outline-memcpy.ll
+++ b/llvm/test/Transforms/IROutliner/outline-memcpy.ll
@@ -3,44 +3,44 @@
; This test checks that we successfully outline identical memcpy instructions.
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
-define i8 @function1(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function1(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
-define i8 @function2(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function2(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memcpy.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[S:%.*]], i8* [[D:%.*]], i64 [[LEN:%.*]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[S:%.*]], ptr [[D:%.*]], i64 [[LEN:%.*]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[S:%.*]], i8* [[D:%.*]], i64 [[LEN:%.*]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[S:%.*]], ptr [[D:%.*]], i64 [[LEN:%.*]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
@@ -48,13 +48,13 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[A:%.*]] = load i8, i8* [[TMP0:%.*]], align 1
-; CHECK-NEXT: [[B:%.*]] = load i8, i8* [[TMP1:%.*]], align 1
-; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[TMP1]], i8* [[TMP0]], i64 [[TMP2:%.*]], i1 false)
+; CHECK-NEXT: [[A:%.*]] = load i8, ptr [[TMP0:%.*]], align 1
+; CHECK-NEXT: [[B:%.*]] = load i8, ptr [[TMP1:%.*]], align 1
+; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr [[TMP1]], ptr [[TMP0]], i64 [[TMP2:%.*]], i1 false)
; CHECK-NEXT: [[C:%.*]] = add i8 [[A]], [[B]]
-; CHECK-NEXT: [[RET:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT: [[RET:%.*]] = load i8, ptr [[TMP0]], align 1
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
-; CHECK-NEXT: store i8 [[RET]], i8* [[TMP3:%.*]], align 1
+; CHECK-NEXT: store i8 [[RET]], ptr [[TMP3:%.*]], align 1
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outline-memmove.ll b/llvm/test/Transforms/IROutliner/outline-memmove.ll
index 804049390834d..cf7924433d5bb 100644
--- a/llvm/test/Transforms/IROutliner/outline-memmove.ll
+++ b/llvm/test/Transforms/IROutliner/outline-memmove.ll
@@ -3,44 +3,44 @@
; This test checks that we sucecssfully outline identical memmove instructions.
-declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
+declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
-define i8 @function1(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function1(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
-define i8 @function2(i8* noalias %s, i8* noalias %d, i64 %len) {
+define i8 @function2(ptr noalias %s, ptr noalias %d, i64 %len) {
entry:
- %a = load i8, i8* %s
- %b = load i8, i8* %d
- call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
+ %a = load i8, ptr %s
+ %b = load i8, ptr %d
+ call void @llvm.memmove.p0.p0.i64(ptr %d, ptr %s, i64 %len, i1 false)
%c = add i8 %a, %b
- %ret = load i8, i8* %s
+ %ret = load i8, ptr %s
ret i8 %ret
}
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[S:%.*]], i8* [[D:%.*]], i64 [[LEN:%.*]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[S:%.*]], ptr [[D:%.*]], i64 [[LEN:%.*]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[RET_LOC:%.*]] = alloca i8, align 1
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[RET_LOC]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[S:%.*]], i8* [[D:%.*]], i64 [[LEN:%.*]], i8* [[RET_LOC]])
-; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, i8* [[RET_LOC]], align 1
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[RET_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[RET_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[S:%.*]], ptr [[D:%.*]], i64 [[LEN:%.*]], ptr [[RET_LOC]])
+; CHECK-NEXT: [[RET_RELOAD:%.*]] = load i8, ptr [[RET_LOC]], align 1
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[RET_LOC]])
; CHECK-NEXT: ret i8 [[RET_RELOAD]]
;
;
@@ -48,13 +48,13 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[A:%.*]] = load i8, i8* [[TMP0:%.*]], align 1
-; CHECK-NEXT: [[B:%.*]] = load i8, i8* [[TMP1:%.*]], align 1
-; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[TMP1]], i8* [[TMP0]], i64 [[TMP2:%.*]], i1 false)
+; CHECK-NEXT: [[A:%.*]] = load i8, ptr [[TMP0:%.*]], align 1
+; CHECK-NEXT: [[B:%.*]] = load i8, ptr [[TMP1:%.*]], align 1
+; CHECK-NEXT: call void @llvm.memmove.p0.p0.i64(ptr [[TMP1]], ptr [[TMP0]], i64 [[TMP2:%.*]], i1 false)
; CHECK-NEXT: [[C:%.*]] = add i8 [[A]], [[B]]
-; CHECK-NEXT: [[RET:%.*]] = load i8, i8* [[TMP0]], align 1
+; CHECK-NEXT: [[RET:%.*]] = load i8, ptr [[TMP0]], align 1
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
-; CHECK-NEXT: store i8 [[RET]], i8* [[TMP3:%.*]], align 1
+; CHECK-NEXT: store i8 [[RET]], ptr [[TMP3:%.*]], align 1
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outline-memset.ll b/llvm/test/Transforms/IROutliner/outline-memset.ll
index 90f8798d39b1d..748256d74e736 100644
--- a/llvm/test/Transforms/IROutliner/outline-memset.ll
+++ b/llvm/test/Transforms/IROutliner/outline-memset.ll
@@ -3,13 +3,12 @@
; This test checks that we successfully outline identical memset instructions.
-declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1)
+declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i32, i1)
define i64 @function1(i64 %x, i64 %z, i64 %n) {
entry:
%pool = alloca [59 x i64], align 4
- %tmp = bitcast [59 x i64]* %pool to i8*
- call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
+ call void @llvm.memset.p0.i64(ptr nonnull %pool, i8 0, i64 236, i32 4, i1 false)
%cmp3 = icmp eq i64 %n, 0
%a = add i64 %x, %z
%c = add i64 %x, %z
@@ -19,8 +18,7 @@ entry:
define i64 @function2(i64 %x, i64 %z, i64 %n) {
entry:
%pool = alloca [59 x i64], align 4
- %tmp = bitcast [59 x i64]* %pool to i8*
- call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
+ call void @llvm.memset.p0.i64(ptr nonnull %pool, i8 0, i64 236, i32 4, i1 false)
%cmp3 = icmp eq i64 %n, 0
%a = add i64 %x, %z
%c = add i64 %x, %z
@@ -29,14 +27,14 @@ entry:
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[POOL:%.*]] = alloca [59 x i64], align 4
-; CHECK-NEXT: call void @outlined_ir_func_0([59 x i64]* [[POOL]], i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[POOL]], i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
; CHECK-NEXT: ret i64 0
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[POOL:%.*]] = alloca [59 x i64], align 4
-; CHECK-NEXT: call void @outlined_ir_func_0([59 x i64]* [[POOL]], i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[POOL]], i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
; CHECK-NEXT: ret i64 0
;
;
@@ -44,8 +42,7 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[TMP:%.*]] = bitcast [59 x i64]* [[TMP0:%.*]] to i8*
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* nonnull align 4 [[TMP]], i8 0, i64 236, i1 false)
+; CHECK-NEXT: call void @llvm.memset.p0.i64(ptr nonnull align 4 [[TMP0:%.*]], i8 0, i64 236, i1 false)
; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i64 [[TMP1:%.*]], 0
; CHECK-NEXT: [[A:%.*]] = add i64 [[TMP2:%.*]], [[TMP3:%.*]]
; CHECK-NEXT: [[C:%.*]] = add i64 [[TMP2]], [[TMP3]]
diff --git a/llvm/test/Transforms/IROutliner/outline-vaarg-intrinsic.ll b/llvm/test/Transforms/IROutliner/outline-vaarg-intrinsic.ll
index 7a2c4ff681aa6..9f565de960575 100644
--- a/llvm/test/Transforms/IROutliner/outline-vaarg-intrinsic.ll
+++ b/llvm/test/Transforms/IROutliner/outline-vaarg-intrinsic.ll
@@ -1,90 +1,95 @@
-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
; RUN: opt -S -passes=verify,iroutliner -ir-outlining-no-cost < %s | FileCheck %s
; This test checks that we sucessfully outline identical memcpy var arg
; intrinsics, but not the var arg instruction itself.
-declare void @llvm.va_start(i8*)
-declare void @llvm.va_copy(i8*, i8*)
-declare void @llvm.va_end(i8*)
+declare void @llvm.va_start(ptr)
+declare void @llvm.va_copy(ptr, ptr)
+declare void @llvm.va_end(ptr)
-define i32 @func1(i32 %a, double %b, i8* %v, ...) nounwind {
+define i32 @func1(i32 %a, double %b, ptr %v, ...) nounwind {
entry:
%a.addr = alloca i32, align 4
%b.addr = alloca double, align 8
- %ap = alloca i8*, align 4
+ %ap = alloca ptr, align 4
%c = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- store double %b, double* %b.addr, align 8
- %ap1 = bitcast i8** %ap to i8*
- call void @llvm.va_start(i8* %ap1)
- %0 = va_arg i8** %ap, i32
- call void @llvm.va_copy(i8* %v, i8* %ap1)
- call void @llvm.va_end(i8* %ap1)
- store i32 %0, i32* %c, align 4
- %tmp = load i32, i32* %c, align 4
+ store i32 %a, ptr %a.addr, align 4
+ store double %b, ptr %b.addr, align 8
+ call void @llvm.va_start(ptr %ap)
+ %0 = va_arg ptr %ap, i32
+ call void @llvm.va_copy(ptr %v, ptr %ap)
+ call void @llvm.va_end(ptr %ap)
+ store i32 %0, ptr %c, align 4
+ %tmp = load i32, ptr %c, align 4
ret i32 %tmp
}
-define i32 @func2(i32 %a, double %b, i8* %v, ...) nounwind {
+define i32 @func2(i32 %a, double %b, ptr %v, ...) nounwind {
entry:
%a.addr = alloca i32, align 4
%b.addr = alloca double, align 8
- %ap = alloca i8*, align 4
+ %ap = alloca ptr, align 4
%c = alloca i32, align 4
- store i32 %a, i32* %a.addr, align 4
- store double %b, double* %b.addr, align 8
- %ap1 = bitcast i8** %ap to i8*
- call void @llvm.va_start(i8* %ap1)
- %0 = va_arg i8** %ap, i32
- call void @llvm.va_copy(i8* %v, i8* %ap1)
- call void @llvm.va_end(i8* %ap1)
- store i32 %0, i32* %c, align 4
- %ap2 = bitcast i8** %ap to i8*
- %tmp = load i32, i32* %c, align 4
+ store i32 %a, ptr %a.addr, align 4
+ store double %b, ptr %b.addr, align 8
+ call void @llvm.va_start(ptr %ap)
+ %0 = va_arg ptr %ap, i32
+ call void @llvm.va_copy(ptr %v, ptr %ap)
+ call void @llvm.va_end(ptr %ap)
+ store i32 %0, ptr %c, align 4
+ %tmp = load i32, ptr %c, align 4
ret i32 %tmp
}
-; CHECK-LABEL: @func1(
+; CHECK-LABEL: define {{[^@]+}}@func1
+; CHECK-SAME: (i32 [[A:%.*]], double [[B:%.*]], ptr [[V:%.*]], ...) #[[ATTR1:[0-9]+]] {
; CHECK-NEXT: entry:
+; CHECK-NEXT: [[TMP_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_ADDR:%.*]] = alloca double, align 8
-; CHECK-NEXT: [[AP:%.*]] = alloca i8*, align 4
+; CHECK-NEXT: [[AP:%.*]] = alloca ptr, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
-; CHECK-NEXT: store double [[B:%.*]], double* [[B_ADDR]], align 8
-; CHECK-NEXT: [[AP1:%.*]] = bitcast i8** [[AP]] to i8*
-; CHECK-NEXT: call void @llvm.va_start(i8* [[AP1]])
-; CHECK-NEXT: [[TMP0:%.*]] = va_arg i8** [[AP]], i32
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[V:%.*]], i8* [[AP1]], i32 [[TMP0]], i32* [[C]])
-; CHECK-NEXT: [[TMP:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: ret i32 [[TMP]]
+; CHECK-NEXT: store i32 [[A]], ptr [[A_ADDR]], align 4
+; CHECK-NEXT: store double [[B]], ptr [[B_ADDR]], align 8
+; CHECK-NEXT: call void @llvm.va_start(ptr [[AP]])
+; CHECK-NEXT: [[TMP0:%.*]] = va_arg ptr [[AP]], i32
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[V]], ptr [[AP]], i32 [[TMP0]], ptr [[C]], ptr [[TMP_LOC]])
+; CHECK-NEXT: [[TMP_RELOAD:%.*]] = load i32, ptr [[TMP_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: ret i32 [[TMP_RELOAD]]
;
;
-; CHECK-LABEL: @func2(
+; CHECK-LABEL: define {{[^@]+}}@func2
+; CHECK-SAME: (i32 [[A:%.*]], double [[B:%.*]], ptr [[V:%.*]], ...) #[[ATTR1]] {
; CHECK-NEXT: entry:
+; CHECK-NEXT: [[TMP_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B_ADDR:%.*]] = alloca double, align 8
-; CHECK-NEXT: [[AP:%.*]] = alloca i8*, align 4
+; CHECK-NEXT: [[AP:%.*]] = alloca ptr, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 [[A:%.*]], i32* [[A_ADDR]], align 4
-; CHECK-NEXT: store double [[B:%.*]], double* [[B_ADDR]], align 8
-; CHECK-NEXT: [[AP1:%.*]] = bitcast i8** [[AP]] to i8*
-; CHECK-NEXT: call void @llvm.va_start(i8* [[AP1]])
-; CHECK-NEXT: [[TMP0:%.*]] = va_arg i8** [[AP]], i32
-; CHECK-NEXT: call void @outlined_ir_func_0(i8* [[V:%.*]], i8* [[AP1]], i32 [[TMP0]], i32* [[C]])
-; CHECK-NEXT: [[AP2:%.*]] = bitcast i8** [[AP]] to i8*
-; CHECK-NEXT: [[TMP:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: ret i32 [[TMP]]
+; CHECK-NEXT: store i32 [[A]], ptr [[A_ADDR]], align 4
+; CHECK-NEXT: store double [[B]], ptr [[B_ADDR]], align 8
+; CHECK-NEXT: call void @llvm.va_start(ptr [[AP]])
+; CHECK-NEXT: [[TMP0:%.*]] = va_arg ptr [[AP]], i32
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[V]], ptr [[AP]], i32 [[TMP0]], ptr [[C]], ptr [[TMP_LOC]])
+; CHECK-NEXT: [[TMP_RELOAD:%.*]] = load i32, ptr [[TMP_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[TMP_LOC]])
+; CHECK-NEXT: ret i32 [[TMP_RELOAD]]
;
;
-; CHECK: define internal void @outlined_ir_func_0(
+; CHECK-LABEL: define {{[^@]+}}@outlined_ir_func_0
+; CHECK-SAME: (ptr [[TMP0:%.*]], ptr [[TMP1:%.*]], i32 [[TMP2:%.*]], ptr [[TMP3:%.*]], ptr [[TMP4:%.*]]) #[[ATTR3:[0-9]+]] {
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: call void @llvm.va_copy(i8* [[TMP0:%.*]], i8* [[TMP1:%.*]])
-; CHECK-NEXT: call void @llvm.va_end(i8* [[TMP1]])
-; CHECK-NEXT: store i32 [[TMP2:%.*]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: call void @llvm.va_copy(ptr [[TMP0]], ptr [[TMP1]])
+; CHECK-NEXT: call void @llvm.va_end(ptr [[TMP1]])
+; CHECK-NEXT: store i32 [[TMP2]], ptr [[TMP3]], align 4
+; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr [[TMP3]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
+; CHECK-NEXT: store i32 [[TMP]], ptr [[TMP4]], align 4
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-across-branch.ll b/llvm/test/Transforms/IROutliner/outlining-across-branch.ll
index d4d8b3fe7556b..4c1675908825c 100644
--- a/llvm/test/Transforms/IROutliner/outlining-across-branch.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-across-branch.ll
@@ -12,12 +12,12 @@ entry:
%result = alloca i32, align 4
%output2 = alloca i32, align 4
%result2 = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %next
next:
- store i32 2, i32* %output, align 4
- store i32 3, i32* %result, align 4
+ store i32 2, ptr %output, align 4
+ store i32 3, ptr %result, align 4
ret void
}
@@ -29,12 +29,12 @@ entry:
%result = alloca i32, align 4
%output2 = alloca i32, align 4
%result2 = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
br label %next
next:
- store i32 2, i32* %output, align 4
- store i32 3, i32* %result, align 4
+ store i32 2, ptr %output, align 4
+ store i32 3, ptr %result, align 4
ret void
}
; CHECK-LABEL: @outline_outputs1(
@@ -45,7 +45,7 @@ next:
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT2:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
;
@@ -57,7 +57,7 @@ next:
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT2:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
;
@@ -65,12 +65,12 @@ next:
; CHECK: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: store i32 2, i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/outlining-address-taken.ll b/llvm/test/Transforms/IROutliner/outlining-address-taken.ll
index d8ba3740c61c8..ce20e6d79b7f3 100644
--- a/llvm/test/Transforms/IROutliner/outlining-address-taken.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-address-taken.ll
@@ -4,7 +4,7 @@
; This test shows that we do not outline from basic blocks with their address
; taken.
- at ba1 = constant i8* blockaddress (@dontoutline, %new_block)
+ at ba1 = constant ptr blockaddress (@dontoutline, %new_block)
define void @outline_1() {
; CHECK-LABEL: @outline_1(
@@ -12,19 +12,19 @@ define void @outline_1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @[[FUNCTION_1:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @[[FUNCTION_1:.*]](ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -34,19 +34,19 @@ define void @outline_2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @[[FUNCTION_1]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @[[FUNCTION_1]](ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -58,12 +58,12 @@ define void @dontoutline() {
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[NEW_BLOCK:%.*]]
; CHECK: new_block:
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: ret void
;
entry:
@@ -72,20 +72,20 @@ entry:
%c = alloca i32, align 4
br label %new_block
new_block:
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @[[FUNCTION_1]](i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: define internal void @[[FUNCTION_1]](ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-bitcasts.ll b/llvm/test/Transforms/IROutliner/outlining-bitcasts.ll
index c1f4093a63532..31f1d12bd3603 100644
--- a/llvm/test/Transforms/IROutliner/outlining-bitcasts.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-bitcasts.ll
@@ -8,8 +8,8 @@
; Additionally, we check that the newly added bitcast instruction is excluded in
; further extractions.
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
define void @outline_bitcast_base() {
entry:
@@ -17,13 +17,12 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %X = bitcast i32* %d to i8*
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -33,18 +32,17 @@ entry:
%b = alloca i32, align 4
%c = alloca i32, align 4
%d = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %X = bitcast i32* %d to i8*
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %X)
- %am = load i32, i32* %b
- %bm = load i32, i32* %a
- %cm = load i32, i32* %c
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %X)
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %d)
+ %am = load i32, ptr %b
+ %bm = load i32, ptr %a
+ %cm = load i32, ptr %c
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %d)
ret void
}
@@ -56,17 +54,15 @@ entry:
define void @outline_bitcast_base2(i32 %a, i32 %b, i32 %c) {
entry:
%d = alloca i32, align 4
- %X = bitcast i32* %d to i8*
%al = add i32 %a, %b
%bl = add i32 %b, %a
%cl = add i32 %b, %c
%buffer = mul i32 %a, %b
- %Y = bitcast i32* %d to i8*
%am = add i32 %a, %b
%bm = add i32 %b, %a
%cm = add i32 %b, %c
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %X)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %X)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %d)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %d)
ret void
}
@@ -76,7 +72,7 @@ entry:
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[D:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], i32* [[D]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
;
@@ -85,34 +81,18 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[D:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], i32* [[D]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[AM:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[BM:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[CM:%.*]] = load i32, i32* [[C]], align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
+; CHECK-NEXT: [[AM:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[BM:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[CM:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @outline_bitcast_base2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[D:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[X:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: [[AL:%.*]] = add i32 [[A:%.*]], [[B:%.*]]
-; CHECK-NEXT: [[BL:%.*]] = add i32 [[B]], [[A]]
-; CHECK-NEXT: [[CL:%.*]] = add i32 [[B]], [[C:%.*]]
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[A:%.*]], i32 [[B:%.*]], i32 [[C:%.*]])
; CHECK-NEXT: [[BUFFER:%.*]] = mul i32 [[A]], [[B]]
-; CHECK-NEXT: [[Y:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: [[AM:%.*]] = add i32 [[A]], [[B]]
-; CHECK-NEXT: [[BM:%.*]] = add i32 [[B]], [[A]]
-; CHECK-NEXT: [[CM:%.*]] = add i32 [[B]], [[C]]
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[D]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[A]], i32 [[B]], i32 [[C]])
; CHECK-NEXT: ret void
;
;
@@ -120,13 +100,28 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: [[X:%.*]] = bitcast i32* [[TMP3:%.*]] to i8*
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[TMP2]], align 4
+; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+; CHECK: entry_after_outline.exitStub:
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @outlined_ir_func_1(
+; CHECK-NEXT: newFuncRoot:
+; CHECK-NEXT: [[D:%.*]] = alloca i32, align 4
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[D]])
+; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
+; CHECK: entry_to_outline:
+; CHECK-NEXT: [[AL:%.*]] = add i32 [[TMP0:%.*]], [[TMP1:%.*]]
+; CHECK-NEXT: [[BL:%.*]] = add i32 [[TMP1]], [[TMP0]]
+; CHECK-NEXT: [[CL:%.*]] = add i32 [[TMP1]], [[TMP2:%.*]]
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[D]])
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
+;
diff --git a/llvm/test/Transforms/IROutliner/outlining-branches-phi-nodes.ll b/llvm/test/Transforms/IROutliner/outlining-branches-phi-nodes.ll
index 8fd29bc0f9ea4..28c23e34771ac 100644
--- a/llvm/test/Transforms/IROutliner/outlining-branches-phi-nodes.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-branches-phi-nodes.ll
@@ -19,24 +19,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_6
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_6
dummy:
ret void
@@ -59,24 +59,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_6
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_6
dummy:
ret void
@@ -100,11 +100,10 @@ block_6:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DIFF_CE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[DIFF_CE_LOC]])
-; CHECK-NEXT: [[DIFF_CE_RELOAD:%.*]] = load i32, i32* [[DIFF_CE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DIFF_CE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[DIFF_CE_LOC]])
+; CHECK-NEXT: [[DIFF_CE_RELOAD:%.*]] = load i32, ptr [[DIFF_CE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DIFF_CE_LOC]])
; CHECK-NEXT: br label [[BLOCK_6:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -128,11 +127,10 @@ block_6:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DIFF_CE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[DIFF_CE_LOC]])
-; CHECK-NEXT: [[DIFF_CE_RELOAD:%.*]] = load i32, i32* [[DIFF_CE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DIFF_CE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[DIFF_CE_LOC]])
+; CHECK-NEXT: [[DIFF_CE_RELOAD:%.*]] = load i32, ptr [[DIFF_CE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DIFF_CE_LOC]])
; CHECK-NEXT: br label [[BLOCK_6:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -145,29 +143,29 @@ block_6:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[BLOCK_2_TO_OUTLINE:%.*]]
; CHECK: block_2_to_outline:
-; CHECK-NEXT: [[A2VAL:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: [[B2VAL:%.*]] = load i32, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: [[A2VAL:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[B2VAL:%.*]] = load i32, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: [[ADD2:%.*]] = add i32 2, [[A2VAL]]
; CHECK-NEXT: [[MUL2:%.*]] = mul i32 2, [[B2VAL]]
; CHECK-NEXT: br label [[BLOCK_5:%.*]]
; CHECK: block_3:
-; CHECK-NEXT: [[AVAL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BVAL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[AVAL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BVAL:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 2, [[AVAL]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 2, [[BVAL]]
; CHECK-NEXT: br label [[BLOCK_4:%.*]]
; CHECK: block_4:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[BLOCK_6_SPLIT:%.*]]
; CHECK: block_5:
-; CHECK-NEXT: store i32 [[ADD2]], i32* [[TMP2]], align 4
-; CHECK-NEXT: store i32 [[MUL2]], i32* [[TMP3]], align 4
+; CHECK-NEXT: store i32 [[ADD2]], ptr [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[MUL2]], ptr [[TMP3]], align 4
; CHECK-NEXT: br label [[BLOCK_6_SPLIT]]
; CHECK: block_6.split:
; CHECK-NEXT: [[DIFF_CE:%.*]] = phi i32 [ [[AVAL]], [[BLOCK_4]] ], [ [[A2VAL]], [[BLOCK_5]] ]
; CHECK-NEXT: br label [[BLOCK_6_EXITSTUB:%.*]]
; CHECK: block_6.exitStub:
-; CHECK-NEXT: store i32 [[DIFF_CE]], i32* [[TMP4:%.*]], align 4
+; CHECK-NEXT: store i32 [[DIFF_CE]], ptr [[TMP4:%.*]], align 4
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll b/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
index 31f2052d8add9..2ba79cc9e6f90 100644
--- a/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-call-and-indirect.ll
@@ -6,18 +6,18 @@
declare void @f1();
-define void @function1(void()* %func) {
+define void @function1(ptr %func) {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void %func()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -26,13 +26,13 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
call void @f1()
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
; CHECK-LABEL: @function1(
@@ -40,7 +40,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* [[FUNC:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr [[FUNC:%.*]])
; CHECK-NEXT: ret void
;
;
@@ -49,7 +49,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void ()* @f1)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr @f1)
; CHECK-NEXT: ret void
;
;
@@ -57,13 +57,13 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: call void [[TMP3:%.*]]()
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll b/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
index 4621077ff2ed2..befc4896f7503 100644
--- a/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-calls-names-must-match.ll
@@ -4,8 +4,8 @@
; This test checks that we do can outline calls, but only if they have the same
; function type and the same name.
-declare void @f1(i32*, i32*);
-declare void @f2(i32*, i32*);
+declare void @f1(ptr, ptr);
+declare void @f2(ptr, ptr);
define void @function1() {
; CHECK-LABEL: @function1(
@@ -13,20 +13,20 @@ define void @function1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f1(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f1(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -36,20 +36,20 @@ define void @function2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f1(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f1(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -59,35 +59,35 @@ define void @function3() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: call void @f2(i32* [[A]], i32* [[B]])
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: call void @f2(ptr [[A]], ptr [[B]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f2(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f2(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: call void @f1(i32* [[ARG0]], i32* [[ARG1]])
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: call void @f1(ptr [[ARG0]], ptr [[ARG1]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-calls.ll b/llvm/test/Transforms/IROutliner/outlining-calls.ll
index f96b46f8813a4..8d4092727577a 100644
--- a/llvm/test/Transforms/IROutliner/outlining-calls.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-calls.ll
@@ -4,21 +4,21 @@
; This test checks that we do can outline calls, but only if they have the same
; function type and the same name.
-declare void @f1(i32*, i32*);
-declare void @f2(i32*, i32*);
+declare void @f1(ptr, ptr);
+declare void @f2(ptr, ptr);
define void @function1() {
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f1(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f1(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -27,13 +27,13 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f1(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f1(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -42,13 +42,13 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- call void @f2(i32* %a, i32* %b)
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ call void @f2(ptr %a, ptr %b)
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -57,7 +57,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f1)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr @f1)
; CHECK-NEXT: ret void
;
;
@@ -66,7 +66,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f1)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr @f1)
; CHECK-NEXT: ret void
;
;
@@ -75,7 +75,7 @@ entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]], void (i32*, i32*)* @f2)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]], ptr @f2)
; CHECK-NEXT: ret void
;
;
@@ -83,13 +83,13 @@ entry:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 4, i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: call void [[TMP3:%.*]](i32* [[TMP0]], i32* [[TMP1]])
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 4, ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: call void [[TMP3:%.*]](ptr [[TMP0]], ptr [[TMP1]])
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[TMP1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[TMP2]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/outlining-commutative-fp.ll b/llvm/test/Transforms/IROutliner/outlining-commutative-fp.ll
index d40d212cdc8aa..6b958b674bcb2 100644
--- a/llvm/test/Transforms/IROutliner/outlining-commutative-fp.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-commutative-fp.ll
@@ -16,19 +16,19 @@ define void @outline_from_fadd1() {
; CHECK-NEXT: [[A:%.*]] = alloca double, align 4
; CHECK-NEXT: [[B:%.*]] = alloca double, align 4
; CHECK-NEXT: [[C:%.*]] = alloca double, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(double* [[A]], double* [[B]], double* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca double, align 4
%b = alloca double, align 4
%c = alloca double, align 4
- store double 2.0, double* %a, align 4
- store double 3.0, double* %b, align 4
- store double 4.0, double* %c, align 4
- %al = load double, double* %a
- %bl = load double, double* %b
- %cl = load double, double* %c
+ store double 2.0, ptr %a, align 4
+ store double 3.0, ptr %b, align 4
+ store double 4.0, ptr %c, align 4
+ %al = load double, ptr %a
+ %bl = load double, ptr %b
+ %cl = load double, ptr %c
%0 = fadd double %al, %bl
%1 = fadd double %al, %cl
%2 = fadd double %bl, %cl
@@ -41,19 +41,19 @@ define void @outline_from_fadd2.0() {
; CHECK-NEXT: [[A:%.*]] = alloca double, align 4
; CHECK-NEXT: [[B:%.*]] = alloca double, align 4
; CHECK-NEXT: [[C:%.*]] = alloca double, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(double* [[A]], double* [[B]], double* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca double, align 4
%b = alloca double, align 4
%c = alloca double, align 4
- store double 2.0, double* %a, align 4
- store double 3.0, double* %b, align 4
- store double 4.0, double* %c, align 4
- %al = load double, double* %a
- %bl = load double, double* %b
- %cl = load double, double* %c
+ store double 2.0, ptr %a, align 4
+ store double 3.0, ptr %b, align 4
+ store double 4.0, ptr %c, align 4
+ %al = load double, ptr %a
+ %bl = load double, ptr %b
+ %cl = load double, ptr %c
%0 = fadd double %al, %bl
%1 = fadd double %al, %cl
%2 = fadd double %bl, %cl
@@ -66,12 +66,12 @@ define void @outline_from_flipped_fadd3.0() {
; CHECK-NEXT: [[A:%.*]] = alloca double, align 4
; CHECK-NEXT: [[B:%.*]] = alloca double, align 4
; CHECK-NEXT: [[C:%.*]] = alloca double, align 4
-; CHECK-NEXT: store double 2.000000e+00, double* [[A]], align 4
-; CHECK-NEXT: store double 3.000000e+00, double* [[B]], align 4
-; CHECK-NEXT: store double 4.000000e+00, double* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load double, double* [[A]], align 8
-; CHECK-NEXT: [[BL:%.*]] = load double, double* [[B]], align 8
-; CHECK-NEXT: [[CL:%.*]] = load double, double* [[C]], align 8
+; CHECK-NEXT: store double 2.000000e+00, ptr [[A]], align 4
+; CHECK-NEXT: store double 3.000000e+00, ptr [[B]], align 4
+; CHECK-NEXT: store double 4.000000e+00, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load double, ptr [[A]], align 8
+; CHECK-NEXT: [[BL:%.*]] = load double, ptr [[B]], align 8
+; CHECK-NEXT: [[CL:%.*]] = load double, ptr [[C]], align 8
; CHECK-NEXT: [[TMP0:%.*]] = fadd double [[BL]], [[AL]]
; CHECK-NEXT: [[TMP1:%.*]] = fadd double [[CL]], [[AL]]
; CHECK-NEXT: [[TMP2:%.*]] = fadd double [[CL]], [[BL]]
@@ -81,26 +81,26 @@ entry:
%a = alloca double, align 4
%b = alloca double, align 4
%c = alloca double, align 4
- store double 2.0, double* %a, align 4
- store double 3.0, double* %b, align 4
- store double 4.0, double* %c, align 4
- %al = load double, double* %a
- %bl = load double, double* %b
- %cl = load double, double* %c
+ store double 2.0, ptr %a, align 4
+ store double 3.0, ptr %b, align 4
+ store double 4.0, ptr %c, align 4
+ %al = load double, ptr %a
+ %bl = load double, ptr %b
+ %cl = load double, ptr %c
%0 = fadd double %bl, %al
%1 = fadd double %cl, %al
%2 = fadd double %cl, %bl
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(double* [[ARG0:%.*]], double* [[ARG1:%.*]], double* [[ARG2:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store double 2.000000e+00, double* [[ARG0]], align 4
-; CHECK-NEXT: store double 3.000000e+00, double* [[ARG1]], align 4
-; CHECK-NEXT: store double 4.000000e+00, double* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load double, double* [[ARG0]], align 8
-; CHECK-NEXT: [[BL:%.*]] = load double, double* [[ARG1]], align 8
-; CHECK-NEXT: [[CL:%.*]] = load double, double* [[ARG2]], align 8
+; CHECK-NEXT: store double 2.000000e+00, ptr [[ARG0]], align 4
+; CHECK-NEXT: store double 3.000000e+00, ptr [[ARG1]], align 4
+; CHECK-NEXT: store double 4.000000e+00, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load double, ptr [[ARG0]], align 8
+; CHECK-NEXT: [[BL:%.*]] = load double, ptr [[ARG1]], align 8
+; CHECK-NEXT: [[CL:%.*]] = load double, ptr [[ARG2]], align 8
; CHECK-NEXT: [[TMP0:%.*]] = fadd double [[AL]], [[BL]]
; CHECK-NEXT: [[TMP1:%.*]] = fadd double [[AL]], [[CL]]
; CHECK-NEXT: [[TMP2:%.*]] = fadd double [[BL]], [[CL]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-commutative.ll b/llvm/test/Transforms/IROutliner/outlining-commutative.ll
index ffa72067cb561..8862dc295d435 100644
--- a/llvm/test/Transforms/IROutliner/outlining-commutative.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-commutative.ll
@@ -18,19 +18,19 @@ define void @outline_from_add1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = add i32 %al, %bl
%1 = add i32 %al, %cl
%2 = add i32 %bl, %cl
@@ -43,19 +43,19 @@ define void @outline_from_add2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = add i32 %al, %bl
%1 = add i32 %al, %cl
%2 = add i32 %bl, %cl
@@ -68,19 +68,19 @@ define void @outline_from_flipped_add3() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = add i32 %bl, %al
%1 = add i32 %cl, %al
%2 = add i32 %cl, %bl
@@ -93,19 +93,19 @@ define void @outline_from_flipped_add4() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = add i32 %bl, %al
%1 = add i32 %cl, %al
%2 = add i32 %cl, %bl
@@ -123,19 +123,19 @@ define void @outline_from_sub1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_2(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_2(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = sub i32 %al, %bl
%1 = sub i32 %al, %cl
%2 = sub i32 %bl, %cl
@@ -148,19 +148,19 @@ define void @outline_from_sub2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_2(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_2(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = sub i32 %al, %bl
%1 = sub i32 %al, %cl
%2 = sub i32 %bl, %cl
@@ -173,19 +173,19 @@ define void @dontoutline_from_flipped_sub3() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = sub i32 %bl, %al
%1 = sub i32 %cl, %al
%2 = sub i32 %cl, %bl
@@ -198,57 +198,57 @@ define void @dontoutline_from_flipped_sub4() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%0 = sub i32 %bl, %al
%1 = sub i32 %cl, %al
%2 = sub i32 %cl, %bl
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[AL]], [[BL]]
; CHECK-NEXT: [[TMP1:%.*]] = add i32 [[AL]], [[CL]]
; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[BL]], [[CL]]
-; CHECK: define internal void @outlined_ir_func_1(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_1(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = sub i32 [[BL]], [[AL]]
; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[CL]], [[AL]]
; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[CL]], [[BL]]
-; CHECK: define internal void @outlined_ir_func_2(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_2(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = sub i32 [[AL]], [[BL]]
; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[AL]], [[CL]]
; CHECK-NEXT: [[TMP2:%.*]] = sub i32 [[BL]], [[CL]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll b/llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll
index c96c02490c38b..b3f2e8102fc1e 100644
--- a/llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll
@@ -16,19 +16,19 @@ define void @outline_attrs1() #0 {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -38,19 +38,19 @@ define void @outline_attrs2() #0 {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -60,19 +60,19 @@ define void @outline_attrs3() #0 {
; CHECK-NEXT: [[A:%.*]] = alloca float, align 4
; CHECK-NEXT: [[B:%.*]] = alloca float, align 4
; CHECK-NEXT: [[C:%.*]] = alloca float, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(float* [[A]], float* [[B]], float* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca float, align 4
%b = alloca float, align 4
%c = alloca float, align 4
- store float 2.0, float* %a, align 4
- store float 3.0, float* %b, align 4
- store float 4.0, float* %c, align 4
- %al = load float, float* %a
- %bl = load float, float* %b
- %cl = load float, float* %c
+ store float 2.0, ptr %a, align 4
+ store float 3.0, ptr %b, align 4
+ store float 4.0, ptr %c, align 4
+ %al = load float, ptr %a
+ %bl = load float, ptr %b
+ %cl = load float, ptr %c
%0 = fmul float %al, %bl
ret void
}
@@ -83,19 +83,19 @@ define void @outline_attrs4() {
; CHECK-NEXT: [[A:%.*]] = alloca float, align 4
; CHECK-NEXT: [[B:%.*]] = alloca float, align 4
; CHECK-NEXT: [[C:%.*]] = alloca float, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(float* [[A]], float* [[B]], float* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca float, align 4
%b = alloca float, align 4
%c = alloca float, align 4
- store float 2.0, float* %a, align 4
- store float 3.0, float* %b, align 4
- store float 4.0, float* %c, align 4
- %al = load float, float* %a
- %bl = load float, float* %b
- %cl = load float, float* %c
+ store float 2.0, ptr %a, align 4
+ store float 3.0, ptr %b, align 4
+ store float 4.0, ptr %c, align 4
+ %al = load float, ptr %a
+ %bl = load float, ptr %b
+ %cl = load float, ptr %c
%0 = fmul float %al, %bl
ret void
}
@@ -103,23 +103,23 @@ entry:
attributes #0 = { "no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" "less-precise-fpmad"="true"
"unsafe-fp-math"="true" "no-infs-fp-math"="true"}
-; CHECK: define internal void @outlined_ir_func_0(float* [[ARG0:%.*]], float* [[ARG1:%.*]], float* [[ARG2:%.*]]) [[ATTR1:#[0-9]+]] {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) [[ATTR1:#[0-9]+]] {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store float 2.000000e+00, float* [[ARG0]], align 4
-; CHECK-NEXT: store float 3.000000e+00, float* [[ARG1]], align 4
-; CHECK-NEXT: store float 4.000000e+00, float* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load float, float* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load float, float* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load float, float* [[ARG2]], align 4
+; CHECK-NEXT: store float 2.000000e+00, ptr [[ARG0]], align 4
+; CHECK-NEXT: store float 3.000000e+00, ptr [[ARG1]], align 4
+; CHECK-NEXT: store float 4.000000e+00, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load float, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load float, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load float, ptr [[ARG2]], align 4
-; CHECK: define internal void @outlined_ir_func_1(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) [[ATTR:#[0-9]+]] {
+; CHECK: define internal void @outlined_ir_func_1(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) [[ATTR:#[0-9]+]] {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK: attributes [[ATTR1]] = { minsize optsize "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "unsafe-fp-math"="false" }
diff --git a/llvm/test/Transforms/IROutliner/outlining-compatible-or-attribute-transfer.ll b/llvm/test/Transforms/IROutliner/outlining-compatible-or-attribute-transfer.ll
index d5db0335284a9..a8c5ed1d85b08 100644
--- a/llvm/test/Transforms/IROutliner/outlining-compatible-or-attribute-transfer.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-compatible-or-attribute-transfer.ll
@@ -15,19 +15,19 @@ define void @outline_attrs1() #0 {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -37,31 +37,31 @@ define void @outline_attrs2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
attributes #0 = { "no-jump-tables"="true" "profile-sample-accurate"="true" "speculative_load_hardening" "noimplicitfloat"="true" "use-sample-profile"="true"}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) [[ATTR:#[0-9]+]] {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) [[ATTR:#[0-9]+]] {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK: attributes [[ATTR]] = { minsize optsize "no-jump-tables"="true" "noimplicitfloat"="true" "profile-sample-accurate"="true" "speculative_load_hardening" "use-sample-profile"="true" }
diff --git a/llvm/test/Transforms/IROutliner/outlining-constants-vs-registers.ll b/llvm/test/Transforms/IROutliner/outlining-constants-vs-registers.ll
index 2fba23896f8aa..a5a163ac548b4 100644
--- a/llvm/test/Transforms/IROutliner/outlining-constants-vs-registers.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-constants-vs-registers.ll
@@ -15,24 +15,24 @@ define void @function_registers_first(i32 %0, i32 %1, i32 %2) {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[TMP0:%.*]], i32* [[A]], i32 [[TMP1:%.*]], i32* [[B]], i32 [[TMP2:%.*]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[TMP0:%.*]], ptr [[A]], i32 [[TMP1:%.*]], ptr [[B]], i32 [[TMP2:%.*]], ptr [[C]])
; CHECK-NEXT: ret void
; CHECK: next:
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 2, i32* [[A]], i32 3, i32* [[B]], i32 4, i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 2, ptr [[A]], i32 3, ptr [[B]], i32 4, ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 %0, i32* %a, align 4
- store i32 %1, i32* %b, align 4
- store i32 %2, i32* %c, align 4
+ store i32 %0, ptr %a, align 4
+ store i32 %1, ptr %b, align 4
+ store i32 %2, ptr %c, align 4
ret void
next:
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
ret void
}
@@ -42,9 +42,9 @@ define void @function_with_constants_first(i32 %0, i32 %1, i32 %2) {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
; CHECK-NEXT: call void @outlined_ir_func_0(i32 2, i32 [[AL]], i32 3, i32 [[BL]], i32 4, i32 [[CL]])
; CHECK-NEXT: ret void
; CHECK: next:
@@ -55,9 +55,9 @@ entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
%3 = add i32 2, %al
%4 = add i32 3, %bl
%5 = add i32 4, %cl
@@ -75,8 +75,8 @@ next:
; CHECK-NEXT: add i32 [[ARG2]], [[ARG3]]
; CHECK-NEXT: add i32 [[ARG4]], [[ARG5]]
-; CHECK: define internal void @outlined_ir_func_1(i32 [[ARG0:%.*]], i32* [[ARG1:%.*]], i32 [[ARG2:%.*]], i32* [[ARG3:%.*]], i32 [[ARG4:%.*]], i32* [[ARG5:%.*]])
+; CHECK: define internal void @outlined_ir_func_1(i32 [[ARG0:%.*]], ptr [[ARG1:%.*]], i32 [[ARG2:%.*]], ptr [[ARG3:%.*]], i32 [[ARG4:%.*]], ptr [[ARG5:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 [[ARG0]], i32* [[ARG1]]
-; CHECK-NEXT: store i32 [[ARG2]], i32* [[ARG3]]
-; CHECK-NEXT: store i32 [[ARG4]], i32* [[ARG5]]
+; CHECK-NEXT: store i32 [[ARG0]], ptr [[ARG1]]
+; CHECK-NEXT: store i32 [[ARG2]], ptr [[ARG3]]
+; CHECK-NEXT: store i32 [[ARG4]], ptr [[ARG5]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-cost-model.ll b/llvm/test/Transforms/IROutliner/outlining-cost-model.ll
index 27453b90562cb..81bf4f09a70d7 100644
--- a/llvm/test/Transforms/IROutliner/outlining-cost-model.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-cost-model.ll
@@ -12,21 +12,21 @@ define void @function1() #0 {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
; NOCOST-LABEL: @function1(
; NOCOST-NEXT: entry:
; NOCOST-NEXT: [[A:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[B:%.*]] = alloca i32, align 4
-; NOCOST-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; NOCOST-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; NOCOST-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%mul = mul i32 %0, %1
%sub = sub i32 %0, %1
@@ -47,21 +47,21 @@ define void @function2() #0 {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
; NOCOST-LABEL: @function2(
; NOCOST-NEXT: entry:
; NOCOST-NEXT: [[A:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[B:%.*]] = alloca i32, align 4
-; NOCOST-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; NOCOST-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; NOCOST-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%mul = mul i32 %0, %1
%sub = sub i32 %0, %1
@@ -84,16 +84,16 @@ define void @function3() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[B]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
-; CHECK-NEXT: store i32 [[ADD]], i32* [[OUTPUT]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[OUTPUT]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[OUTPUT]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[OUTPUT]], align 4
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TMP2]], [[ADD]]
-; CHECK-NEXT: store i32 [[MUL]], i32* [[RESULT]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[RESULT]], align 4
; CHECK-NEXT: ret void
;
; NOCOST-LABEL: @function3(
@@ -104,17 +104,15 @@ define void @function3() #0 {
; NOCOST-NEXT: [[B:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; NOCOST-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; NOCOST-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; NOCOST-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; NOCOST-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; NOCOST-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; NOCOST-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; NOCOST-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; NOCOST-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; NOCOST-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; NOCOST-NEXT: [[TMP0:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; NOCOST-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; NOCOST-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; NOCOST-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; NOCOST-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; NOCOST-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; NOCOST-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; NOCOST-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; NOCOST-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; NOCOST-NEXT: [[TMP0:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; NOCOST-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; NOCOST-NEXT: ret void
;
entry:
@@ -122,16 +120,16 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -142,15 +140,15 @@ define void @function4() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[B]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
-; CHECK-NEXT: store i32 [[ADD]], i32* [[OUTPUT]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[OUTPUT]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[OUTPUT]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[OUTPUT]], align 4
; CHECK-NEXT: [[MUL:%.*]] = mul i32 [[TMP2]], [[ADD]]
-; CHECK-NEXT: store i32 [[MUL]], i32* [[RESULT]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[RESULT]], align 4
; CHECK-NEXT: ret void
;
; NOCOST-LABEL: @function4(
@@ -161,16 +159,14 @@ define void @function4() #0 {
; NOCOST-NEXT: [[B:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; NOCOST-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; NOCOST-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; NOCOST-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; NOCOST-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; NOCOST-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; NOCOST-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; NOCOST-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; NOCOST-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; NOCOST-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; NOCOST-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; NOCOST-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; NOCOST-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; NOCOST-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; NOCOST-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; NOCOST-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; NOCOST-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; NOCOST-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; NOCOST-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; NOCOST-NEXT: call void @outlined_ir_func_2(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; NOCOST-NEXT: ret void
;
entry:
@@ -178,14 +174,14 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/outlining-debug-statements.ll b/llvm/test/Transforms/IROutliner/outlining-debug-statements.ll
index c18153e91de87..f932788c73e2a 100644
--- a/llvm/test/Transforms/IROutliner/outlining-debug-statements.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-debug-statements.ll
@@ -10,20 +10,20 @@ define void @outline_dbg1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
call void @llvm.dbg.value(metadata i64 0, metadata !14, metadata !DIExpression()), !dbg !14
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -35,30 +35,30 @@ define void @outline_dbg2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) #1 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]]) #1 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
!0 = !DIFile(filename: "foo.c", directory: "/tmp")
!1 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
diff --git a/llvm/test/Transforms/IROutliner/outlining-
diff erent-constants.ll b/llvm/test/Transforms/IROutliner/outlining-
diff erent-constants.ll
index 421d802af65b7..1d887b330d78d 100644
--- a/llvm/test/Transforms/IROutliner/outlining-
diff erent-constants.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-
diff erent-constants.ll
@@ -10,19 +10,19 @@ define void @outline_constants1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 3, i32* [[A]], i32 4, i32* [[B]], i32 5, i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 3, ptr [[A]], i32 4, ptr [[B]], i32 5, ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 3, i32* %a, align 4
- store i32 4, i32* %b, align 4
- store i32 5, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 3, ptr %a, align 4
+ store i32 4, ptr %b, align 4
+ store i32 5, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -32,27 +32,27 @@ define void @outline_constants2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 2, i32* [[A]], i32 3, i32* [[B]], i32 4, i32* [[C]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 2, ptr [[A]], i32 3, ptr [[B]], i32 4, ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32 [[ARG0:%.*]], i32* [[ARG1:%.*]], i32 [[ARG2:%.*]], i32* [[ARG3:%.*]], i32 [[ARG4:%.*]], i32* [[ARG5:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_0(i32 [[ARG0:%.*]], ptr [[ARG1:%.*]], i32 [[ARG2:%.*]], ptr [[ARG3:%.*]], i32 [[ARG4:%.*]], ptr [[ARG5:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 [[ARG0]], i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 [[ARG2]], i32* [[ARG3]], align 4
-; CHECK-NEXT: store i32 [[ARG4]], i32* [[ARG5]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG3]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG5]], align 4
+; CHECK-NEXT: store i32 [[ARG0]], ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 [[ARG2]], ptr [[ARG3]], align 4
+; CHECK-NEXT: store i32 [[ARG4]], ptr [[ARG5]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG3]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG5]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-
diff erent-globals.ll b/llvm/test/Transforms/IROutliner/outlining-
diff erent-globals.ll
index ff30b67096df3..c4463be4b627f 100644
--- a/llvm/test/Transforms/IROutliner/outlining-
diff erent-globals.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-
diff erent-globals.ll
@@ -12,12 +12,12 @@
define void @outline_globals1() {
; CHECK-LABEL: @outline_globals1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* @global1, i32* @global2)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr @global1, ptr @global2)
; CHECK-NEXT: ret void
;
entry:
- %0 = load i32, i32* @global1
- %1 = load i32, i32* @global2
+ %0 = load i32, ptr @global1
+ %1 = load i32, ptr @global2
%2 = add i32 %0, %1
ret void
}
@@ -25,18 +25,18 @@ entry:
define void @outline_globals2() {
; CHECK-LABEL: @outline_globals2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* @global3, i32* @global4)
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr @global3, ptr @global4)
; CHECK-NEXT: ret void
;
entry:
- %0 = load i32, i32* @global3
- %1 = load i32, i32* @global4
+ %0 = load i32, ptr @global3
+ %1 = load i32, ptr @global4
%2 = add i32 %0, %1
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]])
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ARG0]]
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARG1]]
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[ARG0]]
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[ARG1]]
; CHECK-NEXT: [[TMP2:%.*]] = add i32 [[TMP0]], [[TMP1]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-
diff erent-output-blocks.ll b/llvm/test/Transforms/IROutliner/outlining-
diff erent-output-blocks.ll
index 2a7b27c4778be..2e1fae352cd44 100644
--- a/llvm/test/Transforms/IROutliner/outlining-
diff erent-output-blocks.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-
diff erent-output-blocks.ll
@@ -14,17 +14,15 @@ define void @outline_outputs1() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]], i32 0)
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]], i32 0)
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -32,17 +30,17 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%sub = sub i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -55,16 +53,14 @@ define void @outline_outputs2() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[SUB_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[SUB_LOC]], i32* [[DOTLOC]], i32 1)
-; CHECK-NEXT: [[SUB_RELOAD:%.*]] = load i32, i32* [[SUB_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[SUB_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[SUB_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[SUB_LOC]], ptr [[DOTLOC]], i32 1)
+; CHECK-NEXT: [[SUB_RELOAD:%.*]] = load i32, ptr [[SUB_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[SUB_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[SUB_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -72,29 +68,29 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
%sub = sub i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
%mul = mul i32 %2, %sub
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]], i32* [[ARG3:%.*]], i32* [[ARG4:%.*]], i32 [[ARG5:%.*]]) #1 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]], i32 [[ARG5:%.*]]) #1 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARG1]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[ARG1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
; CHECK-NEXT: [[SUB:%.*]] = sub i32 [[TMP0]], [[TMP1]]
-; CHECK-NEXT: store i32 [[ADD]], i32* [[ARG2]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[ARG2]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK: _after_outline.exitStub:
; CHECK-NEXT: switch i32 [[ARG5]], label [[BLOCK:%.*]] [
@@ -102,9 +98,9 @@ entry:
; CHECK-NEXT: i32 1, label %[[BLOCK_1:.*]]
; CHECK: [[BLOCK_0]]:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[ARG3]], align 4
-; CHECK-NEXT: store i32 [[TMP2]], i32* [[ARG4]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[ARG3]], align 4
+; CHECK-NEXT: store i32 [[TMP2]], ptr [[ARG4]], align 4
; CHECK: [[BLOCK_1]]:
-; CHECK-NEXT: store i32 [[SUB]], i32* [[ARG3]], align 4
-; CHECK-NEXT: store i32 [[TMP2]], i32* [[ARG4]], align 4
+; CHECK-NEXT: store i32 [[SUB]], ptr [[ARG3]], align 4
+; CHECK-NEXT: store i32 [[TMP2]], ptr [[ARG4]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-
diff erent-structure.ll b/llvm/test/Transforms/IROutliner/outlining-
diff erent-structure.ll
index 3d161f7ee5830..45b33daa8e6c9 100644
--- a/llvm/test/Transforms/IROutliner/outlining-
diff erent-structure.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-
diff erent-structure.ll
@@ -11,22 +11,22 @@ define void @outline_constants1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: call void @[[FUNCTION_0:.*]](i32* [[A]], i32* [[C]], i32* [[B]])
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: call void @[[FUNCTION_0:.*]](ptr [[A]], ptr [[C]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %cl = load i32, i32* %c
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %cl = load i32, ptr %c
+ %bl = load i32, ptr %b
ret void
}
@@ -36,27 +36,27 @@ define void @outline_constants2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: call void @[[FUNCTION_0]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: call void @[[FUNCTION_0]](ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @[[FUNCTION_0]](i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: define internal void @[[FUNCTION_0]](ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-exits-to-phi-node.ll b/llvm/test/Transforms/IROutliner/outlining-exits-to-phi-node.ll
index e58bebbb4cecf..cb5d5057182a4 100644
--- a/llvm/test/Transforms/IROutliner/outlining-exits-to-phi-node.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-exits-to-phi-node.ll
@@ -4,16 +4,16 @@
; Show that we do not extract similar regions that would involve the splitting
; of phi nodes on exit.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
dummy:
ret void
@@ -22,16 +22,16 @@ first:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
dummy:
ret void
@@ -43,11 +43,10 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]])
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -60,11 +59,10 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]])
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -77,18 +75,18 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST_SPLIT:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST_SPLIT]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[C]], [[TEST:%.*]] ], [ [[E]], [[TEST1]] ]
; CHECK-NEXT: br label [[FIRST_EXITSTUB:%.*]]
; CHECK: first.exitStub:
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-gep.ll b/llvm/test/Transforms/IROutliner/outlining-gep.ll
index 3558e47b06cf8..78e2e19a4b788 100644
--- a/llvm/test/Transforms/IROutliner/outlining-gep.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-gep.ll
@@ -8,61 +8,61 @@
%struct.RT = type { i8, [10 x [20 x i32]], i8 }
%struct.ST = type { i32, double, %struct.RT }
-define void @function1(%struct.ST* %s, i64 %t) {
+define void @function1(ptr %s, i64 %t) {
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], %struct.ST* [[S:%.*]], i64 [[T:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[S:%.*]], i64 [[T:%.*]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 %t, i32 1
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = getelementptr inbounds %struct.ST, ptr %s, i64 %t, i32 1
ret void
}
-define void @function2(%struct.ST* %s, i64 %t) {
+define void @function2(ptr %s, i64 %t) {
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], %struct.ST* [[S:%.*]], i64 [[T:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[S:%.*]], i64 [[T:%.*]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 %t, i32 1
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = getelementptr inbounds %struct.ST, ptr %s, i64 %t, i32 1
ret void
}
-define void @function3(%struct.ST* %s, i64 %t) {
+define void @function3(ptr %s, i64 %t) {
; CHECK-LABEL: @function3(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S:%.*]], i64 [[T:%.*]], i32 0
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], ptr [[S:%.*]], i64 [[T:%.*]], i32 0
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 %t, i32 0
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = getelementptr inbounds %struct.ST, ptr %s, i64 %t, i32 0
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], %struct.ST* [[ARG2:%.*]], i64 [[ARG3:%.*]])
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], i64 [[ARG3:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds %struct.ST, %struct.ST* [[ARG2]], i64 [[ARG3]], i32 1
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds %struct.ST, ptr [[ARG2]], i64 [[ARG3]], i32 1
diff --git a/llvm/test/Transforms/IROutliner/outlining-isomorphic-predicates.ll b/llvm/test/Transforms/IROutliner/outlining-isomorphic-predicates.ll
index d19ba6615a544..2fe807e5d30c9 100644
--- a/llvm/test/Transforms/IROutliner/outlining-isomorphic-predicates.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-isomorphic-predicates.ll
@@ -13,16 +13,16 @@ define void @outline_slt1() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp slt i32 %al, %bl
ret void
}
@@ -32,16 +32,16 @@ define void @outline_slt2() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp slt i32 %al, %bl
ret void
}
@@ -51,16 +51,16 @@ define void @outline_sgt() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_1(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp sgt i32 %bl, %al
ret void
}
@@ -73,20 +73,20 @@ define void @dontoutline_sgt() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = icmp sgt i32 [[AL]], [[BL]]
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp sgt i32 %al, %bl
ret void
}
@@ -101,16 +101,16 @@ define void @outline_ugt1() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp ugt i32 %al, %bl
ret void
}
@@ -120,16 +120,16 @@ define void @outline_ugt2() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp ugt i32 %al, %bl
ret void
}
@@ -139,32 +139,32 @@ define void @outline_ult() {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
%0 = icmp ult i32 %bl, %al
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = icmp ugt i32 [[AL]], [[BL]]
-; CHECK: define internal void @outlined_ir_func_1(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]]) #0 {
+; CHECK: define internal void @outlined_ir_func_1(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]]) #0 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
; CHECK-NEXT: [[TMP0:%.*]] = icmp slt i32 [[AL]], [[BL]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-multiple-exits-
diff -outputs.ll b/llvm/test/Transforms/IROutliner/outlining-multiple-exits-
diff -outputs.ll
index 5b01eb097267b..463e097cd2f29 100644
--- a/llvm/test/Transforms/IROutliner/outlining-multiple-exits-
diff -outputs.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-multiple-exits-
diff -outputs.ll
@@ -18,24 +18,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_6
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_7
block_6:
%div = udiv i32 %aval, %bval
@@ -59,24 +59,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_7
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_6
block_6:
%
diff = sub i32 %a2val, %b2val
@@ -103,23 +103,19 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[A2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[B2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[AVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[LT_CAST3:%.*]] = bitcast i32* [[BVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST3]])
-; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[A2VAL_LOC]], i32* [[B2VAL_LOC]], i32* [[AVAL_LOC]], i32* [[BVAL_LOC]], i32 0)
-; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, i32* [[A2VAL_LOC]], align 4
-; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, i32* [[B2VAL_LOC]], align 4
-; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, i32* [[AVAL_LOC]], align 4
-; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, i32* [[BVAL_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST3]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[BVAL_LOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[A2VAL_LOC]], ptr [[B2VAL_LOC]], ptr [[AVAL_LOC]], ptr [[BVAL_LOC]], i32 0)
+; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, ptr [[A2VAL_LOC]], align 4
+; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, ptr [[B2VAL_LOC]], align 4
+; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, ptr [[AVAL_LOC]], align 4
+; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, ptr [[BVAL_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[BVAL_LOC]])
; CHECK-NEXT: br i1 [[TMP0]], label [[BLOCK_6:%.*]], label [[BLOCK_7:%.*]]
; CHECK: block_6:
; CHECK-NEXT: [[DIV:%.*]] = udiv i32 [[AVAL_RELOAD]], [[BVAL_RELOAD]]
@@ -147,23 +143,19 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[A2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[B2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[LT_CAST3:%.*]] = bitcast i32* [[MUL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST3]])
-; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[A2VAL_LOC]], i32* [[B2VAL_LOC]], i32* [[ADD_LOC]], i32* [[MUL_LOC]], i32 1)
-; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, i32* [[A2VAL_LOC]], align 4
-; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, i32* [[B2VAL_LOC]], align 4
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[MUL_RELOAD:%.*]] = load i32, i32* [[MUL_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST3]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[MUL_LOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[A2VAL_LOC]], ptr [[B2VAL_LOC]], ptr [[ADD_LOC]], ptr [[MUL_LOC]], i32 1)
+; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, ptr [[A2VAL_LOC]], align 4
+; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, ptr [[B2VAL_LOC]], align 4
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[MUL_RELOAD:%.*]] = load i32, ptr [[MUL_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[MUL_LOC]])
; CHECK-NEXT: br i1 [[TMP0]], label [[BLOCK_7:%.*]], label [[BLOCK_6:%.*]]
; CHECK: block_6:
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[A2VAL_RELOAD]], [[B2VAL_RELOAD]]
@@ -177,24 +169,24 @@ block_7:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[BLOCK_2_TO_OUTLINE:%.*]]
; CHECK: block_2_to_outline:
-; CHECK-NEXT: [[A2VAL:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: [[B2VAL:%.*]] = load i32, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: [[A2VAL:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[B2VAL:%.*]] = load i32, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: [[ADD2:%.*]] = add i32 2, [[A2VAL]]
; CHECK-NEXT: [[MUL2:%.*]] = mul i32 2, [[B2VAL]]
; CHECK-NEXT: br label [[BLOCK_5:%.*]]
; CHECK: block_3:
-; CHECK-NEXT: [[AVAL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BVAL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[AVAL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BVAL:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 2, [[AVAL]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 2, [[BVAL]]
; CHECK-NEXT: br label [[BLOCK_4:%.*]]
; CHECK: block_4:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[BLOCK_6_EXITSTUB:%.*]]
; CHECK: block_5:
-; CHECK-NEXT: store i32 [[ADD2]], i32* [[TMP2]], align 4
-; CHECK-NEXT: store i32 [[MUL2]], i32* [[TMP3]], align 4
+; CHECK-NEXT: store i32 [[ADD2]], ptr [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[MUL2]], ptr [[TMP3]], align 4
; CHECK-NEXT: br label [[BLOCK_7_EXITSTUB:%.*]]
; CHECK: block_6.exitStub:
; CHECK-NEXT: switch i32 [[TMP8:%.*]], label [[FINAL_BLOCK_1:%.*]] [
@@ -207,20 +199,20 @@ block_7:
; CHECK-NEXT: i32 1, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_0_0:
-; CHECK-NEXT: store i32 [[A2VAL]], i32* [[TMP4:%.*]], align 4
-; CHECK-NEXT: store i32 [[B2VAL]], i32* [[TMP5:%.*]], align 4
+; CHECK-NEXT: store i32 [[A2VAL]], ptr [[TMP4:%.*]], align 4
+; CHECK-NEXT: store i32 [[B2VAL]], ptr [[TMP5:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_0_1:
-; CHECK-NEXT: store i32 [[AVAL]], i32* [[TMP6:%.*]], align 4
-; CHECK-NEXT: store i32 [[BVAL]], i32* [[TMP7:%.*]], align 4
+; CHECK-NEXT: store i32 [[AVAL]], ptr [[TMP6:%.*]], align 4
+; CHECK-NEXT: store i32 [[BVAL]], ptr [[TMP7:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[A2VAL]], i32* [[TMP4]], align 4
-; CHECK-NEXT: store i32 [[B2VAL]], i32* [[TMP5]], align 4
+; CHECK-NEXT: store i32 [[A2VAL]], ptr [[TMP4]], align 4
+; CHECK-NEXT: store i32 [[B2VAL]], ptr [[TMP5]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_1_1:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP6]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP7]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP6]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP7]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: final_block_0:
; CHECK-NEXT: ret i1 false
diff --git a/llvm/test/Transforms/IROutliner/outlining-multiple-exits-one-output-set.ll b/llvm/test/Transforms/IROutliner/outlining-multiple-exits-one-output-set.ll
index 5593ecf0df6a9..5293647ad6c4c 100644
--- a/llvm/test/Transforms/IROutliner/outlining-multiple-exits-one-output-set.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-multiple-exits-one-output-set.ll
@@ -19,24 +19,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_6
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_7
block_6:
ret void
@@ -58,24 +58,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_7
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_6
block_6:
%
diff = sub i32 %a2val, %b2val
@@ -98,7 +98,7 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* null, i32* null, i32* null, i32* null, i32 -1)
+; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr null, ptr null, ptr null, ptr null, i32 -1)
; CHECK-NEXT: br i1 [[TMP0]], label [[BLOCK_6:%.*]], label [[BLOCK_7:%.*]]
; CHECK: block_6:
; CHECK-NEXT: ret void
@@ -124,23 +124,19 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[A2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[B2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[LT_CAST3:%.*]] = bitcast i32* [[MUL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST3]])
-; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[A2VAL_LOC]], i32* [[B2VAL_LOC]], i32* [[ADD_LOC]], i32* [[MUL_LOC]], i32 0)
-; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, i32* [[A2VAL_LOC]], align 4
-; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, i32* [[B2VAL_LOC]], align 4
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[MUL_RELOAD:%.*]] = load i32, i32* [[MUL_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST3]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[MUL_LOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[A2VAL_LOC]], ptr [[B2VAL_LOC]], ptr [[ADD_LOC]], ptr [[MUL_LOC]], i32 0)
+; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, ptr [[A2VAL_LOC]], align 4
+; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, ptr [[B2VAL_LOC]], align 4
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[MUL_RELOAD:%.*]] = load i32, ptr [[MUL_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[MUL_LOC]])
; CHECK-NEXT: br i1 [[TMP0]], label [[BLOCK_7:%.*]], label [[BLOCK_6:%.*]]
; CHECK: block_6:
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[A2VAL_RELOAD]], [[B2VAL_RELOAD]]
@@ -154,24 +150,24 @@ block_7:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[BLOCK_2_TO_OUTLINE:%.*]]
; CHECK: block_2_to_outline:
-; CHECK-NEXT: [[A2VAL:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: [[B2VAL:%.*]] = load i32, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: [[A2VAL:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[B2VAL:%.*]] = load i32, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: [[ADD2:%.*]] = add i32 2, [[A2VAL]]
; CHECK-NEXT: [[MUL2:%.*]] = mul i32 2, [[B2VAL]]
; CHECK-NEXT: br label [[BLOCK_5:%.*]]
; CHECK: block_3:
-; CHECK-NEXT: [[AVAL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BVAL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[AVAL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BVAL:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 2, [[AVAL]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 2, [[BVAL]]
; CHECK-NEXT: br label [[BLOCK_4:%.*]]
; CHECK: block_4:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[BLOCK_6_EXITSTUB:%.*]]
; CHECK: block_5:
-; CHECK-NEXT: store i32 [[ADD2]], i32* [[TMP2]], align 4
-; CHECK-NEXT: store i32 [[MUL2]], i32* [[TMP3]], align 4
+; CHECK-NEXT: store i32 [[ADD2]], ptr [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[MUL2]], ptr [[TMP3]], align 4
; CHECK-NEXT: br label [[BLOCK_7_EXITSTUB:%.*]]
; CHECK: block_6.exitStub:
; CHECK-NEXT: switch i32 [[TMP8:%.*]], label [[FINAL_BLOCK_1:%.*]] [
@@ -182,12 +178,12 @@ block_7:
; CHECK-NEXT: i32 0, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[A2VAL]], i32* [[TMP4:%.*]], align 4
-; CHECK-NEXT: store i32 [[B2VAL]], i32* [[TMP5:%.*]], align 4
+; CHECK-NEXT: store i32 [[A2VAL]], ptr [[TMP4:%.*]], align 4
+; CHECK-NEXT: store i32 [[B2VAL]], ptr [[TMP5:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: output_block_1_1:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP6:%.*]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP7:%.*]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP6:%.*]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP7:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: final_block_0:
; CHECK-NEXT: ret i1 false
diff --git a/llvm/test/Transforms/IROutliner/outlining-multiple-exits.ll b/llvm/test/Transforms/IROutliner/outlining-multiple-exits.ll
index 210aea7e2b5de..663e6d865b64a 100644
--- a/llvm/test/Transforms/IROutliner/outlining-multiple-exits.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-multiple-exits.ll
@@ -19,24 +19,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_6
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_7
block_6:
%div = udiv i32 %aval, %bval
@@ -60,24 +60,24 @@ block_1:
%b2 = alloca i32, align 4
br label %block_2
block_2:
- %a2val = load i32, i32* %a
- %b2val = load i32, i32* %b
+ %a2val = load i32, ptr %a
+ %b2val = load i32, ptr %b
%add2 = add i32 2, %a2val
%mul2 = mul i32 2, %b2val
br label %block_5
block_3:
- %aval = load i32, i32* %a
- %bval = load i32, i32* %b
+ %aval = load i32, ptr %a
+ %bval = load i32, ptr %b
%add = add i32 2, %aval
%mul = mul i32 2, %bval
br label %block_4
block_4:
- store i32 %add, i32* %output, align 4
- store i32 %mul, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 %mul, ptr %result, align 4
br label %block_7
block_5:
- store i32 %add2, i32* %output, align 4
- store i32 %mul2, i32* %result, align 4
+ store i32 %add2, ptr %output, align 4
+ store i32 %mul2, ptr %result, align 4
br label %block_6
block_6:
%
diff = sub i32 %a2val, %b2val
@@ -104,23 +104,19 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[A2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[B2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[AVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[LT_CAST3:%.*]] = bitcast i32* [[BVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST3]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[A2VAL_LOC]], i32* [[B2VAL_LOC]], i32* [[AVAL_LOC]], i32* [[BVAL_LOC]])
-; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, i32* [[A2VAL_LOC]], align 4
-; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, i32* [[B2VAL_LOC]], align 4
-; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, i32* [[AVAL_LOC]], align 4
-; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, i32* [[BVAL_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST3]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[BVAL_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[A2VAL_LOC]], ptr [[B2VAL_LOC]], ptr [[AVAL_LOC]], ptr [[BVAL_LOC]])
+; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, ptr [[A2VAL_LOC]], align 4
+; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, ptr [[B2VAL_LOC]], align 4
+; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, ptr [[AVAL_LOC]], align 4
+; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, ptr [[BVAL_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[BVAL_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[BLOCK_6:%.*]], label [[BLOCK_7:%.*]]
; CHECK: block_6:
; CHECK-NEXT: [[DIV:%.*]] = udiv i32 [[AVAL_RELOAD]], [[BVAL_RELOAD]]
@@ -148,23 +144,19 @@ block_7:
; CHECK-NEXT: [[B2:%.*]] = alloca i32, align 4
; CHECK-NEXT: br label [[BLOCK_2]]
; CHECK: block_2:
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[A2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[B2VAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[LT_CAST2:%.*]] = bitcast i32* [[AVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: [[LT_CAST3:%.*]] = bitcast i32* [[BVAL_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST3]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[A2VAL_LOC]], i32* [[B2VAL_LOC]], i32* [[AVAL_LOC]], i32* [[BVAL_LOC]])
-; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, i32* [[A2VAL_LOC]], align 4
-; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, i32* [[B2VAL_LOC]], align 4
-; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, i32* [[AVAL_LOC]], align 4
-; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, i32* [[BVAL_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST2]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST3]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[BVAL_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[A2VAL_LOC]], ptr [[B2VAL_LOC]], ptr [[AVAL_LOC]], ptr [[BVAL_LOC]])
+; CHECK-NEXT: [[A2VAL_RELOAD:%.*]] = load i32, ptr [[A2VAL_LOC]], align 4
+; CHECK-NEXT: [[B2VAL_RELOAD:%.*]] = load i32, ptr [[B2VAL_LOC]], align 4
+; CHECK-NEXT: [[AVAL_RELOAD:%.*]] = load i32, ptr [[AVAL_LOC]], align 4
+; CHECK-NEXT: [[BVAL_RELOAD:%.*]] = load i32, ptr [[BVAL_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[A2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[B2VAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[AVAL_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[BVAL_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[BLOCK_7:%.*]], label [[BLOCK_6:%.*]]
; CHECK: block_6:
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[A2VAL_RELOAD]], [[B2VAL_RELOAD]]
@@ -178,31 +170,31 @@ block_7:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[BLOCK_2_TO_OUTLINE:%.*]]
; CHECK: block_2_to_outline:
-; CHECK-NEXT: [[A2VAL:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: [[B2VAL:%.*]] = load i32, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: [[A2VAL:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[B2VAL:%.*]] = load i32, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: [[ADD2:%.*]] = add i32 2, [[A2VAL]]
; CHECK-NEXT: [[MUL2:%.*]] = mul i32 2, [[B2VAL]]
; CHECK-NEXT: br label [[BLOCK_5:%.*]]
; CHECK: block_3:
-; CHECK-NEXT: [[AVAL:%.*]] = load i32, i32* [[TMP0]], align 4
-; CHECK-NEXT: [[BVAL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT: [[AVAL:%.*]] = load i32, ptr [[TMP0]], align 4
+; CHECK-NEXT: [[BVAL:%.*]] = load i32, ptr [[TMP1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 2, [[AVAL]]
; CHECK-NEXT: [[MUL:%.*]] = mul i32 2, [[BVAL]]
; CHECK-NEXT: br label [[BLOCK_4:%.*]]
; CHECK: block_4:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[TMP2:%.*]], align 4
-; CHECK-NEXT: store i32 [[MUL]], i32* [[TMP3:%.*]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[MUL]], ptr [[TMP3:%.*]], align 4
; CHECK-NEXT: br label [[BLOCK_6_EXITSTUB:%.*]]
; CHECK: block_5:
-; CHECK-NEXT: store i32 [[ADD2]], i32* [[TMP2]], align 4
-; CHECK-NEXT: store i32 [[MUL2]], i32* [[TMP3]], align 4
+; CHECK-NEXT: store i32 [[ADD2]], ptr [[TMP2]], align 4
+; CHECK-NEXT: store i32 [[MUL2]], ptr [[TMP3]], align 4
; CHECK-NEXT: br label [[BLOCK_7_EXITSTUB:%.*]]
; CHECK: block_6.exitStub:
-; CHECK-NEXT: store i32 [[AVAL]], i32* [[TMP6:%.*]], align 4
-; CHECK-NEXT: store i32 [[BVAL]], i32* [[TMP7:%.*]], align 4
+; CHECK-NEXT: store i32 [[AVAL]], ptr [[TMP6:%.*]], align 4
+; CHECK-NEXT: store i32 [[BVAL]], ptr [[TMP7:%.*]], align 4
; CHECK-NEXT: ret i1 true
; CHECK: block_7.exitStub:
-; CHECK-NEXT: store i32 [[A2VAL]], i32* [[TMP4:%.*]], align 4
-; CHECK-NEXT: store i32 [[B2VAL]], i32* [[TMP5:%.*]], align 4
+; CHECK-NEXT: store i32 [[A2VAL]], ptr [[TMP4:%.*]], align 4
+; CHECK-NEXT: store i32 [[B2VAL]], ptr [[TMP5:%.*]], align 4
; CHECK-NEXT: ret i1 false
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-musttail.ll b/llvm/test/Transforms/IROutliner/outlining-musttail.ll
index bf2569c779845..39f48a096c170 100644
--- a/llvm/test/Transforms/IROutliner/outlining-musttail.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-musttail.ll
@@ -8,27 +8,27 @@ declare void @musttail()
define void @f1() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call void @musttail()
ret void
}
define void @f2() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call void @musttail()
ret void
}
; CHECK-LABEL: @f1(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call void @musttail()
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @f2(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call void @musttail()
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-odr.ll b/llvm/test/Transforms/IROutliner/outlining-odr.ll
index 9b58e1dbebd49..6d6277ab6424d 100644
--- a/llvm/test/Transforms/IROutliner/outlining-odr.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-odr.ll
@@ -11,29 +11,29 @@ define linkonce_odr void @outline_odr1() {
; ODR-NEXT: [[A:%.*]] = alloca i32, align 4
; ODR-NEXT: [[B:%.*]] = alloca i32, align 4
; ODR-NEXT: [[C:%.*]] = alloca i32, align 4
-; ODR-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; ODR-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; ODR-NEXT: ret void
; CHECK-LABEL: @outline_odr1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -43,28 +43,28 @@ define void @outline_odr2() {
; ODR-NEXT: [[A:%.*]] = alloca i32, align 4
; ODR-NEXT: [[B:%.*]] = alloca i32, align 4
; ODR-NEXT: [[C:%.*]] = alloca i32, align 4
-; ODR-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
+; ODR-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[C]])
; ODR-NEXT: ret void
; CHECK-LABEL: @outline_odr2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
-; CHECK-NEXT: store i32 3, i32* [[B]], align 4
-; CHECK-NEXT: store i32 4, i32* [[C]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[A]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[B]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[C]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
+; CHECK-NEXT: store i32 3, ptr [[B]], align 4
+; CHECK-NEXT: store i32 4, ptr [[C]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[B]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[C]], align 4
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/outlining-remapped-outputs.ll b/llvm/test/Transforms/IROutliner/outlining-remapped-outputs.ll
index d4e76014efc2e..6d0b15394f330 100644
--- a/llvm/test/Transforms/IROutliner/outlining-remapped-outputs.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-remapped-outputs.ll
@@ -17,29 +17,25 @@ define void @outline_outputs1() #0 {
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT2:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 2, i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 2, ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: br label [[NEXT:%.*]]
; CHECK: next:
-; CHECK-NEXT: [[LT_CAST4:%.*]] = bitcast i32* [[ADD2_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST4]])
-; CHECK-NEXT: [[LT_CAST5:%.*]] = bitcast i32* [[DOTLOC2]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST5]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[ADD_RELOAD]], i32* [[OUTPUT]], i32* [[RESULT]], i32* [[OUTPUT2]], i32* [[ADD2_LOC]], i32* [[DOTLOC2]])
-; CHECK-NEXT: [[ADD2_RELOAD:%.*]] = load i32, i32* [[ADD2_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD3:%.*]] = load i32, i32* [[DOTLOC2]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST4]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST5]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD3]], i32 [[ADD2_RELOAD]], i32* [[RESULT2]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD2_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC2]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i32 [[ADD_RELOAD]], ptr [[OUTPUT]], ptr [[RESULT]], ptr [[OUTPUT2]], ptr [[ADD2_LOC]], ptr [[DOTLOC2]])
+; CHECK-NEXT: [[ADD2_RELOAD:%.*]] = load i32, ptr [[ADD2_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD3:%.*]] = load i32, ptr [[DOTLOC2]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD2_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC2]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD3]], i32 [[ADD2_RELOAD]], ptr [[RESULT2]])
; CHECK-NEXT: ret void
;
entry:
@@ -49,26 +45,26 @@ entry:
%result = alloca i32, align 4
%output2 = alloca i32, align 4
%result2 = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
br label %next
next:
- store i32 %add, i32* %output, align 4
- store i32 3, i32* %result, align 4
- %4 = load i32, i32* %output, align 4
- %5 = load i32, i32* %result, align 4
+ store i32 %add, ptr %output, align 4
+ store i32 3, ptr %result, align 4
+ %4 = load i32, ptr %output, align 4
+ %5 = load i32, ptr %result, align 4
%add2 = add i32 %4, %5
- store i32 %add2, i32* %output2, align 4
- %6 = load i32, i32* %output2, align 4
+ store i32 %add2, ptr %output2, align 4
+ %6 = load i32, ptr %output2, align 4
%mul2 = mul i32 %6, %add2
- store i32 %mul2, i32* %result2, align 4
+ store i32 %mul2, ptr %result2, align 4
ret void
}
diff --git a/llvm/test/Transforms/IROutliner/outlining-same-constants.ll b/llvm/test/Transforms/IROutliner/outlining-same-constants.ll
index 10b18a6b332ff..d2cf221865893 100644
--- a/llvm/test/Transforms/IROutliner/outlining-same-constants.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-same-constants.ll
@@ -10,19 +10,19 @@ define void @outline_constants1() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @[[FUNCTION_0:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @[[FUNCTION_0:.*]](ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
@@ -32,27 +32,27 @@ define void @outline_constants2() {
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @[[FUNCTION_0]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT: call void @[[FUNCTION_0]](ptr [[A]], ptr [[B]], ptr [[C]])
; CHECK-NEXT: ret void
;
entry:
%a = alloca i32, align 4
%b = alloca i32, align 4
%c = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- store i32 4, i32* %c, align 4
- %al = load i32, i32* %a
- %bl = load i32, i32* %b
- %cl = load i32, i32* %c
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ store i32 4, ptr %c, align 4
+ %al = load i32, ptr %a
+ %bl = load i32, ptr %b
+ %cl = load i32, ptr %c
ret void
}
-; CHECK: define internal void @[[FUNCTION_0]](i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: define internal void @[[FUNCTION_0]](ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]])
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: store i32 4, i32* [[ARG2]], align 4
-; CHECK-NEXT: [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: store i32 4, ptr [[ARG2]], align 4
+; CHECK-NEXT: [[AL:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[BL:%.*]] = load i32, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[CL:%.*]] = load i32, ptr [[ARG2]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-same-globals.ll b/llvm/test/Transforms/IROutliner/outlining-same-globals.ll
index d130b54ac65c6..b16d743bbde20 100644
--- a/llvm/test/Transforms/IROutliner/outlining-same-globals.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-same-globals.ll
@@ -14,8 +14,8 @@ define void @outline_globals1() {
; CHECK-NEXT: ret void
;
entry:
- %0 = load i32, i32* @global1
- %1 = load i32, i32* @global2
+ %0 = load i32, ptr @global1
+ %1 = load i32, ptr @global2
%2 = add i32 %0, %1
ret void
}
@@ -27,15 +27,15 @@ define void @outline_globals2() {
; CHECK-NEXT: ret void
;
entry:
- %0 = load i32, i32* @global1
- %1 = load i32, i32* @global2
+ %0 = load i32, ptr @global1
+ %1 = load i32, ptr @global2
%2 = add i32 %0, %1
ret void
}
; CHECK: define internal void @outlined_ir_func_0()
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @global1, align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* @global2, align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr @global1, align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr @global2, align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP1]], [[TMP2]]
diff --git a/llvm/test/Transforms/IROutliner/outlining-same-output-blocks.ll b/llvm/test/Transforms/IROutliner/outlining-same-output-blocks.ll
index 55d58dc5b769b..380c53d1e77e3 100644
--- a/llvm/test/Transforms/IROutliner/outlining-same-output-blocks.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-same-output-blocks.ll
@@ -14,17 +14,15 @@ define void @outline_outputs1() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[OUTPUT]], align 4
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -32,16 +30,16 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
- %3 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
+ %3 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
@@ -54,16 +52,14 @@ define void @outline_outputs2() #0 {
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[OUTPUT:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[RESULT:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[ADD_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[LT_CAST1:%.*]] = bitcast i32* [[DOTLOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[OUTPUT]], i32* [[ADD_LOC]], i32* [[DOTLOC]])
-; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, i32* [[ADD_LOC]], align 4
-; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, i32* [[DOTLOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST1]])
-; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], i32* [[RESULT]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A]], ptr [[B]], ptr [[OUTPUT]], ptr [[ADD_LOC]], ptr [[DOTLOC]])
+; CHECK-NEXT: [[ADD_RELOAD:%.*]] = load i32, ptr [[ADD_LOC]], align 4
+; CHECK-NEXT: [[DOTRELOAD:%.*]] = load i32, ptr [[DOTLOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[ADD_LOC]])
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTLOC]])
+; CHECK-NEXT: call void @outlined_ir_func_1(i32 [[DOTRELOAD]], i32 [[ADD_RELOAD]], ptr [[RESULT]])
; CHECK-NEXT: ret void
;
entry:
@@ -71,28 +67,28 @@ entry:
%b = alloca i32, align 4
%output = alloca i32, align 4
%result = alloca i32, align 4
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
- %0 = load i32, i32* %a, align 4
- %1 = load i32, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
+ %0 = load i32, ptr %a, align 4
+ %1 = load i32, ptr %b, align 4
%add = add i32 %0, %1
- store i32 %add, i32* %output, align 4
- %2 = load i32, i32* %output, align 4
+ store i32 %add, ptr %output, align 4
+ %2 = load i32, ptr %output, align 4
%mul = mul i32 %2, %add
- store i32 %mul, i32* %result, align 4
+ store i32 %mul, ptr %result, align 4
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]], i32* [[ARG3:%.*]], i32* [[ARG4:%.*]]) #1 {
+; CHECK: define internal void @outlined_ir_func_0(ptr [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr [[ARG2:%.*]], ptr [[ARG3:%.*]], ptr [[ARG4:%.*]]) #1 {
; CHECK: entry_to_outline:
-; CHECK-NEXT: store i32 2, i32* [[ARG0]], align 4
-; CHECK-NEXT: store i32 3, i32* [[ARG1]], align 4
-; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* [[ARG0]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[ARG1]], align 4
+; CHECK-NEXT: store i32 2, ptr [[ARG0]], align 4
+; CHECK-NEXT: store i32 3, ptr [[ARG1]], align 4
+; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[ARG0]], align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[ARG1]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
-; CHECK-NEXT: store i32 [[ADD]], i32* [[ARG2]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARG2]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[ARG2]], align 4
+; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARG2]], align 4
; CHECK: entry_after_outline.exitStub:
-; CHECK-NEXT: store i32 [[ADD]], i32* [[ARG3]], align 4
-; CHECK-NEXT: store i32 [[TMP2]], i32* [[ARG4]], align 4
+; CHECK-NEXT: store i32 [[ADD]], ptr [[ARG3]], align 4
+; CHECK-NEXT: store i32 [[TMP2]], ptr [[ARG4]], align 4
diff --git a/llvm/test/Transforms/IROutliner/outlining-swift-error.ll b/llvm/test/Transforms/IROutliner/outlining-swift-error.ll
index 92c4c427bcc79..68a87a1bc3cb4 100644
--- a/llvm/test/Transforms/IROutliner/outlining-swift-error.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-swift-error.ll
@@ -3,45 +3,42 @@
%swift.error = type opaque
-define void @outlining_swifterror1(%swift.error** swifterror %err) {
+define void @outlining_swifterror1(ptr swifterror %err) {
; CHECK-LABEL: @outlining_swifterror1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[X:%.*]] = alloca i64, align 8
-; CHECK-NEXT: call void @outlined_ir_func_0(i64 5, i64* [[X]], %swift.error** swifterror [[ERR:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i64 5, ptr [[X]], ptr swifterror [[ERR:%.*]])
; CHECK-NEXT: ret void
;
entry:
%x = alloca i64
%0 = mul i64 5, 5
%1 = add i64 %0, %0
- store i64 %1, i64* %x
- %casted = bitcast i64* %x to %swift.error*
- store %swift.error* %casted, %swift.error** %err
+ store i64 %1, ptr %x
+ store ptr %x, ptr %err
ret void
}
-define void @outlining_swifterror2(%swift.error** swifterror %err) {
+define void @outlining_swifterror2(ptr swifterror %err) {
; CHECK-LABEL: @outlining_swifterror2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[X:%.*]] = alloca i64, align 8
-; CHECK-NEXT: call void @outlined_ir_func_0(i64 3, i64* [[X]], %swift.error** swifterror [[ERR:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(i64 3, ptr [[X]], ptr swifterror [[ERR:%.*]])
; CHECK-NEXT: ret void
;
entry:
%x = alloca i64
%0 = mul i64 3, 3
%1 = add i64 %0, %0
- store i64 %1, i64* %x
- %casted = bitcast i64* %x to %swift.error*
- store %swift.error* %casted, %swift.error** %err
+ store i64 %1, ptr %x
+ store ptr %x, ptr %err
ret void
}
-; CHECK: define internal void @outlined_ir_func_0(i64 [[ARG0:%.*]], i64* [[ARG1:%.*]], %swift.error** swifterror [[ARG2:%.*]])
+; CHECK: define internal void @outlined_ir_func_0(i64 [[ARG0:%.*]], ptr [[ARG1:%.*]], ptr swifterror [[ARG2:%.*]])
; CHECK: entry_to_outline:
; CHECK-NEXT: [[TMP0:%.*]] = mul i64 [[ARG0]], [[ARG0]]
; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[TMP0]], [[TMP0]]
-; CHECK-NEXT: store i64 [[TMP1]], i64* [[ARG1]], align 4
-; CHECK-NEXT: %casted = bitcast i64* [[ARG1]] to %swift.error*
-; CHECK-NEXT: store %swift.error* %casted, %swift.error** [[ARG2]], align 8
+; CHECK-NEXT: store i64 [[TMP1]], ptr [[ARG1]], align 4
+; CHECK-NEXT: store ptr [[ARG1]], ptr [[ARG2]], align 8
; CHECK-NEXT: br label %entry_after_outline.exitStub
diff --git a/llvm/test/Transforms/IROutliner/outlining-swifttailcc.ll b/llvm/test/Transforms/IROutliner/outlining-swifttailcc.ll
index 21138a826c22a..48cc128ad68de 100644
--- a/llvm/test/Transforms/IROutliner/outlining-swifttailcc.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-swifttailcc.ll
@@ -7,27 +7,27 @@ declare swifttailcc void @musttail()
define swifttailcc void @f1() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call swifttailcc void @musttail()
ret void
}
define swifttailcc void @f2() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call swifttailcc void @musttail()
ret void
}
; CHECK-LABEL: @f1(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call swifttailcc void @musttail()
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @f2(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call swifttailcc void @musttail()
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/outlining-tailcc.ll b/llvm/test/Transforms/IROutliner/outlining-tailcc.ll
index 4183eb8a7f959..17ca8df4c67f0 100644
--- a/llvm/test/Transforms/IROutliner/outlining-tailcc.ll
+++ b/llvm/test/Transforms/IROutliner/outlining-tailcc.ll
@@ -7,27 +7,27 @@ declare tailcc void @musttail()
define tailcc void @f1() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call tailcc void @musttail()
ret void
}
define tailcc void @f2() {
%a = alloca i32, align 4
- store i32 2, i32* %a, align 4
+ store i32 2, ptr %a, align 4
musttail call tailcc void @musttail()
ret void
}
; CHECK-LABEL: @f1(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call tailcc void @musttail()
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @f2(
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
-; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: store i32 2, ptr [[A]], align 4
; CHECK-NEXT: musttail call tailcc void @musttail()
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/phi-nodes-non-constant.ll b/llvm/test/Transforms/IROutliner/phi-nodes-non-constant.ll
index 5c2bfd915d3bd..5fc8684e2bd88 100644
--- a/llvm/test/Transforms/IROutliner/phi-nodes-non-constant.ll
+++ b/llvm/test/Transforms/IROutliner/phi-nodes-non-constant.ll
@@ -3,52 +3,52 @@
; Show that we do extract phi nodes from the regions.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br label %first
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br label %first
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
}
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
;
;
@@ -56,18 +56,18 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br label [[FIRST]]
; CHECK: first:
; CHECK-NEXT: [[TMP3:%.*]] = phi i32 [ [[C]], [[TEST:%.*]] ], [ [[E]], [[TEST1]] ]
-; CHECK-NEXT: store i32 2, i32* [[TMP1:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/phi-nodes-output-overload.ll b/llvm/test/Transforms/IROutliner/phi-nodes-output-overload.ll
index 439f6f50524eb..9631bfac7d1c0 100644
--- a/llvm/test/Transforms/IROutliner/phi-nodes-output-overload.ll
+++ b/llvm/test/Transforms/IROutliner/phi-nodes-output-overload.ll
@@ -4,16 +4,16 @@
; Show that we do not extract similar regions that would involve the splitting
; of phi nodes on exit.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %next
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
%1 = phi i32 [ %c, %test ], [ %e, %test1 ]
@@ -22,16 +22,16 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
br label %test1
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
br i1 true, label %first, label %next
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
first:
ret void
@@ -43,11 +43,10 @@ next:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]], i32 0)
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]], i32 0)
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[DOTCE_RELOAD]], [[ENTRY:%.*]] ]
@@ -60,11 +59,10 @@ next:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32* [[DOTCE_LOC]], i32 1)
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TMP1:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], ptr [[DOTCE_LOC]], i32 1)
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TMP1]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: first:
; CHECK-NEXT: ret void
@@ -77,13 +75,13 @@ next:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[ENTRY_TO_OUTLINE:%.*]]
; CHECK: entry_to_outline:
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT:%.*]], label [[PHI_BLOCK:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT]], label [[PHI_BLOCK]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[C]], [[TEST:%.*]] ], [ [[E]], [[TEST1]] ]
@@ -97,10 +95,10 @@ next:
; CHECK-NEXT: i32 0, label [[OUTPUT_BLOCK_1_0:%.*]]
; CHECK-NEXT: ]
; CHECK: output_block_0_1:
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_1]]
; CHECK: output_block_1_0:
-; CHECK-NEXT: store i32 [[TMP3:%.*]], i32* [[TMP1]], align 4
+; CHECK-NEXT: store i32 [[TMP3:%.*]], ptr [[TMP1]], align 4
; CHECK-NEXT: br label [[FINAL_BLOCK_0]]
; CHECK: phi_block:
; CHECK-NEXT: [[TMP3]] = phi i32 [ [[C]], [[TEST]] ], [ [[E]], [[TEST1]] ]
diff --git a/llvm/test/Transforms/IROutliner/phi-nodes-parent-block-referential.ll b/llvm/test/Transforms/IROutliner/phi-nodes-parent-block-referential.ll
index 3a06047316302..608abfa95333c 100644
--- a/llvm/test/Transforms/IROutliner/phi-nodes-parent-block-referential.ll
+++ b/llvm/test/Transforms/IROutliner/phi-nodes-parent-block-referential.ll
@@ -4,10 +4,10 @@
; Show that we do not outline when all of the phi nodes in the beginning
; block are included not in the region.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = add i32 %c, %c
br label %test1
dummy:
@@ -15,7 +15,7 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %e, %test1 ], [ %y, %entry ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
%4 = sub i32 %c, %c
br i1 true, label %first, label %test1
@@ -23,10 +23,10 @@ first:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%y = mul i32 %c, %c
br label %test1
dummy:
@@ -34,7 +34,7 @@ dummy:
test1:
%1 = phi i32 [ %e, %test1 ], [ %y, %entry ]
%2 = phi i32 [ %y, %entry ], [ %e, %test1 ]
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%3 = add i32 %c, %c
%4 = mul i32 %c, %c
br i1 true, label %first, label %test1
@@ -45,7 +45,7 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = add i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
@@ -53,11 +53,10 @@ first:
; CHECK: test1:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[E_RELOAD:%.*]], [[TEST1]] ], [ [[Y]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[E_RELOAD]], [[TEST1]] ], [ [[Y]], [[ENTRY]] ]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[E_LOC]])
-; CHECK-NEXT: [[E_RELOAD]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[E_LOC]])
+; CHECK-NEXT: [[E_RELOAD]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
; CHECK-NEXT: [[TMP3:%.*]] = sub i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[FIRST:%.*]], label [[TEST1]]
; CHECK: first:
@@ -68,7 +67,7 @@ first:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[E_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Y:%.*]] = mul i32 [[C]], [[C]]
; CHECK-NEXT: br label [[TEST1:%.*]]
; CHECK: dummy:
@@ -76,11 +75,10 @@ first:
; CHECK: test1:
; CHECK-NEXT: [[TMP1:%.*]] = phi i32 [ [[E_RELOAD:%.*]], [[TEST1]] ], [ [[Y]], [[ENTRY:%.*]] ]
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ [[Y]], [[ENTRY]] ], [ [[E_RELOAD]], [[TEST1]] ]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[E_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[E_LOC]])
-; CHECK-NEXT: [[E_RELOAD]] = load i32, i32* [[E_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[E_LOC]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[E_LOC]])
+; CHECK-NEXT: [[E_RELOAD]] = load i32, ptr [[E_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[E_LOC]])
; CHECK-NEXT: [[TMP3:%.*]] = mul i32 [[C]], [[C]]
; CHECK-NEXT: br i1 true, label [[FIRST:%.*]], label [[TEST1]]
; CHECK: first:
@@ -91,10 +89,10 @@ first:
; CHECK-NEXT: newFuncRoot:
; CHECK-NEXT: br label [[TEST1_TO_OUTLINE:%.*]]
; CHECK: test1_to_outline:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[TMP1:%.*]], [[TMP1]]
; CHECK-NEXT: br label [[TEST1_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: test1_after_outline.exitStub:
-; CHECK-NEXT: store i32 [[E]], i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[E]], ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: ret void
;
diff --git a/llvm/test/Transforms/IROutliner/phi-nodes-simple.ll b/llvm/test/Transforms/IROutliner/phi-nodes-simple.ll
index a14724d2a5322..31cfe2ccea952 100644
--- a/llvm/test/Transforms/IROutliner/phi-nodes-simple.ll
+++ b/llvm/test/Transforms/IROutliner/phi-nodes-simple.ll
@@ -4,38 +4,38 @@
; Show that we are able to outline the simple phi node case of constants when
; the corresponding labels match.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
br label %test
test:
br label %first
first:
%0 = phi i32 [ 0, %test ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
br label %test
test:
br label %first
first:
%0 = phi i32 [ 0, %test ]
- store i32 2, i32* %a, align 4
- store i32 3, i32* %b, align 4
+ store i32 2, ptr %a, align 4
+ store i32 3, ptr %b, align 4
ret void
}
; CHECK-LABEL: @function1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
;
;
; CHECK-LABEL: @function2(
; CHECK-NEXT: entry:
-; CHECK-NEXT: call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT: call void @outlined_ir_func_0(ptr [[A:%.*]], ptr [[B:%.*]])
; CHECK-NEXT: ret void
;
;
@@ -48,8 +48,8 @@ first:
; CHECK-NEXT: br label [[FIRST:%.*]]
; CHECK: first:
; CHECK-NEXT: [[TMP2:%.*]] = phi i32 [ 0, [[TEST]] ]
-; CHECK-NEXT: store i32 2, i32* [[TMP0:%.*]], align 4
-; CHECK-NEXT: store i32 3, i32* [[TMP1:%.*]], align 4
+; CHECK-NEXT: store i32 2, ptr [[TMP0:%.*]], align 4
+; CHECK-NEXT: store i32 3, ptr [[TMP1:%.*]], align 4
; CHECK-NEXT: br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
; CHECK: entry_after_outline.exitStub:
; CHECK-NEXT: ret void
diff --git a/llvm/test/Transforms/IROutliner/region-end-of-module.ll b/llvm/test/Transforms/IROutliner/region-end-of-module.ll
index a645fcfaf8c5e..2ad16078eed27 100644
--- a/llvm/test/Transforms/IROutliner/region-end-of-module.ll
+++ b/llvm/test/Transforms/IROutliner/region-end-of-module.ll
@@ -4,7 +4,7 @@
; This test checks that we do not fail when there is a similarity group with
; an ending instruction that is also the end of the module.
- at a = global i8* null
+ at a = global ptr null
define void @foo() {
entry:
diff --git a/llvm/test/Transforms/IROutliner/region-inputs-in-phi-nodes.ll b/llvm/test/Transforms/IROutliner/region-inputs-in-phi-nodes.ll
index 94cdbc4247cdb..b87ab4b78d6a4 100644
--- a/llvm/test/Transforms/IROutliner/region-inputs-in-phi-nodes.ll
+++ b/llvm/test/Transforms/IROutliner/region-inputs-in-phi-nodes.ll
@@ -4,18 +4,18 @@
; Show that we are able to propogate inputs to the region into the split PHINode
; outside of the region if necessary.
-define void @function1(i32* %a, i32* %b) {
+define void @function1(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = add i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
dummy:
ret void
@@ -26,18 +26,18 @@ next:
ret void
}
-define void @function2(i32* %a, i32* %b) {
+define void @function2(ptr %a, ptr %b) {
entry:
%0 = alloca i32, align 4
- %c = load i32, i32* %0, align 4
+ %c = load i32, ptr %0, align 4
%z = mul i32 %c, %c
br i1 true, label %test1, label %first
test1:
- %e = load i32, i32* %0, align 4
+ %e = load i32, ptr %0, align 4
%1 = add i32 %c, %c
br i1 true, label %first, label %test
test:
- %d = load i32, i32* %0, align 4
+ %d = load i32, ptr %0, align 4
br i1 true, label %first, label %next
dummy:
ret void
@@ -51,13 +51,12 @@ next:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = add i32 [[C]], [[C]]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[DOTCE_LOC]])
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -72,13 +71,12 @@ next:
; CHECK-NEXT: entry:
; CHECK-NEXT: [[DOTCE_LOC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[TMP0:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[C:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[C:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: [[Z:%.*]] = mul i32 [[C]], [[C]]
-; CHECK-NEXT: [[LT_CAST:%.*]] = bitcast i32* [[DOTCE_LOC]] to i8*
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[LT_CAST]])
-; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(i32* [[TMP0]], i32 [[C]], i32* [[DOTCE_LOC]])
-; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, i32* [[DOTCE_LOC]], align 4
-; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[LT_CAST]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[TARGETBLOCK:%.*]] = call i1 @outlined_ir_func_0(ptr [[TMP0]], i32 [[C]], ptr [[DOTCE_LOC]])
+; CHECK-NEXT: [[DOTCE_RELOAD:%.*]] = load i32, ptr [[DOTCE_LOC]], align 4
+; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr [[DOTCE_LOC]])
; CHECK-NEXT: br i1 [[TARGETBLOCK]], label [[FIRST:%.*]], label [[NEXT:%.*]]
; CHECK: dummy:
; CHECK-NEXT: ret void
@@ -95,17 +93,17 @@ next:
; CHECK: entry_to_outline:
; CHECK-NEXT: br i1 true, label [[TEST1:%.*]], label [[FIRST_SPLIT:%.*]]
; CHECK: test1:
-; CHECK-NEXT: [[E:%.*]] = load i32, i32* [[TMP0:%.*]], align 4
+; CHECK-NEXT: [[E:%.*]] = load i32, ptr [[TMP0:%.*]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = add i32 [[TMP1:%.*]], [[TMP1]]
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT]], label [[TEST:%.*]]
; CHECK: test:
-; CHECK-NEXT: [[D:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT: [[D:%.*]] = load i32, ptr [[TMP0]], align 4
; CHECK-NEXT: br i1 true, label [[FIRST_SPLIT]], label [[NEXT_EXITSTUB:%.*]]
; CHECK: first.split:
; CHECK-NEXT: [[DOTCE:%.*]] = phi i32 [ [[D]], [[TEST]] ], [ [[E]], [[TEST1]] ], [ [[TMP1]], [[ENTRY_TO_OUTLINE]] ]
; CHECK-NEXT: br label [[FIRST_EXITSTUB:%.*]]
; CHECK: first.exitStub:
-; CHECK-NEXT: store i32 [[DOTCE]], i32* [[TMP2:%.*]], align 4
+; CHECK-NEXT: store i32 [[DOTCE]], ptr [[TMP2:%.*]], align 4
; CHECK-NEXT: ret i1 true
; CHECK: next.exitStub:
; CHECK-NEXT: ret i1 false
More information about the llvm-commits
mailing list