9ef1d37ffb
Similar to 806761a7629df268c8aed49657aeccffa6bca449 -mtriple= specifies the full target triple while -march= merely sets the architecture part of the default target triple, leaving a target triple which may not make sense. Therefore, -march= is error-prone and not recommended for tests without a target triple. The issue has been benign as we recognize avr-apple-darwin as ELF instead of rejecting it outrightly.
85 lines
2.6 KiB
LLVM
85 lines
2.6 KiB
LLVM
; RUN: llc < %s -mtriple=avr -mattr=avr6 | FileCheck %s
|
|
|
|
declare i16 @allocate(ptr, ptr)
|
|
|
|
; Test taking an address of an alloca with a small offset (adiw)
|
|
define i16 @alloca_addressof_small() {
|
|
entry:
|
|
; CHECK-LABEL: alloca_addressof_small:
|
|
; Test that Y is saved
|
|
; CHECK: push r28
|
|
; CHECK: push r29
|
|
; CHECK: movw r24, r28
|
|
; CHECK: adiw r24, 17
|
|
; CHECK: movw {{.*}}, r28
|
|
; CHECK: adiw {{.*}}, 39
|
|
; CHECK: movw r22, {{.*}}
|
|
; CHECK: pop r29
|
|
; CHECK: pop r28
|
|
%p = alloca [18 x i16]
|
|
%k = alloca [14 x i16]
|
|
%arrayidx = getelementptr inbounds [14 x i16], ptr %k, i16 0, i16 8
|
|
%arrayidx1 = getelementptr inbounds [18 x i16], ptr %p, i16 0, i16 5
|
|
%call = call i16 @allocate(ptr %arrayidx, ptr %arrayidx1)
|
|
ret i16 %call
|
|
}
|
|
|
|
; Test taking an address of an alloca with a big offset (subi/sbci pair)
|
|
define i16 @alloca_addressof_big() {
|
|
entry:
|
|
; CHECK-LABEL: alloca_addressof_big:
|
|
; CHECK: movw r24, r28
|
|
; CHECK: adiw r24, 17
|
|
; CHECK: movw r22, r28
|
|
; CHECK: subi r22, 145
|
|
; CHECK: sbci r23, 255
|
|
%p = alloca [55 x i16]
|
|
%k = alloca [14 x i16]
|
|
%arrayidx = getelementptr inbounds [14 x i16], ptr %k, i16 0, i16 8
|
|
%arrayidx1 = getelementptr inbounds [55 x i16], ptr %p, i16 0, i16 41
|
|
%call = call i16 @allocate(ptr %arrayidx, ptr %arrayidx1)
|
|
ret i16 %call
|
|
}
|
|
|
|
; Test writing to an allocated variable with a small and a big offset
|
|
define i16 @alloca_write(i16 %x) {
|
|
entry:
|
|
; CHECK-LABEL: alloca_write:
|
|
; Small offset here
|
|
; CHECK: std Y+24, {{.*}}
|
|
; CHECK: std Y+23, {{.*}}
|
|
; Big offset here
|
|
; CHECK: adiw r28, 57
|
|
; CHECK: std Y+63, {{.*}}
|
|
; CHECK: std Y+62, {{.*}}
|
|
; CHECK: sbiw r28, 57
|
|
%p = alloca [15 x i16]
|
|
%k = alloca [14 x i16]
|
|
%arrayidx = getelementptr inbounds [15 x i16], ptr %p, i16 0, i16 45
|
|
store i16 22, ptr %arrayidx
|
|
%arrayidx1 = getelementptr inbounds [14 x i16], ptr %k, i16 0, i16 11
|
|
store i16 42, ptr %arrayidx1
|
|
%arrayidx2 = getelementptr inbounds [14 x i16], ptr %k, i16 0, i16 0
|
|
%arrayidx3 = getelementptr inbounds [15 x i16], ptr %p, i16 0, i16 0
|
|
%call = call i16 @allocate(ptr %arrayidx2, ptr %arrayidx3)
|
|
ret i16 %call
|
|
}
|
|
|
|
; Test writing to an allocated variable with a huge offset that cant be
|
|
; materialized with adiw/sbiw but with a subi/sbci pair.
|
|
define void @alloca_write_huge() {
|
|
; CHECK-LABEL: alloca_write_huge:
|
|
; CHECK: subi r28, 41
|
|
; CHECK: sbci r29, 255
|
|
; CHECK: std Y+63, {{.*}}
|
|
; CHECK: std Y+62, {{.*}}
|
|
; CHECK: subi r28, 215
|
|
; CHECK: sbci r29, 0
|
|
%k = alloca [140 x i16]
|
|
%arrayidx = getelementptr inbounds [140 x i16], ptr %k, i16 0, i16 138
|
|
store i16 22, ptr %arrayidx
|
|
%arraydecay = getelementptr inbounds [140 x i16], ptr %k, i16 0, i16 0
|
|
call i16 @allocate(ptr %arraydecay, ptr null)
|
|
ret void
|
|
}
|