[llvm] 13fc189 - SafeStack: Convert tests to opaque pointers
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Sun Nov 27 17:53:09 PST 2022
Author: Matt Arsenault
Date: 2022-11-27T20:28:55-05:00
New Revision: 13fc189fe1909aea3787b2a142603b790458abd6
URL: https://github.com/llvm/llvm-project/commit/13fc189fe1909aea3787b2a142603b790458abd6
DIFF: https://github.com/llvm/llvm-project/commit/13fc189fe1909aea3787b2a142603b790458abd6.diff
LOG: SafeStack: Convert tests to opaque pointers
X86/struct.ll, X86/array.ll and X86/array-aligned required manual
updates to reorder instructions.
Added:
Modified:
llvm/test/Transforms/SafeStack/AArch64/abi.ll
llvm/test/Transforms/SafeStack/AArch64/abi_ssp.ll
llvm/test/Transforms/SafeStack/AArch64/unreachable.ll
llvm/test/Transforms/SafeStack/ARM/abi.ll
llvm/test/Transforms/SafeStack/ARM/debug.ll
llvm/test/Transforms/SafeStack/ARM/setjmp.ll
llvm/test/Transforms/SafeStack/X86/abi.ll
llvm/test/Transforms/SafeStack/X86/abi_ssp.ll
llvm/test/Transforms/SafeStack/X86/addr-taken.ll
llvm/test/Transforms/SafeStack/X86/array-aligned.ll
llvm/test/Transforms/SafeStack/X86/array.ll
llvm/test/Transforms/SafeStack/X86/byval.ll
llvm/test/Transforms/SafeStack/X86/call.ll
llvm/test/Transforms/SafeStack/X86/cast.ll
llvm/test/Transforms/SafeStack/X86/coloring-ssp.ll
llvm/test/Transforms/SafeStack/X86/coloring.ll
llvm/test/Transforms/SafeStack/X86/coloring2.ll
llvm/test/Transforms/SafeStack/X86/constant-gep-call.ll
llvm/test/Transforms/SafeStack/X86/constant-gep.ll
llvm/test/Transforms/SafeStack/X86/constant-geps.ll
llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll
llvm/test/Transforms/SafeStack/X86/debug-loc.ll
llvm/test/Transforms/SafeStack/X86/debug-loc2.ll
llvm/test/Transforms/SafeStack/X86/dynamic-alloca.ll
llvm/test/Transforms/SafeStack/X86/escape-addr-pointer.ll
llvm/test/Transforms/SafeStack/X86/escape-bitcast-store.ll
llvm/test/Transforms/SafeStack/X86/escape-bitcast-store2.ll
llvm/test/Transforms/SafeStack/X86/escape-call.ll
llvm/test/Transforms/SafeStack/X86/escape-casted-pointer.ll
llvm/test/Transforms/SafeStack/X86/escape-gep-call.ll
llvm/test/Transforms/SafeStack/X86/escape-gep-invoke.ll
llvm/test/Transforms/SafeStack/X86/escape-gep-negative.ll
llvm/test/Transforms/SafeStack/X86/escape-gep-ptrtoint.ll
llvm/test/Transforms/SafeStack/X86/escape-gep-store.ll
llvm/test/Transforms/SafeStack/X86/escape-phi-call.ll
llvm/test/Transforms/SafeStack/X86/escape-select-call.ll
llvm/test/Transforms/SafeStack/X86/escape-vector.ll
llvm/test/Transforms/SafeStack/X86/invoke.ll
llvm/test/Transforms/SafeStack/X86/layout-frag.ll
llvm/test/Transforms/SafeStack/X86/layout-region-split.ll
llvm/test/Transforms/SafeStack/X86/memintrinsic-oob-read.ll
llvm/test/Transforms/SafeStack/X86/musttail.ll
llvm/test/Transforms/SafeStack/X86/no-attr.ll
llvm/test/Transforms/SafeStack/X86/no-crash-on-lifetime.ll
llvm/test/Transforms/SafeStack/X86/phi-cycle.ll
llvm/test/Transforms/SafeStack/X86/phi.ll
llvm/test/Transforms/SafeStack/X86/pr54784.ll
llvm/test/Transforms/SafeStack/X86/ret.ll
llvm/test/Transforms/SafeStack/X86/setjmp.ll
llvm/test/Transforms/SafeStack/X86/setjmp2.ll
llvm/test/Transforms/SafeStack/X86/sink-to-use.ll
llvm/test/Transforms/SafeStack/X86/ssp.ll
llvm/test/Transforms/SafeStack/X86/store.ll
llvm/test/Transforms/SafeStack/X86/struct.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/SafeStack/AArch64/abi.ll b/llvm/test/Transforms/SafeStack/AArch64/abi.ll
index bd6710d160c55..18cf49920ace6 100644
--- a/llvm/test/Transforms/SafeStack/AArch64/abi.ll
+++ b/llvm/test/Transforms/SafeStack/AArch64/abi.ll
@@ -3,18 +3,17 @@
define void @foo() nounwind uwtable safestack {
entry:
-; CHECK: %[[TP:.*]] = call i8* @llvm.thread.pointer()
-; CHECK: %[[SPA0:.*]] = getelementptr i8, i8* %[[TP]], i32 72
-; CHECK: %[[SPA:.*]] = bitcast i8* %[[SPA0]] to i8**
-; CHECK: %[[USP:.*]] = load i8*, i8** %[[SPA]]
-; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; CHECK: store i8* %[[USST]], i8** %[[SPA]]
+; CHECK: %[[TP:.*]] = call ptr @llvm.thread.pointer()
+; CHECK: %[[SPA0:.*]] = getelementptr i8, ptr %[[TP]], i32 72
+; CHECK: %[[USP:.*]] = load ptr, ptr %[[SPA0]]
+; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; CHECK: store ptr %[[USST]], ptr %[[SPA0]]
%a = alloca i8, align 8
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
-; CHECK: store i8* %[[USP]], i8** %[[SPA]]
+; CHECK: store ptr %[[USP]], ptr %[[SPA0]]
ret void
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/AArch64/abi_ssp.ll b/llvm/test/Transforms/SafeStack/AArch64/abi_ssp.ll
index c78b20aaa01ab..aab2d5dd4a781 100644
--- a/llvm/test/Transforms/SafeStack/AArch64/abi_ssp.ll
+++ b/llvm/test/Transforms/SafeStack/AArch64/abi_ssp.ll
@@ -4,20 +4,19 @@
define void @foo() nounwind uwtable safestack sspreq {
entry:
; The first @llvm.thread.pointer is for the unsafe stack pointer, skip it.
-; TLS: call i8* @llvm.thread.pointer()
+; TLS: call ptr @llvm.thread.pointer()
-; TLS: %[[TP2:.*]] = call i8* @llvm.thread.pointer()
-; ANDROID: %[[B:.*]] = getelementptr i8, i8* %[[TP2]], i32 40
-; FUCHSIA: %[[B:.*]] = getelementptr i8, i8* %[[TP2]], i32 -16
-; TLS: %[[C:.*]] = bitcast i8* %[[B]] to i8**
-; TLS: %[[StackGuard:.*]] = load i8*, i8** %[[C]]
-; TLS: store i8* %[[StackGuard]], i8** %[[StackGuardSlot:.*]]
+; TLS: %[[TP2:.*]] = call ptr @llvm.thread.pointer()
+; ANDROID: %[[B:.*]] = getelementptr i8, ptr %[[TP2]], i32 40
+; FUCHSIA: %[[B:.*]] = getelementptr i8, ptr %[[TP2]], i32 -16
+; TLS: %[[StackGuard:.*]] = load ptr, ptr %[[B]]
+; TLS: store ptr %[[StackGuard]], ptr %[[StackGuardSlot:.*]]
%a = alloca i128, align 16
- call void @Capture(i128* %a)
+ call void @Capture(ptr %a)
-; TLS: %[[A:.*]] = load i8*, i8** %[[StackGuardSlot]]
-; TLS: icmp ne i8* %[[StackGuard]], %[[A]]
+; TLS: %[[A:.*]] = load ptr, ptr %[[StackGuardSlot]]
+; TLS: icmp ne ptr %[[StackGuard]], %[[A]]
ret void
}
-declare void @Capture(i128*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/AArch64/unreachable.ll b/llvm/test/Transforms/SafeStack/AArch64/unreachable.ll
index 53ed690ebb09b..430c4aa7ae453 100644
--- a/llvm/test/Transforms/SafeStack/AArch64/unreachable.ll
+++ b/llvm/test/Transforms/SafeStack/AArch64/unreachable.ll
@@ -2,12 +2,11 @@
define void @foo() nounwind uwtable safestack {
entry:
-; CHECK: %[[TP:.*]] = call i8* @llvm.thread.pointer()
-; CHECK: %[[SPA0:.*]] = getelementptr i8, i8* %[[TP]], i32 72
-; CHECK: %[[SPA:.*]] = bitcast i8* %[[SPA0]] to i8**
-; CHECK: %[[USP:.*]] = load i8*, i8** %[[SPA]]
-; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; CHECK: store i8* %[[USST]], i8** %[[SPA]]
+; CHECK: %[[TP:.*]] = call ptr @llvm.thread.pointer()
+; CHECK: %[[SPA0:.*]] = getelementptr i8, ptr %[[TP]], i32 72
+; CHECK: %[[USP:.*]] = load ptr, ptr %[[SPA0]]
+; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; CHECK: store ptr %[[USST]], ptr %[[SPA0]]
%a = alloca i8, align 8
br label %ret
@@ -16,8 +15,8 @@ ret:
ret void
dead:
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
br label %ret
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/ARM/abi.ll b/llvm/test/Transforms/SafeStack/ARM/abi.ll
index e33c913ae9169..be4e2e35f9769 100644
--- a/llvm/test/Transforms/SafeStack/ARM/abi.ll
+++ b/llvm/test/Transforms/SafeStack/ARM/abi.ll
@@ -3,16 +3,16 @@
define void @foo() nounwind uwtable safestack {
entry:
-; CHECK: %[[SPA:.*]] = call i8** @__safestack_pointer_address()
-; CHECK: %[[USP:.*]] = load i8*, i8** %[[SPA]]
-; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; CHECK: store i8* %[[USST]], i8** %[[SPA]]
+; CHECK: %[[SPA:.*]] = call ptr @__safestack_pointer_address()
+; CHECK: %[[USP:.*]] = load ptr, ptr %[[SPA]]
+; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; CHECK: store ptr %[[USST]], ptr %[[SPA]]
%a = alloca i8, align 8
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
-; CHECK: store i8* %[[USP]], i8** %[[SPA]]
+; CHECK: store ptr %[[USP]], ptr %[[SPA]]
ret void
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/ARM/debug.ll b/llvm/test/Transforms/SafeStack/ARM/debug.ll
index 2bcfeb8b01e3a..9a61b78d2d966 100644
--- a/llvm/test/Transforms/SafeStack/ARM/debug.ll
+++ b/llvm/test/Transforms/SafeStack/ARM/debug.ll
@@ -13,38 +13,37 @@ target triple = "armv7-pc-linux-android"
; CHECK: !36 = !DILocation(line: 3, column: 11, scope: !17, inlinedAt: !37)
; CHECK: !37 = distinct !DILocation(line: 6, scope: !27)
- at addr = common local_unnamed_addr global i8*** null, align 4, !dbg !0
+ at addr = common local_unnamed_addr global ptr null, align 4, !dbg !0
; Function Attrs: norecurse nounwind readonly safestack
-define i8** @__safestack_pointer_address() local_unnamed_addr #0 !dbg !17 {
+define ptr @__safestack_pointer_address() local_unnamed_addr #0 !dbg !17 {
entry:
- %0 = load i8***, i8**** @addr, align 4, !dbg !20, !tbaa !21
- %1 = load i8**, i8*** %0, align 4, !dbg !25, !tbaa !21
- ret i8** %1, !dbg !26
+ %0 = load ptr, ptr @addr, align 4, !dbg !20, !tbaa !21
+ %1 = load ptr, ptr %0, align 4, !dbg !25, !tbaa !21
+ ret ptr %1, !dbg !26
}
; Function Attrs: nounwind safestack
define void @f() local_unnamed_addr #1 !dbg !27 {
entry:
%c = alloca [16 x i8], align 1
- %0 = getelementptr inbounds [16 x i8], [16 x i8]* %c, i32 0, i32 0, !dbg !35
- call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %0) #5, !dbg !35
- call void @llvm.dbg.declare(metadata [16 x i8]* %c, metadata !31, metadata !DIExpression()), !dbg !36
- call void @Capture(i8* nonnull %0) #5, !dbg !37
- call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %0) #5, !dbg !38
+ call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %c) #5, !dbg !35
+ call void @llvm.dbg.declare(metadata ptr %c, metadata !31, metadata !DIExpression()), !dbg !36
+ call void @Capture(ptr nonnull %c) #5, !dbg !37
+ call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %c) #5, !dbg !38
ret void, !dbg !38
}
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #2
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #2
; Function Attrs: nounwind readnone speculatable
declare void @llvm.dbg.declare(metadata, metadata, metadata) #3
-declare void @Capture(i8*) local_unnamed_addr #4
+declare void @Capture(ptr) local_unnamed_addr #4
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #2
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #2
attributes #0 = { norecurse nounwind readonly safestack "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "target-features"="+armv7-a,+dsp,+neon,+vfp3,-thumb-mode" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind safestack "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "target-features"="+armv7-a,+dsp,+neon,+vfp3,-thumb-mode" "unsafe-fp-math"="false" "use-soft-float"="false" }
diff --git a/llvm/test/Transforms/SafeStack/ARM/setjmp.ll b/llvm/test/Transforms/SafeStack/ARM/setjmp.ll
index 20e46f8f0e215..b86e778aabb16 100644
--- a/llvm/test/Transforms/SafeStack/ARM/setjmp.ll
+++ b/llvm/test/Transforms/SafeStack/ARM/setjmp.ll
@@ -5,32 +5,31 @@
define void @f(i32 %b) safestack {
entry:
-; CHECK: %[[SPA:.*]] = call i8** @__safestack_pointer_address()
-; CHECK: %[[USP:.*]] = load i8*, i8** %[[SPA]]
-; CHECK: %[[USDP:.*]] = alloca i8*
-; CHECK: store i8* %[[USP]], i8** %[[USDP]]
+; CHECK: %[[SPA:.*]] = call ptr @__safestack_pointer_address()
+; CHECK: %[[USP:.*]] = load ptr, ptr %[[SPA]]
+; CHECK: %[[USDP:.*]] = alloca ptr
+; CHECK: store ptr %[[USP]], ptr %[[USDP]]
; CHECK: call i32 @setjmp
- %call = call i32 @setjmp(i32* getelementptr inbounds ([64 x i32], [64 x i32]* @env, i32 0, i32 0)) returns_twice
+ %call = call i32 @setjmp(ptr @env) returns_twice
-; CHECK: %[[USP2:.*]] = load i8*, i8** %[[USDP]]
-; CHECK: store i8* %[[USP2]], i8** %[[SPA]]
+; CHECK: %[[USP2:.*]] = load ptr, ptr %[[USDP]]
+; CHECK: store ptr %[[USP2]], ptr %[[SPA]]
%tobool = icmp eq i32 %b, 0
br i1 %tobool, label %if.end, label %if.then
if.then:
%0 = alloca [42 x i8], align 1
- %.sub = getelementptr inbounds [42 x i8], [42 x i8]* %0, i32 0, i32 0
- call void @_Z7CapturePv(i8* %.sub)
+ call void @_Z7CapturePv(ptr %0)
br label %if.end
if.end:
-; CHECK: store i8* %[[USP:.*]], i8** %[[SPA:.*]]
+; CHECK: store ptr %[[USP:.*]], ptr %[[SPA:.*]]
ret void
}
-declare i32 @setjmp(i32*) returns_twice
+declare i32 @setjmp(ptr) returns_twice
-declare void @_Z7CapturePv(i8*)
+declare void @_Z7CapturePv(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/abi.ll b/llvm/test/Transforms/SafeStack/X86/abi.ll
index f437c4f7157d9..37d8ea6a67f50 100644
--- a/llvm/test/Transforms/SafeStack/X86/abi.ll
+++ b/llvm/test/Transforms/SafeStack/X86/abi.ll
@@ -6,25 +6,25 @@
define void @foo() nounwind uwtable safestack {
entry:
-; TLS: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; TLS: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; TLS: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
+; TLS: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; TLS: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; TLS: store ptr %[[USST]], ptr @__safestack_unsafe_stack_ptr
-; DIRECT-TLS32: %[[USP:.*]] = load i8*, i8* addrspace(256)* inttoptr (i32 36 to i8* addrspace(256)*)
-; DIRECT-TLS32: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; DIRECT-TLS32: store i8* %[[USST]], i8* addrspace(256)* inttoptr (i32 36 to i8* addrspace(256)*)
+; DIRECT-TLS32: %[[USP:.*]] = load ptr, ptr addrspace(256) inttoptr (i32 36 to ptr addrspace(256))
+; DIRECT-TLS32: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; DIRECT-TLS32: store ptr %[[USST]], ptr addrspace(256) inttoptr (i32 36 to ptr addrspace(256))
-; DIRECT-TLS64: %[[USP:.*]] = load i8*, i8* addrspace(257)* inttoptr (i32 72 to i8* addrspace(257)*)
-; DIRECT-TLS64: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; DIRECT-TLS64: store i8* %[[USST]], i8* addrspace(257)* inttoptr (i32 72 to i8* addrspace(257)*)
+; DIRECT-TLS64: %[[USP:.*]] = load ptr, ptr addrspace(257) inttoptr (i32 72 to ptr addrspace(257))
+; DIRECT-TLS64: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; DIRECT-TLS64: store ptr %[[USST]], ptr addrspace(257) inttoptr (i32 72 to ptr addrspace(257))
%a = alloca i8, align 8
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
-; TLS: store i8* %[[USP]], i8** @__safestack_unsafe_stack_ptr
-; DIRECT-TLS32: store i8* %[[USP]], i8* addrspace(256)* inttoptr (i32 36 to i8* addrspace(256)*)
-; DIRECT-TLS64: store i8* %[[USP]], i8* addrspace(257)* inttoptr (i32 72 to i8* addrspace(257)*)
+; TLS: store ptr %[[USP]], ptr @__safestack_unsafe_stack_ptr
+; DIRECT-TLS32: store ptr %[[USP]], ptr addrspace(256) inttoptr (i32 36 to ptr addrspace(256))
+; DIRECT-TLS64: store ptr %[[USP]], ptr addrspace(257) inttoptr (i32 72 to ptr addrspace(257))
ret void
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll b/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll
index a4b193e208df9..7cb754999c657 100644
--- a/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll
+++ b/llvm/test/Transforms/SafeStack/X86/abi_ssp.ll
@@ -10,17 +10,17 @@
define void @foo() safestack sspreq {
entry:
-; TLS32: %[[StackGuard:.*]] = load i8*, i8* addrspace(256)* inttoptr (i32 20 to i8* addrspace(256)*)
-; TLS64: %[[StackGuard:.*]] = load i8*, i8* addrspace(257)* inttoptr (i32 40 to i8* addrspace(257)*)
-; FUCHSIA64: %[[StackGuard:.*]] = load i8*, i8* addrspace(257)* inttoptr (i32 16 to i8* addrspace(257)*)
-; GLOBAL32: %[[StackGuard:.*]] = call i8* @llvm.stackguard()
-; COMMON: store i8* %[[StackGuard]], i8** %[[StackGuardSlot:.*]]
+; TLS32: %[[StackGuard:.*]] = load ptr, ptr addrspace(256) inttoptr (i32 20 to ptr addrspace(256))
+; TLS64: %[[StackGuard:.*]] = load ptr, ptr addrspace(257) inttoptr (i32 40 to ptr addrspace(257))
+; FUCHSIA64: %[[StackGuard:.*]] = load ptr, ptr addrspace(257) inttoptr (i32 16 to ptr addrspace(257))
+; GLOBAL32: %[[StackGuard:.*]] = call ptr @llvm.stackguard()
+; COMMON: store ptr %[[StackGuard]], ptr %[[StackGuardSlot:.*]]
%a = alloca i8, align 1
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
-; COMMON: %[[A:.*]] = load i8*, i8** %[[StackGuardSlot]]
-; COMMON: icmp ne i8* %[[StackGuard]], %[[A]]
+; COMMON: %[[A:.*]] = load ptr, ptr %[[StackGuardSlot]]
+; COMMON: icmp ne ptr %[[StackGuard]], %[[A]]
ret void
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/addr-taken.ll b/llvm/test/Transforms/SafeStack/X86/addr-taken.ll
index 0780a01fa8964..cd9f76217a458 100644
--- a/llvm/test/Transforms/SafeStack/X86/addr-taken.ll
+++ b/llvm/test/Transforms/SafeStack/X86/addr-taken.ll
@@ -11,12 +11,12 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
%retval = alloca i32, align 4
%a = alloca i32, align 4
- %j = alloca i32*, align 8
- store i32 0, i32* %retval
- %0 = load i32, i32* %a, align 4
+ %j = alloca ptr, align 8
+ store i32 0, ptr %retval
+ %0 = load i32, ptr %a, align 4
%add = add nsw i32 %0, 1
- store i32 %add, i32* %a, align 4
- store i32* %a, i32** %j, align 8
+ store i32 %add, ptr %a, align 4
+ store ptr %a, ptr %j, align 8
ret void
}
diff --git a/llvm/test/Transforms/SafeStack/X86/array-aligned.ll b/llvm/test/Transforms/SafeStack/X86/array-aligned.ll
index 26558e4fa812e..ed05d387b511f 100644
--- a/llvm/test/Transforms/SafeStack/X86/array-aligned.ll
+++ b/llvm/test/Transforms/SafeStack/X86/array-aligned.ll
@@ -5,34 +5,30 @@
; array of [16 x i8]
-define void @foo(i8* %a) nounwind uwtable safestack {
+define void @foo(ptr %a) nounwind uwtable safestack {
entry:
- ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
- ; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
+ ; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
- ; CHECK: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USST]], ptr @__safestack_unsafe_stack_ptr
- %a.addr = alloca i8*, align 8
+ %a.addr = alloca ptr, align 8
%buf = alloca [16 x i8], align 16
- ; CHECK: %[[AADDR:.*]] = alloca i8*, align 8
- ; CHECK: store i8* {{.*}}, i8** %[[AADDR]], align 8
- store i8* %a, i8** %a.addr, align 8
+ ; CHECK: %[[AADDR:.*]] = alloca ptr, align 8
+ ; CHECK: store ptr {{.*}}, ptr %[[AADDR]], align 8
+ store ptr %a, ptr %a.addr, align 8
- ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
- ; CHECK: %[[BUFPTR2:.*]] = bitcast i8* %[[BUFPTR]] to [16 x i8]*
- ; CHECK: %[[GEP:.*]] = getelementptr inbounds [16 x i8], [16 x i8]* %[[BUFPTR2]], i32 0, i32 0
- %gep = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
+ ; CHECK: %[[A2:.*]] = load ptr, ptr %[[AADDR]], align 8
+ ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+ %a2 = load ptr, ptr %a.addr, align 8
- ; CHECK: %[[A2:.*]] = load i8*, i8** %[[AADDR]], align 8
- %a2 = load i8*, i8** %a.addr, align 8
+ ; CHECK: call ptr @strcpy(ptr %[[BUFPTR]], ptr %[[A2]])
+ %call = call ptr @strcpy(ptr %buf, ptr %a2)
- ; CHECK: call i8* @strcpy(i8* %[[GEP]], i8* %[[A2]])
- %call = call i8* @strcpy(i8* %gep, i8* %a2)
-
- ; CHECK: store i8* %[[USP]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USP]], ptr @__safestack_unsafe_stack_ptr
ret void
}
-declare i8* @strcpy(i8*, i8*)
+declare ptr @strcpy(ptr, ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/array.ll b/llvm/test/Transforms/SafeStack/X86/array.ll
index b699352322338..45b43f676feb0 100644
--- a/llvm/test/Transforms/SafeStack/X86/array.ll
+++ b/llvm/test/Transforms/SafeStack/X86/array.ll
@@ -5,36 +5,32 @@
; array [4 x i8]
; Requires protector.
-; CHECK: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global i8*
-; SINGLE-THREAD: @__safestack_unsafe_stack_ptr = external global i8*
+; CHECK: @__safestack_unsafe_stack_ptr = external thread_local(initialexec) global ptr
+; SINGLE-THREAD: @__safestack_unsafe_stack_ptr = external global ptr
-define void @foo(i8* %a) nounwind uwtable safestack {
+define void @foo(ptr %a) nounwind uwtable safestack {
entry:
- ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
- ; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
+ ; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
- ; CHECK: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USST]], ptr @__safestack_unsafe_stack_ptr
- %a.addr = alloca i8*, align 8
+ %a.addr = alloca ptr, align 8
%buf = alloca [4 x i8], align 1
- ; CHECK: %[[AADDR:.*]] = alloca i8*, align 8
- ; CHECK: store i8* {{.*}}, i8** %[[AADDR]], align 8
- store i8* %a, i8** %a.addr, align 8
+ ; CHECK: %[[AADDR:.*]] = alloca ptr, align 8
+ ; CHECK: store ptr {{.*}}, ptr %[[AADDR]], align 8
+ store ptr %a, ptr %a.addr, align 8
- ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
- ; CHECK: %[[BUFPTR2:.*]] = bitcast i8* %[[BUFPTR]] to [4 x i8]*
- ; CHECK: %[[GEP:.*]] = getelementptr inbounds [4 x i8], [4 x i8]* %[[BUFPTR2]], i32 0, i32 0
- %gep = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
+ ; CHECK: %[[A2:.*]] = load ptr, ptr %[[AADDR]], align 8
+ ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, ptr %[[USP]], i32 -4
+ %a2 = load ptr, ptr %a.addr, align 8
- ; CHECK: %[[A2:.*]] = load i8*, i8** %[[AADDR]], align 8
- %a2 = load i8*, i8** %a.addr, align 8
+ ; CHECK: call ptr @strcpy(ptr %[[BUFPTR]], ptr %[[A2]])
+ %call = call ptr @strcpy(ptr %buf, ptr %a2)
- ; CHECK: call i8* @strcpy(i8* %[[GEP]], i8* %[[A2]])
- %call = call i8* @strcpy(i8* %gep, i8* %a2)
-
- ; CHECK: store i8* %[[USP]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USP]], ptr @__safestack_unsafe_stack_ptr
ret void
}
@@ -45,8 +41,8 @@ entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret i8
%buf = alloca i8, i32 4, align 1
- %gep = getelementptr inbounds i8, i8* %buf, i32 2
- %x = load i8, i8* %gep, align 1
+ %gep = getelementptr inbounds i8, ptr %buf, i32 2
+ %x = load i8, ptr %gep, align 1
ret i8 %x
}
@@ -57,8 +53,8 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret i8
%buf = alloca i8, i32 4, align 1
- %gep = getelementptr inbounds i8, i8* %buf, i32 5
- %x = load i8, i8* %gep, align 1
+ %gep = getelementptr inbounds i8, ptr %buf, i32 5
+ %x = load i8, ptr %gep, align 1
ret i8 %x
}
@@ -69,8 +65,8 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret i8
%buf = alloca i8, i32 4, align 1
- %gep = getelementptr inbounds i8, i8* %buf, i32 %ofs
- %x = load i8, i8* %gep, align 1
+ %gep = getelementptr inbounds i8, ptr %buf, i32 %ofs
+ %x = load i8, ptr %gep, align 1
ret i8 %x
}
@@ -81,9 +77,9 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret i8
%buf = alloca i8, i32 %sz, align 1
- %gep = getelementptr inbounds i8, i8* %buf, i32 2
- %x = load i8, i8* %gep, align 1
+ %gep = getelementptr inbounds i8, ptr %buf, i32 2
+ %x = load i8, ptr %gep, align 1
ret i8 %x
}
-declare i8* @strcpy(i8*, i8*)
+declare ptr @strcpy(ptr, ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/byval.ll b/llvm/test/Transforms/SafeStack/X86/byval.ll
index e4172137c43ac..761265e279d41 100644
--- a/llvm/test/Transforms/SafeStack/X86/byval.ll
+++ b/llvm/test/Transforms/SafeStack/X86/byval.ll
@@ -7,61 +7,58 @@ target triple = "x86_64-unknown-linux-gnu"
%struct.S = type { [100 x i32] }
; Safe access to a byval argument.
-define i32 @ByValSafe(%struct.S* byval(%struct.S) nocapture readonly align 8 %zzz) norecurse nounwind readonly safestack uwtable {
+define i32 @ByValSafe(ptr byval(%struct.S) nocapture readonly align 8 %zzz) norecurse nounwind readonly safestack uwtable {
entry:
; CHECK-LABEL: @ByValSafe
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret i32
- %arrayidx = getelementptr inbounds %struct.S, %struct.S* %zzz, i64 0, i32 0, i64 3
- %0 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds %struct.S, ptr %zzz, i64 0, i32 0, i64 3
+ %0 = load i32, ptr %arrayidx, align 4
ret i32 %0
}
; Unsafe access to a byval argument.
; Argument is copied to the unsafe stack.
-define i32 @ByValUnsafe(%struct.S* byval(%struct.S) nocapture readonly align 8 %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
+define i32 @ByValUnsafe(ptr byval(%struct.S) nocapture readonly align 8 %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
entry:
; CHECK-LABEL: @ByValUnsafe
; CHECK: %[[A:.*]] = load {{.*}} @__safestack_unsafe_stack_ptr
; CHECK: store {{.*}} @__safestack_unsafe_stack_ptr
- ; CHECK: %[[B:.*]] = getelementptr i8, i8* %[[A]], i32 -400
- ; CHECK: %[[C:.*]] = bitcast %struct.S* %zzz to i8*
- ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[B]], i8* align 8 %[[C]], i64 400, i1 false)
+ ; CHECK: %[[B:.*]] = getelementptr i8, ptr %[[A]], i32 -400
+ ; CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[B]], ptr align 8 %zzz, i64 400, i1 false)
; CHECK: ret i32
- %arrayidx = getelementptr inbounds %struct.S, %struct.S* %zzz, i64 0, i32 0, i64 %idx
- %0 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds %struct.S, ptr %zzz, i64 0, i32 0, i64 %idx
+ %0 = load i32, ptr %arrayidx, align 4
ret i32 %0
}
; Unsafe access to a byval argument.
; Argument is copied to the unsafe stack.
; Check that dest align of memcpy is set according to datalayout prefered alignment
-define i32 @ByValUnsafe2(%struct.S* byval(%struct.S) nocapture readonly %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
+define i32 @ByValUnsafe2(ptr byval(%struct.S) nocapture readonly %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
entry:
; CHECK-LABEL: @ByValUnsafe
; CHECK: %[[A:.*]] = load {{.*}} @__safestack_unsafe_stack_ptr
; CHECK: store {{.*}} @__safestack_unsafe_stack_ptr
- ; CHECK: %[[B:.*]] = getelementptr i8, i8* %[[A]], i32 -400
- ; CHECK: %[[C:.*]] = bitcast %struct.S* %zzz to i8*
- ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[B]], i8* %[[C]], i64 400, i1 false)
+ ; CHECK: %[[B:.*]] = getelementptr i8, ptr %[[A]], i32 -400
+ ; CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[B]], ptr %zzz, i64 400, i1 false)
; CHECK: ret i32
- %arrayidx = getelementptr inbounds %struct.S, %struct.S* %zzz, i64 0, i32 0, i64 %idx
- %0 = load i32, i32* %arrayidx, align 4
+ %arrayidx = getelementptr inbounds %struct.S, ptr %zzz, i64 0, i32 0, i64 %idx
+ %0 = load i32, ptr %arrayidx, align 4
ret i32 %0
}
; Highly aligned byval argument.
-define i32 @ByValUnsafeAligned(%struct.S* byval(%struct.S) nocapture readonly align 64 %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
+define i32 @ByValUnsafeAligned(ptr byval(%struct.S) nocapture readonly align 64 %zzz, i64 %idx) norecurse nounwind readonly safestack uwtable {
entry:
; CHECK-LABEL: @ByValUnsafeAligned
; CHECK: %[[A:.*]] = load {{.*}} @__safestack_unsafe_stack_ptr
- ; CHECK: %[[B:.*]] = ptrtoint i8* %[[A]] to i64
+ ; CHECK: %[[B:.*]] = ptrtoint ptr %[[A]] to i64
; CHECK: and i64 %[[B]], -64
; CHECK: ret i32
- %arrayidx = getelementptr inbounds %struct.S, %struct.S* %zzz, i64 0, i32 0, i64 0
- %0 = load i32, i32* %arrayidx, align 64
- %arrayidx2 = getelementptr inbounds %struct.S, %struct.S* %zzz, i64 0, i32 0, i64 %idx
- %1 = load i32, i32* %arrayidx2, align 4
+ %0 = load i32, ptr %zzz, align 64
+ %arrayidx2 = getelementptr inbounds %struct.S, ptr %zzz, i64 0, i32 0, i64 %idx
+ %1 = load i32, ptr %arrayidx2, align 4
%add = add nsw i32 %1, %0
ret i32 %add
}
diff --git a/llvm/test/Transforms/SafeStack/X86/call.ll b/llvm/test/Transforms/SafeStack/X86/call.ll
index a1ce30ae56a8f..bb1b46275e1cd 100644
--- a/llvm/test/Transforms/SafeStack/X86/call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/call.ll
@@ -9,19 +9,19 @@ target triple = "x86_64-unknown-linux-gnu"
; no arrays / no nested arrays
; Requires no protector.
-define void @foo(i8* %a) nounwind uwtable safestack {
+define void @foo(ptr %a) nounwind uwtable safestack {
entry:
; CHECK-LABEL: define void @foo(
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret void
- %a.addr = alloca i8*, align 8
- store i8* %a, i8** %a.addr, align 8
- %0 = load i8*, i8** %a.addr, align 8
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
+ %a.addr = alloca ptr, align 8
+ store ptr %a, ptr %a.addr, align 8
+ %0 = load ptr, ptr %a.addr, align 8
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %0)
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
define void @call_memset(i64 %len) safestack {
entry:
@@ -29,8 +29,7 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @llvm.memset.p0i8.i64(i8* %arraydecay, i8 1, i64 %len, i1 false)
+ call void @llvm.memset.p0.i64(ptr %q, i8 1, i64 %len, i1 false)
ret void
}
@@ -40,8 +39,8 @@ entry:
; CHECK-NOT: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 2
- call void @llvm.memset.p0i8.i64(i8* %arraydecay, i8 1, i64 7, i1 false)
+ %arraydecay = getelementptr inbounds [10 x i8], ptr %q, i32 0, i32 2
+ call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 7, i1 false)
ret void
}
@@ -51,8 +50,8 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 7
- call void @llvm.memset.p0i8.i64(i8* %arraydecay, i8 1, i64 5, i1 false)
+ %arraydecay = getelementptr inbounds [10 x i8], ptr %q, i32 0, i32 7
+ call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 5, i1 false)
ret void
}
@@ -62,8 +61,8 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr [10 x i8], [10 x i8]* %q, i32 0, i32 -1
- call void @llvm.memset.p0i8.i64(i8* %arraydecay, i8 1, i64 3, i1 false)
+ %arraydecay = getelementptr [10 x i8], ptr %q, i32 0, i32 -1
+ call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 3, i1 false)
ret void
}
@@ -74,8 +73,7 @@ entry:
; CHECK-NOT: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @readnone(i8* %arraydecay)
+ call void @readnone(ptr %q)
ret void
}
@@ -86,8 +84,7 @@ entry:
; CHECK-NOT: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @readnone0(i8* %arraydecay, i8* zeroinitializer)
+ call void @readnone0(ptr %q, ptr zeroinitializer)
ret void
}
@@ -98,8 +95,7 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @readnone0(i8 *zeroinitializer, i8* %arraydecay)
+ call void @readnone0(ptr zeroinitializer, ptr %q)
ret void
}
@@ -110,8 +106,7 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @readonly(i8* %arraydecay)
+ call void @readonly(ptr %q)
ret void
}
@@ -122,8 +117,7 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @arg_readonly(i8* %arraydecay)
+ call void @arg_readonly(ptr %q)
ret void
}
@@ -134,8 +128,7 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @readwrite(i8* %arraydecay)
+ call void @readwrite(ptr %q)
ret void
}
@@ -146,33 +139,31 @@ entry:
; CHECK: @__safestack_unsafe_stack_ptr
; CHECK: ret void
%q = alloca [10 x i8], align 1
- %arraydecay = getelementptr inbounds [10 x i8], [10 x i8]* %q, i32 0, i32 0
- call void @capture(i8* %arraydecay)
+ call void @capture(ptr %q)
ret void
}
; Lifetime intrinsics are always safe.
-define void @call_lifetime(i32* %p) {
+define void @call_lifetime(ptr %p) {
; CHECK-LABEL: define void @call_lifetime
; CHECK-NOT: @__safestack_unsafe_stack_ptr
; CHECK: ret void
entry:
%q = alloca [100 x i8], align 16
- %0 = bitcast [100 x i8]* %q to i8*
- call void @llvm.lifetime.start.p0i8(i64 100, i8* %0)
- call void @llvm.lifetime.end.p0i8(i64 100, i8* %0)
+ call void @llvm.lifetime.start.p0(i64 100, ptr %q)
+ call void @llvm.lifetime.end.p0(i64 100, ptr %q)
ret void
}
-declare void @readonly(i8* nocapture) readonly
-declare void @arg_readonly(i8* readonly nocapture)
-declare void @readwrite(i8* nocapture)
-declare void @capture(i8* readnone) readnone
+declare void @readonly(ptr nocapture) readonly
+declare void @arg_readonly(ptr readonly nocapture)
+declare void @readwrite(ptr nocapture)
+declare void @capture(ptr readnone) readnone
-declare void @readnone(i8* nocapture) readnone
-declare void @readnone0(i8* nocapture readnone, i8* nocapture)
+declare void @readnone(ptr nocapture) readnone
+declare void @readnone0(ptr nocapture readnone, ptr nocapture)
-declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind argmemonly
+declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind argmemonly
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind argmemonly
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) nounwind argmemonly
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind argmemonly
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind argmemonly
diff --git a/llvm/test/Transforms/SafeStack/X86/cast.ll b/llvm/test/Transforms/SafeStack/X86/cast.ll
index 23f525d5e0b18..41f01c3b576ae 100644
--- a/llvm/test/Transforms/SafeStack/X86/cast.ll
+++ b/llvm/test/Transforms/SafeStack/X86/cast.ll
@@ -11,8 +11,8 @@ entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = ptrtoint i32* %a to i64
- %1 = inttoptr i64 %0 to i32*
+ %0 = ptrtoint ptr %a to i64
+ %1 = inttoptr i64 %0 to ptr
ret void
}
@@ -22,9 +22,8 @@ entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret i8
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i8*
- %1 = load i8, i8* %0, align 1
- ret i8 %1
+ %0 = load i8, ptr %a, align 1
+ ret i8 %0
}
define i64 @BitCastWide() nounwind uwtable safestack {
@@ -33,7 +32,6 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret i64
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i64*
- %1 = load i64, i64* %0, align 1
- ret i64 %1
+ %0 = load i64, ptr %a, align 1
+ ret i64 %0
}
diff --git a/llvm/test/Transforms/SafeStack/X86/coloring-ssp.ll b/llvm/test/Transforms/SafeStack/X86/coloring-ssp.ll
index 040632e7526d1..032ffd1994772 100644
--- a/llvm/test/Transforms/SafeStack/X86/coloring-ssp.ll
+++ b/llvm/test/Transforms/SafeStack/X86/coloring-ssp.ll
@@ -4,31 +4,28 @@
define void @f() safestack sspreq {
; CHECK-LABEL: define void @f
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
-; CHECK: %[[A:.*]] = getelementptr i8, i8* %[[USP]], i32 -8
-; CHECK: %[[StackGuardSlot:.*]] = bitcast i8* %[[A]] to i8**
-; CHECK: store i8* %{{.*}}, i8** %[[StackGuardSlot]]
+; CHECK: %[[A:.*]] = getelementptr i8, ptr %[[USP]], i32 -8
+; CHECK: store ptr %{{.*}}, ptr %[[A]]
%x = alloca i64, align 8
%y = alloca i64, align 8
- %x0 = bitcast i64* %x to i8*
- %y0 = bitcast i64* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
- call void @capture64(i64* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
+ call void @capture64(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
- call void @capture64(i64* %y)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
+ call void @capture64(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
ret void
}
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
-declare void @capture64(i64*)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
+declare void @capture64(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/coloring.ll b/llvm/test/Transforms/SafeStack/X86/coloring.ll
index 60e960e693d5e..37bdccffd0c33 100644
--- a/llvm/test/Transforms/SafeStack/X86/coloring.ll
+++ b/llvm/test/Transforms/SafeStack/X86/coloring.ll
@@ -3,42 +3,36 @@
define void @f() safestack {
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%x1 = alloca i32, align 4
%x2 = alloca i32, align 4
- %0 = bitcast i32* %x to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %0)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x)
-; CHECK: %[[A1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
-; CHECK: %[[A2:.*]] = bitcast i8* %[[A1]] to i32*
-; CHECK: call void @capture(i32* nonnull %[[A2]])
+; CHECK: %[[A1:.*]] = getelementptr i8, ptr %[[USP]], i32 -4
+; CHECK: call void @capture(ptr nonnull %[[A1]])
- call void @capture(i32* nonnull %x)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %0)
- %1 = bitcast i32* %x1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
+ call void @capture(ptr nonnull %x)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %x)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x1)
-; CHECK: %[[B1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
-; CHECK: %[[B2:.*]] = bitcast i8* %[[B1]] to i32*
-; CHECK: call void @capture(i32* nonnull %[[B2]])
+; CHECK: %[[B1:.*]] = getelementptr i8, ptr %[[USP]], i32 -4
+; CHECK: call void @capture(ptr nonnull %[[B1]])
- call void @capture(i32* nonnull %x1)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %1)
- %2 = bitcast i32* %x2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %2)
+ call void @capture(ptr nonnull %x1)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %x1)
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x2)
-; CHECK: %[[C1:.*]] = getelementptr i8, i8* %[[USP]], i32 -4
-; CHECK: %[[C2:.*]] = bitcast i8* %[[C1]] to i32*
-; CHECK: call void @capture(i32* nonnull %[[C2]])
+; CHECK: %[[C1:.*]] = getelementptr i8, ptr %[[USP]], i32 -4
+; CHECK: call void @capture(ptr nonnull %[[C1]])
- call void @capture(i32* nonnull %x2)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %2)
+ call void @capture(ptr nonnull %x2)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %x2)
ret void
}
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
-declare void @capture(i32*)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
+declare void @capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/coloring2.ll b/llvm/test/Transforms/SafeStack/X86/coloring2.ll
index dae9feba4b9fc..b2f59906b6036 100644
--- a/llvm/test/Transforms/SafeStack/X86/coloring2.ll
+++ b/llvm/test/Transforms/SafeStack/X86/coloring2.ll
@@ -5,31 +5,28 @@
define void @f() safestack {
; CHECK-LABEL: define void @f
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
%z = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- %z0 = bitcast i32* %z to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @capture32(i32* %y)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @capture32(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture32(i32* %z)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture32(ptr %z)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z)
ret void
}
@@ -37,21 +34,20 @@ entry:
define void @no_markers() safestack {
; CHECK-LABEL: define void @no_markers(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture32(i32* %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture32(ptr %y)
ret void
}
@@ -60,31 +56,28 @@ entry:
define void @g() safestack {
; CHECK-LABEL: define void @g
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
%z = alloca i64, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- %z0 = bitcast i64* %z to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture32(i32* %y)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture32(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture64(i64* %z)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture64(ptr %z)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z)
ret void
}
@@ -93,32 +86,29 @@ entry:
define void @h() safestack {
; CHECK-LABEL: define void @h
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 16
%z = alloca i64, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- %z0 = bitcast i64* %z to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %z0)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
- call void @capture32(i32* %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
+ call void @capture32(ptr %x)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -12
- call void @capture32(i32* %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -12
+ call void @capture32(ptr %y)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture64(i64* %z)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture64(ptr %z)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %z0)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z)
ret void
}
@@ -145,8 +135,8 @@ entry:
define void @i(i1 zeroext %a, i1 zeroext %b) safestack {
; CHECK-LABEL: define void @i
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -32
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -32
%x1 = alloca i64, align 8
%x2 = alloca i64, align 8
%y = alloca i64, align 8
@@ -155,81 +145,73 @@ entry:
%z = alloca i64, align 8
%z1 = alloca i64, align 8
%z2 = alloca i64, align 8
- %0 = bitcast i64* %x1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
- %1 = bitcast i64* %x2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x1)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %x1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+ call void @capture64(ptr nonnull %x1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %x2)
+ call void @capture64(ptr nonnull %x2)
br i1 %a, label %if.then, label %if.else4
if.then: ; preds = %entry
- %2 = bitcast i64* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -24
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -24
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %y)
+ call void @capture64(ptr nonnull %y)
br i1 %b, label %if.then3, label %if.else
if.then3: ; preds = %if.then
- %3 = bitcast i64* %y1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %y1)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3)
+ call void @capture64(ptr nonnull %y1)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y1)
br label %if.end
if.else: ; preds = %if.then
- %4 = bitcast i64* %y2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %4)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %y2)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %4)
+ call void @capture64(ptr nonnull %y2)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y2)
br label %if.end
if.end: ; preds = %if.else, %if.then3
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
br label %if.end9
if.else4: ; preds = %entry
- %5 = bitcast i64* %z to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %5)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -24
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -24
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %z)
+ call void @capture64(ptr nonnull %z)
br i1 %b, label %if.then6, label %if.else7
if.then6: ; preds = %if.else4
- %6 = bitcast i64* %z1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %6)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %z1)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %6)
+ call void @capture64(ptr nonnull %z1)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z1)
br label %if.end8
if.else7: ; preds = %if.else4
- %7 = bitcast i64* %z2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %7)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %z2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
; CHECK: call void @capture64(
- call void @capture64(i64* nonnull %z2)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %7)
+ call void @capture64(ptr nonnull %z2)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z2)
br label %if.end8
if.end8: ; preds = %if.else7, %if.then6
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %5)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %z)
br label %if.end9
if.end9: ; preds = %if.end8, %if.end
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x2)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x1)
ret void
}
@@ -237,51 +219,47 @@ if.end9: ; preds = %if.end8, %if.end
define void @no_merge1(i1 %d) safestack {
; CHECK-LABEL: define void @no_merge1(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %x)
+ call void @capture32(ptr %x)
br i1 %d, label %bb2, label %bb3
bb2:
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
; CHECK: call void @capture32(
- call void @capture32(i32* %y)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @capture32(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
ret void
bb3:
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
ret void
}
define void @merge1(i1 %d) safestack {
; CHECK-LABEL: define void @merge1(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
br i1 %d, label %bb2, label %bb3
bb2:
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %y)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %y0)
+ call void @capture32(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %y)
ret void
bb3:
ret void
@@ -291,23 +269,21 @@ bb3:
define void @merge2_noend(i1 %d) safestack {
; CHECK-LABEL: define void @merge2_noend(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
br i1 %d, label %bb2, label %bb3
bb2:
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %y)
+ call void @capture32(ptr %y)
ret void
bb3:
ret void
@@ -317,23 +293,21 @@ bb3:
define void @merge3_noend(i1 %d) safestack {
; CHECK-LABEL: define void @merge3_noend(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %x)
+ call void @capture32(ptr %x)
br i1 %d, label %bb2, label %bb3
bb2:
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %y)
+ call void @capture32(ptr %y)
ret void
bb3:
ret void
@@ -343,22 +317,20 @@ bb3:
define void @nomerge4_nostart(i1 %d) safestack {
; CHECK-LABEL: define void @nomerge4_nostart(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i32, align 4
%y = alloca i32, align 4
- %x0 = bitcast i32* %x to i8*
- %y0 = bitcast i32* %y to i8*
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
; CHECK: call void @capture32(
- call void @capture32(i32* %x)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %x0)
+ call void @capture32(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %x)
br i1 %d, label %bb2, label %bb3
bb2:
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %y)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
; CHECK: call void @capture32(
- call void @capture32(i32* %y)
+ call void @capture32(ptr %y)
ret void
bb3:
ret void
@@ -367,54 +339,50 @@ bb3:
define void @array_merge() safestack {
; CHECK-LABEL: define void @array_merge(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -800
%A.i1 = alloca [100 x i32], align 4
%B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4
- %0 = bitcast [100 x i32]* %A.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0)
- %1 = bitcast [100 x i32]* %B.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -400
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %A.i)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %B.i)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -400
; CHECK: call void @capture100x32(
- call void @capture100x32([100 x i32]* %A.i)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -800
+ call void @capture100x32(ptr %A.i)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -800
; CHECK: call void @capture100x32(
- call void @capture100x32([100 x i32]* %B.i)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1)
- %2 = bitcast [100 x i32]* %A.i1 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %2)
- %3 = bitcast [100 x i32]* %B.i2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %3)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -400
+ call void @capture100x32(ptr %B.i)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %A.i)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %B.i)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %A.i1)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %B.i2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -400
; CHECK: call void @capture100x32(
- call void @capture100x32([100 x i32]* %A.i1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -800
+ call void @capture100x32(ptr %A.i1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -800
; CHECK: call void @capture100x32(
- call void @capture100x32([100 x i32]* %B.i2)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %2)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %3)
+ call void @capture100x32(ptr %B.i2)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %A.i1)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %B.i2)
ret void
}
define void @myCall_pr15707() safestack {
; CHECK-LABEL: define void @myCall_pr15707(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -200000
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -200000
%buf1 = alloca i8, i32 100000, align 16
%buf2 = alloca i8, i32 100000, align 16
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %buf1)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %buf1)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %buf1)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf1)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %buf2)
- call void @capture8(i8* %buf1)
- call void @capture8(i8* %buf2)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %buf1)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %buf2)
+ call void @capture8(ptr %buf1)
+ call void @capture8(ptr %buf2)
ret void
}
@@ -423,9 +391,9 @@ entry:
define void @bad_range() safestack {
; CHECK-LABEL: define void @bad_range(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
; A.i and B.i unsafe, not merged
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -800
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -800
; A.i1 and B.i2 safe
; CHECK: = alloca [100 x i32], align 4
; CHECK: = alloca [100 x i32], align 4
@@ -434,58 +402,53 @@ entry:
%B.i2 = alloca [100 x i32], align 4
%A.i = alloca [100 x i32], align 4
%B.i = alloca [100 x i32], align 4
- %0 = bitcast [100 x i32]* %A.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %0) nounwind
- %1 = bitcast [100 x i32]* %B.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %1) nounwind
- call void @capture100x32([100 x i32]* %A.i)
- call void @capture100x32([100 x i32]* %B.i)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %0) nounwind
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %1) nounwind
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %A.i) nounwind
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %B.i) nounwind
+ call void @capture100x32(ptr %A.i)
+ call void @capture100x32(ptr %B.i)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %A.i) nounwind
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %B.i) nounwind
br label %block2
block2:
; I am used outside the marked lifetime.
- call void @capture100x32([100 x i32]* %A.i)
- call void @capture100x32([100 x i32]* %B.i)
+ call void @capture100x32(ptr %A.i)
+ call void @capture100x32(ptr %B.i)
ret void
}
%struct.Klass = type { i32, i32 }
-define i32 @shady_range(i32 %argc, i8** nocapture %argv) safestack {
+define i32 @shady_range(i32 %argc, ptr nocapture %argv) safestack {
; CHECK-LABEL: define i32 @shady_range(
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -64
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -64
%a.i = alloca [4 x %struct.Klass], align 16
%b.i = alloca [4 x %struct.Klass], align 16
- %a8 = bitcast [4 x %struct.Klass]* %a.i to i8*
- %b8 = bitcast [4 x %struct.Klass]* %b.i to i8*
; I am used outside the lifetime zone below:
- %z2 = getelementptr inbounds [4 x %struct.Klass], [4 x %struct.Klass]* %a.i, i64 0, i64 0, i32 0
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %a8)
- call void @llvm.lifetime.start.p0i8(i64 -1, i8* %b8)
- call void @capture8(i8* %a8)
- call void @capture8(i8* %b8)
- %z3 = load i32, i32* %z2, align 16
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %a8)
- call void @llvm.lifetime.end.p0i8(i64 -1, i8* %b8)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %a.i)
+ call void @llvm.lifetime.start.p0(i64 -1, ptr %b.i)
+ call void @capture8(ptr %a.i)
+ call void @capture8(ptr %b.i)
+ %z3 = load i32, ptr %a.i, align 16
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %a.i)
+ call void @llvm.lifetime.end.p0(i64 -1, ptr %b.i)
ret i32 %z3
}
define void @end_loop() safestack {
; CHECK-LABEL: define void @end_loop()
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i8, align 4
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x) nounwind
br label %l2
l2:
- call void @capture8(i8* %x)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %x) nounwind
+ call void @capture8(ptr %x)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %x) nounwind
br label %l2
}
@@ -494,22 +457,22 @@ l2:
define void @start_loop() safestack {
; CHECK-LABEL: define void @start_loop()
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
%x = alloca i8, align 4
%y = alloca i8, align 4
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x) nounwind
br label %l2
l2:
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) nounwind
- call void @capture8(i8* %y)
- call void @llvm.lifetime.end.p0i8(i64 4, i8* %y) nounwind
-
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) nounwind
- call void @capture8(i8* %x)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @llvm.lifetime.start.p0(i64 4, ptr %y) nounwind
+ call void @capture8(ptr %y)
+ call void @llvm.lifetime.end.p0(i64 4, ptr %y) nounwind
+
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @llvm.lifetime.start.p0(i64 4, ptr %x) nounwind
+ call void @capture8(ptr %x)
br label %l2
}
@@ -522,43 +485,40 @@ l2:
; CHECK-LABEL: @stack_coloring_liveness_bug
define void @stack_coloring_liveness_bug(i32 %arg0) #0 {
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -64
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -64
%alloca = alloca [32 x i8], align 16
%alloca2 = alloca [32 x i8], align 16
%cond = icmp eq i32 %arg0, 0
br i1 %cond, label %if, label %else
if:
- %alloca.if = bitcast [32 x i8]* %alloca to i8*
br label %end
else:
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
- %alloca.else = bitcast [32 x i8]* %alloca to i8*
- call void @llvm.lifetime.start.p0i8(i64 32, i8* nonnull %alloca.else)
- call void @capture8(i8* %alloca.else)
- call void @llvm.lifetime.end.p0i8(i64 32, i8* nonnull %alloca.else)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
+ call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %alloca)
+ call void @capture8(ptr %alloca)
+ call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %alloca)
br label %end
end:
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -64
- %alloca.end = phi i8* [ %alloca.if, %if], [%alloca.else, %else]
- %alloca2.bitcast = bitcast [32 x i8]* %alloca2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 32, i8* nonnull %alloca2.bitcast)
- call void @llvm.lifetime.start.p0i8(i64 32, i8* nonnull %alloca.end)
- call void @capture2_8(i8* %alloca2.bitcast, i8* %alloca.end)
- call void @llvm.lifetime.end.p0i8(i64 32, i8* nonnull %alloca2.bitcast)
- call void @llvm.lifetime.end.p0i8(i64 32, i8* nonnull %alloca.end)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -64
+ %alloca.end = phi ptr [ %alloca, %if], [%alloca, %else]
+ call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %alloca2)
+ call void @llvm.lifetime.start.p0(i64 32, ptr nonnull %alloca.end)
+ call void @capture2_8(ptr %alloca2, ptr %alloca.end)
+ call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %alloca2)
+ call void @llvm.lifetime.end.p0(i64 32, ptr nonnull %alloca.end)
ret void
}
attributes #0 = { safestack }
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
-declare void @capture8(i8*)
-declare void @capture32(i32*)
-declare void @capture64(i64*)
-declare void @capture100x32([100 x i32]*)
-declare void @capture2_8(i8*, i8*)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
+declare void @capture8(ptr)
+declare void @capture32(ptr)
+declare void @capture64(ptr)
+declare void @capture100x32(ptr)
+declare void @capture2_8(ptr, ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/constant-gep-call.ll b/llvm/test/Transforms/SafeStack/X86/constant-gep-call.ll
index 456c1cb1596b7..880471a8a63d9 100644
--- a/llvm/test/Transforms/SafeStack/X86/constant-gep-call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/constant-gep-call.ll
@@ -16,11 +16,10 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
%c = alloca %struct.nest, align 4
- %b = getelementptr inbounds %struct.nest, %struct.nest* %c, i32 0, i32 1
- %_a = getelementptr inbounds %struct.pair, %struct.pair* %b, i32 0, i32 0
- %0 = load i32, i32* %_a, align 4
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %0)
+ %b = getelementptr inbounds %struct.nest, ptr %c, i32 0, i32 1
+ %0 = load i32, ptr %b, align 4
+ %call = call i32 (ptr, ...) @printf(ptr @.str, i32 %0)
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/constant-gep.ll b/llvm/test/Transforms/SafeStack/X86/constant-gep.ll
index 6468a761dd574..935c3624e387a 100644
--- a/llvm/test/Transforms/SafeStack/X86/constant-gep.ll
+++ b/llvm/test/Transforms/SafeStack/X86/constant-gep.ll
@@ -13,8 +13,6 @@ define signext i8 @foo() nounwind uwtable safestack {
entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
%a = alloca %class.A, align 1
- %array = getelementptr inbounds %class.A, %class.A* %a, i32 0, i32 0
- %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0
- %0 = load i8, i8* %arrayidx, align 1
+ %0 = load i8, ptr %a, align 1
ret i8 %0
}
diff --git a/llvm/test/Transforms/SafeStack/X86/constant-geps.ll b/llvm/test/Transforms/SafeStack/X86/constant-geps.ll
index 8a6f7549bb4e2..fd099db5f943e 100644
--- a/llvm/test/Transforms/SafeStack/X86/constant-geps.ll
+++ b/llvm/test/Transforms/SafeStack/X86/constant-geps.ll
@@ -17,12 +17,6 @@ define signext i8 @foo() nounwind uwtable safestack {
entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
%x = alloca %struct.deep, align 1
- %b = getelementptr inbounds %struct.deep, %struct.deep* %x, i32 0, i32 0
- %c = bitcast %union.anon* %b to %struct.anon*
- %d = getelementptr inbounds %struct.anon, %struct.anon* %c, i32 0, i32 0
- %e = getelementptr inbounds %struct.anon.0, %struct.anon.0* %d, i32 0, i32 0
- %array = bitcast %union.anon.1* %e to [2 x i8]*
- %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %array, i32 0, i64 0
- %0 = load i8, i8* %arrayidx, align 1
+ %0 = load i8, ptr %x, align 1
ret i8 %0
}
diff --git a/llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll b/llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll
index c944f841ca40e..c118c486e5aa9 100644
--- a/llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll
+++ b/llvm/test/Transforms/SafeStack/X86/debug-loc-dynamic.ll
@@ -13,17 +13,17 @@ entry:
tail call void @llvm.dbg.value(metadata i32 %n, metadata !11, metadata !14), !dbg !15
%0 = zext i32 %n to i64, !dbg !16
-; CHECK: store i8* %[[VLA:.*]], i8** @__safestack_unsafe_stack_ptr
-; CHECK: tail call void @llvm.dbg.value(metadata i8* %[[VLA]], metadata ![[TYPE:.*]], metadata !DIExpression(DW_OP_deref))
+; CHECK: store ptr %[[VLA:.*]], ptr @__safestack_unsafe_stack_ptr
+; CHECK: tail call void @llvm.dbg.value(metadata ptr %[[VLA]], metadata ![[TYPE:.*]], metadata !DIExpression(DW_OP_deref))
; CHECK: call void @capture({{.*}} %[[VLA]])
%vla = alloca i8, i64 %0, align 16, !dbg !16
- tail call void @llvm.dbg.value(metadata i8* %vla, metadata !12, metadata !17), !dbg !18
- call void @capture(i8* nonnull %vla), !dbg !19
+ tail call void @llvm.dbg.value(metadata ptr %vla, metadata !12, metadata !17), !dbg !18
+ call void @capture(ptr nonnull %vla), !dbg !19
ret void, !dbg !20
}
-declare void @capture(i8*)
+declare void @capture(ptr)
declare void @llvm.dbg.value(metadata, metadata, metadata)
!llvm.dbg.cu = !{!0}
diff --git a/llvm/test/Transforms/SafeStack/X86/debug-loc.ll b/llvm/test/Transforms/SafeStack/X86/debug-loc.ll
index 2b0018a71539d..8501f7446f99f 100644
--- a/llvm/test/Transforms/SafeStack/X86/debug-loc.ll
+++ b/llvm/test/Transforms/SafeStack/X86/debug-loc.ll
@@ -8,25 +8,25 @@ target triple = "x86_64-unknown-linux-gnu"
%struct.S = type { [100 x i8] }
; Function Attrs: safestack uwtable
-define void @f(%struct.S* byval(%struct.S) align 8 %zzz) #0 !dbg !12 {
+define void @f(ptr byval(%struct.S) align 8 %zzz) #0 !dbg !12 {
; CHECK: define void @f
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
%xxx = alloca %struct.S, align 1
- call void @llvm.dbg.declare(metadata %struct.S* %zzz, metadata !18, metadata !19), !dbg !20
- call void @llvm.dbg.declare(metadata %struct.S* %xxx, metadata !21, metadata !19), !dbg !22
+ call void @llvm.dbg.declare(metadata ptr %zzz, metadata !18, metadata !19), !dbg !20
+ call void @llvm.dbg.declare(metadata ptr %xxx, metadata !21, metadata !19), !dbg !22
; dbg.declare for %zzz and %xxx are gone; replaced with dbg.declare based off the unsafe stack pointer
; CHECK-NOT: call void @llvm.dbg.declare
-; CHECK: call void @llvm.dbg.declare(metadata i8* %[[USP]], metadata ![[VAR_ARG:.*]], metadata !DIExpression(DW_OP_constu, 104, DW_OP_minus))
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[USP]], metadata ![[VAR_ARG:.*]], metadata !DIExpression(DW_OP_constu, 104, DW_OP_minus))
; CHECK-NOT: call void @llvm.dbg.declare
-; CHECK: call void @llvm.dbg.declare(metadata i8* %[[USP]], metadata ![[VAR_LOCAL:.*]], metadata !DIExpression(DW_OP_constu, 208, DW_OP_minus))
+; CHECK: call void @llvm.dbg.declare(metadata ptr %[[USP]], metadata ![[VAR_LOCAL:.*]], metadata !DIExpression(DW_OP_constu, 208, DW_OP_minus))
; CHECK-NOT: call void @llvm.dbg.declare
- call void @Capture(%struct.S* %zzz), !dbg !23
- call void @Capture(%struct.S* %xxx), !dbg !24
+ call void @Capture(ptr %zzz), !dbg !23
+ call void @Capture(ptr %xxx), !dbg !24
; dbg.declare appears before the first use
; CHECK: call void @Capture
@@ -43,7 +43,7 @@ entry:
; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
-declare void @Capture(%struct.S*) #2
+declare void @Capture(ptr) #2
attributes #0 = { safestack uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone }
diff --git a/llvm/test/Transforms/SafeStack/X86/debug-loc2.ll b/llvm/test/Transforms/SafeStack/X86/debug-loc2.ll
index 09033789f5943..05b66a5175cc7 100644
--- a/llvm/test/Transforms/SafeStack/X86/debug-loc2.ll
+++ b/llvm/test/Transforms/SafeStack/X86/debug-loc2.ll
@@ -10,46 +10,44 @@ target triple = "x86_64-unknown-linux-gnu"
; Function Attrs: noinline safestack uwtable
define void @f() #0 !dbg !6 {
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
%x1 = alloca i32, align 4
%x2 = alloca i32, align 4
- %0 = bitcast i32* %x1 to i8*, !dbg !13
- %1 = bitcast i32* %x2 to i8*, !dbg !14
; Unhandled dbg.value: expression does not start with OP_DW_deref
-; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}})
- tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !23), !dbg !16
+; CHECK: call void @llvm.dbg.value(metadata ptr undef, metadata !{{.*}}, metadata !{{.*}})
+ tail call void @llvm.dbg.value(metadata ptr %x1, metadata !10, metadata !23), !dbg !16
; Unhandled dbg.value: expression does not start with OP_DW_deref
-; CHECK: call void @llvm.dbg.value(metadata i32* undef, metadata !{{.*}}, metadata !{{.*}})
- tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !24), !dbg !16
+; CHECK: call void @llvm.dbg.value(metadata ptr undef, metadata !{{.*}}, metadata !{{.*}})
+ tail call void @llvm.dbg.value(metadata ptr %x1, metadata !10, metadata !24), !dbg !16
; Supported dbg.value: rewritted based on the [[USP]] value.
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref, DW_OP_LLVM_fragment, 0, 4))
- tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !25), !dbg !16
+; CHECK: call void @llvm.dbg.value(metadata ptr %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref, DW_OP_LLVM_fragment, 0, 4))
+ tail call void @llvm.dbg.value(metadata ptr %x1, metadata !10, metadata !25), !dbg !16
; Supported dbg.value: rewritted based on the [[USP]] value.
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref))
- tail call void @llvm.dbg.value(metadata i32* %x1, metadata !10, metadata !15), !dbg !16
- call void @capture(i32* nonnull %x1), !dbg !17
+; CHECK: call void @llvm.dbg.value(metadata ptr %[[USP]], metadata ![[X1:.*]], metadata !DIExpression(DW_OP_constu, 4, DW_OP_minus, DW_OP_deref))
+ tail call void @llvm.dbg.value(metadata ptr %x1, metadata !10, metadata !15), !dbg !16
+ call void @capture(ptr nonnull %x1), !dbg !17
; An extra non-dbg.value metadata use of %x2. Replaced with undef.
-; CHECK: call void @llvm.random.metadata.use(metadata i32* undef
- call void @llvm.random.metadata.use(metadata i32* %x2)
+; CHECK: call void @llvm.random.metadata.use(metadata ptr undef
+ call void @llvm.random.metadata.use(metadata ptr %x2)
-; CHECK: call void @llvm.dbg.value(metadata i8* %[[USP]], metadata ![[X2:.*]], metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref))
- call void @llvm.dbg.value(metadata i32* %x2, metadata !12, metadata !15), !dbg !18
- call void @capture(i32* nonnull %x2), !dbg !19
+; CHECK: call void @llvm.dbg.value(metadata ptr %[[USP]], metadata ![[X2:.*]], metadata !DIExpression(DW_OP_constu, 8, DW_OP_minus, DW_OP_deref))
+ call void @llvm.dbg.value(metadata ptr %x2, metadata !12, metadata !15), !dbg !18
+ call void @capture(ptr nonnull %x2), !dbg !19
ret void, !dbg !20
}
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture) #1
-declare void @capture(i32*) #2
+declare void @capture(ptr) #2
; Function Attrs: argmemonly nounwind
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #1
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture) #1
; Function Attrs: nounwind readnone
declare void @llvm.dbg.value(metadata, metadata, metadata) #3
diff --git a/llvm/test/Transforms/SafeStack/X86/dynamic-alloca.ll b/llvm/test/Transforms/SafeStack/X86/dynamic-alloca.ll
index b0571f72f1aaf..d8377781bb6e5 100644
--- a/llvm/test/Transforms/SafeStack/X86/dynamic-alloca.ll
+++ b/llvm/test/Transforms/SafeStack/X86/dynamic-alloca.ll
@@ -8,15 +8,14 @@
; Requires protector.
define void @foo(i32 %n) nounwind uwtable safestack {
entry:
- ; CHECK: %[[SP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[SP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
%n.addr = alloca i32, align 4
- %a = alloca i32*, align 8
- store i32 %n, i32* %n.addr, align 4
- %0 = load i32, i32* %n.addr, align 4
+ %a = alloca ptr, align 8
+ store i32 %n, ptr %n.addr, align 4
+ %0 = load i32, ptr %n.addr, align 4
%conv = sext i32 %0 to i64
%1 = alloca i8, i64 %conv
- %2 = bitcast i8* %1 to i32*
- store i32* %2, i32** %a, align 8
- ; CHECK: store i8* %[[SP:.*]], i8** @__safestack_unsafe_stack_ptr
+ store ptr %1, ptr %a, align 8
+ ; CHECK: store ptr %[[SP:.*]], ptr @__safestack_unsafe_stack_ptr
ret void
}
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-addr-pointer.ll b/llvm/test/Transforms/SafeStack/X86/escape-addr-pointer.ll
index 615d711f62c28..a650ee9661f06 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-addr-pointer.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-addr-pointer.ll
@@ -9,15 +9,15 @@
define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
- %a = alloca i32*, align 8
- %b = alloca i32**, align 8
- %call = call i32* @getp()
- store i32* %call, i32** %a, align 8
- store i32** %a, i32*** %b, align 8
- %0 = load i32**, i32*** %b, align 8
- call void @funcall2(i32** %0)
+ %a = alloca ptr, align 8
+ %b = alloca ptr, align 8
+ %call = call ptr @getp()
+ store ptr %call, ptr %a, align 8
+ store ptr %a, ptr %b, align 8
+ %0 = load ptr, ptr %b, align 8
+ call void @funcall2(ptr %0)
ret void
}
-declare void @funcall2(i32**)
-declare i32* @getp()
+declare void @funcall2(ptr)
+declare ptr @getp()
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store.ll b/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store.ll
index 9d556a6782a13..bde9c3a21964c 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store.ll
@@ -4,20 +4,19 @@
@.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
; Addr-of a local cast to a ptr of a
diff erent type
-; (e.g., int a; ... ; float *b = &a;)
+; (e.g., int a; ... ; ptr b = &a;)
; safestack attribute
; Requires protector.
define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%a = alloca i32, align 4
- %b = alloca float*, align 8
- store i32 0, i32* %a, align 4
- %0 = bitcast i32* %a to float*
- store float* %0, float** %b, align 8
- %1 = load float*, float** %b, align 8
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), float* %1)
+ %b = alloca ptr, align 8
+ store i32 0, ptr %a, align 4
+ store ptr %a, ptr %b, align 8
+ %0 = load ptr, ptr %b, align 8
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %0)
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store2.ll b/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store2.ll
index 5f1f873f4224c..8dd1233cd0230 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store2.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-bitcast-store2.ll
@@ -4,17 +4,16 @@
@.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1
; Addr-of a local cast to a ptr of a
diff erent type (optimized)
-; (e.g., int a; ... ; float *b = &a;)
+; (e.g., int a; ... ; ptr b = &a;)
; safestack attribute
; Requires protector.
define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%a = alloca i32, align 4
- store i32 0, i32* %a, align 4
- %0 = bitcast i32* %a to float*
- call void @funfloat(float* %0) nounwind
+ store i32 0, ptr %a, align 4
+ call void @funfloat(ptr %a) nounwind
ret void
}
-declare void @funfloat(float*)
+declare void @funfloat(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-call.ll b/llvm/test/Transforms/SafeStack/X86/escape-call.ll
index ce09780d2eaf7..9af891e3f62e4 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-call.ll
@@ -9,8 +9,8 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%b = alloca i32, align 4
- call void @funcall(i32* %b) nounwind
+ call void @funcall(ptr %b) nounwind
ret void
}
-declare void @funcall(i32*)
+declare void @funcall(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-casted-pointer.ll b/llvm/test/Transforms/SafeStack/X86/escape-casted-pointer.ll
index bf6ce1d6b2a3a..d482f0c8263f6 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-casted-pointer.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-casted-pointer.ll
@@ -9,16 +9,15 @@
define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
- %a = alloca i32*, align 8
- %b = alloca float**, align 8
- %call = call i32* @getp()
- store i32* %call, i32** %a, align 8
- %0 = bitcast i32** %a to float**
- store float** %0, float*** %b, align 8
- %1 = load float**, float*** %b, align 8
- call void @funfloat2(float** %1)
+ %a = alloca ptr, align 8
+ %b = alloca ptr, align 8
+ %call = call ptr @getp()
+ store ptr %call, ptr %a, align 8
+ store ptr %a, ptr %b, align 8
+ %0 = load ptr, ptr %b, align 8
+ call void @funfloat2(ptr %0)
ret void
}
-declare void @funfloat2(float**)
-declare i32* @getp()
+declare void @funfloat2(ptr)
+declare ptr @getp()
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-gep-call.ll b/llvm/test/Transforms/SafeStack/X86/escape-gep-call.ll
index 42b5dd5c1e72e..759dc5d1cb1ab 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-gep-call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-gep-call.ll
@@ -12,9 +12,9 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%c = alloca %struct.pair, align 4
- %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i64 0, i32 1
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %y) nounwind
+ %y = getelementptr inbounds %struct.pair, ptr %c, i64 0, i32 1
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %y) nounwind
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-gep-invoke.ll b/llvm/test/Transforms/SafeStack/X86/escape-gep-invoke.ll
index 8495ff985f662..d09a3d85d39e5 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-gep-invoke.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-gep-invoke.ll
@@ -9,26 +9,24 @@
; (GEP followed by an invoke)
; safestack attribute
; Requires protector.
-define i32 @foo() uwtable safestack personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i32 @foo() uwtable safestack personality ptr @__gxx_personality_v0 {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%c = alloca %struct.pair, align 4
- %exn.slot = alloca i8*
+ %exn.slot = alloca ptr
%ehselector.slot = alloca i32
- %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
- store i32 0, i32* %a, align 4
- %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
- invoke void @_Z3exceptPi(i32* %a1)
+ store i32 0, ptr %c, align 4
+ invoke void @_Z3exceptPi(ptr %c)
to label %invoke.cont unwind label %lpad
invoke.cont:
ret i32 0
lpad:
- %0 = landingpad { i8*, i32 }
- catch i8* null
+ %0 = landingpad { ptr, i32 }
+ catch ptr null
ret i32 0
}
-declare void @_Z3exceptPi(i32*)
+declare void @_Z3exceptPi(ptr)
declare i32 @__gxx_personality_v0(...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-gep-negative.ll b/llvm/test/Transforms/SafeStack/X86/escape-gep-negative.ll
index 80d405de36d69..896cae9621056 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-gep-negative.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-gep-negative.ll
@@ -10,9 +10,9 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%a = alloca i32, align 4
- %add.ptr5 = getelementptr inbounds i32, i32* %a, i64 -12
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %add.ptr5) nounwind
+ %add.ptr5 = getelementptr inbounds i32, ptr %a, i64 -12
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %add.ptr5) nounwind
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-gep-ptrtoint.ll b/llvm/test/Transforms/SafeStack/X86/escape-gep-ptrtoint.ll
index 73a8e58fb0862..60783b8d657ac 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-gep-ptrtoint.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-gep-ptrtoint.ll
@@ -12,11 +12,11 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%c = alloca %struct.pair, align 4
- %b = alloca i32*, align 8
- %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1
- %0 = ptrtoint i32* %y to i64
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
+ %b = alloca ptr, align 8
+ %y = getelementptr inbounds %struct.pair, ptr %c, i32 0, i32 1
+ %0 = ptrtoint ptr %y to i64
+ %call = call i32 (ptr, ...) @printf(ptr @.str, i64 %0)
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-gep-store.ll b/llvm/test/Transforms/SafeStack/X86/escape-gep-store.ll
index 7c6c0a318b177..b7dad0eb34bae 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-gep-store.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-gep-store.ll
@@ -12,12 +12,12 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%c = alloca %struct.pair, align 4
- %b = alloca i32*, align 8
- %y = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 1
- store i32* %y, i32** %b, align 8
- %0 = load i32*, i32** %b, align 8
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32* %0)
+ %b = alloca ptr, align 8
+ %y = getelementptr inbounds %struct.pair, ptr %c, i32 0, i32 1
+ store ptr %y, ptr %b, align 8
+ %0 = load ptr, ptr %b, align 8
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %0)
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-phi-call.ll b/llvm/test/Transforms/SafeStack/X86/escape-phi-call.ll
index 10b6c1fdce453..1dd5d6e0d9274 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-phi-call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-phi-call.ll
@@ -10,13 +10,13 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
%x = alloca double, align 8
%call = call double @testi_aux() nounwind
- store double %call, double* %x, align 8
+ store double %call, ptr %x, align 8
%cmp = fcmp ogt double %call, 3.140000e+00
br i1 %cmp, label %if.then, label %if.else
if.then: ; preds = %entry
%call1 = call double @testi_aux() nounwind
- store double %call1, double* %x, align 8
+ store double %call1, ptr %x, align 8
br label %if.end4
if.else: ; preds = %entry
@@ -27,10 +27,10 @@ if.then3: ; preds = %if.else
br label %if.end4
if.end4: ; preds = %if.else, %if.then3, %if.then
- %y.0 = phi double* [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ]
- %call5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), double* %y.0) nounwind
+ %y.0 = phi ptr [ null, %if.then ], [ %x, %if.then3 ], [ null, %if.else ]
+ %call5 = call i32 (ptr, ...) @printf(ptr @.str, ptr %y.0) nounwind
ret void
}
declare double @testi_aux()
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-select-call.ll b/llvm/test/Transforms/SafeStack/X86/escape-select-call.ll
index 9e54dd8e14019..5d1046ca96602 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-select-call.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-select-call.ll
@@ -11,12 +11,12 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
%x = alloca double, align 8
%call = call double @testi_aux() nounwind
- store double %call, double* %x, align 8
+ store double %call, ptr %x, align 8
%cmp2 = fcmp ogt double %call, 0.000000e+00
- %y.1 = select i1 %cmp2, double* %x, double* null
- %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), double* %y.1)
+ %y.1 = select i1 %cmp2, ptr %x, ptr null
+ %call2 = call i32 (ptr, ...) @printf(ptr @.str, ptr %y.1)
ret void
}
declare double @testi_aux()
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/escape-vector.ll b/llvm/test/Transforms/SafeStack/X86/escape-vector.ll
index 76b01c7c430c2..c725ba922cf0e 100644
--- a/llvm/test/Transforms/SafeStack/X86/escape-vector.ll
+++ b/llvm/test/Transforms/SafeStack/X86/escape-vector.ll
@@ -12,10 +12,9 @@ define void @foo() nounwind uwtable safestack {
entry:
; CHECK: __safestack_unsafe_stack_ptr
%c = alloca %struct.vec, align 16
- %y = getelementptr inbounds %struct.vec, %struct.vec* %c, i64 0, i32 0
- %add.ptr = getelementptr inbounds <4 x i32>, <4 x i32>* %y, i64 -12
- %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), <4 x i32>* %add.ptr) nounwind
+ %add.ptr = getelementptr inbounds <4 x i32>, ptr %c, i64 -12
+ %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %add.ptr) nounwind
ret void
}
-declare i32 @printf(i8*, ...)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/invoke.ll b/llvm/test/Transforms/SafeStack/X86/invoke.ll
index bfebc336cfd08..5385169950cc3 100644
--- a/llvm/test/Transforms/SafeStack/X86/invoke.ll
+++ b/llvm/test/Transforms/SafeStack/X86/invoke.ll
@@ -6,15 +6,15 @@
; Addr-of a variable passed into an invoke instruction.
; safestack attribute
; Requires protector and stack restore after landing pad.
-define i32 @foo() uwtable safestack personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+define i32 @foo() uwtable safestack personality ptr @__gxx_personality_v0 {
entry:
- ; CHECK: %[[SP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
- ; CHECK: %[[STATICTOP:.*]] = getelementptr i8, i8* %[[SP]], i32 -16
+ ; CHECK: %[[SP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[STATICTOP:.*]] = getelementptr i8, ptr %[[SP]], i32 -16
%a = alloca i32, align 4
- %exn.slot = alloca i8*
+ %exn.slot = alloca ptr
%ehselector.slot = alloca i32
- store i32 0, i32* %a, align 4
- invoke void @_Z3exceptPi(i32* %a)
+ store i32 0, ptr %a, align 4
+ invoke void @_Z3exceptPi(ptr %a)
to label %invoke.cont unwind label %lpad
invoke.cont:
@@ -23,11 +23,11 @@ invoke.cont:
lpad:
; CHECK: landingpad
; CHECK-NEXT: catch
- %0 = landingpad { i8*, i32 }
- catch i8* null
- ; CHECK-NEXT: store i8* %[[STATICTOP]], i8** @__safestack_unsafe_stack_ptr
+ %0 = landingpad { ptr, i32 }
+ catch ptr null
+ ; CHECK-NEXT: store ptr %[[STATICTOP]], ptr @__safestack_unsafe_stack_ptr
ret i32 0
}
-declare void @_Z3exceptPi(i32*)
+declare void @_Z3exceptPi(ptr)
declare i32 @__gxx_personality_v0(...)
diff --git a/llvm/test/Transforms/SafeStack/X86/layout-frag.ll b/llvm/test/Transforms/SafeStack/X86/layout-frag.ll
index 40b9cf7f81294..19c3855bc1cb8 100644
--- a/llvm/test/Transforms/SafeStack/X86/layout-frag.ll
+++ b/llvm/test/Transforms/SafeStack/X86/layout-frag.ll
@@ -4,36 +4,34 @@
define void @f() safestack {
; CHECK-LABEL: define void @f
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
%x0 = alloca i64, align 8
%x1 = alloca i8, align 1
%x2 = alloca i64, align 8
- %x0a = bitcast i64* %x0 to i8*
- %x2a = bitcast i64* %x2 to i8*
- call void @llvm.lifetime.start.p0i8(i64 8, i8* %x0a)
- call void @capture64(i64* %x0)
- call void @llvm.lifetime.end.p0i8(i64 8, i8* %x0a)
+ call void @llvm.lifetime.start.p0(i64 8, ptr %x0)
+ call void @capture64(ptr %x0)
+ call void @llvm.lifetime.end.p0(i64 8, ptr %x0)
- call void @llvm.lifetime.start.p0i8(i64 1, i8* %x1)
- call void @llvm.lifetime.start.p0i8(i64 8, i8* %x2a)
- call void @capture8(i8* %x1)
- call void @capture64(i64* %x2)
- call void @llvm.lifetime.end.p0i8(i64 1, i8* %x1)
- call void @llvm.lifetime.end.p0i8(i64 8, i8* %x2a)
+ call void @llvm.lifetime.start.p0(i64 1, ptr %x1)
+ call void @llvm.lifetime.start.p0(i64 8, ptr %x2)
+ call void @capture8(ptr %x1)
+ call void @capture64(ptr %x2)
+ call void @llvm.lifetime.end.p0(i64 1, ptr %x1)
+ call void @llvm.lifetime.end.p0(i64 8, ptr %x2)
; Test that i64 allocas share space.
-; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
-; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -9
-; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
+; CHECK: getelementptr i8, ptr %unsafe_stack_ptr, i32 -8
+; CHECK: getelementptr i8, ptr %unsafe_stack_ptr, i32 -9
+; CHECK: getelementptr i8, ptr %unsafe_stack_ptr, i32 -8
ret void
}
-declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
-declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
-declare void @capture8(i8*)
-declare void @capture64(i64*)
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
+declare void @capture8(ptr)
+declare void @capture64(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/layout-region-split.ll b/llvm/test/Transforms/SafeStack/X86/layout-region-split.ll
index ceb18bb70c204..3bee85527f824 100644
--- a/llvm/test/Transforms/SafeStack/X86/layout-region-split.ll
+++ b/llvm/test/Transforms/SafeStack/X86/layout-region-split.ll
@@ -4,8 +4,8 @@
define void @f() safestack {
; CHECK-LABEL: define void @f
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -224
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -224
%x0 = alloca i8, align 16
%x1 = alloca i8, align 16
@@ -31,54 +31,54 @@ entry:
%y7 = alloca i8, align 2
%y8 = alloca i8, align 2
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
- call void @capture8(i8* %x0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -32
- call void @capture8(i8* %x1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -48
- call void @capture8(i8* %x2)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -64
- call void @capture8(i8* %x3)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -80
- call void @capture8(i8* %x4)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -96
- call void @capture8(i8* %x5)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -112
- call void @capture8(i8* %x6)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -128
- call void @capture8(i8* %x7)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -144
- call void @capture8(i8* %x8)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -160
- call void @capture8(i8* %x9)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -176
- call void @capture8(i8* %x10)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -192
- call void @capture8(i8* %x11)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -208
- call void @capture8(i8* %x12)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -224
- call void @capture8(i8* %x13)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -2
- call void @capture8(i8* %y0)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -4
- call void @capture8(i8* %y1)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -6
- call void @capture8(i8* %y2)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -8
- call void @capture8(i8* %y3)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -10
- call void @capture8(i8* %y4)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -12
- call void @capture8(i8* %y5)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -14
- call void @capture8(i8* %y6)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -18
- call void @capture8(i8* %y7)
-; CHECK: getelementptr i8, i8* %[[USP]], i32 -20
- call void @capture8(i8* %y8)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -16
+ call void @capture8(ptr %x0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -32
+ call void @capture8(ptr %x1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -48
+ call void @capture8(ptr %x2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -64
+ call void @capture8(ptr %x3)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -80
+ call void @capture8(ptr %x4)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -96
+ call void @capture8(ptr %x5)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -112
+ call void @capture8(ptr %x6)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -128
+ call void @capture8(ptr %x7)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -144
+ call void @capture8(ptr %x8)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -160
+ call void @capture8(ptr %x9)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -176
+ call void @capture8(ptr %x10)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -192
+ call void @capture8(ptr %x11)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -208
+ call void @capture8(ptr %x12)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -224
+ call void @capture8(ptr %x13)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -2
+ call void @capture8(ptr %y0)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -4
+ call void @capture8(ptr %y1)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -6
+ call void @capture8(ptr %y2)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -8
+ call void @capture8(ptr %y3)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -10
+ call void @capture8(ptr %y4)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -12
+ call void @capture8(ptr %y5)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -14
+ call void @capture8(ptr %y6)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -18
+ call void @capture8(ptr %y7)
+; CHECK: getelementptr i8, ptr %[[USP]], i32 -20
+ call void @capture8(ptr %y8)
ret void
}
-declare void @capture8(i8*)
+declare void @capture8(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/memintrinsic-oob-read.ll b/llvm/test/Transforms/SafeStack/X86/memintrinsic-oob-read.ll
index 90af6b3e54043..9bc247ed6c509 100644
--- a/llvm/test/Transforms/SafeStack/X86/memintrinsic-oob-read.ll
+++ b/llvm/test/Transforms/SafeStack/X86/memintrinsic-oob-read.ll
@@ -4,11 +4,11 @@
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
-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)
; CHECK: __safestack_unsafe_stack_ptr
-define void @oob_read(i8* %ptr) safestack {
+define void @oob_read(ptr %ptr) safestack {
%1 = alloca i8
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %ptr, i8* align 1 %1, i64 4, i1 false)
+ call void @llvm.memcpy.p0.p0.i64(ptr align 1 %ptr, ptr align 1 %1, i64 4, i1 false)
ret void
}
diff --git a/llvm/test/Transforms/SafeStack/X86/musttail.ll b/llvm/test/Transforms/SafeStack/X86/musttail.ll
index d209b2ff2ab48..32bc6674a2a22 100644
--- a/llvm/test/Transforms/SafeStack/X86/musttail.ll
+++ b/llvm/test/Transforms/SafeStack/X86/musttail.ll
@@ -4,43 +4,41 @@
target triple = "x86_64-unknown-linux-gnu"
-declare i32 @foo(i32* %p)
-declare void @alloca_test_use([10 x i8]*)
+declare i32 @foo(ptr %p)
+declare void @alloca_test_use(ptr)
-define i32 @call_foo(i32* %a) safestack {
+define i32 @call_foo(ptr %a) safestack {
; CHECK-LABEL: @call_foo(
-; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -16
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_STATIC_TOP]], i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -10
-; CHECK-NEXT: [[X_UNSAFE:%.*]] = bitcast i8* [[TMP1]] to [10 x i8]*
-; CHECK-NEXT: call void @alloca_test_use([10 x i8]* [[X_UNSAFE]])
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_PTR]], i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[R:%.*]] = musttail call i32 @foo(i32* [[A:%.*]])
+; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -16
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_STATIC_TOP]], ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -10
+; CHECK-NEXT: call void @alloca_test_use(ptr [[TMP1]])
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_PTR]], ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[R:%.*]] = musttail call i32 @foo(ptr [[A:%.*]])
; CHECK-NEXT: ret i32 [[R]]
;
%x = alloca [10 x i8], align 1
- call void @alloca_test_use([10 x i8]* %x)
- %r = musttail call i32 @foo(i32* %a)
+ call void @alloca_test_use(ptr %x)
+ %r = musttail call i32 @foo(ptr %a)
ret i32 %r
}
-define i32 @call_foo_cast(i32* %a) safestack {
+define i32 @call_foo_cast(ptr %a) safestack {
; CHECK-LABEL: @call_foo_cast(
-; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -16
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_STATIC_TOP]], i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -10
-; CHECK-NEXT: [[X_UNSAFE:%.*]] = bitcast i8* [[TMP1]] to [10 x i8]*
-; CHECK-NEXT: call void @alloca_test_use([10 x i8]* [[X_UNSAFE]])
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_PTR]], i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[R:%.*]] = musttail call i32 @foo(i32* [[A:%.*]])
+; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -16
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_STATIC_TOP]], ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -10
+; CHECK-NEXT: call void @alloca_test_use(ptr [[TMP1]])
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_PTR]], ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[R:%.*]] = musttail call i32 @foo(ptr [[A:%.*]])
; CHECK-NEXT: [[T:%.*]] = bitcast i32 [[R]] to i32
; CHECK-NEXT: ret i32 [[T]]
;
%x = alloca [10 x i8], align 1
- call void @alloca_test_use([10 x i8]* %x)
- %r = musttail call i32 @foo(i32* %a)
+ call void @alloca_test_use(ptr %x)
+ %r = musttail call i32 @foo(ptr %a)
%t = bitcast i32 %r to i32
ret i32 %t
}
diff --git a/llvm/test/Transforms/SafeStack/X86/no-attr.ll b/llvm/test/Transforms/SafeStack/X86/no-attr.ll
index d9bcefd3c8492..7715ca59f1688 100644
--- a/llvm/test/Transforms/SafeStack/X86/no-attr.ll
+++ b/llvm/test/Transforms/SafeStack/X86/no-attr.ll
@@ -9,19 +9,17 @@
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: @foo
-define void @foo(i8* %a) nounwind uwtable {
+define void @foo(ptr %a) nounwind uwtable {
entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
- %a.addr = alloca i8*, align 8
+ %a.addr = alloca ptr, align 8
%buf = alloca [16 x i8], align 16
- store i8* %a, i8** %a.addr, align 8
- %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
- %0 = load i8*, i8** %a.addr, align 8
- %call = call i8* @strcpy(i8* %arraydecay, i8* %0)
- %arraydecay1 = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
- %call2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %arraydecay1)
+ store ptr %a, ptr %a.addr, align 8
+ %0 = load ptr, ptr %a.addr, align 8
+ %call = call ptr @strcpy(ptr %buf, ptr %0)
+ %call2 = call i32 (ptr, ...) @printf(ptr @.str, ptr %buf)
ret void
}
-declare i8* @strcpy(i8*, i8*)
-declare i32 @printf(i8*, ...)
+declare ptr @strcpy(ptr, ptr)
+declare i32 @printf(ptr, ...)
diff --git a/llvm/test/Transforms/SafeStack/X86/no-crash-on-lifetime.ll b/llvm/test/Transforms/SafeStack/X86/no-crash-on-lifetime.ll
index c6ad220fc3a9d..45e9fa3c2e3fc 100644
--- a/llvm/test/Transforms/SafeStack/X86/no-crash-on-lifetime.ll
+++ b/llvm/test/Transforms/SafeStack/X86/no-crash-on-lifetime.ll
@@ -2,16 +2,15 @@
; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu %s -o /dev/null
%class.F = type { %class.o, i8, [7 x i8] }
-%class.o = type <{ i8*, i32, [4 x i8] }>
+%class.o = type <{ ptr, i32, [4 x i8] }>
-define dso_local void @_ZN1s1tE1F(%class.F* byval(%class.F) %g) local_unnamed_addr safestack align 32 {
+define dso_local void @_ZN1s1tE1F(ptr byval(%class.F) %g) local_unnamed_addr safestack align 32 {
entry:
%ref.tmp.i.i.i = alloca i64, align 1
- call void undef(%class.F* %g)
- %ref.tmp.i.i.0..sroa_idx.i5 = bitcast i64* %ref.tmp.i.i.i to i8*
- call void @llvm.lifetime.start.p0i8(i64 3, i8* %ref.tmp.i.i.0..sroa_idx.i5)
+ call void undef(ptr %g)
+ call void @llvm.lifetime.start.p0(i64 3, ptr %ref.tmp.i.i.i)
ret void
}
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1
diff --git a/llvm/test/Transforms/SafeStack/X86/phi-cycle.ll b/llvm/test/Transforms/SafeStack/X86/phi-cycle.ll
index 026e88785cb1b..18e6a7d50fe43 100644
--- a/llvm/test/Transforms/SafeStack/X86/phi-cycle.ll
+++ b/llvm/test/Transforms/SafeStack/X86/phi-cycle.ll
@@ -14,20 +14,19 @@
define i32 @foo(i32 %arg) nounwind uwtable safestack {
bb:
; CHECK: __safestack_unsafe_stack_ptr
- %tmp = alloca %struct.small*, align 8
- %tmp1 = call i32 (...) @dummy(%struct.small** %tmp) nounwind
- %tmp2 = load %struct.small*, %struct.small** %tmp, align 8
- %tmp3 = ptrtoint %struct.small* %tmp2 to i64
+ %tmp = alloca ptr, align 8
+ %tmp1 = call i32 (...) @dummy(ptr %tmp) nounwind
+ %tmp2 = load ptr, ptr %tmp, align 8
+ %tmp3 = ptrtoint ptr %tmp2 to i64
%tmp4 = trunc i64 %tmp3 to i32
%tmp5 = icmp sgt i32 %tmp4, 0
br i1 %tmp5, label %bb6, label %bb21
bb6: ; preds = %bb17, %bb
- %tmp7 = phi %struct.small* [ %tmp19, %bb17 ], [ %tmp2, %bb ]
+ %tmp7 = phi ptr [ %tmp19, %bb17 ], [ %tmp2, %bb ]
%tmp8 = phi i64 [ %tmp20, %bb17 ], [ 1, %bb ]
%tmp9 = phi i32 [ %tmp14, %bb17 ], [ %tmp1, %bb ]
- %tmp10 = getelementptr inbounds %struct.small, %struct.small* %tmp7, i64 0, i32 0
- %tmp11 = load i8, i8* %tmp10, align 1
+ %tmp11 = load i8, ptr %tmp7, align 1
%tmp12 = icmp eq i8 %tmp11, 1
%tmp13 = add nsw i32 %tmp9, 8
%tmp14 = select i1 %tmp12, i32 %tmp13, i32 %tmp9
@@ -36,8 +35,8 @@ bb6: ; preds = %bb17, %bb
br i1 %tmp16, label %bb21, label %bb17
bb17: ; preds = %bb6
- %tmp18 = getelementptr inbounds %struct.small*, %struct.small** %tmp, i64 %tmp8
- %tmp19 = load %struct.small*, %struct.small** %tmp18, align 8
+ %tmp18 = getelementptr inbounds ptr, ptr %tmp, i64 %tmp8
+ %tmp19 = load ptr, ptr %tmp18, align 8
%tmp20 = add i64 %tmp8, 1
br label %bb6
diff --git a/llvm/test/Transforms/SafeStack/X86/phi.ll b/llvm/test/Transforms/SafeStack/X86/phi.ll
index 3ee56aa0f566b..18380431f6398 100644
--- a/llvm/test/Transforms/SafeStack/X86/phi.ll
+++ b/llvm/test/Transforms/SafeStack/X86/phi.ll
@@ -4,8 +4,8 @@
define void @f(i1 %d1, i1 %d2) safestack {
entry:
; CHECK-LABEL: define void @f(
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK-NEXT: getelementptr i8, i8* %[[USP]], i32 -16
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK-NEXT: getelementptr i8, ptr %[[USP]], i32 -16
; CHECK: br i1 %d1, label %[[BB0:.*]], label %[[BB1:.*]]
%a = alloca i32, align 8
%b = alloca i32, align 8
@@ -13,23 +13,21 @@ entry:
bb0:
; CHECK: [[BB0]]:
-; CHECK: %[[Ai8:.*]] = getelementptr i8, i8* %unsafe_stack_ptr, i32
-; CHECK: %[[AUNSAFE:.*]] = bitcast i8* %[[Ai8]] to i32*
+; CHECK: %[[Ai8:.*]] = getelementptr i8, ptr %unsafe_stack_ptr, i32
; CHECK: br i1
br i1 %d2, label %bb2, label %bb2
bb1:
; CHECK: [[BB1]]:
-; CHECK: %[[Bi8:.*]] = getelementptr i8, i8* %unsafe_stack_ptr, i32
-; CHECK: %[[BUNSAFE:.*]] = bitcast i8* %[[Bi8]] to i32*
+; CHECK: %[[Bi8:.*]] = getelementptr i8, ptr %unsafe_stack_ptr, i32
; CHECK: br label
br label %bb2
bb2:
-; CHECK: phi i32* [ %[[AUNSAFE]], %[[BB0]] ], [ %[[AUNSAFE]], %[[BB0]] ], [ %[[BUNSAFE]], %[[BB1]] ]
- %c = phi i32* [ %a, %bb0 ], [ %a, %bb0 ], [ %b, %bb1 ]
- call void @capture(i32* %c)
+; CHECK: phi ptr [ %[[Ai8]], %[[BB0]] ], [ %[[Ai8]], %[[BB0]] ], [ %[[Bi8]], %[[BB1]] ]
+ %c = phi ptr [ %a, %bb0 ], [ %a, %bb0 ], [ %b, %bb1 ]
+ call void @capture(ptr %c)
ret void
}
-declare void @capture(i32*)
+declare void @capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/pr54784.ll b/llvm/test/Transforms/SafeStack/X86/pr54784.ll
index d8433f941ec25..940f56004e810 100644
--- a/llvm/test/Transforms/SafeStack/X86/pr54784.ll
+++ b/llvm/test/Transforms/SafeStack/X86/pr54784.ll
@@ -3,24 +3,22 @@
target triple = "x86_64-unknown-unknown"
-define void @min_of_pointers(i32* %p) safestack {
+define void @min_of_pointers(ptr %p) safestack {
; CHECK-LABEL: @min_of_pointers(
-; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -16
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_STATIC_TOP]], i8** @__safestack_unsafe_stack_ptr, align 8
-; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -4
-; CHECK-NEXT: [[A_UNSAFE1:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32* [[A_UNSAFE1]], [[P:%.*]]
-; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, i8* [[UNSAFE_STACK_PTR]], i32 -4
-; CHECK-NEXT: [[A_UNSAFE:%.*]] = bitcast i8* [[TMP2]] to i32*
-; CHECK-NEXT: [[S:%.*]] = select i1 [[CMP]], i32* [[A_UNSAFE]], i32* [[P]]
-; CHECK-NEXT: store i32 0, i32* [[S]], align 4
-; CHECK-NEXT: store i8* [[UNSAFE_STACK_PTR]], i8** @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[UNSAFE_STACK_PTR:%.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[UNSAFE_STACK_STATIC_TOP:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -16
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_STATIC_TOP]], ptr @__safestack_unsafe_stack_ptr, align 8
+; CHECK-NEXT: [[TMP1:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -4
+; CHECK-NEXT: [[CMP:%.*]] = icmp ult ptr [[TMP1]], [[P:%.*]]
+; CHECK-NEXT: [[TMP2:%.*]] = getelementptr i8, ptr [[UNSAFE_STACK_PTR]], i32 -4
+; CHECK-NEXT: [[S:%.*]] = select i1 [[CMP]], ptr [[TMP2]], ptr [[P]]
+; CHECK-NEXT: store i32 0, ptr [[S]], align 4
+; CHECK-NEXT: store ptr [[UNSAFE_STACK_PTR]], ptr @__safestack_unsafe_stack_ptr, align 8
; CHECK-NEXT: ret void
;
%a = alloca i32
- %cmp = icmp ult i32* %a, %p
- %s = select i1 %cmp, i32* %a, i32* %p
- store i32 0, i32* %s
+ %cmp = icmp ult ptr %a, %p
+ %s = select i1 %cmp, ptr %a, ptr %p
+ store i32 0, ptr %s
ret void
}
diff --git a/llvm/test/Transforms/SafeStack/X86/ret.ll b/llvm/test/Transforms/SafeStack/X86/ret.ll
index b2b8e56652979..b8a3e0569d492 100644
--- a/llvm/test/Transforms/SafeStack/X86/ret.ll
+++ b/llvm/test/Transforms/SafeStack/X86/ret.ll
@@ -12,6 +12,6 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret i64
%x = alloca [100 x i32], align 16
- %0 = ptrtoint [100 x i32]* %x to i64
+ %0 = ptrtoint ptr %x to i64
ret i64 %0
}
diff --git a/llvm/test/Transforms/SafeStack/X86/setjmp.ll b/llvm/test/Transforms/SafeStack/X86/setjmp.ll
index e38bff68e94c9..64a39e0816316 100644
--- a/llvm/test/Transforms/SafeStack/X86/setjmp.ll
+++ b/llvm/test/Transforms/SafeStack/X86/setjmp.ll
@@ -11,19 +11,19 @@
; Requires protector.
define i32 @foo() nounwind uwtable safestack {
entry:
- ; CHECK: %[[SP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
- ; CHECK: %[[STATICTOP:.*]] = getelementptr i8, i8* %[[SP]], i32 -16
+ ; CHECK: %[[SP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[STATICTOP:.*]] = getelementptr i8, ptr %[[SP]], i32 -16
%retval = alloca i32, align 4
%x = alloca i32, align 4
- store i32 0, i32* %retval
- store i32 42, i32* %x, align 4
- %call = call i32 @_setjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @buf, i32 0, i32 0)) returns_twice
+ store i32 0, ptr %retval
+ store i32 42, ptr %x, align 4
+ %call = call i32 @_setjmp(ptr @buf) returns_twice
; CHECK: setjmp
- ; CHECK-NEXT: store i8* %[[STATICTOP]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK-NEXT: store ptr %[[STATICTOP]], ptr @__safestack_unsafe_stack_ptr
%tobool = icmp ne i32 %call, 0
br i1 %tobool, label %if.else, label %if.then
if.then: ; preds = %entry
- call void @funcall(i32* %x)
+ call void @funcall(ptr %x)
br label %if.end
if.else: ; preds = %entry
call i32 (...) @dummy()
@@ -32,6 +32,6 @@ if.end: ; preds = %if.else, %if.then
ret i32 0
}
-declare i32 @_setjmp(%struct.__jmp_buf_tag*)
-declare void @funcall(i32*)
+declare i32 @_setjmp(ptr)
+declare void @funcall(ptr)
declare i32 @dummy(...)
diff --git a/llvm/test/Transforms/SafeStack/X86/setjmp2.ll b/llvm/test/Transforms/SafeStack/X86/setjmp2.ll
index dc83c48242075..97cbc2e27067b 100644
--- a/llvm/test/Transforms/SafeStack/X86/setjmp2.ll
+++ b/llvm/test/Transforms/SafeStack/X86/setjmp2.ll
@@ -12,32 +12,31 @@
; CHECK: @foo(i32 %[[ARG:.*]])
define i32 @foo(i32 %size) nounwind uwtable safestack {
entry:
- ; CHECK: %[[SP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
- ; CHECK-NEXT: %[[DYNPTR:.*]] = alloca i8*
- ; CHECK-NEXT: store i8* %[[SP]], i8** %[[DYNPTR]]
+ ; CHECK: %[[SP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+ ; CHECK-NEXT: %[[DYNPTR:.*]] = alloca ptr
+ ; CHECK-NEXT: store ptr %[[SP]], ptr %[[DYNPTR]]
; CHECK-NEXT: %[[ZEXT:.*]] = zext i32 %[[ARG]] to i64
; CHECK-NEXT: %[[MUL:.*]] = mul i64 %[[ZEXT]], 4
- ; CHECK-NEXT: %[[SP2:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
- ; CHECK-NEXT: %[[PTRTOINT:.*]] = ptrtoint i8* %[[SP2]] to i64
+ ; CHECK-NEXT: %[[SP2:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+ ; CHECK-NEXT: %[[PTRTOINT:.*]] = ptrtoint ptr %[[SP2]] to i64
; CHECK-NEXT: %[[SUB:.*]] = sub i64 %[[PTRTOINT]], %[[MUL]]
; CHECK-NEXT: %[[AND:.*]] = and i64 %[[SUB]], -16
- ; CHECK-NEXT: %[[INTTOPTR:.*]] = inttoptr i64 %[[AND]] to i8*
- ; CHECK-NEXT: store i8* %[[INTTOPTR]], i8** @__safestack_unsafe_stack_ptr
- ; CHECK-NEXT: store i8* %[[INTTOPTR]], i8** %unsafe_stack_dynamic_ptr
- ; CHECK-NEXT: %[[ALLOCA:.*]] = bitcast i8* %[[INTTOPTR]] to i32*
+ ; CHECK-NEXT: %[[INTTOPTR:.*]] = inttoptr i64 %[[AND]] to ptr
+ ; CHECK-NEXT: store ptr %[[INTTOPTR]], ptr @__safestack_unsafe_stack_ptr
+ ; CHECK-NEXT: store ptr %[[INTTOPTR]], ptr %unsafe_stack_dynamic_ptr
%a = alloca i32, i32 %size
; CHECK: setjmp
- ; CHECK-NEXT: %[[LOAD:.*]] = load i8*, i8** %[[DYNPTR]]
- ; CHECK-NEXT: store i8* %[[LOAD]], i8** @__safestack_unsafe_stack_ptr
- %call = call i32 @_setjmp(%struct.__jmp_buf_tag* getelementptr inbounds ([1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* @buf, i32 0, i32 0)) returns_twice
+ ; CHECK-NEXT: %[[LOAD:.*]] = load ptr, ptr %[[DYNPTR]]
+ ; CHECK-NEXT: store ptr %[[LOAD]], ptr @__safestack_unsafe_stack_ptr
+ %call = call i32 @_setjmp(ptr @buf) returns_twice
- ; CHECK: call void @funcall(i32* %[[ALLOCA]])
- call void @funcall(i32* %a)
- ; CHECK-NEXT: store i8* %[[SP:.*]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: call void @funcall(ptr %[[INTTOPTR]])
+ call void @funcall(ptr %a)
+ ; CHECK-NEXT: store ptr %[[SP:.*]], ptr @__safestack_unsafe_stack_ptr
ret i32 0
}
-declare i32 @_setjmp(%struct.__jmp_buf_tag*)
-declare void @funcall(i32*)
+declare i32 @_setjmp(ptr)
+declare void @funcall(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/sink-to-use.ll b/llvm/test/Transforms/SafeStack/X86/sink-to-use.ll
index e208ce1da9d45..1a7984a7c04a0 100644
--- a/llvm/test/Transforms/SafeStack/X86/sink-to-use.ll
+++ b/llvm/test/Transforms/SafeStack/X86/sink-to-use.ll
@@ -7,16 +7,14 @@ entry:
%x0 = alloca i32, align 4
%x1 = alloca i32, align 4
-; CHECK: %[[A:.*]] = getelementptr i8, i8* %{{.*}}, i32 -4
-; CHECK: %[[X0:.*]] = bitcast i8* %[[A]] to i32*
-; CHECK: call void @use(i32* %[[X0]])
- call void @use(i32* %x0)
+; CHECK: %[[A:.*]] = getelementptr i8, ptr %{{.*}}, i32 -4
+; CHECK: call void @use(ptr %[[A]])
+ call void @use(ptr %x0)
-; CHECK: %[[B:.*]] = getelementptr i8, i8* %{{.*}}, i32 -8
-; CHECK: %[[X1:.*]] = bitcast i8* %[[B]] to i32*
-; CHECK: call void @use(i32* %[[X1]])
- call void @use(i32* %x1)
+; CHECK: %[[B:.*]] = getelementptr i8, ptr %{{.*}}, i32 -8
+; CHECK: call void @use(ptr %[[B]])
+ call void @use(ptr %x1)
ret void
}
-declare void @use(i32*)
+declare void @use(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/ssp.ll b/llvm/test/Transforms/SafeStack/X86/ssp.ll
index e4286dbd2cb1b..56e1ac69d1d75 100644
--- a/llvm/test/Transforms/SafeStack/X86/ssp.ll
+++ b/llvm/test/Transforms/SafeStack/X86/ssp.ll
@@ -2,29 +2,28 @@
define void @foo() safestack sspreq {
entry:
-; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
-; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
-; CHECK: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
+; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
+; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+; CHECK: store ptr %[[USST]], ptr @__safestack_unsafe_stack_ptr
-; CHECK: %[[A:.*]] = getelementptr i8, i8* %[[USP]], i32 -8
-; CHECK: %[[StackGuardSlot:.*]] = bitcast i8* %[[A]] to i8**
-; CHECK: %[[StackGuard:.*]] = call i8* @llvm.stackguard()
-; CHECK: store i8* %[[StackGuard]], i8** %[[StackGuardSlot]]
+; CHECK: %[[A:.*]] = getelementptr i8, ptr %[[USP]], i32 -8
+; CHECK: %[[StackGuard:.*]] = call ptr @llvm.stackguard()
+; CHECK: store ptr %[[StackGuard]], ptr %[[A]]
%a = alloca i8, align 1
; CHECK: call void @Capture
- call void @Capture(i8* %a)
+ call void @Capture(ptr %a)
-; CHECK: %[[B:.*]] = load i8*, i8** %[[StackGuardSlot]]
-; CHECK: %[[COND:.*]] = icmp ne i8* %[[StackGuard]], %[[B]]
+; CHECK: %[[B:.*]] = load ptr, ptr %[[A]]
+; CHECK: %[[COND:.*]] = icmp ne ptr %[[StackGuard]], %[[B]]
; CHECK: br i1 %[[COND]], {{.*}} !prof
; CHECK: call void @__stack_chk_fail()
; CHECK-NEXT: unreachable
-; CHECK: store i8* %[[USP]], i8** @__safestack_unsafe_stack_ptr
+; CHECK: store ptr %[[USP]], ptr @__safestack_unsafe_stack_ptr
; CHECK-NEXT: ret void
ret void
}
-declare void @Capture(i8*)
+declare void @Capture(ptr)
diff --git a/llvm/test/Transforms/SafeStack/X86/store.ll b/llvm/test/Transforms/SafeStack/X86/store.ll
index f493dd038bb82..6fc08760a72c7 100644
--- a/llvm/test/Transforms/SafeStack/X86/store.ll
+++ b/llvm/test/Transforms/SafeStack/X86/store.ll
@@ -9,9 +9,9 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = ptrtoint i32* %a to i64
- %1 = inttoptr i64 %0 to i64*
- store i64 zeroinitializer, i64* %1
+ %0 = ptrtoint ptr %a to i64
+ %1 = inttoptr i64 %0 to ptr
+ store i64 zeroinitializer, ptr %1
ret void
}
@@ -21,8 +21,7 @@ entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i8*
- store i8 zeroinitializer, i8* %0
+ store i8 zeroinitializer, ptr %a
ret void
}
@@ -32,9 +31,8 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i8*
- %1 = getelementptr i8, i8* %0, i32 4
- store i8 zeroinitializer, i8* %1
+ %0 = getelementptr i8, ptr %a, i32 4
+ store i8 zeroinitializer, ptr %0
ret void
}
@@ -44,9 +42,8 @@ entry:
; CHECK: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i8*
- %1 = getelementptr i8, i8* %0, i32 -1
- store i8 zeroinitializer, i8* %1
+ %0 = getelementptr i8, ptr %a, i32 -1
+ store i8 zeroinitializer, ptr %0
ret void
}
@@ -56,8 +53,7 @@ entry:
; CHECK-NOT: __safestack_unsafe_stack_ptr
; CHECK: ret void
%a = alloca i32, align 4
- %0 = bitcast i32* %a to i8*
- %1 = getelementptr i8, i8* %0, i32 3
- store i8 zeroinitializer, i8* %1
+ %0 = getelementptr i8, ptr %a, i32 3
+ store i8 zeroinitializer, ptr %0
ret void
}
diff --git a/llvm/test/Transforms/SafeStack/X86/struct.ll b/llvm/test/Transforms/SafeStack/X86/struct.ll
index b64803d160c66..8bce24bb53808 100644
--- a/llvm/test/Transforms/SafeStack/X86/struct.ll
+++ b/llvm/test/Transforms/SafeStack/X86/struct.ll
@@ -7,34 +7,30 @@
; struct { [16 x i8] }
-define void @foo(i8* %a) nounwind uwtable safestack {
+define void @foo(ptr %a) nounwind uwtable safestack {
entry:
- ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: %[[USP:.*]] = load ptr, ptr @__safestack_unsafe_stack_ptr
- ; CHECK: %[[USST:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
+ ; CHECK: %[[USST:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
- ; CHECK: store i8* %[[USST]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USST]], ptr @__safestack_unsafe_stack_ptr
- %a.addr = alloca i8*, align 8
+ %a.addr = alloca ptr, align 8
%buf = alloca %struct.foo, align 1
- ; CHECK: %[[AADDR:.*]] = alloca i8*, align 8
- ; CHECK: store i8* {{.*}}, i8** %[[AADDR]], align 8
- store i8* %a, i8** %a.addr, align 8
+ ; CHECK: %[[AADDR:.*]] = alloca ptr, align 8
+ ; CHECK: store ptr {{.*}}, ptr %[[AADDR]], align 8
+ store ptr %a, ptr %a.addr, align 8
- ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, i8* %[[USP]], i32 -16
- ; CHECK: %[[BUFPTR2:.*]] = bitcast i8* %[[BUFPTR]] to %struct.foo*
- ; CHECK: %[[GEP:.*]] = getelementptr inbounds %struct.foo, %struct.foo* %[[BUFPTR2]], i32 0, i32 0, i32 0
- %gep = getelementptr inbounds %struct.foo, %struct.foo* %buf, i32 0, i32 0, i32 0
+ ; CHECK: %[[A:.*]] = load ptr, ptr %[[AADDR]], align 8
+ ; CHECK: %[[BUFPTR:.*]] = getelementptr i8, ptr %[[USP]], i32 -16
+ %a2 = load ptr, ptr %a.addr, align 8
- ; CHECK: %[[A:.*]] = load i8*, i8** %[[AADDR]], align 8
- %a2 = load i8*, i8** %a.addr, align 8
+ ; CHECK: call ptr @strcpy(ptr %[[BUFPTR]], ptr %[[A]])
+ %call = call ptr @strcpy(ptr %buf, ptr %a2)
- ; CHECK: call i8* @strcpy(i8* %[[GEP]], i8* %[[A]])
- %call = call i8* @strcpy(i8* %gep, i8* %a2)
-
- ; CHECK: store i8* %[[USP]], i8** @__safestack_unsafe_stack_ptr
+ ; CHECK: store ptr %[[USP]], ptr @__safestack_unsafe_stack_ptr
ret void
}
-declare i8* @strcpy(i8*, i8*)
+declare ptr @strcpy(ptr, ptr)
More information about the llvm-commits
mailing list