mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-02-23 05:29:23 +00:00
bb78930489
Low order register of a double word register operand. Operands
are defined by the name of the variable they are marked with in
the inline assembler code. This is a way to specify that the
operand just refers to the low order register for that variable.
It is the opposite of modifier 'D' which specifies the high order
register.
Example:
main()
{
long long ll_input = 0x1111222233334444LL;
long long ll_val = 3;
int i_result = 0;
__asm__ __volatile__(
"or %0, %L1, %2"
: "=r" (i_result)
: "r" (ll_input), "r" (ll_val));
}
Which results in:
lui $2, %hi(_gp_disp)
addiu $2, $2, %lo(_gp_disp)
addiu $sp, $sp, -8
addu $2, $2, $25
sw $2, 0($sp)
lui $2, 13107
ori $3, $2, 17476 <-- Low 32 bits of ll_input
lui $2, 4369
ori $4, $2, 8738 <-- High 32 bits of ll_input
addiu $5, $zero, 3 <-- Low 32 bits of ll_val
addiu $2, $zero, 0 <-- High 32 bits of ll_val
#APP
or $3, $4, $5 <-- or i_result, high 32 ll_input, low 32 of ll_val
#NO_APP
addiu $sp, $sp, 8
jr $ra
If not direction is done for the long long for 32 bit variables results
in using the low 32 bits as ll_val shows.
There is an existing bug if 'L' or 'D' is used for the destination register
for 32 bit long longs in that the target value will be updated incorrectly
for the non-specified part unless explicitly set within the inline asm code.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@160028 91177308-0d34-0410-b5e6-96231b3b80d8
93 lines
2.9 KiB
LLVM
93 lines
2.9 KiB
LLVM
; Positive test for inline register constraints
|
|
;
|
|
; RUN: llc -march=mipsel < %s | FileCheck %s -check-prefix=LITTLE
|
|
; RUN: llc -march=mips < %s | FileCheck %s -check-prefix=BIG
|
|
|
|
%union.u_tag = type { i64 }
|
|
%struct.anon = type { i32, i32 }
|
|
@uval = common global %union.u_tag zeroinitializer, align 8
|
|
define i32 @main() nounwind {
|
|
entry:
|
|
|
|
; X with -3
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},0xfffffffffffffffd
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:X}", "=r,r,I"(i32 7, i32 -3) nounwind
|
|
|
|
; x with -3
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},0xfffd
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:x}", "=r,r,I"(i32 7, i32 -3) nounwind
|
|
|
|
; d with -3
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},-3
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:d}", "=r,r,I"(i32 7, i32 -3) nounwind
|
|
|
|
; m with -3
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},-4
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:m}", "=r,r,I"(i32 7, i32 -3) nounwind
|
|
|
|
; z with -3
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},-3
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:z}", "=r,r,I"(i32 7, i32 -3) nounwind
|
|
|
|
; z with 0
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},$0
|
|
;LITTLE: #NO_APP
|
|
tail call i32 asm sideeffect "addi $0,$1,${2:z}", "=r,r,I"(i32 7, i32 0) nounwind
|
|
|
|
; a long long in 32 bit mode (use to assert)
|
|
;LITTLE: #APP
|
|
;LITTLE: addi ${{[0-9]+}},${{[0-9]+}},3
|
|
;LITTLE: #NO_APP
|
|
tail call i64 asm sideeffect "addi $0,$1,$2 \0A\09", "=r,r,X"(i64 1229801703532086340, i64 3) nounwind
|
|
|
|
; D, in little endian the source reg will be 4 bytes into the long long
|
|
;LITTLE: lw ${{[0-9]+}}, %got(uval)(${{[0-9,a-z]+}})
|
|
;LITTLE: lw $[[SECOND:[0-9]+]], 4(${{[0-9]+}})
|
|
;LITTLE-NEXT: lw $[[FIRST:[0-9]+]], 0(${{[0-9]+}})
|
|
;LITTLE: #APP
|
|
;LITTLE: or ${{[0-9]+}},$[[FIRST]],${{[0-9]+}}
|
|
;LITTLE: #NO_APP
|
|
|
|
; D, in big endian the source reg will also be 4 bytes into the long long
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: #APP
|
|
;BIG: lw ${{[0-9]+}}, %got(uval)(${{[0-9,a-z]+}})
|
|
;BIG: lw $[[SECOND:[0-9]+]], 4(${{[0-9]+}})
|
|
;BIG-NEXT: lw $[[FIRST:[0-9]+]], 0(${{[0-9]+}})
|
|
;BIG: #APP
|
|
;BIG: or ${{[0-9]+}},$[[SECOND]],${{[0-9]+}}
|
|
;BIG: #NO_APP
|
|
%7 = load i64* getelementptr inbounds (%union.u_tag* @uval, i32 0, i32 0), align 8
|
|
%trunc1 = trunc i64 %7 to i32
|
|
tail call i32 asm sideeffect "or $0,${1:D},$2", "=r,r,r"(i64 %7, i32 %trunc1) nounwind
|
|
|
|
; L, in little endian the source reg will be 4 bytes into the long long
|
|
;LITTLE: #APP
|
|
;LITTLE: or ${{[0-9]+}},$[[SECOND]],${{[0-9]+}}
|
|
;LITTLE: #NO_APP
|
|
; L, in big endian the source reg will be 0 bytes into the long long
|
|
;BIG: #APP
|
|
;BIG: or ${{[0-9]+}},$[[FIRST]],${{[0-9]+}}
|
|
;BIG: #NO_APP
|
|
tail call i32 asm sideeffect "or $0,${1:L},$2", "=r,r,r"(i64 %7, i32 %trunc1) nounwind
|
|
|
|
ret i32 0
|
|
}
|
|
|