mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 07:29:55 +00:00
91fa1da2f7
merge all zero-sized alloca's into one, fixing c43204g from the Ada ACATS conformance testsuite. What happened there was that a variable sized object was being allocated on the stack, "alloca i8, i32 %size". It was then being passed to another function, which tested that the address was not null (raising an exception if it was) then manipulated %size bytes in it (load and/or store). The optimizers cleverly managed to deduce that %size was zero (congratulations to them, as it isn't at all obvious), which made the alloca zero size, causing the optimizers to replace it with null, which then caused the check mentioned above to fail, and the exception to be raised, wrongly. Note that no loads and stores were actually being done to the alloca (the loop that does them is executed %size times, i.e. is not executed), only the not-null address check. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@159202 91177308-0d34-0410-b5e6-96231b3b80d8
97 lines
2.5 KiB
LLVM
97 lines
2.5 KiB
LLVM
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
|
|
|
|
; RUN: opt < %s -instcombine -S | FileCheck %s
|
|
; END.
|
|
|
|
declare void @use(...)
|
|
|
|
@int = global i32 zeroinitializer
|
|
|
|
; Zero byte allocas should be merged if they can't be deleted.
|
|
; CHECK: @test
|
|
; CHECK: alloca
|
|
; CHECK-NOT: alloca
|
|
define void @test() {
|
|
%X = alloca [0 x i32] ; <[0 x i32]*> [#uses=1]
|
|
call void (...)* @use( [0 x i32]* %X )
|
|
%Y = alloca i32, i32 0 ; <i32*> [#uses=1]
|
|
call void (...)* @use( i32* %Y )
|
|
%Z = alloca { } ; <{ }*> [#uses=1]
|
|
call void (...)* @use( { }* %Z )
|
|
%size = load i32* @int
|
|
%A = alloca {{}}, i32 %size
|
|
call void (...)* @use( {{}}* %A )
|
|
ret void
|
|
}
|
|
|
|
; Zero byte allocas should be deleted.
|
|
; CHECK: @test2
|
|
; CHECK-NOT: alloca
|
|
define void @test2() {
|
|
%A = alloca i32 ; <i32*> [#uses=1]
|
|
store i32 123, i32* %A
|
|
ret void
|
|
}
|
|
|
|
; Zero byte allocas should be deleted.
|
|
; CHECK: @test3
|
|
; CHECK-NOT: alloca
|
|
define void @test3() {
|
|
%A = alloca { i32 } ; <{ i32 }*> [#uses=1]
|
|
%B = getelementptr { i32 }* %A, i32 0, i32 0 ; <i32*> [#uses=1]
|
|
store i32 123, i32* %B
|
|
ret void
|
|
}
|
|
|
|
; CHECK: @test4
|
|
; CHECK: = zext i32 %n to i64
|
|
; CHECK: %A = alloca i32, i64 %
|
|
define i32* @test4(i32 %n) {
|
|
%A = alloca i32, i32 %n
|
|
ret i32* %A
|
|
}
|
|
|
|
; Allocas which are only used by GEPs, bitcasts, and stores (transitively)
|
|
; should be deleted.
|
|
define void @test5() {
|
|
; CHECK: @test5
|
|
; CHECK-NOT: alloca
|
|
; CHECK-NOT: store
|
|
; CHECK: ret
|
|
|
|
entry:
|
|
%a = alloca { i32 }
|
|
%b = alloca i32*
|
|
%a.1 = getelementptr { i32 }* %a, i32 0, i32 0
|
|
store i32 123, i32* %a.1
|
|
store i32* %a.1, i32** %b
|
|
%b.1 = bitcast i32** %b to i32*
|
|
store i32 123, i32* %b.1
|
|
%a.2 = getelementptr { i32 }* %a, i32 0, i32 0
|
|
store atomic i32 2, i32* %a.2 unordered, align 4
|
|
%a.3 = getelementptr { i32 }* %a, i32 0, i32 0
|
|
store atomic i32 3, i32* %a.3 release, align 4
|
|
%a.4 = getelementptr { i32 }* %a, i32 0, i32 0
|
|
store atomic i32 4, i32* %a.4 seq_cst, align 4
|
|
ret void
|
|
}
|
|
|
|
declare void @f(i32* %p)
|
|
|
|
; Check that we don't delete allocas in some erroneous cases.
|
|
define void @test6() {
|
|
; CHECK: @test6
|
|
; CHECK-NOT: ret
|
|
; CHECK: alloca
|
|
; CHECK-NEXT: alloca
|
|
; CHECK: ret
|
|
|
|
entry:
|
|
%a = alloca { i32 }
|
|
%b = alloca i32
|
|
%a.1 = getelementptr { i32 }* %a, i32 0, i32 0
|
|
store volatile i32 123, i32* %a.1
|
|
tail call void @f(i32* %b)
|
|
ret void
|
|
}
|