1; RUN: llc -mattr=sram,addsubiw < %s -march=avr | FileCheck %s
2
3@char = common global i8 0
4@char.array = common global [3 x i8] zeroinitializer
5@char.static = internal global i8 0
6
7@int = common global i16 0
8@int.array = common global [3 x i16] zeroinitializer
9@int.static = internal global i16 0
10
11@long = common global i32 0
12@long.array = common global [3 x i32] zeroinitializer
13@long.static = internal global i32 0
14
15@longlong = common global i64 0
16@longlong.array = common global [3 x i64] zeroinitializer
17@longlong.static = internal global i64 0
18
19define void @global8_store() {
20; CHECK-LABEL: global8_store:
21; CHECK: ldi [[REG:r[0-9]+]], 6
22; CHECK: sts char, [[REG]]
23  store i8 6, i8* @char
24  ret void
25}
26
27define i8 @global8_load() {
28; CHECK-LABEL: global8_load:
29; CHECK: lds r24, char
30  %result = load i8, i8* @char
31  ret i8 %result
32}
33
34define void @array8_store() {
35; CHECK-LABEL: array8_store:
36; CHECK: ldi [[REG1:r[0-9]+]], 1
37; CHECK: sts char.array, [[REG1]]
38; CHECK: ldi [[REG2:r[0-9]+]], 2
39; CHECK: sts char.array+1, [[REG2]]
40; CHECK: ldi [[REG:r[0-9]+]], 3
41; CHECK: sts char.array+2, [[REG]]
42  store i8 1, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 0)
43  store i8 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 1)
44  store i8 3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
45  ret void
46}
47
48define i8 @array8_load() {
49; CHECK-LABEL: array8_load:
50; CHECK: lds r24, char.array+2
51  %result = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
52  ret i8 %result
53}
54
55define i8 @static8_inc() {
56; CHECK-LABEL: static8_inc:
57; CHECK: lds r24, char.static
58; CHECK: inc r24
59; CHECK: sts char.static, r24
60  %1 = load i8, i8* @char.static
61  %inc = add nsw i8 %1, 1
62  store i8 %inc, i8* @char.static
63  ret i8 %inc
64}
65
66define void @global16_store() {
67; CHECK-LABEL: global16_store:
68; CHECK: ldi [[REG1:r[0-9]+]], 187
69; CHECK: ldi [[REG2:r[0-9]+]], 170
70; CHECK: sts int+1, [[REG2]]
71; CHECK: sts int, [[REG1]]
72  store i16 43707, i16* @int
73  ret void
74}
75
76define i16 @global16_load() {
77; CHECK-LABEL: global16_load:
78; CHECK: lds r24, int
79; CHECK: lds r25, int+1
80  %result = load i16, i16* @int
81  ret i16 %result
82}
83
84define void @array16_store() {
85; CHECK-LABEL: array16_store:
86; CHECK: ldi [[REG1:r[0-9]+]], 187
87; CHECK: ldi [[REG2:r[0-9]+]], 170
88; CHECK: sts int.array+1, [[REG2]]
89; CHECK: sts int.array, [[REG1]]
90; CHECK: ldi [[REG1:r[0-9]+]], 204
91; CHECK: ldi [[REG2:r[0-9]+]], 170
92; CHECK: sts int.array+3, [[REG2]]
93; CHECK: sts int.array+2, [[REG1]]
94; CHECK: ldi [[REG1:r[0-9]+]], 221
95; CHECK: ldi [[REG2:r[0-9]+]], 170
96; CHECK: sts int.array+5, [[REG2]]
97; CHECK: sts int.array+4, [[REG1]]
98  store i16 43707, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 0)
99  store i16 43724, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 1)
100  store i16 43741, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 2)
101  ret void
102}
103
104define i16 @array16_load() {
105; CHECK-LABEL: array16_load:
106; CHECK: lds r24, int.array+4
107; CHECK: lds r25, int.array+5
108  %result = load i16, i16* getelementptr inbounds ([3 x i16], [3 x i16]* @int.array, i32 0, i64 2)
109  ret i16 %result
110}
111
112define i16 @static16_inc() {
113; CHECK-LABEL: static16_inc:
114; CHECK: lds r24, int.static
115; CHECK: lds r25, int.static+1
116; CHECK: adiw r24, 1
117; CHECK: sts int.static+1, r25
118; CHECK: sts int.static, r24
119  %1 = load i16, i16* @int.static
120  %inc = add nsw i16 %1, 1
121  store i16 %inc, i16* @int.static
122  ret i16 %inc
123}
124
125define void @global32_store() {
126; CHECK-LABEL: global32_store:
127; CHECK: ldi [[REG1:r[0-9]+]], 187
128; CHECK: ldi [[REG2:r[0-9]+]], 170
129; CHECK: sts long+3, [[REG2]]
130; CHECK: sts long+2, [[REG1]]
131; CHECK: ldi [[REG1:r[0-9]+]], 221
132; CHECK: ldi [[REG2:r[0-9]+]], 204
133; CHECK: sts long+1, [[REG2]]
134; CHECK: sts long, [[REG1]]
135  store i32 2864434397, i32* @long
136  ret void
137}
138
139define i32 @global32_load() {
140; CHECK-LABEL: global32_load:
141; CHECK: lds r22, long
142; CHECK: lds r23, long+1
143; CHECK: lds r24, long+2
144; CHECK: lds r25, long+3
145  %result = load i32, i32* @long
146  ret i32 %result
147}
148
149define void @array32_store() {
150; CHECK-LABEL: array32_store:
151; CHECK: ldi [[REG1:r[0-9]+]], 27
152; CHECK: ldi [[REG2:r[0-9]+]], 172
153; CHECK: sts long.array+3, [[REG2]]
154; CHECK: sts long.array+2, [[REG1]]
155; CHECK: ldi [[REG1:r[0-9]+]], 68
156; CHECK: ldi [[REG2:r[0-9]+]], 13
157; CHECK: sts long.array+1, [[REG2]]
158; CHECK: sts long.array, [[REG1]]
159; CHECK: ldi [[REG1:r[0-9]+]], 102
160; CHECK: ldi [[REG2:r[0-9]+]], 85
161; CHECK: sts long.array+7, [[REG2]]
162; CHECK: sts long.array+6, [[REG1]]
163; CHECK: ldi [[REG1:r[0-9]+]], 136
164; CHECK: ldi [[REG2:r[0-9]+]], 119
165; CHECK: sts long.array+5, [[REG2]]
166; CHECK: sts long.array+4, [[REG1]]
167; CHECK: ldi [[REG1:r[0-9]+]], 170
168; CHECK: ldi [[REG2:r[0-9]+]], 153
169; CHECK: sts long.array+11, [[REG2]]
170; CHECK: sts long.array+10, [[REG1]]
171; CHECK: ldi [[REG1:r[0-9]+]], 204
172; CHECK: ldi [[REG2:r[0-9]+]], 187
173; CHECK: sts long.array+9, [[REG2]]
174; CHECK: sts long.array+8, [[REG1]]
175  store i32 2887454020, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 0)
176  store i32 1432778632, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 1)
177  store i32 2578103244, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 2)
178  ret void
179}
180
181define i32 @array32_load() {
182; CHECK-LABEL: array32_load:
183; CHECK: lds r22, long.array+8
184; CHECK: lds r23, long.array+9
185; CHECK: lds r24, long.array+10
186; CHECK: lds r25, long.array+11
187  %result = load i32, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @long.array, i32 0, i64 2)
188  ret i32 %result
189}
190
191define i32 @static32_inc() {
192; CHECK-LABEL: static32_inc:
193; CHECK: lds r22, long.static
194; CHECK: lds r23, long.static+1
195; CHECK: lds r24, long.static+2
196; CHECK: lds r25, long.static+3
197; CHECK: subi r22, 255
198; CHECK: sbci r23, 255
199; CHECK: sbci r24, 255
200; CHECK: sbci r25, 255
201; CHECK: sts long.static+3, r25
202; CHECK: sts long.static+2, r24
203; CHECK: sts long.static+1, r23
204; CHECK: sts long.static, r22
205  %1 = load i32, i32* @long.static
206  %inc = add nsw i32 %1, 1
207  store i32 %inc, i32* @long.static
208  ret i32 %inc
209}
210
211define void @global64_store() {
212; CHECK-LABEL: global64_store:
213; CHECK: ldi [[REG1:r[0-9]+]], 34
214; CHECK: ldi [[REG2:r[0-9]+]], 17
215; CHECK: sts longlong+7, [[REG2]]
216; CHECK: sts longlong+6, [[REG1]]
217; CHECK: ldi [[REG1:r[0-9]+]], 68
218; CHECK: ldi [[REG2:r[0-9]+]], 51
219; CHECK: sts longlong+5, [[REG2]]
220; CHECK: sts longlong+4, [[REG1]]
221; CHECK: ldi [[REG1:r[0-9]+]], 102
222; CHECK: ldi [[REG2:r[0-9]+]], 85
223; CHECK: sts longlong+3, [[REG2]]
224; CHECK: sts longlong+2, [[REG1]]
225; CHECK: ldi [[REG1:r[0-9]+]], 136
226; CHECK: ldi [[REG2:r[0-9]+]], 119
227; CHECK: sts longlong+1, [[REG2]]
228; CHECK: sts longlong, [[REG1]]
229  store i64 1234605616436508552, i64* @longlong
230  ret void
231}
232
233define i64 @global64_load() {
234; CHECK-LABEL: global64_load:
235; CHECK: lds r18, longlong
236; CHECK: lds r19, longlong+1
237; CHECK: lds r20, longlong+2
238; CHECK: lds r21, longlong+3
239; CHECK: lds r22, longlong+4
240; CHECK: lds r23, longlong+5
241; CHECK: lds r24, longlong+6
242; CHECK: lds r25, longlong+7
243  %result = load i64, i64* @longlong
244  ret i64 %result
245}
246
247define void @array64_store() {
248; CHECK-LABEL: array64_store:
249; CHECK: ldi [[REG1:r[0-9]+]], 34
250; CHECK: ldi [[REG2:r[0-9]+]], 17
251; CHECK: sts longlong.array+7, [[REG2]]
252; CHECK: sts longlong.array+6, [[REG1]]
253; CHECK: ldi [[REG1:r[0-9]+]], 68
254; CHECK: ldi [[REG2:r[0-9]+]], 51
255; CHECK: sts longlong.array+5, [[REG2]]
256; CHECK: sts longlong.array+4, [[REG1]]
257; CHECK: ldi [[REG1:r[0-9]+]], 102
258; CHECK: ldi [[REG2:r[0-9]+]], 85
259; CHECK: sts longlong.array+3, [[REG2]]
260; CHECK: sts longlong.array+2, [[REG1]]
261; CHECK: ldi [[REG1:r[0-9]+]], 136
262; CHECK: ldi [[REG2:r[0-9]+]], 119
263; CHECK: sts longlong.array+1, [[REG2]]
264; CHECK: sts longlong.array, [[REG1]]
265  store i64 1234605616436508552, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 0)
266  store i64 81985529216486895, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 1)
267  store i64 1836475854449306472, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 2)
268  ret void
269}
270
271define i64 @array64_load() {
272; CHECK-LABEL: array64_load:
273; CHECK: lds r18, longlong.array+16
274; CHECK: lds r19, longlong.array+17
275; CHECK: lds r20, longlong.array+18
276; CHECK: lds r21, longlong.array+19
277; CHECK: lds r22, longlong.array+20
278; CHECK: lds r23, longlong.array+21
279; CHECK: lds r24, longlong.array+22
280; CHECK: lds r25, longlong.array+23
281  %result = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @longlong.array, i64 0, i64 2)
282  ret i64 %result
283}
284
285define i64 @static64_inc() {
286; CHECK-LABEL: static64_inc:
287; CHECK: lds r18, longlong.static
288; CHECK: lds r19, longlong.static+1
289; CHECK: lds r20, longlong.static+2
290; CHECK: lds r21, longlong.static+3
291; CHECK: lds r22, longlong.static+4
292; CHECK: lds r23, longlong.static+5
293; CHECK: lds r24, longlong.static+6
294; CHECK: lds r25, longlong.static+7
295; CHECK: subi r18, 255
296; CHECK: sbci r19, 255
297; CHECK: sbci r20, 255
298; CHECK: sbci r21, 255
299; CHECK: sbci r22, 255
300; CHECK: sbci r23, 255
301; CHECK: sbci r24, 255
302; CHECK: sbci r25, 255
303; CHECK: sts longlong.static+7, r25
304; CHECK: sts longlong.static+6, r24
305; CHECK: sts longlong.static+5, r23
306; CHECK: sts longlong.static+4, r22
307; CHECK: sts longlong.static+3, r21
308; CHECK: sts longlong.static+2, r20
309; CHECK: sts longlong.static+1, r19
310; CHECK: sts longlong.static, r18
311  %1 = load i64, i64* @longlong.static
312  %inc = add nsw i64 %1, 1
313  store i64 %inc, i64* @longlong.static
314  ret i64 %inc
315}
316
317define i8 @constantaddr_read8() {
318; CHECK-LABEL: constantaddr_read8:
319; CHECK: lds r24, 1234
320  %1 = load i8, i8* inttoptr (i16 1234 to i8*)
321  ret i8 %1
322}
323
324define i16 @constantaddr_read16() {
325; CHECK-LABEL: constantaddr_read16:
326; CHECK: lds r24, 1234
327; CHECK: lds r25, 1235
328  %1 = load i16, i16* inttoptr (i16 1234 to i16*)
329  ret i16 %1
330}
331
332define void @constantaddr_write8() {
333; CHECK-LABEL: constantaddr_write8:
334; CHECK: sts 1234
335  store i8 22, i8* inttoptr (i16 1234 to i8*)
336  ret void
337}
338
339define void @constantaddr_write16() {
340; CHECK-LABEL: constantaddr_write16:
341; CHECK: sts 1235
342; CHECK: sts 1234
343  store i16 2222, i16* inttoptr (i16 1234 to i16*)
344  ret void
345}
346