350 lines
10 KiB
LLVM
350 lines
10 KiB
LLVM
; RUN: llc -mattr=sram,addsubiw < %s -march=avr | FileCheck %s
|
|
|
|
@char = common global i8 0
|
|
@char.array = common global [3 x i8] zeroinitializer
|
|
@char.static = internal global i8 0
|
|
|
|
@int = common global i16 0
|
|
@int.array = common global [3 x i16] zeroinitializer
|
|
@int.static = internal global i16 0
|
|
|
|
@long = common global i32 0
|
|
@long.array = common global [3 x i32] zeroinitializer
|
|
@long.static = internal global i32 0
|
|
|
|
@longlong = common global i64 0
|
|
@longlong.array = common global [3 x i64] zeroinitializer
|
|
@longlong.static = internal global i64 0
|
|
|
|
define void @global8_store() {
|
|
; CHECK-LABEL: global8_store:
|
|
; CHECK: ldi [[REG:r[0-9]+]], 6
|
|
; CHECK: sts char, [[REG]]
|
|
store i8 6, i8* @char
|
|
ret void
|
|
}
|
|
|
|
define i8 @global8_load() {
|
|
; CHECK-LABEL: global8_load:
|
|
; CHECK: lds r24, char
|
|
%result = load i8, i8* @char
|
|
ret i8 %result
|
|
}
|
|
|
|
define void @array8_store() {
|
|
; CHECK-LABEL: array8_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 3
|
|
; CHECK: sts char.array+2, [[REG1]]
|
|
; CHECK: ldi [[REG3:r[0-9]+]], 1
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 2
|
|
; CHECK: sts char.array+1, [[REG2]]
|
|
; CHECK: sts char.array, [[REG3]]
|
|
store i8 1, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 0)
|
|
store i8 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 1)
|
|
store i8 3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
|
|
ret void
|
|
}
|
|
|
|
define i8 @array8_load() {
|
|
; CHECK-LABEL: array8_load:
|
|
; CHECK: lds r24, char.array+2
|
|
%result = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
|
|
ret i8 %result
|
|
}
|
|
|
|
define i8 @static8_inc() {
|
|
; CHECK-LABEL: static8_inc:
|
|
; CHECK: lds r24, char.static
|
|
; CHECK: inc r24
|
|
; CHECK: sts char.static, r24
|
|
%1 = load i8, i8* @char.static
|
|
%inc = add nsw i8 %1, 1
|
|
store i8 %inc, i8* @char.static
|
|
ret i8 %inc
|
|
}
|
|
|
|
define void @global16_store() {
|
|
; CHECK-LABEL: global16_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 187
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 170
|
|
; CHECK: sts int+1, [[REG2]]
|
|
; CHECK: sts int, [[REG1]]
|
|
store i16 43707, i16* @int
|
|
ret void
|
|
}
|
|
|
|
define i16 @global16_load() {
|
|
; CHECK-LABEL: global16_load:
|
|
; CHECK: lds r24, int
|
|
; CHECK: lds r25, int+1
|
|
%result = load i16, i16* @int
|
|
ret i16 %result
|
|
}
|
|
|
|
define void @array16_store() {
|
|
; CHECK-LABEL: array16_store:
|
|
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 204
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 170
|
|
; CHECK: sts int.array+3, [[REG2]]
|
|
; CHECK: sts int.array+2, [[REG1]]
|
|
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 187
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 170
|
|
; CHECK: sts int.array+1, [[REG2]]
|
|
; CHECK: sts int.array, [[REG1]]
|
|
|
|
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 221
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 170
|
|
; CHECK: sts int.array+5, [[REG2]]
|
|
; CHECK: sts int.array+4, [[REG1]]
|
|
store i16 43707, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 0)
|
|
store i16 43724, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 1)
|
|
store i16 43741, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 2)
|
|
ret void
|
|
}
|
|
|
|
define i16 @array16_load() {
|
|
; CHECK-LABEL: array16_load:
|
|
; CHECK: lds r24, int.array+4
|
|
; CHECK: lds r25, int.array+5
|
|
%result = load i16, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 2)
|
|
ret i16 %result
|
|
}
|
|
|
|
define i16 @static16_inc() {
|
|
; CHECK-LABEL: static16_inc:
|
|
; CHECK: lds r24, int.static
|
|
; CHECK: lds r25, int.static+1
|
|
; CHECK: adiw r24, 1
|
|
; CHECK: sts int.static+1, r25
|
|
; CHECK: sts int.static, r24
|
|
%1 = load i16, i16* @int.static
|
|
%inc = add nsw i16 %1, 1
|
|
store i16 %inc, i16* @int.static
|
|
ret i16 %inc
|
|
}
|
|
|
|
define void @global32_store() {
|
|
; CHECK-LABEL: global32_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 187
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 170
|
|
; CHECK: sts long+3, [[REG2]]
|
|
; CHECK: sts long+2, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 221
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 204
|
|
; CHECK: sts long+1, [[REG2]]
|
|
; CHECK: sts long, [[REG1]]
|
|
store i32 2864434397, i32* @long
|
|
ret void
|
|
}
|
|
|
|
define i32 @global32_load() {
|
|
; CHECK-LABEL: global32_load:
|
|
; CHECK: lds r22, long
|
|
; CHECK: lds r23, long+1
|
|
; CHECK: lds r24, long+2
|
|
; CHECK: lds r25, long+3
|
|
%result = load i32, i32* @long
|
|
ret i32 %result
|
|
}
|
|
|
|
define void @array32_store() {
|
|
; CHECK-LABEL: array32_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 102
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 85
|
|
; CHECK: sts long.array+7, [[REG2]]
|
|
; CHECK: sts long.array+6, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 136
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 119
|
|
; CHECK: sts long.array+5, [[REG2]]
|
|
; CHECK: sts long.array+4, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 27
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 172
|
|
; CHECK: sts long.array+3, [[REG2]]
|
|
; CHECK: sts long.array+2, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 68
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 13
|
|
; CHECK: sts long.array+1, [[REG2]]
|
|
; CHECK: sts long.array, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 170
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 153
|
|
; CHECK: sts long.array+11, [[REG2]]
|
|
; CHECK: sts long.array+10, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 204
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 187
|
|
; CHECK: sts long.array+9, [[REG2]]
|
|
; CHECK: sts long.array+8, [[REG1]]
|
|
store i32 2887454020, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 0)
|
|
store i32 1432778632, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 1)
|
|
store i32 2578103244, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 2)
|
|
ret void
|
|
}
|
|
|
|
define i32 @array32_load() {
|
|
; CHECK-LABEL: array32_load:
|
|
; CHECK: lds r22, long.array+8
|
|
; CHECK: lds r23, long.array+9
|
|
; CHECK: lds r24, long.array+10
|
|
; CHECK: lds r25, long.array+11
|
|
%result = load i32, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 2)
|
|
ret i32 %result
|
|
}
|
|
|
|
define i32 @static32_inc() {
|
|
; CHECK-LABEL: static32_inc:
|
|
; CHECK: lds r22, long.static
|
|
; CHECK: lds r23, long.static+1
|
|
; CHECK: lds r24, long.static+2
|
|
; CHECK: lds r25, long.static+3
|
|
; CHECK: subi r22, 255
|
|
; CHECK: sbci r23, 255
|
|
; CHECK: sbci r24, 255
|
|
; CHECK: sbci r25, 255
|
|
; CHECK: sts long.static+3, r25
|
|
; CHECK: sts long.static+2, r24
|
|
; CHECK: sts long.static+1, r23
|
|
; CHECK: sts long.static, r22
|
|
%1 = load i32, i32* @long.static
|
|
%inc = add nsw i32 %1, 1
|
|
store i32 %inc, i32* @long.static
|
|
ret i32 %inc
|
|
}
|
|
|
|
define void @global64_store() {
|
|
; CHECK-LABEL: global64_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 34
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 17
|
|
; CHECK: sts longlong+7, [[REG2]]
|
|
; CHECK: sts longlong+6, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 68
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 51
|
|
; CHECK: sts longlong+5, [[REG2]]
|
|
; CHECK: sts longlong+4, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 102
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 85
|
|
; CHECK: sts longlong+3, [[REG2]]
|
|
; CHECK: sts longlong+2, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 136
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 119
|
|
; CHECK: sts longlong+1, [[REG2]]
|
|
; CHECK: sts longlong, [[REG1]]
|
|
store i64 1234605616436508552, i64* @longlong
|
|
ret void
|
|
}
|
|
|
|
define i64 @global64_load() {
|
|
; CHECK-LABEL: global64_load:
|
|
; CHECK: lds r18, longlong
|
|
; CHECK: lds r19, longlong+1
|
|
; CHECK: lds r20, longlong+2
|
|
; CHECK: lds r21, longlong+3
|
|
; CHECK: lds r22, longlong+4
|
|
; CHECK: lds r23, longlong+5
|
|
; CHECK: lds r24, longlong+6
|
|
; CHECK: lds r25, longlong+7
|
|
%result = load i64, i64* @longlong
|
|
ret i64 %result
|
|
}
|
|
|
|
define void @array64_store() {
|
|
; CHECK-LABEL: array64_store:
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 34
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 17
|
|
; CHECK: sts longlong.array+7, [[REG2]]
|
|
; CHECK: sts longlong.array+6, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 68
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 51
|
|
; CHECK: sts longlong.array+5, [[REG2]]
|
|
; CHECK: sts longlong.array+4, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 102
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 85
|
|
; CHECK: sts longlong.array+3, [[REG2]]
|
|
; CHECK: sts longlong.array+2, [[REG1]]
|
|
; CHECK: ldi [[REG1:r[0-9]+]], 136
|
|
; CHECK: ldi [[REG2:r[0-9]+]], 119
|
|
; CHECK: sts longlong.array+1, [[REG2]]
|
|
; CHECK: sts longlong.array, [[REG1]]
|
|
store i64 1234605616436508552, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 0)
|
|
store i64 81985529216486895, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 1)
|
|
store i64 1836475854449306472, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 2)
|
|
ret void
|
|
}
|
|
|
|
define i64 @array64_load() {
|
|
; CHECK-LABEL: array64_load:
|
|
; CHECK: lds r18, longlong.array+16
|
|
; CHECK: lds r19, longlong.array+17
|
|
; CHECK: lds r20, longlong.array+18
|
|
; CHECK: lds r21, longlong.array+19
|
|
; CHECK: lds r22, longlong.array+20
|
|
; CHECK: lds r23, longlong.array+21
|
|
; CHECK: lds r24, longlong.array+22
|
|
; CHECK: lds r25, longlong.array+23
|
|
%result = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 2)
|
|
ret i64 %result
|
|
}
|
|
|
|
define i64 @static64_inc() {
|
|
; CHECK-LABEL: static64_inc:
|
|
; CHECK: lds r18, longlong.static
|
|
; CHECK: lds r19, longlong.static+1
|
|
; CHECK: lds r20, longlong.static+2
|
|
; CHECK: lds r21, longlong.static+3
|
|
; CHECK: lds r22, longlong.static+4
|
|
; CHECK: lds r23, longlong.static+5
|
|
; CHECK: lds r24, longlong.static+6
|
|
; CHECK: lds r25, longlong.static+7
|
|
; CHECK: subi r18, 255
|
|
; CHECK: sbci r19, 255
|
|
; CHECK: sbci r20, 255
|
|
; CHECK: sbci r21, 255
|
|
; CHECK: sbci r22, 255
|
|
; CHECK: sbci r23, 255
|
|
; CHECK: sbci r24, 255
|
|
; CHECK: sbci r25, 255
|
|
; CHECK: sts longlong.static+7, r25
|
|
; CHECK: sts longlong.static+6, r24
|
|
; CHECK: sts longlong.static+5, r23
|
|
; CHECK: sts longlong.static+4, r22
|
|
; CHECK: sts longlong.static+3, r21
|
|
; CHECK: sts longlong.static+2, r20
|
|
; CHECK: sts longlong.static+1, r19
|
|
; CHECK: sts longlong.static, r18
|
|
%1 = load i64, i64* @longlong.static
|
|
%inc = add nsw i64 %1, 1
|
|
store i64 %inc, i64* @longlong.static
|
|
ret i64 %inc
|
|
}
|
|
|
|
define i8 @constantaddr_read8() {
|
|
; CHECK-LABEL: constantaddr_read8:
|
|
; CHECK: lds r24, 1234
|
|
%1 = load i8, i8* inttoptr (i16 1234 to i8*)
|
|
ret i8 %1
|
|
}
|
|
|
|
define i16 @constantaddr_read16() {
|
|
; CHECK-LABEL: constantaddr_read16:
|
|
; CHECK: lds r24, 1234
|
|
; CHECK: lds r25, 1235
|
|
%1 = load i16, i16* inttoptr (i16 1234 to i16*)
|
|
ret i16 %1
|
|
}
|
|
|
|
define void @constantaddr_write8() {
|
|
; CHECK-LABEL: constantaddr_write8:
|
|
; CHECK: sts 1234
|
|
store i8 22, i8* inttoptr (i16 1234 to i8*)
|
|
ret void
|
|
}
|
|
|
|
define void @constantaddr_write16() {
|
|
; CHECK-LABEL: constantaddr_write16:
|
|
; CHECK: sts 1235
|
|
; CHECK: sts 1234
|
|
store i16 2222, i16* inttoptr (i16 1234 to i16*)
|
|
ret void
|
|
}
|