mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-30 15:32:52 +01:00
77f91408dd
Unlike most -- hopefully "all other", but I'm still checking -- memory instructions we support, LOAD REVERSED and STORE REVERSED may access the memory location several times. This means that they are not suitable for volatile loads and stores. This patch is a prerequisite for better atomic load and store support. The same principle applies there: almost all memory instructions we support are inherently atomic ("block concurrent"), but LOAD REVERSED and STORE REVERSED are exceptions. Other instructions continue to allow volatile operands. I will add positive "allows volatile" tests at the same time as the "allows atomic load or store" tests. llvm-svn: 183002
100 lines
2.6 KiB
LLVM
100 lines
2.6 KiB
LLVM
; Test 32-bit byteswaps from registers to memory.
|
|
;
|
|
; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
|
|
|
|
declare i32 @llvm.bswap.i32(i32 %a)
|
|
|
|
; Check STRV with no displacement.
|
|
define void @f1(i32 *%dst, i32 %a) {
|
|
; CHECK: f1:
|
|
; CHECK: strv %r3, 0(%r2)
|
|
; CHECK: br %r14
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%dst
|
|
ret void
|
|
}
|
|
|
|
; Check the high end of the aligned STRV range.
|
|
define void @f2(i32 *%dst, i32 %a) {
|
|
; CHECK: f2:
|
|
; CHECK: strv %r3, 524284(%r2)
|
|
; CHECK: br %r14
|
|
%ptr = getelementptr i32 *%dst, i64 131071
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check the next word up, which needs separate address logic.
|
|
; Other sequences besides this one would be OK.
|
|
define void @f3(i32 *%dst, i32 %a) {
|
|
; CHECK: f3:
|
|
; CHECK: agfi %r2, 524288
|
|
; CHECK: strv %r3, 0(%r2)
|
|
; CHECK: br %r14
|
|
%ptr = getelementptr i32 *%dst, i64 131072
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check the high end of the negative aligned STRV range.
|
|
define void @f4(i32 *%dst, i32 %a) {
|
|
; CHECK: f4:
|
|
; CHECK: strv %r3, -4(%r2)
|
|
; CHECK: br %r14
|
|
%ptr = getelementptr i32 *%dst, i64 -1
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check the low end of the STRV range.
|
|
define void @f5(i32 *%dst, i32 %a) {
|
|
; CHECK: f5:
|
|
; CHECK: strv %r3, -524288(%r2)
|
|
; CHECK: br %r14
|
|
%ptr = getelementptr i32 *%dst, i64 -131072
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check the next word down, which needs separate address logic.
|
|
; Other sequences besides this one would be OK.
|
|
define void @f6(i32 *%dst, i32 %a) {
|
|
; CHECK: f6:
|
|
; CHECK: agfi %r2, -524292
|
|
; CHECK: strv %r3, 0(%r2)
|
|
; CHECK: br %r14
|
|
%ptr = getelementptr i32 *%dst, i64 -131073
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check that STRV allows an index.
|
|
define void @f7(i64 %src, i64 %index, i32 %a) {
|
|
; CHECK: f7:
|
|
; CHECK: strv %r4, 524287({{%r3,%r2|%r2,%r3}})
|
|
; CHECK: br %r14
|
|
%add1 = add i64 %src, %index
|
|
%add2 = add i64 %add1, 524287
|
|
%ptr = inttoptr i64 %add2 to i32 *
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store i32 %swapped, i32 *%ptr
|
|
ret void
|
|
}
|
|
|
|
; Check that volatile stores do not use STRV, which might access the
|
|
; storage multple times.
|
|
define void @f8(i32 *%dst, i32 %a) {
|
|
; CHECK: f8:
|
|
; CHECK: lrvr [[REG:%r[0-5]]], %r3
|
|
; CHECK: st [[REG]], 0(%r2)
|
|
; CHECK: br %r14
|
|
%swapped = call i32 @llvm.bswap.i32(i32 %a)
|
|
store volatile i32 %swapped, i32 *%dst
|
|
ret void
|
|
}
|