|
95
|
1 ; RUN: llc < %s -mtriple=armv7-apple-ios -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-IOS --check-prefix=CHECK
|
|
|
2 ; RUN: llc < %s -mtriple=thumbv7m-none-macho -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-DARWIN --check-prefix=CHECK
|
|
|
3 ; RUN: llc < %s -mtriple=arm-none-eabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
|
|
|
4 ; RUN: llc < %s -mtriple=arm-none-eabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
|
|
100
|
5 ; RUN: llc < %s -mtriple=arm-none-androideabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
|
|
|
6 ; RUN: llc < %s -mtriple=arm-none-gnueabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
|
|
|
7 ; RUN: llc < %s -mtriple=arm-none-gnueabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
|
|
120
|
8 ; RUN: llc < %s -mtriple=arm-none-musleabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
|
|
|
9 ; RUN: llc < %s -mtriple=arm-none-musleabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
|
|
95
|
10
|
|
120
|
11 define void @f1(i8* %dest, i8* %src) "no-frame-pointer-elim"="true" {
|
|
95
|
12 entry:
|
|
|
13 ; CHECK-LABEL: f1
|
|
|
14
|
|
100
|
15 ; CHECK-IOS: bl _memmove
|
|
|
16 ; CHECK-DARWIN: bl _memmove
|
|
|
17 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
18 ; CHECK-GNUEABI: bl memmove
|
|
95
|
19 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 0, i1 false)
|
|
|
20
|
|
100
|
21 ; CHECK-IOS: bl _memcpy
|
|
|
22 ; CHECK-DARWIN: bl _memcpy
|
|
|
23 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
24 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
25 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 0, i1 false)
|
|
|
26
|
|
|
27 ; EABI memset swaps arguments
|
|
|
28 ; CHECK-IOS: mov r1, #1
|
|
100
|
29 ; CHECK-IOS: bl _memset
|
|
95
|
30 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
31 ; CHECK-DARWIN: bl _memset
|
|
95
|
32 ; CHECK-EABI: mov r2, #1
|
|
100
|
33 ; CHECK-EABI: bl __aeabi_memset
|
|
|
34 ; CHECK-GNUEABI: mov r1, #1
|
|
|
35 ; CHECK-GNUEABI: bl memset
|
|
95
|
36 call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 0, i1 false)
|
|
|
37
|
|
|
38 ; EABI uses memclr if value set to 0
|
|
|
39 ; CHECK-IOS: mov r1, #0
|
|
100
|
40 ; CHECK-IOS: bl _memset
|
|
95
|
41 ; CHECK-DARWIN: movs r1, #0
|
|
100
|
42 ; CHECK-DARWIN: bl _memset
|
|
|
43 ; CHECK-EABI: bl __aeabi_memclr
|
|
|
44 ; CHECK-GNUEABI: bl memset
|
|
95
|
45 call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 0, i1 false)
|
|
100
|
46
|
|
95
|
47 ; EABI uses aligned function variants if possible
|
|
|
48
|
|
100
|
49 ; CHECK-IOS: bl _memmove
|
|
|
50 ; CHECK-DARWIN: bl _memmove
|
|
|
51 ; CHECK-EABI: bl __aeabi_memmove4
|
|
|
52 ; CHECK-GNUEABI: bl memmove
|
|
95
|
53 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 4, i1 false)
|
|
|
54
|
|
100
|
55 ; CHECK-IOS: bl _memcpy
|
|
|
56 ; CHECK-DARWIN: bl _memcpy
|
|
|
57 ; CHECK-EABI: bl __aeabi_memcpy4
|
|
|
58 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
59 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 4, i1 false)
|
|
|
60
|
|
100
|
61 ; CHECK-IOS: bl _memset
|
|
|
62 ; CHECK-DARWIN: bl _memset
|
|
|
63 ; CHECK-EABI: bl __aeabi_memset4
|
|
|
64 ; CHECK-GNUEABI: bl memset
|
|
95
|
65 call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 4, i1 false)
|
|
|
66
|
|
100
|
67 ; CHECK-IOS: bl _memset
|
|
|
68 ; CHECK-DARWIN: bl _memset
|
|
|
69 ; CHECK-EABI: bl __aeabi_memclr4
|
|
|
70 ; CHECK-GNUEABI: bl memset
|
|
95
|
71 call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 4, i1 false)
|
|
|
72
|
|
100
|
73 ; CHECK-IOS: bl _memmove
|
|
|
74 ; CHECK-DARWIN: bl _memmove
|
|
|
75 ; CHECK-EABI: bl __aeabi_memmove8
|
|
|
76 ; CHECK-GNUEABI: bl memmove
|
|
95
|
77 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 8, i1 false)
|
|
|
78
|
|
100
|
79 ; CHECK-IOS: bl _memcpy
|
|
|
80 ; CHECK-DARWIN: bl _memcpy
|
|
|
81 ; CHECK-EABI: bl __aeabi_memcpy8
|
|
|
82 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
83 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 8, i1 false)
|
|
|
84
|
|
100
|
85 ; CHECK-IOS: bl _memset
|
|
|
86 ; CHECK-DARWIN: bl _memset
|
|
|
87 ; CHECK-EABI: bl __aeabi_memset8
|
|
|
88 ; CHECK-GNUEABI: bl memset
|
|
95
|
89 call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 8, i1 false)
|
|
|
90
|
|
100
|
91 ; CHECK-IOS: bl _memset
|
|
|
92 ; CHECK-DARWIN: bl _memset
|
|
|
93 ; CHECK-EABI: bl __aeabi_memclr8
|
|
|
94 ; CHECK-GNUEABI: bl memset
|
|
95
|
95 call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 8, i1 false)
|
|
|
96
|
|
|
97 unreachable
|
|
|
98 }
|
|
|
99
|
|
|
100 ; Check that alloca arguments to memory intrinsics are automatically aligned if at least 8 bytes in size
|
|
120
|
101 define void @f2(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
102 entry:
|
|
|
103 ; CHECK-LABEL: f2
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
104
|
|
95
|
105 ; IOS (ARMv7) should 8-byte align, others should 4-byte align
|
|
|
106 ; CHECK-IOS: add r1, sp, #32
|
|
100
|
107 ; CHECK-IOS: bl _memmove
|
|
95
|
108 ; CHECK-DARWIN: add r1, sp, #28
|
|
100
|
109 ; CHECK-DARWIN: bl _memmove
|
|
120
|
110 ; CHECK-EABI: {{add r1, sp, #28|sub r1, r(7|11), #20}}
|
|
100
|
111 ; CHECK-EABI: bl __aeabi_memmove
|
|
120
|
112 ; CHECK-GNUEABI: {{add r1, sp, #28|sub r1, r(7|11), #20}}
|
|
100
|
113 ; CHECK-GNUEABI: bl memmove
|
|
95
|
114 %arr0 = alloca [9 x i8], align 1
|
|
|
115 %0 = bitcast [9 x i8]* %arr0 to i8*
|
|
|
116 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
117
|
|
|
118 ; CHECK: add r1, sp, #16
|
|
100
|
119 ; CHECK-IOS: bl _memcpy
|
|
|
120 ; CHECK-DARWIN: bl _memcpy
|
|
|
121 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
122 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
123 %arr1 = alloca [9 x i8], align 1
|
|
|
124 %1 = bitcast [9 x i8]* %arr1 to i8*
|
|
|
125 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
126
|
|
95
|
127 ; CHECK-IOS: mov r0, sp
|
|
|
128 ; CHECK-IOS: mov r1, #1
|
|
100
|
129 ; CHECK-IOS: bl _memset
|
|
95
|
130 ; CHECK-DARWIN: add r0, sp, #4
|
|
|
131 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
132 ; CHECK-DARWIN: bl _memset
|
|
95
|
133 ; CHECK-EABI: add r0, sp, #4
|
|
|
134 ; CHECK-EABI: mov r2, #1
|
|
100
|
135 ; CHECK-EABI: bl __aeabi_memset
|
|
|
136 ; CHECK-GNUEABI: add r0, sp, #4
|
|
|
137 ; CHECK-GNUEABI: mov r1, #1
|
|
|
138 ; CHECK-GNUEABI: bl memset
|
|
95
|
139 %arr2 = alloca [9 x i8], align 1
|
|
|
140 %2 = bitcast [9 x i8]* %arr2 to i8*
|
|
|
141 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
142
|
|
|
143 unreachable
|
|
|
144 }
|
|
|
145
|
|
|
146 ; Check that alloca arguments are not aligned if less than 8 bytes in size
|
|
120
|
147 define void @f3(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
148 entry:
|
|
95
|
149 ; CHECK-LABEL: f3
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
150
|
|
120
|
151 ; CHECK: {{add(.w)? r1, sp, #17|sub(.w)? r1, r(7|11), #15}}
|
|
100
|
152 ; CHECK-IOS: bl _memmove
|
|
|
153 ; CHECK-DARWIN: bl _memmove
|
|
|
154 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
155 ; CHECK-GNUEABI: bl memmove
|
|
95
|
156 %arr0 = alloca [7 x i8], align 1
|
|
|
157 %0 = bitcast [7 x i8]* %arr0 to i8*
|
|
|
158 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
159
|
|
120
|
160 ; CHECK: {{add(.w)? r1, sp, #10|sub(.w)? r1, r(7|11), #22}}
|
|
100
|
161 ; CHECK-IOS: bl _memcpy
|
|
|
162 ; CHECK-DARWIN: bl _memcpy
|
|
|
163 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
164 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
165 %arr1 = alloca [7 x i8], align 1
|
|
|
166 %1 = bitcast [7 x i8]* %arr1 to i8*
|
|
|
167 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
|
|
168
|
|
120
|
169 ; CHECK: {{add(.w)? r0, sp, #3|sub(.w)? r0, r(7|11), #29}}
|
|
95
|
170 ; CHECK-IOS: mov r1, #1
|
|
100
|
171 ; CHECK-IOS: bl _memset
|
|
95
|
172 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
173 ; CHECK-DARWIN: bl _memset
|
|
95
|
174 ; CHECK-EABI: mov r2, #1
|
|
100
|
175 ; CHECK-EABI: bl __aeabi_memset
|
|
|
176 ; CHECK-GNUEABI: mov r1, #1
|
|
|
177 ; CHECK-GNUEABI: bl memset
|
|
95
|
178 %arr2 = alloca [7 x i8], align 1
|
|
|
179 %2 = bitcast [7 x i8]* %arr2 to i8*
|
|
|
180 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
181
|
|
|
182 unreachable
|
|
|
183 }
|
|
|
184
|
|
|
185 ; Check that alloca arguments are not aligned if size+offset is less than 8 bytes
|
|
120
|
186 define void @f4(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
187 entry:
|
|
|
188 ; CHECK-LABEL: f4
|
|
|
189
|
|
120
|
190 ; CHECK: {{add(.w)? r., sp, #23|sub(.w)? r., r(7|11), #17}}
|
|
100
|
191 ; CHECK-IOS: bl _memmove
|
|
|
192 ; CHECK-DARWIN: bl _memmove
|
|
|
193 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
194 ; CHECK-GNUEABI: bl memmove
|
|
95
|
195 %arr0 = alloca [9 x i8], align 1
|
|
|
196 %0 = getelementptr inbounds [9 x i8], [9 x i8]* %arr0, i32 0, i32 4
|
|
|
197 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
198
|
|
120
|
199 ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w) r., r(7|11), #26}}
|
|
100
|
200 ; CHECK-IOS: bl _memcpy
|
|
|
201 ; CHECK-DARWIN: bl _memcpy
|
|
|
202 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
203 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
204 %arr1 = alloca [9 x i8], align 1
|
|
|
205 %1 = getelementptr inbounds [9 x i8], [9 x i8]* %arr1, i32 0, i32 4
|
|
|
206 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
207
|
|
120
|
208 ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w) r., r(7|11), #35}}
|
|
95
|
209 ; CHECK-IOS: mov r1, #1
|
|
100
|
210 ; CHECK-IOS: bl _memset
|
|
95
|
211 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
212 ; CHECK-DARWIN: bl _memset
|
|
95
|
213 ; CHECK-EABI: mov r2, #1
|
|
100
|
214 ; CHECK-EABI: bl __aeabi_memset
|
|
|
215 ; CHECK-GNUEABI: mov r1, #1
|
|
|
216 ; CHECK-GNUEABI: bl memset
|
|
95
|
217 %arr2 = alloca [9 x i8], align 1
|
|
|
218 %2 = getelementptr inbounds [9 x i8], [9 x i8]* %arr2, i32 0, i32 4
|
|
|
219 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
220
|
|
|
221 unreachable
|
|
|
222 }
|
|
|
223
|
|
|
224 ; Check that alloca arguments are not aligned if the offset is not a multiple of 4
|
|
120
|
225 define void @f5(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
226 entry:
|
|
|
227 ; CHECK-LABEL: f5
|
|
|
228
|
|
120
|
229 ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #21}}
|
|
100
|
230 ; CHECK-IOS: bl _memmove
|
|
|
231 ; CHECK-DARWIN: bl _memmove
|
|
|
232 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
233 ; CHECK-GNUEABI: bl memmove
|
|
95
|
234 %arr0 = alloca [13 x i8], align 1
|
|
|
235 %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 1
|
|
|
236 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
237
|
|
120
|
238 ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
|
|
100
|
239 ; CHECK-IOS: bl _memcpy
|
|
|
240 ; CHECK-DARWIN: bl _memcpy
|
|
|
241 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
242 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
243 %arr1 = alloca [13 x i8], align 1
|
|
|
244 %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 1
|
|
|
245 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
|
|
246
|
|
120
|
247 ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
|
|
95
|
248 ; CHECK-IOS: mov r1, #1
|
|
100
|
249 ; CHECK-IOS: bl _memset
|
|
95
|
250 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
251 ; CHECK-DARWIN: bl _memset
|
|
95
|
252 ; CHECK-EABI: mov r2, #1
|
|
100
|
253 ; CHECK-EABI: bl __aeabi_memset
|
|
|
254 ; CHECK-GNUEABI: mov r1, #1
|
|
|
255 ; CHECK-GNUEABI: bl memset
|
|
95
|
256 %arr2 = alloca [13 x i8], align 1
|
|
|
257 %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 1
|
|
|
258 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
259
|
|
|
260 unreachable
|
|
|
261 }
|
|
|
262
|
|
|
263 ; Check that alloca arguments are not aligned if the offset is unknown
|
|
120
|
264 define void @f6(i8* %dest, i32 %n, i32 %i) "no-frame-pointer-elim"="true" {
|
|
95
|
265 entry:
|
|
|
266 ; CHECK-LABEL: f6
|
|
|
267
|
|
120
|
268 ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #(25|29)}}
|
|
100
|
269 ; CHECK-IOS: bl _memmove
|
|
|
270 ; CHECK-DARWIN: bl _memmove
|
|
|
271 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
272 ; CHECK-GNUEABI: bl memmove
|
|
95
|
273 %arr0 = alloca [13 x i8], align 1
|
|
|
274 %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 %i
|
|
|
275 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
276
|
|
120
|
277 ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #42}}
|
|
100
|
278 ; CHECK-IOS: bl _memcpy
|
|
|
279 ; CHECK-DARWIN: bl _memcpy
|
|
|
280 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
281 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
282 %arr1 = alloca [13 x i8], align 1
|
|
|
283 %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 %i
|
|
|
284 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
|
|
285
|
|
120
|
286 ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #55}}
|
|
95
|
287 ; CHECK-IOS: mov r1, #1
|
|
100
|
288 ; CHECK-IOS: bl _memset
|
|
95
|
289 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
290 ; CHECK-DARWIN: bl _memset
|
|
95
|
291 ; CHECK-EABI: mov r2, #1
|
|
100
|
292 ; CHECK-EABI: bl __aeabi_memset
|
|
|
293 ; CHECK-GNUEABI: mov r1, #1
|
|
|
294 ; CHECK-GNUEABI: bl memset
|
|
95
|
295 %arr2 = alloca [13 x i8], align 1
|
|
|
296 %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 %i
|
|
|
297 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
298
|
|
|
299 unreachable
|
|
|
300 }
|
|
|
301
|
|
|
302 ; Check that alloca arguments are not aligned if the GEP is not inbounds
|
|
120
|
303 define void @f7(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
304 entry:
|
|
|
305 ; CHECK-LABEL: f7
|
|
|
306
|
|
120
|
307 ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #21}}
|
|
100
|
308 ; CHECK-IOS: bl _memmove
|
|
|
309 ; CHECK-DARWIN: bl _memmove
|
|
|
310 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
311 ; CHECK-GNUEABI: bl memmove
|
|
95
|
312 %arr0 = alloca [13 x i8], align 1
|
|
|
313 %0 = getelementptr [13 x i8], [13 x i8]* %arr0, i32 0, i32 4
|
|
|
314 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
315
|
|
120
|
316 ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
|
|
100
|
317 ; CHECK-IOS: bl _memcpy
|
|
|
318 ; CHECK-DARWIN: bl _memcpy
|
|
|
319 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
320 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
321 %arr1 = alloca [13 x i8], align 1
|
|
|
322 %1 = getelementptr [13 x i8], [13 x i8]* %arr1, i32 0, i32 4
|
|
|
323 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
|
|
324
|
|
120
|
325 ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
|
|
95
|
326 ; CHECK-IOS: mov r1, #1
|
|
100
|
327 ; CHECK-IOS: bl _memset
|
|
95
|
328 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
329 ; CHECK-DARWIN: bl _memset
|
|
95
|
330 ; CHECK-EABI: mov r2, #1
|
|
100
|
331 ; CHECK-EABI: bl __aeabi_memset
|
|
|
332 ; CHECK-GNUEABI: mov r1, #1
|
|
|
333 ; CHECK-GNUEABI: bl memset
|
|
95
|
334 %arr2 = alloca [13 x i8], align 1
|
|
|
335 %2 = getelementptr [13 x i8], [13 x i8]* %arr2, i32 0, i32 4
|
|
|
336 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
337
|
|
|
338 unreachable
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
339 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
340
|
|
95
|
341 ; Check that alloca arguments are not aligned when the offset is past the end of the allocation
|
|
120
|
342 define void @f8(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
343 entry:
|
|
|
344 ; CHECK-LABEL: f8
|
|
|
345
|
|
120
|
346 ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #21}}
|
|
100
|
347 ; CHECK-IOS: bl _memmove
|
|
|
348 ; CHECK-DARWIN: bl _memmove
|
|
|
349 ; CHECK-EABI: bl __aeabi_memmove
|
|
|
350 ; CHECK-GNUEABI: bl memmove
|
|
95
|
351 %arr0 = alloca [13 x i8], align 1
|
|
|
352 %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 16
|
|
|
353 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
|
|
|
354
|
|
120
|
355 ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
|
|
100
|
356 ; CHECK-IOS: bl _memcpy
|
|
|
357 ; CHECK-DARWIN: bl _memcpy
|
|
|
358 ; CHECK-EABI: bl __aeabi_memcpy
|
|
|
359 ; CHECK-GNUEABI: bl memcpy
|
|
95
|
360 %arr1 = alloca [13 x i8], align 1
|
|
|
361 %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 16
|
|
|
362 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
|
|
|
363
|
|
120
|
364 ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
|
|
95
|
365 ; CHECK-IOS: mov r1, #1
|
|
100
|
366 ; CHECK-IOS: bl _memset
|
|
95
|
367 ; CHECK-DARWIN: movs r1, #1
|
|
100
|
368 ; CHECK-DARWIN: bl _memset
|
|
95
|
369 ; CHECK-EABI: mov r2, #1
|
|
100
|
370 ; CHECK-EABI: bl __aeabi_memset
|
|
|
371 ; CHECK-GNUEABI: mov r1, #1
|
|
|
372 ; CHECK-GNUEABI: bl memset
|
|
95
|
373 %arr2 = alloca [13 x i8], align 1
|
|
|
374 %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 16
|
|
|
375 call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
|
|
|
376
|
|
|
377 unreachable
|
|
|
378 }
|
|
|
379
|
|
|
380 ; Check that global variables are aligned if they are large enough, but only if
|
|
|
381 ; they are defined in this object and don't have an explicit section.
|
|
|
382 @arr1 = global [7 x i8] c"\01\02\03\04\05\06\07", align 1
|
|
|
383 @arr2 = global [8 x i8] c"\01\02\03\04\05\06\07\08", align 1
|
|
|
384 @arr3 = global [7 x i8] c"\01\02\03\04\05\06\07", section "foo,bar", align 1
|
|
|
385 @arr4 = global [8 x i8] c"\01\02\03\04\05\06\07\08", section "foo,bar", align 1
|
|
|
386 @arr5 = weak global [7 x i8] c"\01\02\03\04\05\06\07", align 1
|
|
|
387 @arr6 = weak_odr global [7 x i8] c"\01\02\03\04\05\06\07", align 1
|
|
|
388 @arr7 = external global [7 x i8], align 1
|
|
120
|
389 @arr8 = internal global [128 x i8] undef
|
|
|
390 @arr9 = weak_odr global [128 x i8] undef
|
|
|
391 define void @f9(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
|
|
95
|
392 entry:
|
|
|
393 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr1, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
394 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @arr2, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
395 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr3, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
396 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @arr4, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
397 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr5, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
398 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr6, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
399 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr7, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
120
|
400 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([128 x i8], [128 x i8]* @arr8, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
|
401 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([128 x i8], [128 x i8]* @arr9, i32 0, i32 0), i32 %n, i32 1, i1 false)
|
|
95
|
402
|
|
|
403 unreachable
|
|
|
404 }
|
|
|
405
|
|
|
406 ; CHECK: {{\.data|\.section.+data}}
|
|
100
|
407 ; CHECK-NOT: .p2align
|
|
95
|
408 ; CHECK: arr1:
|
|
100
|
409 ; CHECK-IOS: .p2align 3
|
|
|
410 ; CHECK-DARWIN: .p2align 2
|
|
|
411 ; CHECK-EABI-NOT: .p2align
|
|
|
412 ; CHECK-GNUEABI-NOT: .p2align
|
|
95
|
413 ; CHECK: arr2:
|
|
|
414 ; CHECK: {{\.section.+foo,bar}}
|
|
100
|
415 ; CHECK-NOT: .p2align
|
|
95
|
416 ; CHECK: arr3:
|
|
100
|
417 ; CHECK-NOT: .p2align
|
|
95
|
418 ; CHECK: arr4:
|
|
|
419 ; CHECK: {{\.data|\.section.+data}}
|
|
100
|
420 ; CHECK-NOT: .p2align
|
|
95
|
421 ; CHECK: arr5:
|
|
100
|
422 ; CHECK-NOT: .p2align
|
|
95
|
423 ; CHECK: arr6:
|
|
120
|
424 ; CHECK: .p2align 4
|
|
|
425 ; CHECK: arr8:
|
|
|
426 ; CHECK: .p2align 4
|
|
|
427 ; CHECK: arr9:
|
|
|
428
|
|
95
|
429 ; CHECK-NOT: arr7:
|
|
|
430
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
431 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
432 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
433 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
|
