| // RUN: llvm-mc -triple x86_64-unknown-unknown -show-encoding %s > %t 2> %t.err |
| // RUN: FileCheck < %t %s |
| // RUN: FileCheck --check-prefix=CHECK-STDERR < %t.err %s |
| |
| monitor |
| // CHECK: monitor |
| // CHECK: encoding: [0x0f,0x01,0xc8] |
| monitor %rax, %rcx, %rdx |
| // CHECK: monitor |
| // CHECK: encoding: [0x0f,0x01,0xc8] |
| mwait |
| // CHECK: mwait |
| // CHECK: encoding: [0x0f,0x01,0xc9] |
| mwait %rax, %rcx |
| // CHECK: mwait |
| // CHECK: encoding: [0x0f,0x01,0xc9] |
| |
| // Suffix inference: |
| |
| // CHECK: addl $0, %eax |
| add $0, %eax |
| // CHECK: addb $255, %al |
| add $0xFF, %al |
| // CHECK: orq %rax, %rdx |
| or %rax, %rdx |
| // CHECK: shlq $3, %rax |
| shl $3, %rax |
| |
| |
| // CHECK: subb %al, %al |
| subb %al, %al |
| |
| // CHECK: addl $24, %eax |
| addl $24, %eax |
| |
| // CHECK: movl %eax, 10(%ebp) |
| movl %eax, 10(%ebp) |
| // CHECK: movl %eax, 10(%ebp,%ebx) |
| movl %eax, 10(%ebp, %ebx) |
| // CHECK: movl %eax, 10(%ebp,%ebx,4) |
| movl %eax, 10(%ebp, %ebx, 4) |
| // CHECK: movl %eax, 10(,%ebx,4) |
| movl %eax, 10(, %ebx, 4) |
| |
| // CHECK: movl 0, %eax |
| movl 0, %eax |
| // CHECK: movl $0, %eax |
| movl $0, %eax |
| |
| // CHECK: ret |
| ret |
| |
| // FIXME: Check that this matches SUB32ri8 |
| // CHECK: subl $1, %eax |
| subl $1, %eax |
| |
| // FIXME: Check that this matches SUB32ri8 |
| // CHECK: subl $-1, %eax |
| subl $-1, %eax |
| |
| // FIXME: Check that this matches SUB32ri |
| // CHECK: subl $256, %eax |
| subl $256, %eax |
| |
| // FIXME: Check that this matches XOR64ri8 |
| // CHECK: xorq $1, %rax |
| xorq $1, %rax |
| |
| // FIXME: Check that this matches XOR64ri32 |
| // CHECK: xorq $256, %rax |
| xorq $256, %rax |
| |
| // FIXME: Check that this matches SUB8rr |
| // CHECK: subb %al, %bl |
| subb %al, %bl |
| |
| // FIXME: Check that this matches SUB16rr |
| // CHECK: subw %ax, %bx |
| subw %ax, %bx |
| |
| // FIXME: Check that this matches SUB32rr |
| // CHECK: subl %eax, %ebx |
| subl %eax, %ebx |
| |
| // FIXME: Check that this matches the correct instruction. |
| // CHECK: callq *%rax |
| call *%rax |
| |
| // FIXME: Check that this matches the correct instruction. |
| // CHECK: shldl %cl, %eax, %ebx |
| shldl %cl, %eax, %ebx |
| |
| // CHECK: shll $2, %eax |
| shll $2, %eax |
| |
| // CHECK: shll $2, %eax |
| sall $2, %eax |
| |
| // CHECK: rep |
| // CHECK: insb |
| rep;insb |
| |
| // CHECK: rep |
| // CHECK: outsb |
| rep;outsb |
| |
| // CHECK: rep |
| // CHECK: movsb |
| rep;movsb |
| |
| |
| // rdar://8470918 |
| smovb // CHECK: movsb |
| smovw // CHECK: movsw |
| smovl // CHECK: movsd |
| smovq // CHECK: movsq |
| |
| // rdar://8456361 |
| // CHECK: rep |
| // CHECK: movsd |
| rep movsd |
| |
| // CHECK: rep |
| // CHECK: lodsb |
| rep;lodsb |
| |
| // CHECK: rep |
| // CHECK: stosb |
| rep;stosb |
| |
| // NOTE: repz and repe have the same opcode as rep |
| // CHECK: rep |
| // CHECK: cmpsb |
| repz;cmpsb |
| |
| // NOTE: repnz has the same opcode as repne |
| // CHECK: repne |
| // CHECK: cmpsb |
| repnz;cmpsb |
| |
| // NOTE: repe and repz have the same opcode as rep |
| // CHECK: rep |
| // CHECK: scasb |
| repe;scasb |
| |
| // CHECK: repne |
| // CHECK: scasb |
| repne;scasb |
| |
| // CHECK: lock |
| // CHECK: cmpxchgb %al, (%ebx) |
| lock;cmpxchgb %al, 0(%ebx) |
| |
| // CHECK: cs |
| // CHECK: movb (%eax), %al |
| cs;movb 0(%eax), %al |
| |
| // CHECK: ss |
| // CHECK: movb (%eax), %al |
| ss;movb 0(%eax), %al |
| |
| // CHECK: ds |
| // CHECK: movb (%eax), %al |
| ds;movb 0(%eax), %al |
| |
| // CHECK: es |
| // CHECK: movb (%eax), %al |
| es;movb 0(%eax), %al |
| |
| // CHECK: fs |
| // CHECK: movb (%eax), %al |
| fs;movb 0(%eax), %al |
| |
| // CHECK: gs |
| // CHECK: movb (%eax), %al |
| gs;movb 0(%eax), %al |
| |
| // CHECK: fadd %st(0) |
| // CHECK: fadd %st(1) |
| // CHECK: fadd %st(7) |
| |
| fadd %st(0) |
| fadd %st(1) |
| fadd %st(7) |
| |
| // CHECK: leal 0, %eax |
| leal 0, %eax |
| |
| // rdar://7986634 - Insensitivity on opcodes. |
| // CHECK: int3 |
| INT3 |
| |
| // rdar://8735979 - int $3 -> int3 |
| // CHECK: int3 |
| int $3 |
| |
| |
| // Allow scale factor without index register. |
| // CHECK: movaps %xmm3, (%esi) |
| // CHECK-STDERR: warning: scale factor without index register is ignored |
| movaps %xmm3, (%esi, 2) |
| |
| // CHECK: imull $12, %eax, %eax |
| imul $12, %eax |
| |
| // CHECK: imull %ecx, %eax |
| imull %ecx, %eax |
| |
| |
| // rdar://8208481 |
| // CHECK: outb %al, $161 |
| outb %al, $161 |
| // CHECK: outw %ax, $128 |
| outw %ax, $128 |
| // CHECK: inb $161, %al |
| inb $161, %al |
| |
| // rdar://8017621 |
| // CHECK: pushq $1 |
| push $1 |
| |
| // rdar://9716860 |
| pushq $1 |
| // CHECK: encoding: [0x6a,0x01] |
| pushq $1111111 |
| // CHECK: encoding: [0x68,0x47,0xf4,0x10,0x00] |
| |
| // rdar://8017530 |
| // CHECK: sldtw 4 |
| sldt 4 |
| |
| // rdar://8208499 |
| // CHECK: cmovnew %bx, %ax |
| cmovnz %bx, %ax |
| // CHECK: cmovneq %rbx, %rax |
| cmovnzq %rbx, %rax |
| |
| |
| // rdar://8407928 |
| // CHECK: inb $127, %al |
| // CHECK: inw %dx |
| // CHECK: outb %al, $127 |
| // CHECK: outw %dx |
| // CHECK: inl %dx |
| inb $0x7f |
| inw %dx |
| outb $0x7f |
| outw %dx |
| inl %dx |
| |
| |
| // PR8114 |
| // CHECK: outb %dx |
| // CHECK: outb %dx |
| // CHECK: outw %dx |
| // CHECK: outw %dx |
| // CHECK: outl %dx |
| // CHECK: outl %dx |
| |
| out %al, (%dx) |
| outb %al, (%dx) |
| out %ax, (%dx) |
| outw %ax, (%dx) |
| out %eax, (%dx) |
| outl %eax, (%dx) |
| |
| // CHECK: inb %dx |
| // CHECK: inb %dx |
| // CHECK: inw %dx |
| // CHECK: inw %dx |
| // CHECK: inl %dx |
| // CHECK: inl %dx |
| |
| in (%dx), %al |
| inb (%dx), %al |
| in (%dx), %ax |
| inw (%dx), %ax |
| in (%dx), %eax |
| inl (%dx), %eax |
| |
| // rdar://8431422 |
| |
| // CHECK: fxch |
| // CHECK: fucom |
| // CHECK: fucomp |
| // CHECK: faddp |
| // CHECK: faddp %st(0) |
| // CHECK: fsubp |
| // CHECK: fsubrp |
| // CHECK: fmulp |
| // CHECK: fdivp |
| // CHECK: fdivrp |
| |
| fxch |
| fucom |
| fucomp |
| faddp |
| faddp %st |
| fsubp |
| fsubrp |
| fmulp |
| fdivp |
| fdivrp |
| |
| // CHECK: fcomi |
| // CHECK: fcomi %st(2) |
| // CHECK: fucomi |
| // CHECK: fucomi %st(2) |
| // CHECK: fucomi %st(2) |
| |
| fcomi |
| fcomi %st(2) |
| fucomi |
| fucomi %st(2) |
| fucomi %st(2), %st |
| |
| // CHECK: fnstsw |
| // CHECK: fnstsw |
| // CHECK: fnstsw |
| // CHECK: fnstsw |
| |
| fnstsw |
| fnstsw %ax |
| fnstsw %eax |
| fnstsw %al |
| |
| // rdar://8431880 |
| // CHECK: rclb %bl |
| // CHECK: rcll 3735928559(%ebx,%ecx,8) |
| // CHECK: rcrl %ecx |
| // CHECK: rcrl 305419896 |
| rcl %bl |
| rcll 0xdeadbeef(%ebx,%ecx,8) |
| rcr %ecx |
| rcrl 0x12345678 |
| |
| rclb %bl // CHECK: rclb %bl # encoding: [0xd0,0xd3] |
| rclb $1, %bl // CHECK: rclb %bl # encoding: [0xd0,0xd3] |
| rclb $2, %bl // CHECK: rclb $2, %bl # encoding: [0xc0,0xd3,0x02] |
| |
| // rdar://8418316 |
| // CHECK: shldw $1, %bx, %bx |
| // CHECK: shldw $1, %bx, %bx |
| // CHECK: shrdw $1, %bx, %bx |
| // CHECK: shrdw $1, %bx, %bx |
| |
| shld %bx,%bx |
| shld $1, %bx,%bx |
| shrd %bx,%bx |
| shrd $1, %bx,%bx |
| |
| // CHECK: sldtl %ecx |
| // CHECK: encoding: [0x0f,0x00,0xc1] |
| // CHECK: sldtw %cx |
| // CHECK: encoding: [0x66,0x0f,0x00,0xc1] |
| |
| sldt %ecx |
| sldt %cx |
| |
| // CHECK: lcalll *3135175374 |
| // CHECK: ljmpl *3135175374 |
| lcall *0xbadeface |
| ljmp *0xbadeface |
| |
| |
| // rdar://8444631 |
| // CHECK: enter $31438, $0 |
| // CHECK: encoding: [0xc8,0xce,0x7a,0x00] |
| // CHECK: enter $31438, $1 |
| // CHECK: encoding: [0xc8,0xce,0x7a,0x01] |
| // CHECK: enter $31438, $127 |
| // CHECK: encoding: [0xc8,0xce,0x7a,0x7f] |
| enter $0x7ace,$0 |
| enter $0x7ace,$1 |
| enter $0x7ace,$0x7f |
| |
| |
| // rdar://8456364 |
| // CHECK: movw %cs, %ax |
| mov %CS, %ax |
| |
| // rdar://8456391 |
| fcmovb %st(1), %st(0) // CHECK: fcmovb %st(1), %st(0) |
| fcmove %st(1), %st(0) // CHECK: fcmove %st(1), %st(0) |
| fcmovbe %st(1), %st(0) // CHECK: fcmovbe %st(1), %st(0) |
| fcmovu %st(1), %st(0) // CHECK: fcmovu %st(1), %st(0) |
| |
| fcmovnb %st(1), %st(0) // CHECK: fcmovnb %st(1), %st(0) |
| fcmovne %st(1), %st(0) // CHECK: fcmovne %st(1), %st(0) |
| fcmovnbe %st(1), %st(0) // CHECK: fcmovnbe %st(1), %st(0) |
| fcmovnu %st(1), %st(0) // CHECK: fcmovnu %st(1), %st(0) |
| |
| fcmovnae %st(1), %st(0) // CHECK: fcmovb %st(1), %st(0) |
| fcmovna %st(1), %st(0) // CHECK: fcmovbe %st(1), %st(0) |
| |
| fcmovae %st(1), %st(0) // CHECK: fcmovnb %st(1), %st(0) |
| fcmova %st(1), %st(0) // CHECK: fcmovnbe %st(1), %st(0) |
| |
| // rdar://8456417 |
| .byte 88 + 1 & 15 // CHECK: .byte 9 |
| |
| // rdar://8456412 |
| mov %rdx, %cr0 |
| // CHECK: movq %rdx, %cr0 |
| // CHECK: encoding: [0x0f,0x22,0xc2] |
| mov %rdx, %cr4 |
| // CHECK: movq %rdx, %cr4 |
| // CHECK: encoding: [0x0f,0x22,0xe2] |
| mov %rdx, %cr8 |
| // CHECK: movq %rdx, %cr8 |
| // CHECK: encoding: [0x44,0x0f,0x22,0xc2] |
| mov %rdx, %cr15 |
| // CHECK: movq %rdx, %cr15 |
| // CHECK: encoding: [0x44,0x0f,0x22,0xfa] |
| |
| // rdar://8456371 - Handle commutable instructions written backward. |
| // CHECK: faddp %st(1) |
| // CHECK: fmulp %st(2) |
| faddp %st, %st(1) |
| fmulp %st, %st(2) |
| |
| // rdar://8468087 - Encode these accurately, they are not synonyms. |
| // CHECK: fmul %st(0), %st(1) |
| // CHECK: encoding: [0xdc,0xc9] |
| // CHECK: fmul %st(1) |
| // CHECK: encoding: [0xd8,0xc9] |
| fmul %st, %st(1) |
| fmul %st(1), %st |
| |
| // CHECK: fadd %st(0), %st(1) |
| // CHECK: encoding: [0xdc,0xc1] |
| // CHECK: fadd %st(1) |
| // CHECK: encoding: [0xd8,0xc1] |
| fadd %st, %st(1) |
| fadd %st(1), %st |
| |
| |
| // rdar://8416805 |
| // CHECK: xorb %al, %al |
| // CHECK: encoding: [0x30,0xc0] |
| // CHECK: xorw %di, %di |
| // CHECK: encoding: [0x66,0x31,0xff] |
| // CHECK: xorl %esi, %esi |
| // CHECK: encoding: [0x31,0xf6] |
| // CHECK: xorq %rsi, %rsi |
| // CHECK: encoding: [0x48,0x31,0xf6] |
| clrb %al |
| clr %di |
| clr %esi |
| clr %rsi |
| |
| // rdar://8456378 |
| cltq // CHECK: cltq |
| cdqe // CHECK: cltq |
| cwde // CHECK: cwtl |
| cwtl // CHECK: cwtl |
| |
| // rdar://8416805 |
| cbw // CHECK: cbtw |
| cwd // CHECK: cwtd |
| cdq // CHECK: cltd |
| |
| // rdar://8456378 and PR7557 - fstsw |
| fstsw %ax |
| // CHECK: wait |
| // CHECK: fnstsw |
| fstsw (%rax) |
| // CHECK: wait |
| // CHECK: fnstsw (%rax) |
| |
| // PR8259 |
| fstcw (%rsp) |
| // CHECK: wait |
| // CHECK: fnstcw (%rsp) |
| |
| // PR8259 |
| fstcw (%rsp) |
| // CHECK: wait |
| // CHECK: fnstcw (%rsp) |
| |
| // PR8258 |
| finit |
| // CHECK: wait |
| // CHECK: fninit |
| |
| fsave 32493 |
| // CHECK: wait |
| // CHECK: fnsave 32493 |
| |
| |
| // rdar://8456382 - cvtsd2si support. |
| cvtsd2si %xmm1, %rax |
| // CHECK: cvtsd2siq %xmm1, %rax |
| // CHECK: encoding: [0xf2,0x48,0x0f,0x2d,0xc1] |
| cvtsd2si %xmm1, %eax |
| // CHECK: cvtsd2sil %xmm1, %eax |
| // CHECK: encoding: [0xf2,0x0f,0x2d,0xc1] |
| |
| cvtsd2siq %xmm0, %rax // CHECK: cvtsd2siq %xmm0, %rax |
| cvtsd2sil %xmm0, %eax // CHECK: cvtsd2sil %xmm0, %eax |
| cvtsd2si %xmm0, %rax // CHECK: cvtsd2siq %xmm0, %rax |
| |
| |
| cvttpd2dq %xmm1, %xmm0 // CHECK: cvttpd2dq %xmm1, %xmm0 |
| cvttpd2dq (%rax), %xmm0 // CHECK: cvttpd2dq (%rax), %xmm0 |
| |
| cvttps2dq %xmm1, %xmm0 // CHECK: cvttps2dq %xmm1, %xmm0 |
| cvttps2dq (%rax), %xmm0 // CHECK: cvttps2dq (%rax), %xmm0 |
| |
| // rdar://8456376 - llvm-mc rejects 'roundss' |
| roundss $0xE, %xmm0, %xmm0 // CHECK: encoding: [0x66,0x0f,0x3a,0x0a,0xc0,0x0e] |
| roundps $0xE, %xmm0, %xmm0 // CHECK: encoding: [0x66,0x0f,0x3a,0x08,0xc0,0x0e] |
| roundsd $0xE, %xmm0, %xmm0 // CHECK: encoding: [0x66,0x0f,0x3a,0x0b,0xc0,0x0e] |
| roundpd $0xE, %xmm0, %xmm0 // CHECK: encoding: [0x66,0x0f,0x3a,0x09,0xc0,0x0e] |
| |
| |
| // rdar://8482675 - 32-bit mem operand support in 64-bit mode (0x67 prefix) |
| leal 8(%eax), %esi |
| // CHECK: leal 8(%eax), %esi |
| // CHECK: encoding: [0x67,0x8d,0x70,0x08] |
| leaq 8(%eax), %rsi |
| // CHECK: leaq 8(%eax), %rsi |
| // CHECK: encoding: [0x67,0x48,0x8d,0x70,0x08] |
| leaq 8(%rax), %rsi |
| // CHECK: leaq 8(%rax), %rsi |
| // CHECK: encoding: [0x48,0x8d,0x70,0x08] |
| |
| |
| cvttpd2dq 0xdeadbeef(%ebx,%ecx,8),%xmm5 |
| // CHECK: cvttpd2dq 3735928559(%ebx,%ecx,8), %xmm5 |
| // CHECK: encoding: [0x67,0x66,0x0f,0xe6,0xac,0xcb,0xef,0xbe,0xad,0xde] |
| |
| // rdar://8490728 - llvm-mc rejects 'movmskpd' |
| movmskpd %xmm6, %rax |
| // CHECK: movmskpd %xmm6, %rax |
| // CHECK: encoding: [0x66,0x48,0x0f,0x50,0xc6] |
| movmskpd %xmm6, %eax |
| // CHECK: movmskpd %xmm6, %eax |
| // CHECK: encoding: [0x66,0x0f,0x50,0xc6] |
| |
| // rdar://8491845 - Gas supports commuted forms of non-commutable instructions. |
| fdivrp %st(0), %st(1) // CHECK: encoding: [0xde,0xf9] |
| fdivrp %st(1), %st(0) // CHECK: encoding: [0xde,0xf9] |
| |
| fsubrp %ST(0), %ST(1) // CHECK: encoding: [0xde,0xe9] |
| fsubrp %ST(1), %ST(0) // CHECK: encoding: [0xde,0xe9] |
| |
| // also PR8861 |
| fdivp %st(0), %st(1) // CHECK: encoding: [0xde,0xf1] |
| fdivp %st(1), %st(0) // CHECK: encoding: [0xde,0xf1] |
| |
| |
| movl foo(%rip), %eax |
| // CHECK: movl foo(%rip), %eax |
| // CHECK: encoding: [0x8b,0x05,A,A,A,A] |
| // CHECK: fixup A - offset: 2, value: foo-4, kind: reloc_riprel_4byte |
| |
| movb $12, foo(%rip) |
| // CHECK: movb $12, foo(%rip) |
| // CHECK: encoding: [0xc6,0x05,A,A,A,A,0x0c] |
| // CHECK: fixup A - offset: 2, value: foo-5, kind: reloc_riprel_4byte |
| |
| movw $12, foo(%rip) |
| // CHECK: movw $12, foo(%rip) |
| // CHECK: encoding: [0x66,0xc7,0x05,A,A,A,A,0x0c,0x00] |
| // CHECK: fixup A - offset: 3, value: foo-6, kind: reloc_riprel_4byte |
| |
| movl $12, foo(%rip) |
| // CHECK: movl $12, foo(%rip) |
| // CHECK: encoding: [0xc7,0x05,A,A,A,A,0x0c,0x00,0x00,0x00] |
| // CHECK: fixup A - offset: 2, value: foo-8, kind: reloc_riprel_4byte |
| |
| movq $12, foo(%rip) |
| // CHECK: movq $12, foo(%rip) |
| // CHECK: encoding: [0x48,0xc7,0x05,A,A,A,A,0x0c,0x00,0x00,0x00] |
| // CHECK: fixup A - offset: 3, value: foo-8, kind: reloc_riprel_4byte |
| |
| // CHECK: addq $-424, %rax |
| // CHECK: encoding: [0x48,0x05,0x58,0xfe,0xff,0xff] |
| addq $-424, %rax |
| |
| |
| // CHECK: movq _foo@GOTPCREL(%rip), %rax |
| // CHECK: encoding: [0x48,0x8b,0x05,A,A,A,A] |
| // CHECK: fixup A - offset: 3, value: _foo@GOTPCREL-4, kind: reloc_riprel_4byte_movq_load |
| movq _foo@GOTPCREL(%rip), %rax |
| |
| // CHECK: movq _foo@GOTPCREL(%rip), %r14 |
| // CHECK: encoding: [0x4c,0x8b,0x35,A,A,A,A] |
| // CHECK: fixup A - offset: 3, value: _foo@GOTPCREL-4, kind: reloc_riprel_4byte_movq_load |
| movq _foo@GOTPCREL(%rip), %r14 |
| |
| |
| // CHECK: movq (%r13,%rax,8), %r13 |
| // CHECK: encoding: [0x4d,0x8b,0x6c,0xc5,0x00] |
| movq 0x00(%r13,%rax,8),%r13 |
| |
| // CHECK: testq %rax, %rbx |
| // CHECK: encoding: [0x48,0x85,0xd8] |
| testq %rax, %rbx |
| |
| // CHECK: cmpq %rbx, %r14 |
| // CHECK: encoding: [0x49,0x39,0xde] |
| cmpq %rbx, %r14 |
| |
| // rdar://7947167 |
| |
| movsq |
| // CHECK: movsq |
| // CHECK: encoding: [0x48,0xa5] |
| |
| movsl |
| // CHECK: movsd |
| // CHECK: encoding: [0xa5] |
| |
| stosq |
| // CHECK: stosq |
| // CHECK: encoding: [0x48,0xab] |
| stosl |
| // CHECK: stosl |
| // CHECK: encoding: [0xab] |
| |
| |
| // Not moffset forms of moves, they are x86-32 only! rdar://7947184 |
| movb 0, %al // CHECK: movb 0, %al # encoding: [0x8a,0x04,0x25,0x00,0x00,0x00,0x00] |
| movw 0, %ax // CHECK: movw 0, %ax # encoding: [0x66,0x8b,0x04,0x25,0x00,0x00,0x00,0x00] |
| movl 0, %eax // CHECK: movl 0, %eax # encoding: [0x8b,0x04,0x25,0x00,0x00,0x00,0x00] |
| |
| // CHECK: pushfq # encoding: [0x9c] |
| pushf |
| // CHECK: pushfq # encoding: [0x9c] |
| pushfq |
| // CHECK: popfq # encoding: [0x9d] |
| popf |
| // CHECK: popfq # encoding: [0x9d] |
| popfq |
| |
| // CHECK: movabsq $-281474976710654, %rax |
| // CHECK: encoding: [0x48,0xb8,0x02,0x00,0x00,0x00,0x00,0x00,0xff,0xff] |
| movabsq $0xFFFF000000000002, %rax |
| |
| // CHECK: movabsq $-281474976710654, %rax |
| // CHECK: encoding: [0x48,0xb8,0x02,0x00,0x00,0x00,0x00,0x00,0xff,0xff] |
| movq $0xFFFF000000000002, %rax |
| |
| // CHECK: movq $-65536, %rax |
| // CHECK: encoding: [0x48,0xc7,0xc0,0x00,0x00,0xff,0xff] |
| movq $0xFFFFFFFFFFFF0000, %rax |
| |
| // CHECK: movq $-256, %rax |
| // CHECK: encoding: [0x48,0xc7,0xc0,0x00,0xff,0xff,0xff] |
| movq $0xFFFFFFFFFFFFFF00, %rax |
| |
| // CHECK: movq $10, %rax |
| // CHECK: encoding: [0x48,0xc7,0xc0,0x0a,0x00,0x00,0x00] |
| movq $10, %rax |
| |
| // rdar://8014869 |
| // |
| // CHECK: ret |
| // CHECK: encoding: [0xc3] |
| retq |
| |
| // CHECK: sete %al |
| // CHECK: encoding: [0x0f,0x94,0xc0] |
| setz %al |
| |
| // CHECK: setne %al |
| // CHECK: encoding: [0x0f,0x95,0xc0] |
| setnz %al |
| |
| // CHECK: je 0 |
| // CHECK: encoding: [0x74,A] |
| jz 0 |
| |
| // CHECK: jne |
| // CHECK: encoding: [0x75,A] |
| jnz 0 |
| |
| // PR9264 |
| btl $1, 0 // CHECK: btl $1, 0 # encoding: [0x0f,0xba,0x24,0x25,0x00,0x00,0x00,0x00,0x01] |
| bt $1, 0 // CHECK: btl $1, 0 # encoding: [0x0f,0xba,0x24,0x25,0x00,0x00,0x00,0x00,0x01] |
| |
| // rdar://8017515 |
| btq $0x01,%rdx |
| // CHECK: btq $1, %rdx |
| // CHECK: encoding: [0x48,0x0f,0xba,0xe2,0x01] |
| |
| //rdar://8017633 |
| // CHECK: movzbl %al, %esi |
| // CHECK: encoding: [0x0f,0xb6,0xf0] |
| movzx %al, %esi |
| |
| // CHECK: movzbq %al, %rsi |
| // CHECK: encoding: [0x48,0x0f,0xb6,0xf0] |
| movzx %al, %rsi |
| |
| // CHECK: movsbw %al, %ax |
| // CHECK: encoding: [0x66,0x0f,0xbe,0xc0] |
| movsx %al, %ax |
| |
| // CHECK: movsbl %al, %eax |
| // CHECK: encoding: [0x0f,0xbe,0xc0] |
| movsx %al, %eax |
| |
| // CHECK: movswl %ax, %eax |
| // CHECK: encoding: [0x0f,0xbf,0xc0] |
| movsx %ax, %eax |
| |
| // CHECK: movsbq %bl, %rax |
| // CHECK: encoding: [0x48,0x0f,0xbe,0xc3] |
| movsx %bl, %rax |
| |
| // CHECK: movswq %cx, %rax |
| // CHECK: encoding: [0x48,0x0f,0xbf,0xc1] |
| movsx %cx, %rax |
| |
| // CHECK: movslq %edi, %rax |
| // CHECK: encoding: [0x48,0x63,0xc7] |
| movsx %edi, %rax |
| |
| // CHECK: movzbw %al, %ax |
| // CHECK: encoding: [0x66,0x0f,0xb6,0xc0] |
| movzx %al, %ax |
| |
| // CHECK: movzbl %al, %eax |
| // CHECK: encoding: [0x0f,0xb6,0xc0] |
| movzx %al, %eax |
| |
| // CHECK: movzwl %ax, %eax |
| // CHECK: encoding: [0x0f,0xb7,0xc0] |
| movzx %ax, %eax |
| |
| // CHECK: movzbq %bl, %rax |
| // CHECK: encoding: [0x48,0x0f,0xb6,0xc3] |
| movzx %bl, %rax |
| |
| // CHECK: movzwq %cx, %rax |
| // CHECK: encoding: [0x48,0x0f,0xb7,0xc1] |
| movzx %cx, %rax |
| |
| // CHECK: movsbw (%rax), %ax |
| // CHECK: encoding: [0x66,0x0f,0xbe,0x00] |
| movsx (%rax), %ax |
| |
| // CHECK: movzbw (%rax), %ax |
| // CHECK: encoding: [0x66,0x0f,0xb6,0x00] |
| movzx (%rax), %ax |
| |
| |
| // rdar://7873482 |
| // CHECK: [0x65,0x8b,0x04,0x25,0x7c,0x00,0x00,0x00] |
| movl %gs:124, %eax |
| |
| // CHECK: jmpq *8(%rax) |
| // CHECK: encoding: [0xff,0x60,0x08] |
| jmp *8(%rax) |
| |
| // CHECK: btq $61, -216(%rbp) |
| // CHECK: encoding: [0x48,0x0f,0xba,0xa5,0x28,0xff,0xff,0xff,0x3d] |
| btq $61, -216(%rbp) |
| |
| |
| // rdar://8061602 |
| L1: |
| jecxz L1 |
| // CHECK: jecxz L1 |
| // CHECK: encoding: [0x67,0xe3,A] |
| jrcxz L1 |
| // CHECK: jrcxz L1 |
| // CHECK: encoding: [0xe3,A] |
| |
| // PR8061 |
| xchgl 368(%rax),%ecx |
| // CHECK: xchgl %ecx, 368(%rax) |
| xchgl %ecx, 368(%rax) |
| // CHECK: xchgl %ecx, 368(%rax) |
| |
| // rdar://8407548 |
| xchg 0xdeadbeef(%rbx,%rcx,8),%bl |
| // CHECK: xchgb %bl, 3735928559(%rbx,%rcx,8) |
| |
| |
| |
| // PR7254 |
| lock incl 1(%rsp) |
| // CHECK: lock |
| // CHECK: incl 1(%rsp) |
| |
| // rdar://8741045 |
| lock/incl 1(%rsp) |
| // CHECK: lock |
| // CHECK: incl 1(%rsp) |
| |
| // rdar://8033482 |
| rep movsl |
| // CHECK: rep |
| // CHECK: encoding: [0xf3] |
| // CHECK: movsd |
| // CHECK: encoding: [0xa5] |
| |
| |
| // rdar://8403974 |
| iret |
| // CHECK: iretl |
| // CHECK: encoding: [0xcf] |
| iretw |
| // CHECK: iretw |
| // CHECK: encoding: [0x66,0xcf] |
| iretl |
| // CHECK: iretl |
| // CHECK: encoding: [0xcf] |
| iretq |
| // CHECK: iretq |
| // CHECK: encoding: [0x48,0xcf] |
| |
| // rdar://8416805 |
| // CHECK: retw $31438 |
| // CHECK: encoding: [0x66,0xc2,0xce,0x7a] |
| retw $0x7ace |
| |
| // CHECK: lretw $31438 |
| // CHECK: encoding: [0x66,0xca,0xce,0x7a] |
| lretw $0x7ace |
| |
| // PR8592 |
| lretq // CHECK: lretq # encoding: [0x48,0xcb] |
| lretl // CHECK: lretl # encoding: [0xcb] |
| lret // CHECK: lretl # encoding: [0xcb] |
| |
| // rdar://8403907 |
| sysret |
| // CHECK: sysretl |
| // CHECK: encoding: [0x0f,0x07] |
| sysretl |
| // CHECK: sysretl |
| // CHECK: encoding: [0x0f,0x07] |
| sysretq |
| // CHECK: sysretq |
| // CHECK: encoding: [0x48,0x0f,0x07] |
| |
| // rdar://8407242 |
| push %fs |
| // CHECK: pushq %fs |
| // CHECK: encoding: [0x0f,0xa0] |
| push %gs |
| // CHECK: pushq %gs |
| // CHECK: encoding: [0x0f,0xa8] |
| |
| pushw %fs |
| // CHECK: pushw %fs |
| // CHECK: encoding: [0x66,0x0f,0xa0] |
| pushw %gs |
| // CHECK: pushw %gs |
| // CHECK: encoding: [0x66,0x0f,0xa8] |
| |
| |
| pop %fs |
| // CHECK: popq %fs |
| // CHECK: encoding: [0x0f,0xa1] |
| pop %gs |
| // CHECK: popq %gs |
| // CHECK: encoding: [0x0f,0xa9] |
| |
| popw %fs |
| // CHECK: popw %fs |
| // CHECK: encoding: [0x66,0x0f,0xa1] |
| popw %gs |
| // CHECK: popw %gs |
| // CHECK: encoding: [0x66,0x0f,0xa9] |
| |
| // rdar://8438816 |
| fildq -8(%rsp) |
| fildll -8(%rsp) |
| // CHECK: fildll -8(%rsp) |
| // CHECK: encoding: [0xdf,0x6c,0x24,0xf8] |
| // CHECK: fildll -8(%rsp) |
| // CHECK: encoding: [0xdf,0x6c,0x24,0xf8] |
| |
| // CHECK: callq a |
| callq a |
| |
| // CHECK: leaq -40(%rbp), %r15 |
| leaq -40(%rbp), %r15 |
| |
| |
| |
| // rdar://8013734 - Alias dr6=db6 |
| mov %dr6, %rax |
| mov %db6, %rax |
| // CHECK: movq %dr6, %rax |
| // CHECK: movq %dr6, %rax |
| |
| |
| // INC/DEC encodings. |
| incb %al // CHECK: incb %al # encoding: [0xfe,0xc0] |
| incw %ax // CHECK: incw %ax # encoding: [0x66,0xff,0xc0] |
| incl %eax // CHECK: incl %eax # encoding: [0xff,0xc0] |
| decb %al // CHECK: decb %al # encoding: [0xfe,0xc8] |
| decw %ax // CHECK: decw %ax # encoding: [0x66,0xff,0xc8] |
| decl %eax // CHECK: decl %eax # encoding: [0xff,0xc8] |
| |
| // rdar://8416805 |
| // CHECK: lgdt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x50,0x04] |
| lgdt 4(%rax) |
| |
| // CHECK: lgdt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x50,0x04] |
| lgdtq 4(%rax) |
| |
| // CHECK: lidt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x58,0x04] |
| lidt 4(%rax) |
| |
| // CHECK: lidt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x58,0x04] |
| lidtq 4(%rax) |
| |
| // CHECK: sgdt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x40,0x04] |
| sgdt 4(%rax) |
| |
| // CHECK: sgdt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x40,0x04] |
| sgdtq 4(%rax) |
| |
| // CHECK: sidt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x48,0x04] |
| sidt 4(%rax) |
| |
| // CHECK: sidt 4(%rax) |
| // CHECK: encoding: [0x0f,0x01,0x48,0x04] |
| sidtq 4(%rax) |
| |
| |
| // rdar://8208615 |
| mov (%rsi), %gs // CHECK: movl (%rsi), %gs # encoding: [0x8e,0x2e] |
| mov %gs, (%rsi) // CHECK: movl %gs, (%rsi) # encoding: [0x8c,0x2e] |
| |
| |
| // rdar://8431864 |
| div %bl,%al |
| div %bx,%ax |
| div %ecx,%eax |
| div 0xdeadbeef(%ebx,%ecx,8),%eax |
| div 0x45,%eax |
| div 0x7eed,%eax |
| div 0xbabecafe,%eax |
| div 0x12345678,%eax |
| idiv %bl,%al |
| idiv %bx,%ax |
| idiv %ecx,%eax |
| idiv 0xdeadbeef(%ebx,%ecx,8),%eax |
| idiv 0x45,%eax |
| idiv 0x7eed,%eax |
| idiv 0xbabecafe,%eax |
| idiv 0x12345678,%eax |
| |
| // PR8524 |
| movd %rax, %mm5 // CHECK: movd %rax, %mm5 # encoding: [0x48,0x0f,0x6e,0xe8] |
| movd %mm5, %rbx // CHECK: movd %mm5, %rbx # encoding: [0x48,0x0f,0x7e,0xeb] |
| movq %rax, %mm5 // CHECK: movd %rax, %mm5 # encoding: [0x48,0x0f,0x6e,0xe8] |
| movq %mm5, %rbx // CHECK: movd %mm5, %rbx # encoding: [0x48,0x0f,0x7e,0xeb] |
| |
| rex64 // CHECK: rex64 # encoding: [0x48] |
| data16 // CHECK: data16 # encoding: [0x66] |
| |
| // PR8855 |
| movq 18446744073709551615,%rbx // CHECK: movq -1, %rbx |
| |
| // PR8946 |
| movdqu %xmm0, %xmm1 // CHECK: movdqu %xmm0, %xmm1 # encoding: [0xf3,0x0f,0x6f,0xc8] |
| |
| // PR8935 |
| xgetbv // CHECK: xgetbv # encoding: [0x0f,0x01,0xd0] |
| xsetbv // CHECK: xsetbv # encoding: [0x0f,0x01,0xd1] |
| |
| // CHECK: loope 0 |
| // CHECK: encoding: [0xe1,A] |
| loopz 0 |
| |
| // CHECK: loopne 0 |
| // CHECK: encoding: [0xe0,A] |
| loopnz 0 |
| |
| // CHECK: outsb # encoding: [0x6e] |
| // CHECK: outsb |
| // CHECK: outsb |
| outsb |
| outsb %ds:(%rsi), %dx |
| outsb (%rsi), %dx |
| |
| // CHECK: outsw # encoding: [0x66,0x6f] |
| // CHECK: outsw |
| // CHECK: outsw |
| outsw |
| outsw %ds:(%rsi), %dx |
| outsw (%rsi), %dx |
| |
| // CHECK: outsl # encoding: [0x6f] |
| // CHECK: outsl |
| outsl |
| outsl %ds:(%rsi), %dx |
| outsl (%rsi), %dx |
| |
| // CHECK: insb # encoding: [0x6c] |
| // CHECK: insb |
| insb |
| insb %dx, %es:(%rdi) |
| |
| // CHECK: insw # encoding: [0x66,0x6d] |
| // CHECK: insw |
| insw |
| insw %dx, %es:(%rdi) |
| |
| // CHECK: insl # encoding: [0x6d] |
| // CHECK: insl |
| insl |
| insl %dx, %es:(%rdi) |
| |
| // CHECK: movsb # encoding: [0xa4] |
| // CHECK: movsb |
| // CHECK: movsb |
| movsb |
| movsb %ds:(%rsi), %es:(%rdi) |
| movsb (%rsi), %es:(%rdi) |
| |
| // CHECK: movsw # encoding: [0x66,0xa5] |
| // CHECK: movsw |
| // CHECK: movsw |
| movsw |
| movsw %ds:(%rsi), %es:(%rdi) |
| movsw (%rsi), %es:(%rdi) |
| |
| // CHECK: movsd # encoding: [0xa5] |
| // CHECK: movsd |
| // CHECK: movsd |
| movsl |
| movsl %ds:(%rsi), %es:(%rdi) |
| movsl (%rsi), %es:(%rdi) |
| |
| // CHECK: movsq # encoding: [0x48,0xa5] |
| // CHECK: movsq |
| // CHECK: movsq |
| movsq |
| movsq %ds:(%rsi), %es:(%rdi) |
| movsq (%rsi), %es:(%rdi) |
| |
| // CHECK: lodsb # encoding: [0xac] |
| // CHECK: lodsb |
| // CHECK: lodsb |
| // CHECK: lodsb |
| // CHECK: lodsb |
| lodsb |
| lodsb %ds:(%rsi), %al |
| lodsb (%rsi), %al |
| lods %ds:(%rsi), %al |
| lods (%rsi), %al |
| |
| // CHECK: lodsw # encoding: [0x66,0xad] |
| // CHECK: lodsw |
| // CHECK: lodsw |
| // CHECK: lodsw |
| // CHECK: lodsw |
| lodsw |
| lodsw %ds:(%rsi), %ax |
| lodsw (%rsi), %ax |
| lods %ds:(%rsi), %ax |
| lods (%rsi), %ax |
| |
| // CHECK: lodsl # encoding: [0xad] |
| // CHECK: lodsl |
| // CHECK: lodsl |
| // CHECK: lodsl |
| // CHECK: lodsl |
| lodsl |
| lodsl %ds:(%rsi), %eax |
| lodsl (%rsi), %eax |
| lods %ds:(%rsi), %eax |
| lods (%rsi), %eax |
| |
| // CHECK: lodsq # encoding: [0x48,0xad] |
| // CHECK: lodsq |
| // CHECK: lodsq |
| // CHECK: lodsq |
| // CHECK: lodsq |
| lodsq |
| lodsq %ds:(%rsi), %rax |
| lodsq (%rsi), %rax |
| lods %ds:(%rsi), %rax |
| lods (%rsi), %rax |
| |
| // CHECK: stosb # encoding: [0xaa] |
| // CHECK: stosb |
| // CHECK: stosb |
| stosb |
| stosb %al, %es:(%rdi) |
| stos %al, %es:(%rdi) |
| |
| // CHECK: stosw # encoding: [0x66,0xab] |
| // CHECK: stosw |
| // CHECK: stosw |
| stosw |
| stosw %ax, %es:(%rdi) |
| stos %ax, %es:(%rdi) |
| |
| // CHECK: stosl # encoding: [0xab] |
| // CHECK: stosl |
| // CHECK: stosl |
| stosl |
| stosl %eax, %es:(%rdi) |
| stos %eax, %es:(%rdi) |
| |
| // CHECK: stosq # encoding: [0x48,0xab] |
| // CHECK: stosq |
| // CHECK: stosq |
| stosq |
| stosq %rax, %es:(%rdi) |
| stos %rax, %es:(%rdi) |
| |
| // CHECK: strw |
| // CHECK: encoding: [0x66,0x0f,0x00,0xc8] |
| str %ax |
| |
| // CHECK: strl |
| // CHECK: encoding: [0x0f,0x00,0xc8] |
| str %eax |
| |
| // CHECK: strw |
| // CHECK: encoding: [0x66,0x0f,0x00,0xc8] |
| str %ax |
| |
| // CHECK: strq |
| // CHECK: encoding: [0x48,0x0f,0x00,0xc8] |
| str %rax |
| |
| // CHECK: movd %rdi, %xmm0 |
| // CHECK: encoding: [0x66,0x48,0x0f,0x6e,0xc7] |
| movq %rdi,%xmm0 |
| |
| // CHECK: movd %rdi, %xmm0 |
| // CHECK: encoding: [0x66,0x48,0x0f,0x6e,0xc7] |
| movd %rdi,%xmm0 |
| |
| // CHECK: movntil %eax, (%rdi) |
| // CHECK: encoding: [0x0f,0xc3,0x07] |
| // CHECK: movntil |
| movntil %eax, (%rdi) |
| movnti %eax, (%rdi) |
| |
| // CHECK: movntiq %rax, (%rdi) |
| // CHECK: encoding: [0x48,0x0f,0xc3,0x07] |
| // CHECK: movntiq |
| movntiq %rax, (%rdi) |
| movnti %rax, (%rdi) |
| |
| // CHECK: pclmulqdq $17, %xmm0, %xmm1 |
| // CHECK: encoding: [0x66,0x0f,0x3a,0x44,0xc8,0x11] |
| pclmulhqhqdq %xmm0, %xmm1 |
| |
| // CHECK: pclmulqdq $1, %xmm0, %xmm1 |
| // CHECK: encoding: [0x66,0x0f,0x3a,0x44,0xc8,0x01] |
| pclmulqdq $1, %xmm0, %xmm1 |
| |
| // CHECK: pclmulqdq $16, (%rdi), %xmm1 |
| // CHECK: encoding: [0x66,0x0f,0x3a,0x44,0x0f,0x10] |
| pclmullqhqdq (%rdi), %xmm1 |
| |
| // CHECK: pclmulqdq $0, (%rdi), %xmm1 |
| // CHECK: encoding: [0x66,0x0f,0x3a,0x44,0x0f,0x00] |
| pclmulqdq $0, (%rdi), %xmm1 |
| |
| // PR10345 |
| // CHECK: xchgq %rax, %rax |
| // CHECK: encoding: [0x48,0x90] |
| xchgq %rax, %rax |
| |
| // CHECK: xchgl %eax, %eax |
| // CHECK: encoding: [0x87,0xc0] |
| xchgl %eax, %eax |
| |
| // CHECK: xchgw %ax, %ax |
| // CHECK: encoding: [0x66,0x90] |
| xchgw %ax, %ax |
| |
| // CHECK: xchgl %ecx, %eax |
| // CHECK: encoding: [0x91] |
| xchgl %ecx, %eax |
| |
| // CHECK: xchgl %ecx, %eax |
| // CHECK: encoding: [0x91] |
| xchgl %eax, %ecx |
