[llvm] e87aa92 - [SimplifyCFG] Convert some tests to opaque pointers (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Jan 4 07:27:57 PST 2023
Author: Nikita Popov
Date: 2023-01-04T16:27:49+01:00
New Revision: e87aa9206606064fa3e9cd5a8c097a542ff0d559
URL: https://github.com/llvm/llvm-project/commit/e87aa9206606064fa3e9cd5a8c097a542ff0d559
DIFF: https://github.com/llvm/llvm-project/commit/e87aa9206606064fa3e9cd5a8c097a542ff0d559.diff
LOG: [SimplifyCFG] Convert some tests to opaque pointers (NFC)
Added:
Modified:
llvm/test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll
llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
llvm/test/Transforms/SimplifyCFG/select-gep.ll
llvm/test/Transforms/SimplifyCFG/volatile-phioper.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll b/llvm/test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll
index 07edb3f6c8ae6..9ec0dc2182b89 100644
--- a/llvm/test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll
+++ b/llvm/test/Transforms/SimplifyCFG/X86/switch_to_lookup_table.ll
@@ -14,7 +14,7 @@ target triple = "x86_64-unknown-linux-gnu"
; CHECK: @switch.table.h = private unnamed_addr constant [4 x float] [float 0x40091EB860000000, float 0x3FF3BE76C0000000, float 0x4012449BA0000000, float 0x4001AE1480000000], align 4
; The table for @foostring
-; CHECK: @switch.table.foostring = private unnamed_addr constant [4 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str2, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str3, i64 0, i64 0)], align 8
+; CHECK: @switch.table.foostring = private unnamed_addr constant [4 x ptr] [ptr @.str, ptr @.str1, ptr @.str2, ptr @.str3], align 8
; The table for @earlyreturncrash
; CHECK: @switch.table.earlyreturncrash = private unnamed_addr constant [4 x i32] [i32 42, i32 9, i32 88, i32 5], align 4
@@ -40,8 +40,8 @@ define i32 @f(i32 %c) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[SWITCH_TABLEIDX]], 7
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [7 x i32], [7 x i32]* @switch.table.f, i32 0, i32 [[SWITCH_TABLEIDX]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [7 x i32], ptr @switch.table.f, i32 0, i32 [[SWITCH_TABLEIDX]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 15, [[ENTRY:%.*]] ]
@@ -80,8 +80,8 @@ define i8 @char(i32 %c) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[SWITCH_TABLEIDX]], 9
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [9 x i8], [9 x i8]* @switch.table.char, i32 0, i32 [[SWITCH_TABLEIDX]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i8, i8* [[SWITCH_GEP]], align 1
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [9 x i8], ptr @switch.table.char, i32 0, i32 [[SWITCH_TABLEIDX]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i8, ptr [[SWITCH_GEP]], align 1
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i8 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 15, [[ENTRY:%.*]] ]
@@ -127,8 +127,8 @@ define void @h(i32 %x) {
; CHECK-NEXT: [[SWITCH_SHIFTAMT:%.*]] = mul i32 [[X]], 8
; CHECK-NEXT: [[SWITCH_DOWNSHIFT:%.*]] = lshr i32 89655594, [[SWITCH_SHIFTAMT]]
; CHECK-NEXT: [[SWITCH_MASKED:%.*]] = trunc i32 [[SWITCH_DOWNSHIFT]] to i8
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x float], [4 x float]* @switch.table.h, i32 0, i32 [[X]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load float, float* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x float], ptr @switch.table.h, i32 0, i32 [[X]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load float, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[SW_EPILOG]]
; CHECK: sw.epilog:
; CHECK-NEXT: [[A_0:%.*]] = phi i8 [ [[SWITCH_MASKED]], [[SWITCH_LOOKUP]] ], [ 7, [[ENTRY:%.*]] ]
@@ -166,18 +166,18 @@ sw.epilog:
@.str3 = private unnamed_addr constant [4 x i8] c"qux\00", align 1
@.str4 = private unnamed_addr constant [6 x i8] c"error\00", align 1
-define i8* @foostring(i32 %x) {
+define ptr @foostring(i32 %x) {
; CHECK-LABEL: @foostring(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[X:%.*]], 4
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* @switch.table.foostring, i32 0, i32 [[X]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i8*, i8** [[SWITCH_GEP]], align 8
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x ptr], ptr @switch.table.foostring, i32 0, i32 [[X]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load ptr, ptr [[SWITCH_GEP]], align 8
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
-; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i8* [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str4, i64 0, i64 0), [[ENTRY:%.*]] ]
-; CHECK-NEXT: ret i8* [[RETVAL_0]]
+; CHECK-NEXT: [[RETVAL_0:%.*]] = phi ptr [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ @.str4, [[ENTRY:%.*]] ]
+; CHECK-NEXT: ret ptr [[RETVAL_0]]
;
entry:
switch i32 %x, label %sw.default [
@@ -193,12 +193,12 @@ sw.bb3: br label %return
sw.default: br label %return
return:
- %retval.0 = phi i8* [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str4, i64 0, i64 0), %sw.default ],
- [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str3, i64 0, i64 0), %sw.bb3 ],
- [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str2, i64 0, i64 0), %sw.bb2 ],
- [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), %sw.bb1 ],
- [ getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), %entry ]
- ret i8* %retval.0
+ %retval.0 = phi ptr [ @.str4, %sw.default ],
+ [ @.str3, %sw.bb3 ],
+ [ @.str2, %sw.bb2 ],
+ [ @.str1, %sw.bb1 ],
+ [ @.str, %entry ]
+ ret ptr %retval.0
}
@@ -211,10 +211,10 @@ define i32 @earlyreturncrash(i32 %x) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[X:%.*]], 4
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[SW_EPILOG:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.earlyreturncrash, i32 0, i32 [[X]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
-; CHECK-NEXT: [[SWITCH_GEP1:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.earlyreturncrash.1, i32 0, i32 [[X]]
-; CHECK-NEXT: [[SWITCH_LOAD2:%.*]] = load i32, i32* [[SWITCH_GEP1]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], ptr @switch.table.earlyreturncrash, i32 0, i32 [[X]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP1:%.*]] = getelementptr inbounds [4 x i32], ptr @switch.table.earlyreturncrash.1, i32 0, i32 [[X]]
+; CHECK-NEXT: [[SWITCH_LOAD2:%.*]] = load i32, ptr [[SWITCH_GEP1]], align 4
; CHECK-NEXT: br label [[SW_EPILOG]]
; CHECK: sw.epilog:
; CHECK-NEXT: [[A_0:%.*]] = phi i32 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 7, [[ENTRY:%.*]] ]
@@ -386,8 +386,8 @@ define i32 @large(i32 %x) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[SWITCH_TABLEIDX]], 199
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [199 x i32], [199 x i32]* @switch.table.large, i32 0, i32 [[SWITCH_TABLEIDX]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [199 x i32], ptr @switch.table.large, i32 0, i32 [[SWITCH_TABLEIDX]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ]
@@ -817,8 +817,8 @@ define i32 @cprop(i32 %x, i32 %y) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[SWITCH_TABLEIDX]], 7
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [7 x i32], [7 x i32]* @switch.table.cprop, i32 0, i32 [[SWITCH_TABLEIDX]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [7 x i32], ptr @switch.table.cprop, i32 0, i32 [[SWITCH_TABLEIDX]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 123, [[ENTRY:%.*]] ]
@@ -839,8 +839,8 @@ sw.bb1: br label %return
sw.bb2:
%and = and i32 %x, 1
- %and.ptr = inttoptr i32 %and to i8*
- %tobool = icmp ne i8* %and.ptr, null
+ %and.ptr = inttoptr i32 %and to ptr
+ %tobool = icmp ne ptr %and.ptr, null
%cond = select i1 %tobool, i32 -123, i32 456
%sub = sub nsw i32 %x, %cond
br label %return
@@ -867,8 +867,8 @@ define i32 @unreachable_case(i32 %x) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[X:%.*]], 9
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [9 x i32], [9 x i32]* @switch.table.unreachable_case, i32 0, i32 [[X]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [9 x i32], ptr @switch.table.unreachable_case, i32 0, i32 [[X]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 2, [[ENTRY:%.*]] ]
@@ -902,8 +902,8 @@ return:
define i32 @unreachable_default(i32 %x) {
; CHECK-LABEL: @unreachable_default(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.unreachable_default, i32 0, i32 [[X:%.*]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], ptr @switch.table.unreachable_default, i32 0, i32 [[X:%.*]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: ret i32 [[SWITCH_LOAD]]
;
entry:
@@ -982,8 +982,8 @@ define i32 @nodefaultnoholes(i32 %c) {
; CHECK-NEXT: call void @exit(i32 1)
; CHECK-NEXT: unreachable
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.nodefaultnoholes, i32 0, i32 [[C]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], ptr @switch.table.nodefaultnoholes, i32 0, i32 [[C]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: ret i32 [[SWITCH_LOAD]]
;
entry:
@@ -1020,8 +1020,8 @@ define i32 @nodefaultwithholes(i32 %c) {
; CHECK-NEXT: [[SWITCH_LOBIT:%.*]] = trunc i8 [[SWITCH_SHIFTED]] to i1
; CHECK-NEXT: br i1 [[SWITCH_LOBIT]], label [[SWITCH_LOOKUP:%.*]], label [[SW_DEFAULT]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [6 x i32], [6 x i32]* @switch.table.nodefaultwithholes, i32 0, i32 [[C]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [6 x i32], ptr @switch.table.nodefaultwithholes, i32 0, i32 [[C]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: ret i32 [[SWITCH_LOAD]]
;
entry:
@@ -1085,8 +1085,8 @@ define i32 @threecases(i32 %c) {
; CHECK-NEXT: [[TMP0:%.*]] = icmp ult i32 [[C:%.*]], 3
; CHECK-NEXT: br i1 [[TMP0]], label [[SWITCH_LOOKUP:%.*]], label [[RETURN:%.*]]
; CHECK: switch.lookup:
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [3 x i32], [3 x i32]* @switch.table.threecases, i32 0, i32 [[C]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [3 x i32], ptr @switch.table.threecases, i32 0, i32 [[C]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
; CHECK-NEXT: [[X:%.*]] = phi i32 [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ], [ 3, [[ENTRY:%.*]] ]
@@ -1138,7 +1138,7 @@ return:
@tls_b = thread_local global i32 0
@tls_c = thread_local global i32 0
@tls_d = thread_local global i32 0
-define i32* @tls(i32 %x) {
+define ptr @tls(i32 %x) {
; CHECK-LABEL: @tls(
; CHECK-NEXT: entry:
; CHECK-NEXT: switch i32 [[X:%.*]], label [[SW_DEFAULT:%.*]] [
@@ -1153,8 +1153,8 @@ define i32* @tls(i32 %x) {
; CHECK: sw.default:
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
-; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32* [ @tls_d, [[SW_DEFAULT]] ], [ @tls_c, [[SW_BB2]] ], [ @tls_b, [[SW_BB1]] ], [ @tls_a, [[ENTRY:%.*]] ]
-; CHECK-NEXT: ret i32* [[RETVAL_0]]
+; CHECK-NEXT: [[RETVAL_0:%.*]] = phi ptr [ @tls_d, [[SW_DEFAULT]] ], [ @tls_c, [[SW_BB2]] ], [ @tls_b, [[SW_BB1]] ], [ @tls_a, [[ENTRY:%.*]] ]
+; CHECK-NEXT: ret ptr [[RETVAL_0]]
;
entry:
switch i32 %x, label %sw.default [
@@ -1169,8 +1169,8 @@ sw.bb2:
sw.default:
br label %return
return:
- %retval.0 = phi i32* [ @tls_d, %sw.default ], [ @tls_c, %sw.bb2 ], [ @tls_b, %sw.bb1 ], [ @tls_a, %entry ]
- ret i32* %retval.0
+ %retval.0 = phi ptr [ @tls_d, %sw.default ], [ @tls_c, %sw.bb2 ], [ @tls_b, %sw.bb1 ], [ @tls_a, %entry ]
+ ret ptr %retval.0
}
; Don't build tables for switches with dllimport variables.
@@ -1178,7 +1178,7 @@ return:
@dllimport_b = external dllimport global [3x i32]
@dllimport_c = external dllimport global [3x i32]
@dllimport_d = external dllimport global [3x i32]
-define i32* @dllimport(i32 %x) {
+define ptr @dllimport(i32 %x) {
; CHECK-LABEL: @dllimport(
; CHECK-NEXT: entry:
; CHECK-NEXT: switch i32 [[X:%.*]], label [[SW_DEFAULT:%.*]] [
@@ -1193,8 +1193,8 @@ define i32* @dllimport(i32 %x) {
; CHECK: sw.default:
; CHECK-NEXT: br label [[RETURN]]
; CHECK: return:
-; CHECK-NEXT: [[RETVAL_0:%.*]] = phi i32* [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_d, i32 0, i32 0), [[SW_DEFAULT]] ], [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_c, i32 0, i32 0), [[SW_BB2]] ], [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_b, i32 0, i32 0), [[SW_BB1]] ], [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_a, i32 0, i32 0), [[ENTRY:%.*]] ]
-; CHECK-NEXT: ret i32* [[RETVAL_0]]
+; CHECK-NEXT: [[RETVAL_0:%.*]] = phi ptr [ @dllimport_d, [[SW_DEFAULT]] ], [ @dllimport_c, [[SW_BB2]] ], [ @dllimport_b, [[SW_BB1]] ], [ @dllimport_a, [[ENTRY:%.*]] ]
+; CHECK-NEXT: ret ptr [[RETVAL_0]]
;
entry:
switch i32 %x, label %sw.default [
@@ -1209,11 +1209,11 @@ sw.bb2:
sw.default:
br label %return
return:
- %retval.0 = phi i32* [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_d, i32 0, i32 0), %sw.default ],
- [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_c, i32 0, i32 0), %sw.bb2 ],
- [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_b, i32 0, i32 0), %sw.bb1 ],
- [ getelementptr inbounds ([3 x i32], [3 x i32]* @dllimport_a, i32 0, i32 0), %entry ]
- ret i32* %retval.0
+ %retval.0 = phi ptr [ @dllimport_d, %sw.default ],
+ [ @dllimport_c, %sw.bb2 ],
+ [ @dllimport_b, %sw.bb1 ],
+ [ @dllimport_a, %entry ]
+ ret ptr %retval.0
}
; We can use linear mapping.
@@ -1545,8 +1545,8 @@ define i32 @covered_switch_with_bit_tests(i3) {
; CHECK-NEXT: br i1 [[SWITCH_LOBIT]], label [[SWITCH_LOOKUP:%.*]], label [[L6:%.*]]
; CHECK: switch.lookup:
; CHECK-NEXT: [[SWITCH_TABLEIDX_ZEXT:%.*]] = zext i3 [[SWITCH_TABLEIDX]] to i4
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [8 x i32], [8 x i32]* @switch.table.covered_switch_with_bit_tests, i32 0, i4 [[SWITCH_TABLEIDX_ZEXT]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [8 x i32], ptr @switch.table.covered_switch_with_bit_tests, i32 0, i4 [[SWITCH_TABLEIDX_ZEXT]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: br label [[L6]]
; CHECK: l6:
; CHECK-NEXT: [[R:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[SWITCH_LOAD]], [[SWITCH_LOOKUP]] ]
@@ -1593,9 +1593,9 @@ cleanup:
br i1 %cleanup.dest.slot.0, label %for.cond, label %cleanup4
for.cond:
- %e.0 = phi i64* [ undef, %cleanup ], [ %incdec.ptr, %for.cond2 ]
- %pi = ptrtoint i64* %e.0 to i64
- %incdec.ptr = getelementptr inbounds i64, i64* %e.0, i64 1
+ %e.0 = phi ptr [ undef, %cleanup ], [ %incdec.ptr, %for.cond2 ]
+ %pi = ptrtoint ptr %e.0 to i64
+ %incdec.ptr = getelementptr inbounds i64, ptr %e.0, i64 1
br label %for.cond2
for.cond2:
@@ -1608,7 +1608,7 @@ cleanup4:
declare void @throw(i1)
-define void @wineh_test(i64 %val) personality i32 (...)* @__CxxFrameHandler3 {
+define void @wineh_test(i64 %val) personality ptr @__CxxFrameHandler3 {
; CHECK-LABEL: @wineh_test(
; CHECK-NEXT: entry:
; CHECK-NEXT: invoke void @throw(i1 false)
@@ -1698,8 +1698,8 @@ define i32 @signed_overflow1(i8 %n) {
; CHECK-NEXT: [[TRUNC:%.*]] = trunc i8 [[N:%.*]] to i2
; CHECK-NEXT: [[SWITCH_TABLEIDX:%.*]] = sub i2 [[TRUNC]], -2
; CHECK-NEXT: [[SWITCH_TABLEIDX_ZEXT:%.*]] = zext i2 [[SWITCH_TABLEIDX]] to i3
-; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.signed_overflow1, i32 0, i3 [[SWITCH_TABLEIDX_ZEXT]]
-; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, i32* [[SWITCH_GEP]], align 4
+; CHECK-NEXT: [[SWITCH_GEP:%.*]] = getelementptr inbounds [4 x i32], ptr @switch.table.signed_overflow1, i32 0, i3 [[SWITCH_TABLEIDX_ZEXT]]
+; CHECK-NEXT: [[SWITCH_LOAD:%.*]] = load i32, ptr [[SWITCH_GEP]], align 4
; CHECK-NEXT: ret i32 [[SWITCH_LOAD]]
;
start:
diff --git a/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll b/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
index d90b87d9a240b..bd63e6658c9a6 100644
--- a/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
+++ b/llvm/test/Transforms/SimplifyCFG/fold-branch-to-common-dest.ll
@@ -6,7 +6,7 @@ declare void @sideeffect1()
declare void @sideeffect2()
declare void @use8(i8)
declare i1 @gen1()
-declare i32 @speculate_call(i32 *) #0
+declare i32 @speculate_call(ptr) #0
; Basic cases, blocks have nothing other than the comparison itself.
@@ -121,11 +121,11 @@ final_right:
; When we fold the dispatch block into pred, the call is moved to pred
; and the attribute nonnull propagates poison paramater. However, since the
; function is speculatable, it can never cause UB. So, we need not technically drop it.
-define void @one_pred_with_spec_call(i8 %v0, i8 %v1, i32* %p) {
+define void @one_pred_with_spec_call(i8 %v0, i8 %v1, ptr %p) {
; CHECK-LABEL: @one_pred_with_spec_call(
; CHECK-NEXT: pred:
-; CHECK-NEXT: [[C0:%.*]] = icmp ne i32* [[P:%.*]], null
-; CHECK-NEXT: [[X:%.*]] = call i32 @speculate_call(i32* nonnull [[P]])
+; CHECK-NEXT: [[C0:%.*]] = icmp ne ptr [[P:%.*]], null
+; CHECK-NEXT: [[X:%.*]] = call i32 @speculate_call(ptr nonnull [[P]])
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1:%.*]], 0
; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[C0]], i1 [[C1]], i1 false
; CHECK-NEXT: br i1 [[OR_COND]], label [[COMMON_RET:%.*]], label [[FINAL_RIGHT:%.*]]
@@ -136,11 +136,11 @@ define void @one_pred_with_spec_call(i8 %v0, i8 %v1, i32* %p) {
; CHECK-NEXT: br label [[COMMON_RET]]
;
pred:
- %c0 = icmp ne i32* %p, null
+ %c0 = icmp ne ptr %p, null
br i1 %c0, label %dispatch, label %final_right
dispatch:
- %x = call i32 @speculate_call(i32* nonnull %p)
+ %x = call i32 @speculate_call(ptr nonnull %p)
%c1 = icmp eq i8 %v1, 0
br i1 %c1, label %final_left, label %final_right
@@ -153,11 +153,11 @@ final_right:
}
; Drop dereferenceable on the parameter
-define void @one_pred_with_spec_call_deref(i8 %v0, i8 %v1, i32* %p) {
+define void @one_pred_with_spec_call_deref(i8 %v0, i8 %v1, ptr %p) {
; CHECK-LABEL: @one_pred_with_spec_call_deref(
; CHECK-NEXT: pred:
-; CHECK-NEXT: [[C0:%.*]] = icmp ne i32* [[P:%.*]], null
-; CHECK-NEXT: [[X:%.*]] = call i32 @speculate_call(i32* [[P]])
+; CHECK-NEXT: [[C0:%.*]] = icmp ne ptr [[P:%.*]], null
+; CHECK-NEXT: [[X:%.*]] = call i32 @speculate_call(ptr [[P]])
; CHECK-NEXT: [[C1:%.*]] = icmp eq i8 [[V1:%.*]], 0
; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[C0]], i1 [[C1]], i1 false
; CHECK-NEXT: br i1 [[OR_COND]], label [[COMMON_RET:%.*]], label [[FINAL_RIGHT:%.*]]
@@ -168,11 +168,11 @@ define void @one_pred_with_spec_call_deref(i8 %v0, i8 %v1, i32* %p) {
; CHECK-NEXT: br label [[COMMON_RET]]
;
pred:
- %c0 = icmp ne i32* %p, null
+ %c0 = icmp ne ptr %p, null
br i1 %c0, label %dispatch, label %final_right
dispatch:
- %x = call i32 @speculate_call(i32* dereferenceable(12) %p)
+ %x = call i32 @speculate_call(ptr dereferenceable(12) %p)
%c1 = icmp eq i8 %v1, 0
br i1 %c1, label %final_left, label %final_right
@@ -944,7 +944,7 @@ define void @pr48450_3() {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND1:%.*]]
; CHECK: for.cond1:
-; CHECK-NEXT: [[V:%.*]] = load i8, i8* @f.b, align 1
+; CHECK-NEXT: [[V:%.*]] = load i8, ptr @f.b, align 1
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i8 [[V]], 1
; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT: br label [[FOR_COND1]]
@@ -953,7 +953,7 @@ entry:
br label %for.cond1
for.cond1:
- %v = load i8, i8* @f.b, align 1
+ %v = load i8, ptr @f.b, align 1
%cmp = icmp slt i8 %v, 1
br i1 %cmp, label %for.body, label %for.end
@@ -999,7 +999,7 @@ define void @pr49510() {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND:%.*]]
; CHECK: for.cond:
-; CHECK-NEXT: [[TMP0:%.*]] = load i16, i16* @global_pr49510, align 1
+; CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr @global_pr49510, align 1
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i16 [[TMP0]], 0
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i16 [[TMP0]], 0
; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[TOBOOL]], [[CMP]]
@@ -1011,7 +1011,7 @@ entry:
br label %for.cond
for.cond:
- %0 = load i16, i16* @global_pr49510, align 1
+ %0 = load i16, ptr @global_pr49510, align 1
%tobool = icmp ne i16 %0, 0
br i1 %tobool, label %land.rhs, label %for.end
@@ -1034,11 +1034,11 @@ define i32 @pr51125() {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[L:%.*]]
; CHECK: L:
-; CHECK-NEXT: [[LD:%.*]] = load i32, i32* @global_pr51125, align 4
+; CHECK-NEXT: [[LD:%.*]] = load i32, ptr @global_pr51125, align 4
; CHECK-NEXT: [[ISZERO:%.*]] = icmp eq i32 [[LD]], 0
; CHECK-NEXT: br i1 [[ISZERO]], label [[EXIT:%.*]], label [[L2:%.*]]
; CHECK: L2:
-; CHECK-NEXT: store i32 -1, i32* @global_pr51125, align 4
+; CHECK-NEXT: store i32 -1, ptr @global_pr51125, align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[LD]], -1
; CHECK-NEXT: br i1 [[CMP]], label [[L]], label [[EXIT]]
; CHECK: exit:
@@ -1049,12 +1049,12 @@ entry:
br label %L
L:
- %ld = load i32, i32* @global_pr51125, align 4
+ %ld = load i32, ptr @global_pr51125, align 4
%iszero = icmp eq i32 %ld, 0
br i1 %iszero, label %exit, label %L2
L2:
- store i32 -1, i32* @global_pr51125, align 4
+ store i32 -1, ptr @global_pr51125, align 4
%cmp = icmp eq i32 %ld, -1
br i1 %cmp, label %L, label %exit
@@ -1064,13 +1064,12 @@ exit:
}
; https://github.com/llvm/llvm-project/issues/53861
-define i32 @firewall(i8* %data) {
+define i32 @firewall(ptr %data) {
; CHECK-LABEL: @firewall(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[I:%.*]] = load i8, i8* [[DATA:%.*]], align 1
-; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, i8* [[DATA]], i64 64
-; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[ADD_PTR]] to i16*
-; CHECK-NEXT: [[I2:%.*]] = load i16, i16* [[I1]], align 2
+; CHECK-NEXT: [[I:%.*]] = load i8, ptr [[DATA:%.*]], align 1
+; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i8, ptr [[DATA]], i64 64
+; CHECK-NEXT: [[I2:%.*]] = load i16, ptr [[ADD_PTR]], align 2
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[I]], 17
; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i16 [[I2]], 1
; CHECK-NEXT: [[OR_COND:%.*]] = select i1 [[CMP]], i1 [[CMP3]], i1 false
@@ -1087,10 +1086,9 @@ define i32 @firewall(i8* %data) {
; CHECK-NEXT: ret i32 [[RETVAL_0]]
;
entry:
- %i = load i8, i8* %data, align 1
- %add.ptr = getelementptr inbounds i8, i8* %data, i64 64
- %i1 = bitcast i8* %add.ptr to i16*
- %i2 = load i16, i16* %i1, align 2
+ %i = load i8, ptr %data, align 1
+ %add.ptr = getelementptr inbounds i8, ptr %data, i64 64
+ %i2 = load i16, ptr %add.ptr, align 2
%cmp = icmp eq i8 %i, 17
%cmp3 = icmp eq i16 %i2, 1
%or.cond = select i1 %cmp, i1 %cmp3, i1 false
diff --git a/llvm/test/Transforms/SimplifyCFG/select-gep.ll b/llvm/test/Transforms/SimplifyCFG/select-gep.ll
index 096ef4b517e80..9710977f538a5 100644
--- a/llvm/test/Transforms/SimplifyCFG/select-gep.ll
+++ b/llvm/test/Transforms/SimplifyCFG/select-gep.ll
@@ -3,24 +3,24 @@
%ST = type { i8, i8 }
-define i8* @test1(%ST* %x, i8* %y) nounwind {
+define ptr @test1(ptr %x, ptr %y) nounwind {
; CHECK-LABEL: @test1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP:%.*]] = icmp eq %ST* [[X:%.*]], null
-; CHECK-NEXT: [[INCDEC_PTR:%.*]] = getelementptr [[ST:%.*]], %ST* [[X]], i32 0, i32 1
-; CHECK-NEXT: [[INCDEC_PTR_Y:%.*]] = select i1 [[CMP]], i8* [[INCDEC_PTR]], i8* [[Y:%.*]]
-; CHECK-NEXT: ret i8* [[INCDEC_PTR_Y]]
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[X:%.*]], null
+; CHECK-NEXT: [[INCDEC_PTR:%.*]] = getelementptr [[ST:%.*]], ptr [[X]], i32 0, i32 1
+; CHECK-NEXT: [[INCDEC_PTR_Y:%.*]] = select i1 [[CMP]], ptr [[INCDEC_PTR]], ptr [[Y:%.*]]
+; CHECK-NEXT: ret ptr [[INCDEC_PTR_Y]]
;
entry:
- %cmp = icmp eq %ST* %x, null
+ %cmp = icmp eq ptr %x, null
br i1 %cmp, label %if.then, label %if.end
if.then:
- %incdec.ptr = getelementptr %ST, %ST* %x, i32 0, i32 1
+ %incdec.ptr = getelementptr %ST, ptr %x, i32 0, i32 1
br label %if.end
if.end:
- %x.addr = phi i8* [ %incdec.ptr, %if.then ], [ %y, %entry ]
- ret i8* %x.addr
+ %x.addr = phi ptr [ %incdec.ptr, %if.then ], [ %y, %entry ]
+ ret ptr %x.addr
}
diff --git a/llvm/test/Transforms/SimplifyCFG/volatile-phioper.ll b/llvm/test/Transforms/SimplifyCFG/volatile-phioper.ll
index 41ae375478c71..8d775596a2d9a 100644
--- a/llvm/test/Transforms/SimplifyCFG/volatile-phioper.ll
+++ b/llvm/test/Transforms/SimplifyCFG/volatile-phioper.ll
@@ -10,7 +10,7 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
-define void @test(i8** nocapture %PeiServices) #0 {
+define void @test(ptr nocapture %PeiServices) #0 {
; CHECK-LABEL: @test(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CALL:%.*]] = tail call i32 (...) @Trace() #[[ATTR2:[0-9]+]]
@@ -20,12 +20,12 @@ define void @test(i8** nocapture %PeiServices) #0 {
; CHECK-NEXT: [[CALL1:%.*]] = tail call i32 (...) @Trace() #[[ATTR2]]
; CHECK-NEXT: br label [[WHILE_BODY]]
; CHECK: while.body:
-; CHECK-NEXT: [[ADDR_017:%.*]] = phi i8* [ [[INCDEC_PTR:%.*]], [[WHILE_BODY]] ], [ null, [[IF_THEN]] ], [ null, [[ENTRY:%.*]] ]
+; CHECK-NEXT: [[ADDR_017:%.*]] = phi ptr [ [[INCDEC_PTR:%.*]], [[WHILE_BODY]] ], [ null, [[IF_THEN]] ], [ null, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[X_016:%.*]] = phi i8 [ [[INC:%.*]], [[WHILE_BODY]] ], [ 0, [[IF_THEN]] ], [ 0, [[ENTRY]] ]
; CHECK-NEXT: [[INC]] = add i8 [[X_016]], 1
-; CHECK-NEXT: [[INCDEC_PTR]] = getelementptr inbounds i8, i8* [[ADDR_017]], i64 1
-; CHECK-NEXT: store volatile i8 [[X_016]], i8* [[ADDR_017]], align 1
-; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint i8* [[INCDEC_PTR]] to i64
+; CHECK-NEXT: [[INCDEC_PTR]] = getelementptr inbounds i8, ptr [[ADDR_017]], i64 1
+; CHECK-NEXT: store volatile i8 [[X_016]], ptr [[ADDR_017]], align 1
+; CHECK-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[INCDEC_PTR]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[TMP0]] to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[TMP1]], 4096
; CHECK-NEXT: br i1 [[CMP]], label [[WHILE_BODY]], label [[END:%.*]]
@@ -42,12 +42,12 @@ if.then: ; preds = %entry
br label %while.body
while.body: ; preds = %entry, %if.then, %while.body
- %Addr.017 = phi i8* [ %incdec.ptr, %while.body ], [ null, %if.then ], [ null, %entry ]
+ %Addr.017 = phi ptr [ %incdec.ptr, %while.body ], [ null, %if.then ], [ null, %entry ]
%x.016 = phi i8 [ %inc, %while.body ], [ 0, %if.then ], [ 0, %entry ]
%inc = add i8 %x.016, 1
- %incdec.ptr = getelementptr inbounds i8, i8* %Addr.017, i64 1
- store volatile i8 %x.016, i8* %Addr.017, align 1
- %0 = ptrtoint i8* %incdec.ptr to i64
+ %incdec.ptr = getelementptr inbounds i8, ptr %Addr.017, i64 1
+ store volatile i8 %x.016, ptr %Addr.017, align 1
+ %0 = ptrtoint ptr %incdec.ptr to i64
%1 = trunc i64 %0 to i32
%cmp = icmp ult i32 %1, 4096
br i1 %cmp, label %while.body, label %end
More information about the llvm-commits
mailing list