From 0ddd65658e3feaf1828e4ff3d9342d435a6a2bb1 Mon Sep 17 00:00:00 2001 From: Ayke van Laethem Date: Thu, 16 Mar 2023 19:34:35 +0100 Subject: [PATCH] transform: update allocs test to opaque pointers Also, rename most of the SSA values while we're at it. --- transform/testdata/allocs.ll | 62 ++++++++++++++------------------ transform/testdata/allocs.out.ll | 60 ++++++++++++++----------------- 2 files changed, 53 insertions(+), 69 deletions(-) diff --git a/transform/testdata/allocs.ll b/transform/testdata/allocs.ll index 58af2ea8..1c2fdd5a 100644 --- a/transform/testdata/allocs.ll +++ b/transform/testdata/allocs.ll @@ -3,57 +3,51 @@ target triple = "armv7m-none-eabi" @runtime.zeroSizedAlloc = internal global i8 0, align 1 -declare nonnull i8* @runtime.alloc(i32, i8*) +declare nonnull ptr @runtime.alloc(i32, ptr) ; Test allocating a single int (i32) that should be allocated on the stack. define void @testInt() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - store i32 5, i32* %2 + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + store i32 5, ptr %alloc ret void } ; Test allocating an array of 3 i16 values that should be allocated on the ; stack. define i16 @testArray() { - %1 = call i8* @runtime.alloc(i32 6, i8* null) - %2 = bitcast i8* %1 to i16* - %3 = getelementptr i16, i16* %2, i32 1 - store i16 5, i16* %3 - %4 = getelementptr i16, i16* %2, i32 2 - %5 = load i16, i16* %4 - ret i16 %5 + %alloc = call ptr @runtime.alloc(i32 6, ptr null) + %alloc.1 = getelementptr i16, ptr %alloc, i32 1 + store i16 5, ptr %alloc.1 + %alloc.2 = getelementptr i16, ptr %alloc, i32 2 + %val = load i16, ptr %alloc.2 + ret i16 %val } ; Call a function that will let the pointer escape, so the heap-to-stack ; transform shouldn't be applied. define void @testEscapingCall() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @escapeIntPtr(i32* %2) + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %val = call ptr @escapeIntPtr(ptr %alloc) ret void } define void @testEscapingCall2() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @escapeIntPtrSometimes(i32* %2, i32* %2) + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %val = call ptr @escapeIntPtrSometimes(ptr %alloc, ptr %alloc) ret void } ; Call a function that doesn't let the pointer escape. define void @testNonEscapingCall() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @noescapeIntPtr(i32* %2) + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %val = call ptr @noescapeIntPtr(ptr %alloc) ret void } ; Return the allocated value, which lets it escape. -define i32* @testEscapingReturn() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - ret i32* %2 +define ptr @testEscapingReturn() { + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + ret ptr %alloc } ; Do a non-escaping allocation in a loop. @@ -61,25 +55,23 @@ define void @testNonEscapingLoop() { entry: br label %loop loop: - %0 = call i8* @runtime.alloc(i32 4, i8* null) - %1 = bitcast i8* %0 to i32* - %2 = call i32* @noescapeIntPtr(i32* %1) - %3 = icmp eq i32* null, %2 - br i1 %3, label %loop, label %end + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %ptr = call ptr @noescapeIntPtr(ptr %alloc) + %result = icmp eq ptr null, %ptr + br i1 %result, label %loop, label %end end: ret void } ; Test a zero-sized allocation. define void @testZeroSizedAlloc() { - %1 = call i8* @runtime.alloc(i32 0, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @noescapeIntPtr(i32* %2) + %alloc = call ptr @runtime.alloc(i32 0, ptr null) + %ptr = call ptr @noescapeIntPtr(ptr %alloc) ret void } -declare i32* @escapeIntPtr(i32*) +declare ptr @escapeIntPtr(ptr) -declare i32* @noescapeIntPtr(i32* nocapture) +declare ptr @noescapeIntPtr(ptr nocapture) -declare i32* @escapeIntPtrSometimes(i32* nocapture, i32*) +declare ptr @escapeIntPtrSometimes(ptr nocapture, ptr) diff --git a/transform/testdata/allocs.out.ll b/transform/testdata/allocs.out.ll index 48f9b768..d1b07e6c 100644 --- a/transform/testdata/allocs.out.ll +++ b/transform/testdata/allocs.out.ll @@ -3,53 +3,47 @@ target triple = "armv7m-none-eabi" @runtime.zeroSizedAlloc = internal global i8 0, align 1 -declare nonnull i8* @runtime.alloc(i32, i8*) +declare nonnull ptr @runtime.alloc(i32, ptr) define void @testInt() { %stackalloc.alloca = alloca [4 x i8], align 4 - store [4 x i8] zeroinitializer, [4 x i8]* %stackalloc.alloca, align 4 - %stackalloc = bitcast [4 x i8]* %stackalloc.alloca to i32* - store i32 5, i32* %stackalloc, align 4 + store [4 x i8] zeroinitializer, ptr %stackalloc.alloca, align 4 + store i32 5, ptr %stackalloc.alloca, align 4 ret void } define i16 @testArray() { %stackalloc.alloca = alloca [6 x i8], align 2 - store [6 x i8] zeroinitializer, [6 x i8]* %stackalloc.alloca, align 2 - %stackalloc = bitcast [6 x i8]* %stackalloc.alloca to i16* - %1 = getelementptr i16, i16* %stackalloc, i32 1 - store i16 5, i16* %1, align 2 - %2 = getelementptr i16, i16* %stackalloc, i32 2 - %3 = load i16, i16* %2, align 2 - ret i16 %3 + store [6 x i8] zeroinitializer, ptr %stackalloc.alloca, align 2 + %alloc.1 = getelementptr i16, ptr %stackalloc.alloca, i32 1 + store i16 5, ptr %alloc.1, align 2 + %alloc.2 = getelementptr i16, ptr %stackalloc.alloca, i32 2 + %val = load i16, ptr %alloc.2, align 2 + ret i16 %val } define void @testEscapingCall() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @escapeIntPtr(i32* %2) + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %val = call ptr @escapeIntPtr(ptr %alloc) ret void } define void @testEscapingCall2() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - %3 = call i32* @escapeIntPtrSometimes(i32* %2, i32* %2) + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + %val = call ptr @escapeIntPtrSometimes(ptr %alloc, ptr %alloc) ret void } define void @testNonEscapingCall() { %stackalloc.alloca = alloca [4 x i8], align 4 - store [4 x i8] zeroinitializer, [4 x i8]* %stackalloc.alloca, align 4 - %stackalloc = bitcast [4 x i8]* %stackalloc.alloca to i32* - %1 = call i32* @noescapeIntPtr(i32* %stackalloc) + store [4 x i8] zeroinitializer, ptr %stackalloc.alloca, align 4 + %val = call ptr @noescapeIntPtr(ptr %stackalloc.alloca) ret void } -define i32* @testEscapingReturn() { - %1 = call i8* @runtime.alloc(i32 4, i8* null) - %2 = bitcast i8* %1 to i32* - ret i32* %2 +define ptr @testEscapingReturn() { + %alloc = call ptr @runtime.alloc(i32 4, ptr null) + ret ptr %alloc } define void @testNonEscapingLoop() { @@ -58,24 +52,22 @@ entry: br label %loop loop: ; preds = %loop, %entry - store [4 x i8] zeroinitializer, [4 x i8]* %stackalloc.alloca, align 4 - %stackalloc = bitcast [4 x i8]* %stackalloc.alloca to i32* - %0 = call i32* @noescapeIntPtr(i32* %stackalloc) - %1 = icmp eq i32* null, %0 - br i1 %1, label %loop, label %end + store [4 x i8] zeroinitializer, ptr %stackalloc.alloca, align 4 + %ptr = call ptr @noescapeIntPtr(ptr %stackalloc.alloca) + %result = icmp eq ptr null, %ptr + br i1 %result, label %loop, label %end end: ; preds = %loop ret void } define void @testZeroSizedAlloc() { - %1 = bitcast i8* @runtime.zeroSizedAlloc to i32* - %2 = call i32* @noescapeIntPtr(i32* %1) + %ptr = call ptr @noescapeIntPtr(ptr @runtime.zeroSizedAlloc) ret void } -declare i32* @escapeIntPtr(i32*) +declare ptr @escapeIntPtr(ptr) -declare i32* @noescapeIntPtr(i32* nocapture) +declare ptr @noescapeIntPtr(ptr nocapture) -declare i32* @escapeIntPtrSometimes(i32* nocapture, i32*) +declare ptr @escapeIntPtrSometimes(ptr nocapture, ptr)