1 // REQUIRES: x86-registered-target 2 // RUN: %clang_cc1 %s -triple i386-apple-darwin10 -fasm-blocks -emit-llvm -o - | FileCheck %s 3 4 void t1() { 5 // CHECK: @t1 6 // CHECK: call void asm sideeffect inteldialect "", "~{dirflag},~{fpsr},~{flags}"() 7 // CHECK: ret void 8 __asm {} 9 } 10 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 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 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 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 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 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
