1 // REQUIRES: x86-registered-target
2 // RUN: %clang_cc1 %s -triple i386-apple-darwin10 -fasm-blocks -emit-llvm -o - | FileCheck %s
3
t1()4 void t1() {
5 // CHECK: @t1
6 // CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"()
7 // CHECK: ret void
8 __asm {}
9 }
10
t2()11 void t2() {
12 // CHECK: @t2
13 // CHECK: call void asm sideeffect inteldialect "nop\0A\09nop\0A\09nop", "~{dirflag},~{fpsr},~{flags}"()
14 // CHECK: ret void
15 __asm nop
16 __asm nop
17 __asm nop
18 }
19
t3()20 void t3() {
21 // CHECK: @t3
22 // CHECK: call void asm sideeffect inteldialect "nop\0A\09nop\0A\09nop", "~{dirflag},~{fpsr},~{flags}"()
23 // CHECK: ret void
24 __asm nop __asm nop __asm nop
25 }
26
t4(void)27 void t4(void) {
28 // CHECK: @t4
29 // CHECK: call void asm sideeffect inteldialect "mov ebx, eax\0A\09mov ecx, ebx", "~{ebx},~{ecx},~{dirflag},~{fpsr},~{flags}"()
30 // CHECK: ret void
31 __asm mov ebx, eax
32 __asm mov ecx, ebx
33 }
34
t5(void)35 void t5(void) {
36 // CHECK: @t5
37 // CHECK: call void asm sideeffect inteldialect "mov ebx, eax\0A\09mov ecx, ebx", "~{ebx},~{ecx},~{dirflag},~{fpsr},~{flags}"()
38 // CHECK: ret void
39 __asm mov ebx, eax __asm mov ecx, ebx
40 }
41
t6(void)42 void t6(void) {
43 __asm int 0x2c
44 // CHECK: t6
45 // CHECK: call void asm sideeffect inteldialect "int $$0x2c", "~{dirflag},~{fpsr},~{flags}"()
46 }
47
t7()48 void t7() {
49 __asm {
50 int 0x2c ; } asm comments are fun! }{
51 }
52 __asm {
53 {
54 int 0x2c ; } asm comments are fun! }{
55 }
56 }
57 __asm {}
58 // CHECK: t7
59 // CHECK: call void asm sideeffect inteldialect "int $$0x2c", "~{dirflag},~{fpsr},~{flags}"()
60 // CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"()
61 }
62
63 int t8() {
64 __asm int 4 ; } comments for single-line asm
65 __asm {}
66 __asm { int 5}
67 __asm int 6
68 __asm int 7
69 __asm {
70 int 8
71 }
72 return 10;
73 // CHECK: t8
74 // CHECK: call i32 asm sideeffect inteldialect "int $$4", "={eax},~{dirflag},~{fpsr},~{flags}"()
75 // CHECK: call i32 asm sideeffect inteldialect "", "={eax},~{dirflag},~{fpsr},~{flags}"()
76 // CHECK: call i32 asm sideeffect inteldialect "int $$5", "={eax},~{dirflag},~{fpsr},~{flags}"()
77 // CHECK: call i32 asm sideeffect inteldialect "int $$6\0A\09int $$7", "={eax},~{dirflag},~{fpsr},~{flags}"()
78 // CHECK: call i32 asm sideeffect inteldialect "int $$8", "={eax},~{dirflag},~{fpsr},~{flags}"()
79 // CHECK: ret i32 10
80 }
81
82 void t9() {
83 __asm {
84 push ebx
85 { mov ebx, 0x07 }
86 __asm { pop ebx }
87 }
88 // CHECK: t9
89 // CHECK: call void asm sideeffect inteldialect "push ebx\0A\09mov ebx, $$0x07\0A\09pop ebx\0A\09", "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
90 }
91
92 unsigned t10(void) {
93 unsigned i = 1, j;
94 __asm {
95 mov eax, i
96 mov j, eax
97 }
98 return j;
99 // CHECK: t10
100 // CHECK: [[r:%[a-zA-Z0-9]+]] = alloca i32, align 4
101 // CHECK: [[I:%[a-zA-Z0-9]+]] = alloca i32, align 4
102 // CHECK: [[J:%[a-zA-Z0-9]+]] = alloca i32, align 4
103 // CHECK: store i32 1, i32* [[I]], align 4
104 // CHECK: call i32 asm sideeffect inteldialect "mov eax, dword ptr $2\0A\09mov dword ptr $0, eax", "=*m,={eax},*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}})
105 // CHECK: [[RET:%[a-zA-Z0-9]+]] = load i32, i32* [[J]], align 4
106 // CHECK: ret i32 [[RET]]
107 }
108
109 void t11(void) {
110 __asm mov eax, 1
111 // CHECK: t11
112 // CHECK: call void asm sideeffect inteldialect "mov eax, $$1", "~{eax},~{dirflag},~{fpsr},~{flags}"()
113 }
114
115 unsigned t12(void) {
116 unsigned i = 1, j, l = 1, m;
117 __asm {
118 mov eax, i
119 mov j, eax
120 mov eax, l
121 mov m, eax
122 }
123 return j + m;
124 // CHECK: t12
125 // CHECK: call i32 asm sideeffect inteldialect "mov eax, dword ptr $3\0A\09mov dword ptr $0, eax\0A\09mov eax, dword ptr $4\0A\09mov dword ptr $1, eax", "=*m,=*m,={eax},*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}})
126 }
127
128 void t13() {
129 char i = 1;
130 short j = 2;
131 __asm movzx eax, i
132 __asm movzx eax, j
133 // CHECK: t13
134 // CHECK: call void asm sideeffect inteldialect "movzx eax, byte ptr $0\0A\09movzx eax, word ptr $1", "*m,*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i8* %{{.*}}i, i16* %{{.*}}j)
135 }
136
137 void t14() {
138 unsigned i = 1, j = 2;
139 __asm {
140 .if 1
141 { mov eax, i }
142 .else
143 mov ebx, j
144 .endif
145 }
146 // CHECK: t14
147 // CHECK: call void asm sideeffect inteldialect ".if 1\0A\09mov eax, dword ptr $0\0A\09.else\0A\09mov ebx, j\0A\09.endif", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
148 }
149
150 int gvar = 10;
151 void t15() {
152 // CHECK: t15
153 int lvar = 10;
154 __asm mov eax, lvar ; eax = 10
155 // CHECK: mov eax, dword ptr $0
156 __asm mov eax, offset lvar ; eax = address of lvar
157 // CHECK: mov eax, $1
158 __asm mov eax, offset gvar ; eax = address of gvar
159 // CHECK: mov eax, $2
160 // CHECK: "*m,r,r,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* @{{.*}})
161 }
162
163 void t16() {
164 int var = 10;
165 __asm mov [eax], offset var
166 // CHECK: t16
167 // CHECK: call void asm sideeffect inteldialect "mov [eax], $0", "r,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
168 }
169
170 void t17() {
171 // CHECK: t17
172 __asm _emit 0x4A
173 // CHECK: .byte 0x4A
174 __asm _emit 0x43
175 // CHECK: .byte 0x43
176 __asm _emit 0x4B
177 // CHECK: .byte 0x4B
178 __asm _EMIT 0x4B
179 // CHECK: .byte 0x4B
180 // CHECK: "~{dirflag},~{fpsr},~{flags}"()
181 }
182
183 void t20() {
184 // CHECK: t20
185 char bar;
186 int foo;
187 char _bar[2];
188 int _foo[4];
189
190 __asm mov eax, LENGTH foo
191 // CHECK: mov eax, $$1
192 __asm mov eax, LENGTH bar
193 // CHECK: mov eax, $$1
194 __asm mov eax, LENGTH _foo
195 // CHECK: mov eax, $$4
196 __asm mov eax, LENGTH _bar
197 // CHECK: mov eax, $$2
198
199 __asm mov eax, TYPE foo
200 // CHECK: mov eax, $$4
201 __asm mov eax, TYPE bar
202 // CHECK: mov eax, $$1
203 __asm mov eax, TYPE _foo
204 // CHECK: mov eax, $$4
205 __asm mov eax, TYPE _bar
206 // CHECK: mov eax, $$1
207
208 __asm mov eax, SIZE foo
209 // CHECK: mov eax, $$4
210 __asm mov eax, SIZE bar
211 // CHECK: mov eax, $$1
212 __asm mov eax, SIZE _foo
213 // CHECK: mov eax, $$16
214 __asm mov eax, SIZE _bar
215 // CHECK: mov eax, $$2
216 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
217 }
218
219 void t21() {
220 __asm {
221 __asm push ebx
222 __asm mov ebx, 0x07
223 __asm pop ebx
224 }
225 // CHECK: t21
226 // CHECK: call void asm sideeffect inteldialect "push ebx\0A\09mov ebx, $$0x07\0A\09pop ebx", "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
227 }
228
229 extern void t22_helper(int x);
230 void t22() {
231 int x = 0;
232 __asm {
233 __asm push ebx
234 __asm mov ebx, esp
235 }
236 t22_helper(x);
237 __asm {
238 __asm mov esp, ebx
239 __asm pop ebx
240 }
241 // CHECK: t22
242 // CHECK: call void asm sideeffect inteldialect "push ebx\0A\09mov ebx, esp", "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
243 // CHECK: call void @t22_helper
244 // CHECK: call void asm sideeffect inteldialect "mov esp, ebx\0A\09pop ebx", "~{ebx},~{esp},~{dirflag},~{fpsr},~{flags}"()
245 }
246
247 void t23() {
248 __asm {
249 the_label:
250 }
251 // CHECK: t23
252 // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.0__the_label:", "~{dirflag},~{fpsr},~{flags}"()
253 }
254
255 void t24_helper(void) {}
256 void t24() {
257 __asm call t24_helper
258 // CHECK: t24
259 // CHECK: call void asm sideeffect inteldialect "call dword ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(void ()* @t24_helper)
260 }
261
262 void t25() {
263 // CHECK: t25
264 __asm mov eax, 0ffffffffh
265 // CHECK: mov eax, $$4294967295
266 __asm mov eax, 0fh
267 // CHECK: mov eax, $$15
268 __asm mov eax, 0a2h
269 // CHECK: mov eax, $$162
270 __asm mov eax, 0xa2h
271 // CHECK: mov eax, $$0xa2h
272 __asm mov eax, 0xa2
273 // CHECK: mov eax, $$0xa2
274 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
275 }
276
277 void t26() {
278 // CHECK: t26
279 __asm pushad
280 // CHECK: pushad
281 __asm mov eax, 0
282 // CHECK: mov eax, $$0
283 __asm __emit 0fh
284 // CHECK: .byte 0fh
285 __asm __emit 0a2h
286 // CHECK: .byte 0a2h
287 __asm __EMIT 0a2h
288 // CHECK: .byte 0a2h
289 __asm popad
290 // CHECK: popad
291 // CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"()
292 }
293
294 void t27() {
295 __asm mov eax, fs:[0h]
296 // CHECK: t27
297 // CHECK: call void asm sideeffect inteldialect "mov eax, fs:[$$0h]", "~{eax},~{dirflag},~{fpsr},~{flags}"()
298 }
299
300 void t28() {
301 // CHECK: t28
302 __asm align 8
303 // CHECK: .align 3
304 __asm align 16;
305 // CHECK: .align 4
306 __asm align 128;
307 // CHECK: .align 7
308 __asm ALIGN 256;
309 // CHECK: .align 8
310 // CHECK: "~{dirflag},~{fpsr},~{flags}"()
311 }
312
313 void t29() {
314 // CHECK: t29
315 int arr[2] = {0, 0};
316 int olen = 0, osize = 0, otype = 0;
317 __asm mov olen, LENGTH arr
318 // CHECK: mov dword ptr $0, $$2
319 __asm mov osize, SIZE arr
320 // CHECK: mov dword ptr $1, $$8
321 __asm mov otype, TYPE arr
322 // CHECK: mov dword ptr $2, $$4
323 // CHECK: "=*m,=*m,=*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}})
324 }
325
326 int results[2] = {13, 37};
327 int *t30()
328 // CHECK: t30
329 {
330 int *res;
331 __asm lea edi, results
332 // CHECK: lea edi, dword ptr $2
333 __asm mov res, edi
334 // CHECK: mov dword ptr $0, edi
335 return res;
336 // CHECK: "=*m,={eax},*m,~{edi},~{dirflag},~{fpsr},~{flags}"(i32** %{{.*}}, [2 x i32]* @{{.*}})
337 }
338
339 void t31() {
340 // CHECK: t31
341 __asm pushad
342 // CHECK: pushad
343 __asm popad
344 // CHECK: popad
345 // CHECK: "~{eax},~{ebp},~{ebx},~{ecx},~{edi},~{edx},~{esi},~{esp},~{dirflag},~{fpsr},~{flags}"()
346 }
347
348 void t32() {
349 // CHECK: t32
350 int i;
351 __asm mov eax, i
352 // CHECK: mov eax, dword ptr $0
353 __asm mov eax, dword ptr i
354 // CHECK: mov eax, dword ptr $1
355 __asm mov ax, word ptr i
356 // CHECK: mov ax, word ptr $2
357 __asm mov al, byte ptr i
358 // CHECK: mov al, byte ptr $3
359 // CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}})
360 }
361
362 void t33() {
363 // CHECK: t33
364 int i;
365 __asm mov eax, [i]
366 // CHECK: mov eax, dword ptr $0
367 __asm mov eax, dword ptr [i]
368 // CHECK: mov eax, dword ptr $1
369 __asm mov ax, word ptr [i]
370 // CHECK: mov ax, word ptr $2
371 __asm mov al, byte ptr [i]
372 // CHECK: mov al, byte ptr $3
373 // CHECK: "*m,*m,*m,*m,~{al},~{ax},~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}}, i32* %{{.*}})
374 }
375
376 void t34() {
377 // CHECK: t34
378 __asm prefetchnta 64[eax]
379 // CHECK: prefetchnta $$64[eax]
380 __asm mov eax, dword ptr 4[eax]
381 // CHECK: mov eax, dword ptr $$4[eax]
382 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
383 }
384
385 void t35() {
386 // CHECK: t35
387 __asm prefetchnta [eax + (200*64)]
388 // CHECK: prefetchnta [eax + ($$200*$$64)]
389 __asm mov eax, dword ptr [eax + (200*64)]
390 // CHECK: mov eax, dword ptr [eax + ($$200*$$64)]
391 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
392 }
393
394 void t36() {
395 // CHECK: t36
396 int arr[4];
397 // Work around PR20368: These should be single line blocks
398 __asm { mov eax, 4[arr] }
399 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
400 __asm { mov eax, 4[arr + 4] }
401 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
402 __asm { mov eax, 8[arr + 4 + 32*2 - 4] }
403 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$72$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
404 __asm { mov eax, 12[4 + arr] }
405 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$16$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
406 __asm { mov eax, 4[4 + arr + 4] }
407 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$12$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
408 __asm { mov eax, 4[64 + arr + (2*32)] }
409 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$132$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
410 __asm { mov eax, 4[64 + arr - 2*32] }
411 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
412 __asm { mov eax, [arr + 4] }
413 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
414 __asm { mov eax, [arr + 4 + 32*2 - 4] }
415 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$64$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
416 __asm { mov eax, [4 + arr] }
417 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
418 __asm { mov eax, [4 + arr + 4] }
419 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
420 __asm { mov eax, [64 + arr + (2*32)] }
421 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$128$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
422 __asm { mov eax, [64 + arr - 2*32] }
423 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
424 }
425
426 void t37() {
427 // CHECK: t37
428 __asm mov eax, 4 + 8
429 // CHECK: mov eax, $$12
430 __asm mov eax, 4 + 8 * 16
431 // CHECK: mov eax, $$132
432 __asm mov eax, -4 + 8 * 16
433 // CHECK: mov eax, $$124
434 __asm mov eax, (4 + 4) * 16
435 // CHECK: mov eax, $$128
436 __asm mov eax, 4 + 8 * -16
437 // CHECK: mov eax, $$4294967172
438 __asm mov eax, 4 + 16 / -8
439 // CHECK: mov eax, $$2
440 __asm mov eax, (16 + 16) / -8
441 // CHECK: mov eax, $$4294967292
442 __asm mov eax, ~15
443 // CHECK: mov eax, $$4294967280
444 __asm mov eax, 6 ^ 3
445 // CHECK: mov eax, $$5
446 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
447 }
448
449 void t38() {
450 // CHECK: t38
451 int arr[4];
452 // Work around PR20368: These should be single line blocks
453 __asm { mov eax, 4+4[arr] }
454 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
455 __asm { mov eax, (4+4)[arr + 4] }
456 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$12$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
457 __asm { mov eax, 8*2[arr + 4 + 32*2 - 4] }
458 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$80$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
459 __asm { mov eax, 12+20[4 + arr] }
460 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$36$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
461 __asm { mov eax, 4*16+4[4 + arr + 4] }
462 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$76$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
463 __asm { mov eax, 4*4[64 + arr + (2*32)] }
464 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$144$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
465 __asm { mov eax, 4*(4-2)[64 + arr - 2*32] }
466 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
467 __asm { mov eax, 32*(4-2)[arr - 2*32] }
468 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$0$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"([4 x i32]* %{{.*}})
469 }
470
471 void cpuid() {
472 __asm cpuid
473 // CHECK-LABEL: define void @cpuid
474 // CHECK: call void asm sideeffect inteldialect "cpuid", "~{eax},~{ebx},~{ecx},~{edx},~{dirflag},~{fpsr},~{flags}"()
475 }
476
477 typedef struct {
478 int a;
479 int b;
480 } A;
481
482 typedef struct {
483 int b1;
484 A b2;
485 } B;
486
487 typedef struct {
488 int c1;
489 A c2;
490 int c3;
491 B c4;
492 } C;
493
494 void t39() {
495 // CHECK-LABEL: define void @t39
496 __asm mov eax, [eax].A.b
497 // CHECK: mov eax, [eax].4
498 __asm mov eax, [eax] A.b
499 // CHECK: mov eax, [eax] .4
500 __asm mov eax, fs:[0] A.b
501 // CHECK: mov eax, fs:[$$0] .4
502 __asm mov eax, [eax].B.b2.a
503 // CHECK: mov eax, [eax].4
504 __asm mov eax, [eax] B.b2.b
505 // CHECK: mov eax, [eax] .8
506 __asm mov eax, fs:[0] C.c2.b
507 // CHECK: mov eax, fs:[$$0] .8
508 __asm mov eax, [eax]C.c4.b2.b
509 // CHECK: mov eax, [eax].24
510 // CHECK: "~{eax},~{dirflag},~{fpsr},~{flags}"()
511 }
512
513 void t40(float a) {
514 // CHECK-LABEL: define void @t40
515 int i;
516 __asm fld a
517 // CHECK: fld dword ptr $1
518 __asm fistp i
519 // CHECK: fistp dword ptr $0
520 // CHECK: "=*m,*m,~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}}, float* %{{.*}})
521 }
522
523 void t41(unsigned short a) {
524 // CHECK-LABEL: define void @t41(i16 zeroext %a)
525 __asm mov cs, a;
526 // CHECK: mov cs, word ptr $0
527 __asm mov ds, a;
528 // CHECK: mov ds, word ptr $1
529 __asm mov es, a;
530 // CHECK: mov es, word ptr $2
531 __asm mov fs, a;
532 // CHECK: mov fs, word ptr $3
533 __asm mov gs, a;
534 // CHECK: mov gs, word ptr $4
535 __asm mov ss, a;
536 // CHECK: mov ss, word ptr $5
537 // CHECK: "*m,*m,*m,*m,*m,*m,~{dirflag},~{fpsr},~{flags}"(i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}}, i16* {{.*}})
538 }
539
540 void t42() {
541 // CHECK-LABEL: define void @t42
542 int flags;
543 __asm mov flags, eax
544 // CHECK: mov dword ptr $0, eax
545 // CHECK: "=*m,~{dirflag},~{fpsr},~{flags}"(i32* %flags)
546 }
547
548 void t43() {
549 // CHECK-LABEL: define void @t43
550 C strct;
551 // Work around PR20368: These should be single line blocks
552 __asm { mov eax, 4[strct.c1] }
553 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
554 __asm { mov eax, 4[strct.c3 + 4] }
555 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
556 __asm { mov eax, 8[strct.c2.a + 4 + 32*2 - 4] }
557 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$72$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
558 __asm { mov eax, 12[4 + strct.c2.b] }
559 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$16$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
560 __asm { mov eax, 4[4 + strct.c4.b2.b + 4] }
561 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$12$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
562 __asm { mov eax, 4[64 + strct.c1 + (2*32)] }
563 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$132$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
564 __asm { mov eax, 4[64 + strct.c2.a - 2*32] }
565 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
566 __asm { mov eax, [strct.c4.b1 + 4] }
567 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
568 __asm { mov eax, [strct.c4.b2.a + 4 + 32*2 - 4] }
569 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$64$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
570 __asm { mov eax, [4 + strct.c1] }
571 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$4$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
572 __asm { mov eax, [4 + strct.c2.b + 4] }
573 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$8$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
574 __asm { mov eax, [64 + strct.c3 + (2*32)] }
575 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $$128$0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
576 __asm { mov eax, [64 + strct.c4.b2.b - 2*32] }
577 // CHECK: call void asm sideeffect inteldialect "mov eax, dword ptr $0", "*m,~{eax},~{dirflag},~{fpsr},~{flags}"(i32* %{{.*}})
578 }
579
580 void call_clobber() {
581 __asm call t41
582 // CHECK-LABEL: define void @call_clobber
583 // CHECK: call void asm sideeffect inteldialect "call dword ptr $0", "*m,~{dirflag},~{fpsr},~{flags}"(void (i16)* @t41)
584 }
585
586 void xgetbv() {
587 __asm xgetbv
588 }
589 // CHECK-LABEL: define void @xgetbv()
590 // CHECK: call void asm sideeffect inteldialect "xgetbv", "~{eax},~{edx},~{dirflag},~{fpsr},~{flags}"()
591
592 void label1() {
593 __asm {
594 label:
595 jmp label
596 }
597 // CHECK-LABEL: define void @label1()
598 // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.1__label:\0A\09jmp {{.*}}__MSASMLABEL_.1__label", "~{dirflag},~{fpsr},~{flags}"() [[ATTR1:#[0-9]+]]
599 }
600
601 void label2() {
602 __asm {
603 jmp label
604 label:
605 }
606 // CHECK-LABEL: define void @label2
607 // CHECK: call void asm sideeffect inteldialect "jmp {{.*}}__MSASMLABEL_.2__label\0A\09{{.*}}__MSASMLABEL_.2__label:", "~{dirflag},~{fpsr},~{flags}"()
608 }
609
610 void label3() {
611 __asm {
612 label:
613 mov eax, label
614 }
615 // CHECK-LABEL: define void @label3
616 // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.3__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.3__label", "~{eax},~{dirflag},~{fpsr},~{flags}"()
617 }
618
619 void label4() {
620 __asm {
621 label:
622 mov eax, [label]
623 }
624 // CHECK-LABEL: define void @label4
625 // CHECK: call void asm sideeffect inteldialect "{{.*}}__MSASMLABEL_.4__label:\0A\09mov eax, {{.*}}__MSASMLABEL_.4__label", "~{eax},~{dirflag},~{fpsr},~{flags}"()
626 }
627
628 void label5() {
629 __asm {
630 jmp dollar_label$
631 dollar_label$:
632 }
633 // CHECK-LABEL: define void @label5
634 // CHECK: call void asm sideeffect inteldialect "jmp {{.*}}__MSASMLABEL_.5__dollar_label$$\0A\09{{.*}}__MSASMLABEL_.5__dollar_label$$:", "~{dirflag},~{fpsr},~{flags}"()
635 }
636
637 typedef union _LARGE_INTEGER {
638 struct {
639 unsigned int LowPart;
640 unsigned int HighPart;
641 };
642 struct {
643 unsigned int LowPart;
644 unsigned int HighPart;
645 } u;
646 unsigned long long QuadPart;
647 } LARGE_INTEGER, *PLARGE_INTEGER;
648
649 int test_indirect_field(LARGE_INTEGER LargeInteger) {
650 __asm mov eax, LargeInteger.LowPart
651 }
652 // CHECK-LABEL: define i32 @test_indirect_field(
653 // CHECK: call i32 asm sideeffect inteldialect "mov eax, dword ptr $1",
654
655 // MS ASM containing labels must not be duplicated (PR23715).
656 // CHECK: attributes [[ATTR1]] = { {{.*}}noduplicate{{.*}} }
657