mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
2d43b2fbd5
An instruction like this will need to allocate some stack space for the
last parameter:
%x = call addrspace(1) i16 @bar(i64 undef, i64 undef, i16 undef, i16 0)
This worked fine when passing an actual value (in this case 0). However,
when passing undef, no value was pushed to the stack and therefore no
push instructions were created. This caused an unbalanced stack leading
to interesting results.
This commit fixes that by replacing the push logic with a regular stack
adjustment and stack-relative load/stores. This is less efficient but at
least it correctly compiles the code.
I can think of a few improvements in the future:
* The stack should have been adjusted in the function prologue when
there are no allocas in the function.
* Many (if not most) stack adjustments can be replaced by
pushing/popping the values directly. Exactly like the previous code
attempted but didn't do correctly.
* Small stack adjustments can be done more efficiently with a few
push/pop instructions (pushing/popping bogus values), both for code
size and for speed.
All in all, as long as there are no allocas in the function I think that
it is almost always more efficient to emit regular push/pop
instructions. This is however left for future optimizations.
Differential Revision: https://reviews.llvm.org/D78581
60 lines
1.6 KiB
LLVM
60 lines
1.6 KiB
LLVM
; RUN: llc -mattr=sram,movw,addsubiw < %s -march=avr | FileCheck %s
|
|
|
|
declare void @llvm.va_start(i8*)
|
|
declare i16 @vsprintf(i8* nocapture, i8* nocapture, i8*)
|
|
declare void @llvm.va_end(i8*)
|
|
|
|
define i16 @varargs1(i8* nocapture %x, ...) {
|
|
; CHECK-LABEL: varargs1:
|
|
; CHECK: movw r20, r28
|
|
; CHECK: subi r20, 215
|
|
; CHECK: sbci r21, 255
|
|
; CHECK: movw r24, r28
|
|
; CHECK: adiw r24, 3
|
|
; CHECK: ldd r22, Y+39
|
|
; CHECK: ldd r23, Y+40
|
|
; CHECK: call
|
|
%buffer = alloca [32 x i8]
|
|
%ap = alloca i8*
|
|
%ap1 = bitcast i8** %ap to i8*
|
|
call void @llvm.va_start(i8* %ap1)
|
|
%arraydecay = getelementptr inbounds [32 x i8], [32 x i8]* %buffer, i16 0, i16 0
|
|
%1 = load i8*, i8** %ap
|
|
%call = call i16 @vsprintf(i8* %arraydecay, i8* %x, i8* %1)
|
|
call void @llvm.va_end(i8* %ap1)
|
|
ret i16 0
|
|
}
|
|
|
|
define i16 @varargs2(i8* nocapture %x, ...) {
|
|
; CHECK-LABEL: varargs2:
|
|
; CHECK: ldd r24, [[REG:X|Y|Z]]+{{[0-9]+}}
|
|
; CHECK: ldd r25, [[REG]]+{{[0-9]+}}
|
|
%ap = alloca i8*
|
|
%ap1 = bitcast i8** %ap to i8*
|
|
call void @llvm.va_start(i8* %ap1)
|
|
%1 = va_arg i8** %ap, i16
|
|
call void @llvm.va_end(i8* %ap1)
|
|
ret i16 %1
|
|
}
|
|
|
|
declare void @var1223(i16, ...)
|
|
define void @varargcall() {
|
|
; CHECK-LABEL: varargcall:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 189
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 205
|
|
; CHECK: std Z+3, [[REG1]]
|
|
; CHECK: std Z+4, [[REG2]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 191
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 223
|
|
; CHECK: std Z+5, [[REG1]]
|
|
; CHECK: std Z+6, [[REG2]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 205
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 171
|
|
; CHECK: std Z+1, [[REG1]]
|
|
; CHECK: std Z+2, [[REG2]]
|
|
; CHECK: call
|
|
; CHECK: adiw r30, 6
|
|
tail call void (i16, ...) @var1223(i16 -21555, i16 -12867, i16 -8257)
|
|
ret void
|
|
}
|