| # Check 32bit HLE instructions |
| |
| .allow_index_reg |
| .text |
| _start: |
| |
| # Tests for op imm8 regb/m8 |
| xacquire lock adcb $100,(%ecx) |
| lock xacquire adcb $100,(%ecx) |
| xrelease lock adcb $100,(%ecx) |
| lock xrelease adcb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcb $100,(%ecx) |
| xacquire lock addb $100,(%ecx) |
| lock xacquire addb $100,(%ecx) |
| xrelease lock addb $100,(%ecx) |
| lock xrelease addb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; addb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; addb $100,(%ecx) |
| xacquire lock andb $100,(%ecx) |
| lock xacquire andb $100,(%ecx) |
| xrelease lock andb $100,(%ecx) |
| lock xrelease andb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; andb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; andb $100,(%ecx) |
| xrelease movb $100,(%ecx) |
| xacquire lock orb $100,(%ecx) |
| lock xacquire orb $100,(%ecx) |
| xrelease lock orb $100,(%ecx) |
| lock xrelease orb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; orb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; orb $100,(%ecx) |
| xacquire lock sbbb $100,(%ecx) |
| lock xacquire sbbb $100,(%ecx) |
| xrelease lock sbbb $100,(%ecx) |
| lock xrelease sbbb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbb $100,(%ecx) |
| xacquire lock subb $100,(%ecx) |
| lock xacquire subb $100,(%ecx) |
| xrelease lock subb $100,(%ecx) |
| lock xrelease subb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; subb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; subb $100,(%ecx) |
| xacquire lock xorb $100,(%ecx) |
| lock xacquire xorb $100,(%ecx) |
| xrelease lock xorb $100,(%ecx) |
| lock xrelease xorb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorb $100,(%ecx) |
| |
| # Tests for op imm16 regs/m16 |
| xacquire lock adcw $1000,(%ecx) |
| lock xacquire adcw $1000,(%ecx) |
| xrelease lock adcw $1000,(%ecx) |
| lock xrelease adcw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcw $1000,(%ecx) |
| xacquire lock addw $1000,(%ecx) |
| lock xacquire addw $1000,(%ecx) |
| xrelease lock addw $1000,(%ecx) |
| lock xrelease addw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; addw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; addw $1000,(%ecx) |
| xacquire lock andw $1000,(%ecx) |
| lock xacquire andw $1000,(%ecx) |
| xrelease lock andw $1000,(%ecx) |
| lock xrelease andw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; andw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; andw $1000,(%ecx) |
| xrelease movw $1000,(%ecx) |
| xacquire lock orw $1000,(%ecx) |
| lock xacquire orw $1000,(%ecx) |
| xrelease lock orw $1000,(%ecx) |
| lock xrelease orw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; orw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; orw $1000,(%ecx) |
| xacquire lock sbbw $1000,(%ecx) |
| lock xacquire sbbw $1000,(%ecx) |
| xrelease lock sbbw $1000,(%ecx) |
| lock xrelease sbbw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbw $1000,(%ecx) |
| xacquire lock subw $1000,(%ecx) |
| lock xacquire subw $1000,(%ecx) |
| xrelease lock subw $1000,(%ecx) |
| lock xrelease subw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; subw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; subw $1000,(%ecx) |
| xacquire lock xorw $1000,(%ecx) |
| lock xacquire xorw $1000,(%ecx) |
| xrelease lock xorw $1000,(%ecx) |
| lock xrelease xorw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorw $1000,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorw $1000,(%ecx) |
| |
| # Tests for op imm32 regl/m32 |
| xacquire lock adcl $10000000,(%ecx) |
| lock xacquire adcl $10000000,(%ecx) |
| xrelease lock adcl $10000000,(%ecx) |
| lock xrelease adcl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcl $10000000,(%ecx) |
| xacquire lock addl $10000000,(%ecx) |
| lock xacquire addl $10000000,(%ecx) |
| xrelease lock addl $10000000,(%ecx) |
| lock xrelease addl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; addl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; addl $10000000,(%ecx) |
| xacquire lock andl $10000000,(%ecx) |
| lock xacquire andl $10000000,(%ecx) |
| xrelease lock andl $10000000,(%ecx) |
| lock xrelease andl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; andl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; andl $10000000,(%ecx) |
| xrelease movl $10000000,(%ecx) |
| xacquire lock orl $10000000,(%ecx) |
| lock xacquire orl $10000000,(%ecx) |
| xrelease lock orl $10000000,(%ecx) |
| lock xrelease orl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; orl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; orl $10000000,(%ecx) |
| xacquire lock sbbl $10000000,(%ecx) |
| lock xacquire sbbl $10000000,(%ecx) |
| xrelease lock sbbl $10000000,(%ecx) |
| lock xrelease sbbl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbl $10000000,(%ecx) |
| xacquire lock subl $10000000,(%ecx) |
| lock xacquire subl $10000000,(%ecx) |
| xrelease lock subl $10000000,(%ecx) |
| lock xrelease subl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; subl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; subl $10000000,(%ecx) |
| xacquire lock xorl $10000000,(%ecx) |
| lock xacquire xorl $10000000,(%ecx) |
| xrelease lock xorl $10000000,(%ecx) |
| lock xrelease xorl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorl $10000000,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorl $10000000,(%ecx) |
| |
| # Tests for op imm8 regs/m16 |
| xacquire lock adcw $100,(%ecx) |
| lock xacquire adcw $100,(%ecx) |
| xrelease lock adcw $100,(%ecx) |
| lock xrelease adcw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcw $100,(%ecx) |
| xacquire lock addw $100,(%ecx) |
| lock xacquire addw $100,(%ecx) |
| xrelease lock addw $100,(%ecx) |
| lock xrelease addw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; addw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; addw $100,(%ecx) |
| xacquire lock andw $100,(%ecx) |
| lock xacquire andw $100,(%ecx) |
| xrelease lock andw $100,(%ecx) |
| lock xrelease andw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; andw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; andw $100,(%ecx) |
| xacquire lock btcw $100,(%ecx) |
| lock xacquire btcw $100,(%ecx) |
| xrelease lock btcw $100,(%ecx) |
| lock xrelease btcw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btcw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btcw $100,(%ecx) |
| xacquire lock btrw $100,(%ecx) |
| lock xacquire btrw $100,(%ecx) |
| xrelease lock btrw $100,(%ecx) |
| lock xrelease btrw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btrw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btrw $100,(%ecx) |
| xacquire lock btsw $100,(%ecx) |
| lock xacquire btsw $100,(%ecx) |
| xrelease lock btsw $100,(%ecx) |
| lock xrelease btsw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btsw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btsw $100,(%ecx) |
| xrelease movw $100,(%ecx) |
| xacquire lock orw $100,(%ecx) |
| lock xacquire orw $100,(%ecx) |
| xrelease lock orw $100,(%ecx) |
| lock xrelease orw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; orw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; orw $100,(%ecx) |
| xacquire lock sbbw $100,(%ecx) |
| lock xacquire sbbw $100,(%ecx) |
| xrelease lock sbbw $100,(%ecx) |
| lock xrelease sbbw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbw $100,(%ecx) |
| xacquire lock subw $100,(%ecx) |
| lock xacquire subw $100,(%ecx) |
| xrelease lock subw $100,(%ecx) |
| lock xrelease subw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; subw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; subw $100,(%ecx) |
| xacquire lock xorw $100,(%ecx) |
| lock xacquire xorw $100,(%ecx) |
| xrelease lock xorw $100,(%ecx) |
| lock xrelease xorw $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorw $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorw $100,(%ecx) |
| |
| # Tests for op imm8 regl/m32 |
| xacquire lock adcl $100,(%ecx) |
| lock xacquire adcl $100,(%ecx) |
| xrelease lock adcl $100,(%ecx) |
| lock xrelease adcl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcl $100,(%ecx) |
| xacquire lock addl $100,(%ecx) |
| lock xacquire addl $100,(%ecx) |
| xrelease lock addl $100,(%ecx) |
| lock xrelease addl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; addl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; addl $100,(%ecx) |
| xacquire lock andl $100,(%ecx) |
| lock xacquire andl $100,(%ecx) |
| xrelease lock andl $100,(%ecx) |
| lock xrelease andl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; andl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; andl $100,(%ecx) |
| xacquire lock btcl $100,(%ecx) |
| lock xacquire btcl $100,(%ecx) |
| xrelease lock btcl $100,(%ecx) |
| lock xrelease btcl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btcl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btcl $100,(%ecx) |
| xacquire lock btrl $100,(%ecx) |
| lock xacquire btrl $100,(%ecx) |
| xrelease lock btrl $100,(%ecx) |
| lock xrelease btrl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btrl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btrl $100,(%ecx) |
| xacquire lock btsl $100,(%ecx) |
| lock xacquire btsl $100,(%ecx) |
| xrelease lock btsl $100,(%ecx) |
| lock xrelease btsl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; btsl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; btsl $100,(%ecx) |
| xrelease movl $100,(%ecx) |
| xacquire lock orl $100,(%ecx) |
| lock xacquire orl $100,(%ecx) |
| xrelease lock orl $100,(%ecx) |
| lock xrelease orl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; orl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; orl $100,(%ecx) |
| xacquire lock sbbl $100,(%ecx) |
| lock xacquire sbbl $100,(%ecx) |
| xrelease lock sbbl $100,(%ecx) |
| lock xrelease sbbl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbl $100,(%ecx) |
| xacquire lock subl $100,(%ecx) |
| lock xacquire subl $100,(%ecx) |
| xrelease lock subl $100,(%ecx) |
| lock xrelease subl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; subl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; subl $100,(%ecx) |
| xacquire lock xorl $100,(%ecx) |
| lock xacquire xorl $100,(%ecx) |
| xrelease lock xorl $100,(%ecx) |
| lock xrelease xorl $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorl $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorl $100,(%ecx) |
| |
| # Tests for op imm8 regb/m8 |
| xacquire lock adcb $100,(%ecx) |
| lock xacquire adcb $100,(%ecx) |
| xrelease lock adcb $100,(%ecx) |
| lock xrelease adcb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcb $100,(%ecx) |
| xacquire lock addb $100,(%ecx) |
| lock xacquire addb $100,(%ecx) |
| xrelease lock addb $100,(%ecx) |
| lock xrelease addb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; addb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; addb $100,(%ecx) |
| xacquire lock andb $100,(%ecx) |
| lock xacquire andb $100,(%ecx) |
| xrelease lock andb $100,(%ecx) |
| lock xrelease andb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; andb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; andb $100,(%ecx) |
| xrelease movb $100,(%ecx) |
| xacquire lock orb $100,(%ecx) |
| lock xacquire orb $100,(%ecx) |
| xrelease lock orb $100,(%ecx) |
| lock xrelease orb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; orb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; orb $100,(%ecx) |
| xacquire lock sbbb $100,(%ecx) |
| lock xacquire sbbb $100,(%ecx) |
| xrelease lock sbbb $100,(%ecx) |
| lock xrelease sbbb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbb $100,(%ecx) |
| xacquire lock subb $100,(%ecx) |
| lock xacquire subb $100,(%ecx) |
| xrelease lock subb $100,(%ecx) |
| lock xrelease subb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; subb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; subb $100,(%ecx) |
| xacquire lock xorb $100,(%ecx) |
| lock xacquire xorb $100,(%ecx) |
| xrelease lock xorb $100,(%ecx) |
| lock xrelease xorb $100,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorb $100,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorb $100,(%ecx) |
| |
| # Tests for op regb regb/m8 |
| # Tests for op regb/m8 regb |
| xacquire lock adcb %al,(%ecx) |
| lock xacquire adcb %al,(%ecx) |
| xrelease lock adcb %al,(%ecx) |
| lock xrelease adcb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcb %al,(%ecx) |
| xacquire lock addb %al,(%ecx) |
| lock xacquire addb %al,(%ecx) |
| xrelease lock addb %al,(%ecx) |
| lock xrelease addb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; addb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; addb %al,(%ecx) |
| xacquire lock andb %al,(%ecx) |
| lock xacquire andb %al,(%ecx) |
| xrelease lock andb %al,(%ecx) |
| lock xrelease andb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; andb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; andb %al,(%ecx) |
| xrelease movb %al,(%ecx) |
| xrelease movb %al,0x12345678 |
| xacquire lock orb %al,(%ecx) |
| lock xacquire orb %al,(%ecx) |
| xrelease lock orb %al,(%ecx) |
| lock xrelease orb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; orb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; orb %al,(%ecx) |
| xacquire lock sbbb %al,(%ecx) |
| lock xacquire sbbb %al,(%ecx) |
| xrelease lock sbbb %al,(%ecx) |
| lock xrelease sbbb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbb %al,(%ecx) |
| xacquire lock subb %al,(%ecx) |
| lock xacquire subb %al,(%ecx) |
| xrelease lock subb %al,(%ecx) |
| lock xrelease subb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; subb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; subb %al,(%ecx) |
| xacquire lock xchgb %al,(%ecx) |
| lock xacquire xchgb %al,(%ecx) |
| xacquire xchgb %al,(%ecx) |
| xrelease lock xchgb %al,(%ecx) |
| lock xrelease xchgb %al,(%ecx) |
| xrelease xchgb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; xchgb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; xchgb %al,(%ecx) |
| xacquire lock xorb %al,(%ecx) |
| lock xacquire xorb %al,(%ecx) |
| xrelease lock xorb %al,(%ecx) |
| lock xrelease xorb %al,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorb %al,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorb %al,(%ecx) |
| |
| # Tests for op regs regs/m16 |
| # Tests for op regs/m16 regs |
| xacquire lock adcw %ax,(%ecx) |
| lock xacquire adcw %ax,(%ecx) |
| xrelease lock adcw %ax,(%ecx) |
| lock xrelease adcw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcw %ax,(%ecx) |
| xacquire lock addw %ax,(%ecx) |
| lock xacquire addw %ax,(%ecx) |
| xrelease lock addw %ax,(%ecx) |
| lock xrelease addw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; addw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; addw %ax,(%ecx) |
| xacquire lock andw %ax,(%ecx) |
| lock xacquire andw %ax,(%ecx) |
| xrelease lock andw %ax,(%ecx) |
| lock xrelease andw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; andw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; andw %ax,(%ecx) |
| xrelease movw %ax,(%ecx) |
| xrelease movw %ax,0x12345678 |
| xacquire lock orw %ax,(%ecx) |
| lock xacquire orw %ax,(%ecx) |
| xrelease lock orw %ax,(%ecx) |
| lock xrelease orw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; orw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; orw %ax,(%ecx) |
| xacquire lock sbbw %ax,(%ecx) |
| lock xacquire sbbw %ax,(%ecx) |
| xrelease lock sbbw %ax,(%ecx) |
| lock xrelease sbbw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbw %ax,(%ecx) |
| xacquire lock subw %ax,(%ecx) |
| lock xacquire subw %ax,(%ecx) |
| xrelease lock subw %ax,(%ecx) |
| lock xrelease subw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; subw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; subw %ax,(%ecx) |
| xacquire lock xchgw %ax,(%ecx) |
| lock xacquire xchgw %ax,(%ecx) |
| xacquire xchgw %ax,(%ecx) |
| xrelease lock xchgw %ax,(%ecx) |
| lock xrelease xchgw %ax,(%ecx) |
| xrelease xchgw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xchgw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xchgw %ax,(%ecx) |
| xacquire lock xorw %ax,(%ecx) |
| lock xacquire xorw %ax,(%ecx) |
| xrelease lock xorw %ax,(%ecx) |
| lock xrelease xorw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorw %ax,(%ecx) |
| |
| # Tests for op regl regl/m32 |
| # Tests for op regl/m32 regl |
| xacquire lock adcl %eax,(%ecx) |
| lock xacquire adcl %eax,(%ecx) |
| xrelease lock adcl %eax,(%ecx) |
| lock xrelease adcl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; adcl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; adcl %eax,(%ecx) |
| xacquire lock addl %eax,(%ecx) |
| lock xacquire addl %eax,(%ecx) |
| xrelease lock addl %eax,(%ecx) |
| lock xrelease addl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; addl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; addl %eax,(%ecx) |
| xacquire lock andl %eax,(%ecx) |
| lock xacquire andl %eax,(%ecx) |
| xrelease lock andl %eax,(%ecx) |
| lock xrelease andl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; andl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; andl %eax,(%ecx) |
| xrelease movl %eax,(%ecx) |
| xrelease movl %eax,0x12345678 |
| xacquire lock orl %eax,(%ecx) |
| lock xacquire orl %eax,(%ecx) |
| xrelease lock orl %eax,(%ecx) |
| lock xrelease orl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; orl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; orl %eax,(%ecx) |
| xacquire lock sbbl %eax,(%ecx) |
| lock xacquire sbbl %eax,(%ecx) |
| xrelease lock sbbl %eax,(%ecx) |
| lock xrelease sbbl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; sbbl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; sbbl %eax,(%ecx) |
| xacquire lock subl %eax,(%ecx) |
| lock xacquire subl %eax,(%ecx) |
| xrelease lock subl %eax,(%ecx) |
| lock xrelease subl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; subl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; subl %eax,(%ecx) |
| xacquire lock xchgl %eax,(%ecx) |
| lock xacquire xchgl %eax,(%ecx) |
| xacquire xchgl %eax,(%ecx) |
| xrelease lock xchgl %eax,(%ecx) |
| lock xrelease xchgl %eax,(%ecx) |
| xrelease xchgl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xchgl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xchgl %eax,(%ecx) |
| xacquire lock xorl %eax,(%ecx) |
| lock xacquire xorl %eax,(%ecx) |
| xrelease lock xorl %eax,(%ecx) |
| lock xrelease xorl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xorl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xorl %eax,(%ecx) |
| |
| # Tests for op regs, regs/m16 |
| xacquire lock btcw %ax,(%ecx) |
| lock xacquire btcw %ax,(%ecx) |
| xrelease lock btcw %ax,(%ecx) |
| lock xrelease btcw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btcw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btcw %ax,(%ecx) |
| xacquire lock btrw %ax,(%ecx) |
| lock xacquire btrw %ax,(%ecx) |
| xrelease lock btrw %ax,(%ecx) |
| lock xrelease btrw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btrw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btrw %ax,(%ecx) |
| xacquire lock btsw %ax,(%ecx) |
| lock xacquire btsw %ax,(%ecx) |
| xrelease lock btsw %ax,(%ecx) |
| lock xrelease btsw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btsw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btsw %ax,(%ecx) |
| xacquire lock cmpxchgw %ax,(%ecx) |
| lock xacquire cmpxchgw %ax,(%ecx) |
| xrelease lock cmpxchgw %ax,(%ecx) |
| lock xrelease cmpxchgw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; cmpxchgw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; cmpxchgw %ax,(%ecx) |
| xacquire lock xaddw %ax,(%ecx) |
| lock xacquire xaddw %ax,(%ecx) |
| xrelease lock xaddw %ax,(%ecx) |
| lock xrelease xaddw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xaddw %ax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xaddw %ax,(%ecx) |
| |
| # Tests for op regl regl/m32 |
| xacquire lock btcl %eax,(%ecx) |
| lock xacquire btcl %eax,(%ecx) |
| xrelease lock btcl %eax,(%ecx) |
| lock xrelease btcl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btcl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btcl %eax,(%ecx) |
| xacquire lock btrl %eax,(%ecx) |
| lock xacquire btrl %eax,(%ecx) |
| xrelease lock btrl %eax,(%ecx) |
| lock xrelease btrl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btrl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btrl %eax,(%ecx) |
| xacquire lock btsl %eax,(%ecx) |
| lock xacquire btsl %eax,(%ecx) |
| xrelease lock btsl %eax,(%ecx) |
| lock xrelease btsl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; btsl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; btsl %eax,(%ecx) |
| xacquire lock cmpxchgl %eax,(%ecx) |
| lock xacquire cmpxchgl %eax,(%ecx) |
| xrelease lock cmpxchgl %eax,(%ecx) |
| lock xrelease cmpxchgl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; cmpxchgl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; cmpxchgl %eax,(%ecx) |
| xacquire lock xaddl %eax,(%ecx) |
| lock xacquire xaddl %eax,(%ecx) |
| xrelease lock xaddl %eax,(%ecx) |
| lock xrelease xaddl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf2; xaddl %eax,(%ecx) |
| .byte 0xf0; .byte 0xf3; xaddl %eax,(%ecx) |
| |
| # Tests for op regb/m8 |
| xacquire lock decb (%ecx) |
| lock xacquire decb (%ecx) |
| xrelease lock decb (%ecx) |
| lock xrelease decb (%ecx) |
| .byte 0xf0; .byte 0xf2; decb (%ecx) |
| .byte 0xf0; .byte 0xf3; decb (%ecx) |
| xacquire lock incb (%ecx) |
| lock xacquire incb (%ecx) |
| xrelease lock incb (%ecx) |
| lock xrelease incb (%ecx) |
| .byte 0xf0; .byte 0xf2; incb (%ecx) |
| .byte 0xf0; .byte 0xf3; incb (%ecx) |
| xacquire lock negb (%ecx) |
| lock xacquire negb (%ecx) |
| xrelease lock negb (%ecx) |
| lock xrelease negb (%ecx) |
| .byte 0xf0; .byte 0xf2; negb (%ecx) |
| .byte 0xf0; .byte 0xf3; negb (%ecx) |
| xacquire lock notb (%ecx) |
| lock xacquire notb (%ecx) |
| xrelease lock notb (%ecx) |
| lock xrelease notb (%ecx) |
| .byte 0xf0; .byte 0xf2; notb (%ecx) |
| .byte 0xf0; .byte 0xf3; notb (%ecx) |
| |
| # Tests for op regs/m16 |
| xacquire lock decw (%ecx) |
| lock xacquire decw (%ecx) |
| xrelease lock decw (%ecx) |
| lock xrelease decw (%ecx) |
| .byte 0xf0; .byte 0xf2; decw (%ecx) |
| .byte 0xf0; .byte 0xf3; decw (%ecx) |
| xacquire lock incw (%ecx) |
| lock xacquire incw (%ecx) |
| xrelease lock incw (%ecx) |
| lock xrelease incw (%ecx) |
| .byte 0xf0; .byte 0xf2; incw (%ecx) |
| .byte 0xf0; .byte 0xf3; incw (%ecx) |
| xacquire lock negw (%ecx) |
| lock xacquire negw (%ecx) |
| xrelease lock negw (%ecx) |
| lock xrelease negw (%ecx) |
| .byte 0xf0; .byte 0xf2; negw (%ecx) |
| .byte 0xf0; .byte 0xf3; negw (%ecx) |
| xacquire lock notw (%ecx) |
| lock xacquire notw (%ecx) |
| xrelease lock notw (%ecx) |
| lock xrelease notw (%ecx) |
| .byte 0xf0; .byte 0xf2; notw (%ecx) |
| .byte 0xf0; .byte 0xf3; notw (%ecx) |
| |
| # Tests for op regl/m32 |
| xacquire lock decl (%ecx) |
| lock xacquire decl (%ecx) |
| xrelease lock decl (%ecx) |
| lock xrelease decl (%ecx) |
| .byte 0xf0; .byte 0xf2; decl (%ecx) |
| .byte 0xf0; .byte 0xf3; decl (%ecx) |
| xacquire lock incl (%ecx) |
| lock xacquire incl (%ecx) |
| xrelease lock incl (%ecx) |
| lock xrelease incl (%ecx) |
| .byte 0xf0; .byte 0xf2; incl (%ecx) |
| .byte 0xf0; .byte 0xf3; incl (%ecx) |
| xacquire lock negl (%ecx) |
| lock xacquire negl (%ecx) |
| xrelease lock negl (%ecx) |
| lock xrelease negl (%ecx) |
| .byte 0xf0; .byte 0xf2; negl (%ecx) |
| .byte 0xf0; .byte 0xf3; negl (%ecx) |
| xacquire lock notl (%ecx) |
| lock xacquire notl (%ecx) |
| xrelease lock notl (%ecx) |
| lock xrelease notl (%ecx) |
| .byte 0xf0; .byte 0xf2; notl (%ecx) |
| .byte 0xf0; .byte 0xf3; notl (%ecx) |
| |
| # Tests for op m64 |
| xacquire lock cmpxchg8bq (%ecx) |
| lock xacquire cmpxchg8bq (%ecx) |
| xrelease lock cmpxchg8bq (%ecx) |
| lock xrelease cmpxchg8bq (%ecx) |
| .byte 0xf0; .byte 0xf2; cmpxchg8bq (%ecx) |
| .byte 0xf0; .byte 0xf3; cmpxchg8bq (%ecx) |
| |
| # Tests for op regb, regb/m8 |
| xacquire lock cmpxchgb %cl,(%ecx) |
| lock xacquire cmpxchgb %cl,(%ecx) |
| xrelease lock cmpxchgb %cl,(%ecx) |
| lock xrelease cmpxchgb %cl,(%ecx) |
| .byte 0xf0; .byte 0xf2; cmpxchgb %cl,(%ecx) |
| .byte 0xf0; .byte 0xf3; cmpxchgb %cl,(%ecx) |
| xacquire lock xaddb %cl,(%ecx) |
| lock xacquire xaddb %cl,(%ecx) |
| xrelease lock xaddb %cl,(%ecx) |
| lock xrelease xaddb %cl,(%ecx) |
| .byte 0xf0; .byte 0xf2; xaddb %cl,(%ecx) |
| .byte 0xf0; .byte 0xf3; xaddb %cl,(%ecx) |
| |
| .intel_syntax noprefix |
| |
| # Tests for op imm8 regb/m8 |
| xacquire lock adc BYTE PTR [ecx],100 |
| lock xacquire adc BYTE PTR [ecx],100 |
| xrelease lock adc BYTE PTR [ecx],100 |
| lock xrelease adc BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; adc BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; adc BYTE PTR [ecx],100 |
| xacquire lock add BYTE PTR [ecx],100 |
| lock xacquire add BYTE PTR [ecx],100 |
| xrelease lock add BYTE PTR [ecx],100 |
| lock xrelease add BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; add BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; add BYTE PTR [ecx],100 |
| xacquire lock and BYTE PTR [ecx],100 |
| lock xacquire and BYTE PTR [ecx],100 |
| xrelease lock and BYTE PTR [ecx],100 |
| lock xrelease and BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; and BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; and BYTE PTR [ecx],100 |
| xrelease mov BYTE PTR [ecx],100 |
| xacquire lock or BYTE PTR [ecx],100 |
| lock xacquire or BYTE PTR [ecx],100 |
| xrelease lock or BYTE PTR [ecx],100 |
| lock xrelease or BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; or BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; or BYTE PTR [ecx],100 |
| xacquire lock sbb BYTE PTR [ecx],100 |
| lock xacquire sbb BYTE PTR [ecx],100 |
| xrelease lock sbb BYTE PTR [ecx],100 |
| lock xrelease sbb BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sbb BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sbb BYTE PTR [ecx],100 |
| xacquire lock sub BYTE PTR [ecx],100 |
| lock xacquire sub BYTE PTR [ecx],100 |
| xrelease lock sub BYTE PTR [ecx],100 |
| lock xrelease sub BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sub BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sub BYTE PTR [ecx],100 |
| xacquire lock xor BYTE PTR [ecx],100 |
| lock xacquire xor BYTE PTR [ecx],100 |
| xrelease lock xor BYTE PTR [ecx],100 |
| lock xrelease xor BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; xor BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; xor BYTE PTR [ecx],100 |
| |
| # Tests for op imm16 regs/m16 |
| xacquire lock adc WORD PTR [ecx],1000 |
| lock xacquire adc WORD PTR [ecx],1000 |
| xrelease lock adc WORD PTR [ecx],1000 |
| lock xrelease adc WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; adc WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; adc WORD PTR [ecx],1000 |
| xacquire lock add WORD PTR [ecx],1000 |
| lock xacquire add WORD PTR [ecx],1000 |
| xrelease lock add WORD PTR [ecx],1000 |
| lock xrelease add WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; add WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; add WORD PTR [ecx],1000 |
| xacquire lock and WORD PTR [ecx],1000 |
| lock xacquire and WORD PTR [ecx],1000 |
| xrelease lock and WORD PTR [ecx],1000 |
| lock xrelease and WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; and WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; and WORD PTR [ecx],1000 |
| xrelease mov WORD PTR [ecx],1000 |
| xacquire lock or WORD PTR [ecx],1000 |
| lock xacquire or WORD PTR [ecx],1000 |
| xrelease lock or WORD PTR [ecx],1000 |
| lock xrelease or WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; or WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; or WORD PTR [ecx],1000 |
| xacquire lock sbb WORD PTR [ecx],1000 |
| lock xacquire sbb WORD PTR [ecx],1000 |
| xrelease lock sbb WORD PTR [ecx],1000 |
| lock xrelease sbb WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; sbb WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; sbb WORD PTR [ecx],1000 |
| xacquire lock sub WORD PTR [ecx],1000 |
| lock xacquire sub WORD PTR [ecx],1000 |
| xrelease lock sub WORD PTR [ecx],1000 |
| lock xrelease sub WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; sub WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; sub WORD PTR [ecx],1000 |
| xacquire lock xor WORD PTR [ecx],1000 |
| lock xacquire xor WORD PTR [ecx],1000 |
| xrelease lock xor WORD PTR [ecx],1000 |
| lock xrelease xor WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf2; xor WORD PTR [ecx],1000 |
| .byte 0xf0; .byte 0xf3; xor WORD PTR [ecx],1000 |
| |
| # Tests for op imm32 regl/m32 |
| xacquire lock adc DWORD PTR [ecx],10000000 |
| lock xacquire adc DWORD PTR [ecx],10000000 |
| xrelease lock adc DWORD PTR [ecx],10000000 |
| lock xrelease adc DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; adc DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; adc DWORD PTR [ecx],10000000 |
| xacquire lock add DWORD PTR [ecx],10000000 |
| lock xacquire add DWORD PTR [ecx],10000000 |
| xrelease lock add DWORD PTR [ecx],10000000 |
| lock xrelease add DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; add DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; add DWORD PTR [ecx],10000000 |
| xacquire lock and DWORD PTR [ecx],10000000 |
| lock xacquire and DWORD PTR [ecx],10000000 |
| xrelease lock and DWORD PTR [ecx],10000000 |
| lock xrelease and DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; and DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; and DWORD PTR [ecx],10000000 |
| xrelease mov DWORD PTR [ecx],10000000 |
| xacquire lock or DWORD PTR [ecx],10000000 |
| lock xacquire or DWORD PTR [ecx],10000000 |
| xrelease lock or DWORD PTR [ecx],10000000 |
| lock xrelease or DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; or DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; or DWORD PTR [ecx],10000000 |
| xacquire lock sbb DWORD PTR [ecx],10000000 |
| lock xacquire sbb DWORD PTR [ecx],10000000 |
| xrelease lock sbb DWORD PTR [ecx],10000000 |
| lock xrelease sbb DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; sbb DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; sbb DWORD PTR [ecx],10000000 |
| xacquire lock sub DWORD PTR [ecx],10000000 |
| lock xacquire sub DWORD PTR [ecx],10000000 |
| xrelease lock sub DWORD PTR [ecx],10000000 |
| lock xrelease sub DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; sub DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; sub DWORD PTR [ecx],10000000 |
| xacquire lock xor DWORD PTR [ecx],10000000 |
| lock xacquire xor DWORD PTR [ecx],10000000 |
| xrelease lock xor DWORD PTR [ecx],10000000 |
| lock xrelease xor DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf2; xor DWORD PTR [ecx],10000000 |
| .byte 0xf0; .byte 0xf3; xor DWORD PTR [ecx],10000000 |
| |
| # Tests for op imm8 regs/m16 |
| xacquire lock adc WORD PTR [ecx],100 |
| lock xacquire adc WORD PTR [ecx],100 |
| xrelease lock adc WORD PTR [ecx],100 |
| lock xrelease adc WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; adc WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; adc WORD PTR [ecx],100 |
| xacquire lock add WORD PTR [ecx],100 |
| lock xacquire add WORD PTR [ecx],100 |
| xrelease lock add WORD PTR [ecx],100 |
| lock xrelease add WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; add WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; add WORD PTR [ecx],100 |
| xacquire lock and WORD PTR [ecx],100 |
| lock xacquire and WORD PTR [ecx],100 |
| xrelease lock and WORD PTR [ecx],100 |
| lock xrelease and WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; and WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; and WORD PTR [ecx],100 |
| xacquire lock btc WORD PTR [ecx],100 |
| lock xacquire btc WORD PTR [ecx],100 |
| xrelease lock btc WORD PTR [ecx],100 |
| lock xrelease btc WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; btc WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; btc WORD PTR [ecx],100 |
| xacquire lock btr WORD PTR [ecx],100 |
| lock xacquire btr WORD PTR [ecx],100 |
| xrelease lock btr WORD PTR [ecx],100 |
| lock xrelease btr WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; btr WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; btr WORD PTR [ecx],100 |
| xacquire lock bts WORD PTR [ecx],100 |
| lock xacquire bts WORD PTR [ecx],100 |
| xrelease lock bts WORD PTR [ecx],100 |
| lock xrelease bts WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; bts WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; bts WORD PTR [ecx],100 |
| xrelease mov WORD PTR [ecx],100 |
| xacquire lock or WORD PTR [ecx],100 |
| lock xacquire or WORD PTR [ecx],100 |
| xrelease lock or WORD PTR [ecx],100 |
| lock xrelease or WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; or WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; or WORD PTR [ecx],100 |
| xacquire lock sbb WORD PTR [ecx],100 |
| lock xacquire sbb WORD PTR [ecx],100 |
| xrelease lock sbb WORD PTR [ecx],100 |
| lock xrelease sbb WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sbb WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sbb WORD PTR [ecx],100 |
| xacquire lock sub WORD PTR [ecx],100 |
| lock xacquire sub WORD PTR [ecx],100 |
| xrelease lock sub WORD PTR [ecx],100 |
| lock xrelease sub WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sub WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sub WORD PTR [ecx],100 |
| xacquire lock xor WORD PTR [ecx],100 |
| lock xacquire xor WORD PTR [ecx],100 |
| xrelease lock xor WORD PTR [ecx],100 |
| lock xrelease xor WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; xor WORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; xor WORD PTR [ecx],100 |
| |
| # Tests for op imm8 regl/m32 |
| xacquire lock adc DWORD PTR [ecx],100 |
| lock xacquire adc DWORD PTR [ecx],100 |
| xrelease lock adc DWORD PTR [ecx],100 |
| lock xrelease adc DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; adc DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; adc DWORD PTR [ecx],100 |
| xacquire lock add DWORD PTR [ecx],100 |
| lock xacquire add DWORD PTR [ecx],100 |
| xrelease lock add DWORD PTR [ecx],100 |
| lock xrelease add DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; add DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; add DWORD PTR [ecx],100 |
| xacquire lock and DWORD PTR [ecx],100 |
| lock xacquire and DWORD PTR [ecx],100 |
| xrelease lock and DWORD PTR [ecx],100 |
| lock xrelease and DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; and DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; and DWORD PTR [ecx],100 |
| xacquire lock btc DWORD PTR [ecx],100 |
| lock xacquire btc DWORD PTR [ecx],100 |
| xrelease lock btc DWORD PTR [ecx],100 |
| lock xrelease btc DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; btc DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; btc DWORD PTR [ecx],100 |
| xacquire lock btr DWORD PTR [ecx],100 |
| lock xacquire btr DWORD PTR [ecx],100 |
| xrelease lock btr DWORD PTR [ecx],100 |
| lock xrelease btr DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; btr DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; btr DWORD PTR [ecx],100 |
| xacquire lock bts DWORD PTR [ecx],100 |
| lock xacquire bts DWORD PTR [ecx],100 |
| xrelease lock bts DWORD PTR [ecx],100 |
| lock xrelease bts DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; bts DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; bts DWORD PTR [ecx],100 |
| xrelease mov DWORD PTR [ecx],100 |
| xacquire lock or DWORD PTR [ecx],100 |
| lock xacquire or DWORD PTR [ecx],100 |
| xrelease lock or DWORD PTR [ecx],100 |
| lock xrelease or DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; or DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; or DWORD PTR [ecx],100 |
| xacquire lock sbb DWORD PTR [ecx],100 |
| lock xacquire sbb DWORD PTR [ecx],100 |
| xrelease lock sbb DWORD PTR [ecx],100 |
| lock xrelease sbb DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sbb DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sbb DWORD PTR [ecx],100 |
| xacquire lock sub DWORD PTR [ecx],100 |
| lock xacquire sub DWORD PTR [ecx],100 |
| xrelease lock sub DWORD PTR [ecx],100 |
| lock xrelease sub DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sub DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sub DWORD PTR [ecx],100 |
| xacquire lock xor DWORD PTR [ecx],100 |
| lock xacquire xor DWORD PTR [ecx],100 |
| xrelease lock xor DWORD PTR [ecx],100 |
| lock xrelease xor DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; xor DWORD PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; xor DWORD PTR [ecx],100 |
| |
| # Tests for op imm8 regb/m8 |
| xacquire lock adc BYTE PTR [ecx],100 |
| lock xacquire adc BYTE PTR [ecx],100 |
| xrelease lock adc BYTE PTR [ecx],100 |
| lock xrelease adc BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; adc BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; adc BYTE PTR [ecx],100 |
| xacquire lock add BYTE PTR [ecx],100 |
| lock xacquire add BYTE PTR [ecx],100 |
| xrelease lock add BYTE PTR [ecx],100 |
| lock xrelease add BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; add BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; add BYTE PTR [ecx],100 |
| xacquire lock and BYTE PTR [ecx],100 |
| lock xacquire and BYTE PTR [ecx],100 |
| xrelease lock and BYTE PTR [ecx],100 |
| lock xrelease and BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; and BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; and BYTE PTR [ecx],100 |
| xrelease mov BYTE PTR [ecx],100 |
| xacquire lock or BYTE PTR [ecx],100 |
| lock xacquire or BYTE PTR [ecx],100 |
| xrelease lock or BYTE PTR [ecx],100 |
| lock xrelease or BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; or BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; or BYTE PTR [ecx],100 |
| xacquire lock sbb BYTE PTR [ecx],100 |
| lock xacquire sbb BYTE PTR [ecx],100 |
| xrelease lock sbb BYTE PTR [ecx],100 |
| lock xrelease sbb BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sbb BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sbb BYTE PTR [ecx],100 |
| xacquire lock sub BYTE PTR [ecx],100 |
| lock xacquire sub BYTE PTR [ecx],100 |
| xrelease lock sub BYTE PTR [ecx],100 |
| lock xrelease sub BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; sub BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; sub BYTE PTR [ecx],100 |
| xacquire lock xor BYTE PTR [ecx],100 |
| lock xacquire xor BYTE PTR [ecx],100 |
| xrelease lock xor BYTE PTR [ecx],100 |
| lock xrelease xor BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf2; xor BYTE PTR [ecx],100 |
| .byte 0xf0; .byte 0xf3; xor BYTE PTR [ecx],100 |
| |
| # Tests for op regb regb/m8 |
| # Tests for op regb/m8 regb |
| xacquire lock adc BYTE PTR [ecx],al |
| lock xacquire adc BYTE PTR [ecx],al |
| xrelease lock adc BYTE PTR [ecx],al |
| lock xrelease adc BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; adc BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; adc BYTE PTR [ecx],al |
| xacquire lock add BYTE PTR [ecx],al |
| lock xacquire add BYTE PTR [ecx],al |
| xrelease lock add BYTE PTR [ecx],al |
| lock xrelease add BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; add BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; add BYTE PTR [ecx],al |
| xacquire lock and BYTE PTR [ecx],al |
| lock xacquire and BYTE PTR [ecx],al |
| xrelease lock and BYTE PTR [ecx],al |
| lock xrelease and BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; and BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; and BYTE PTR [ecx],al |
| xrelease mov BYTE PTR [ecx],al |
| xacquire lock or BYTE PTR [ecx],al |
| lock xacquire or BYTE PTR [ecx],al |
| xrelease lock or BYTE PTR [ecx],al |
| lock xrelease or BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; or BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; or BYTE PTR [ecx],al |
| xacquire lock sbb BYTE PTR [ecx],al |
| lock xacquire sbb BYTE PTR [ecx],al |
| xrelease lock sbb BYTE PTR [ecx],al |
| lock xrelease sbb BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; sbb BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; sbb BYTE PTR [ecx],al |
| xacquire lock sub BYTE PTR [ecx],al |
| lock xacquire sub BYTE PTR [ecx],al |
| xrelease lock sub BYTE PTR [ecx],al |
| lock xrelease sub BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; sub BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; sub BYTE PTR [ecx],al |
| xacquire lock xchg BYTE PTR [ecx],al |
| lock xacquire xchg BYTE PTR [ecx],al |
| xacquire xchg BYTE PTR [ecx],al |
| xrelease lock xchg BYTE PTR [ecx],al |
| lock xrelease xchg BYTE PTR [ecx],al |
| xrelease xchg BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; xchg BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; xchg BYTE PTR [ecx],al |
| xacquire lock xor BYTE PTR [ecx],al |
| lock xacquire xor BYTE PTR [ecx],al |
| xrelease lock xor BYTE PTR [ecx],al |
| lock xrelease xor BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf2; xor BYTE PTR [ecx],al |
| .byte 0xf0; .byte 0xf3; xor BYTE PTR [ecx],al |
| |
| # Tests for op regs regs/m16 |
| # Tests for op regs/m16 regs |
| xacquire lock adc WORD PTR [ecx],ax |
| lock xacquire adc WORD PTR [ecx],ax |
| xrelease lock adc WORD PTR [ecx],ax |
| lock xrelease adc WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; adc WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; adc WORD PTR [ecx],ax |
| xacquire lock add WORD PTR [ecx],ax |
| lock xacquire add WORD PTR [ecx],ax |
| xrelease lock add WORD PTR [ecx],ax |
| lock xrelease add WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; add WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; add WORD PTR [ecx],ax |
| xacquire lock and WORD PTR [ecx],ax |
| lock xacquire and WORD PTR [ecx],ax |
| xrelease lock and WORD PTR [ecx],ax |
| lock xrelease and WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; and WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; and WORD PTR [ecx],ax |
| xrelease mov WORD PTR [ecx],ax |
| xacquire lock or WORD PTR [ecx],ax |
| lock xacquire or WORD PTR [ecx],ax |
| xrelease lock or WORD PTR [ecx],ax |
| lock xrelease or WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; or WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; or WORD PTR [ecx],ax |
| xacquire lock sbb WORD PTR [ecx],ax |
| lock xacquire sbb WORD PTR [ecx],ax |
| xrelease lock sbb WORD PTR [ecx],ax |
| lock xrelease sbb WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; sbb WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; sbb WORD PTR [ecx],ax |
| xacquire lock sub WORD PTR [ecx],ax |
| lock xacquire sub WORD PTR [ecx],ax |
| xrelease lock sub WORD PTR [ecx],ax |
| lock xrelease sub WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; sub WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; sub WORD PTR [ecx],ax |
| xacquire lock xchg WORD PTR [ecx],ax |
| lock xacquire xchg WORD PTR [ecx],ax |
| xacquire xchg WORD PTR [ecx],ax |
| xrelease lock xchg WORD PTR [ecx],ax |
| lock xrelease xchg WORD PTR [ecx],ax |
| xrelease xchg WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; xchg WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; xchg WORD PTR [ecx],ax |
| xacquire lock xor WORD PTR [ecx],ax |
| lock xacquire xor WORD PTR [ecx],ax |
| xrelease lock xor WORD PTR [ecx],ax |
| lock xrelease xor WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; xor WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; xor WORD PTR [ecx],ax |
| |
| # Tests for op regl regl/m32 |
| # Tests for op regl/m32 regl |
| xacquire lock adc DWORD PTR [ecx],eax |
| lock xacquire adc DWORD PTR [ecx],eax |
| xrelease lock adc DWORD PTR [ecx],eax |
| lock xrelease adc DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; adc DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; adc DWORD PTR [ecx],eax |
| xacquire lock add DWORD PTR [ecx],eax |
| lock xacquire add DWORD PTR [ecx],eax |
| xrelease lock add DWORD PTR [ecx],eax |
| lock xrelease add DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; add DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; add DWORD PTR [ecx],eax |
| xacquire lock and DWORD PTR [ecx],eax |
| lock xacquire and DWORD PTR [ecx],eax |
| xrelease lock and DWORD PTR [ecx],eax |
| lock xrelease and DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; and DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; and DWORD PTR [ecx],eax |
| xrelease mov DWORD PTR [ecx],eax |
| xacquire lock or DWORD PTR [ecx],eax |
| lock xacquire or DWORD PTR [ecx],eax |
| xrelease lock or DWORD PTR [ecx],eax |
| lock xrelease or DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; or DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; or DWORD PTR [ecx],eax |
| xacquire lock sbb DWORD PTR [ecx],eax |
| lock xacquire sbb DWORD PTR [ecx],eax |
| xrelease lock sbb DWORD PTR [ecx],eax |
| lock xrelease sbb DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; sbb DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; sbb DWORD PTR [ecx],eax |
| xacquire lock sub DWORD PTR [ecx],eax |
| lock xacquire sub DWORD PTR [ecx],eax |
| xrelease lock sub DWORD PTR [ecx],eax |
| lock xrelease sub DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; sub DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; sub DWORD PTR [ecx],eax |
| xacquire lock xchg DWORD PTR [ecx],eax |
| lock xacquire xchg DWORD PTR [ecx],eax |
| xacquire xchg DWORD PTR [ecx],eax |
| xrelease lock xchg DWORD PTR [ecx],eax |
| lock xrelease xchg DWORD PTR [ecx],eax |
| xrelease xchg DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; xchg DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; xchg DWORD PTR [ecx],eax |
| xacquire lock xor DWORD PTR [ecx],eax |
| lock xacquire xor DWORD PTR [ecx],eax |
| xrelease lock xor DWORD PTR [ecx],eax |
| lock xrelease xor DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; xor DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; xor DWORD PTR [ecx],eax |
| |
| # Tests for op regs, regs/m16 |
| xacquire lock btc WORD PTR [ecx],ax |
| lock xacquire btc WORD PTR [ecx],ax |
| xrelease lock btc WORD PTR [ecx],ax |
| lock xrelease btc WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; btc WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; btc WORD PTR [ecx],ax |
| xacquire lock btr WORD PTR [ecx],ax |
| lock xacquire btr WORD PTR [ecx],ax |
| xrelease lock btr WORD PTR [ecx],ax |
| lock xrelease btr WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; btr WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; btr WORD PTR [ecx],ax |
| xacquire lock bts WORD PTR [ecx],ax |
| lock xacquire bts WORD PTR [ecx],ax |
| xrelease lock bts WORD PTR [ecx],ax |
| lock xrelease bts WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; bts WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; bts WORD PTR [ecx],ax |
| xacquire lock cmpxchg WORD PTR [ecx],ax |
| lock xacquire cmpxchg WORD PTR [ecx],ax |
| xrelease lock cmpxchg WORD PTR [ecx],ax |
| lock xrelease cmpxchg WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; cmpxchg WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; cmpxchg WORD PTR [ecx],ax |
| xacquire lock xadd WORD PTR [ecx],ax |
| lock xacquire xadd WORD PTR [ecx],ax |
| xrelease lock xadd WORD PTR [ecx],ax |
| lock xrelease xadd WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf2; xadd WORD PTR [ecx],ax |
| .byte 0xf0; .byte 0xf3; xadd WORD PTR [ecx],ax |
| |
| # Tests for op regl regl/m32 |
| xacquire lock btc DWORD PTR [ecx],eax |
| lock xacquire btc DWORD PTR [ecx],eax |
| xrelease lock btc DWORD PTR [ecx],eax |
| lock xrelease btc DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; btc DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; btc DWORD PTR [ecx],eax |
| xacquire lock btr DWORD PTR [ecx],eax |
| lock xacquire btr DWORD PTR [ecx],eax |
| xrelease lock btr DWORD PTR [ecx],eax |
| lock xrelease btr DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; btr DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; btr DWORD PTR [ecx],eax |
| xacquire lock bts DWORD PTR [ecx],eax |
| lock xacquire bts DWORD PTR [ecx],eax |
| xrelease lock bts DWORD PTR [ecx],eax |
| lock xrelease bts DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; bts DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; bts DWORD PTR [ecx],eax |
| xacquire lock cmpxchg DWORD PTR [ecx],eax |
| lock xacquire cmpxchg DWORD PTR [ecx],eax |
| xrelease lock cmpxchg DWORD PTR [ecx],eax |
| lock xrelease cmpxchg DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; cmpxchg DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; cmpxchg DWORD PTR [ecx],eax |
| xacquire lock xadd DWORD PTR [ecx],eax |
| lock xacquire xadd DWORD PTR [ecx],eax |
| xrelease lock xadd DWORD PTR [ecx],eax |
| lock xrelease xadd DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf2; xadd DWORD PTR [ecx],eax |
| .byte 0xf0; .byte 0xf3; xadd DWORD PTR [ecx],eax |
| |
| # Tests for op regb/m8 |
| xacquire lock dec BYTE PTR [ecx] |
| lock xacquire dec BYTE PTR [ecx] |
| xrelease lock dec BYTE PTR [ecx] |
| lock xrelease dec BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf2; dec BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf3; dec BYTE PTR [ecx] |
| xacquire lock inc BYTE PTR [ecx] |
| lock xacquire inc BYTE PTR [ecx] |
| xrelease lock inc BYTE PTR [ecx] |
| lock xrelease inc BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf2; inc BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf3; inc BYTE PTR [ecx] |
| xacquire lock neg BYTE PTR [ecx] |
| lock xacquire neg BYTE PTR [ecx] |
| xrelease lock neg BYTE PTR [ecx] |
| lock xrelease neg BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf2; neg BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf3; neg BYTE PTR [ecx] |
| xacquire lock not BYTE PTR [ecx] |
| lock xacquire not BYTE PTR [ecx] |
| xrelease lock not BYTE PTR [ecx] |
| lock xrelease not BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf2; not BYTE PTR [ecx] |
| .byte 0xf0; .byte 0xf3; not BYTE PTR [ecx] |
| |
| # Tests for op regs/m16 |
| xacquire lock dec WORD PTR [ecx] |
| lock xacquire dec WORD PTR [ecx] |
| xrelease lock dec WORD PTR [ecx] |
| lock xrelease dec WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; dec WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; dec WORD PTR [ecx] |
| xacquire lock inc WORD PTR [ecx] |
| lock xacquire inc WORD PTR [ecx] |
| xrelease lock inc WORD PTR [ecx] |
| lock xrelease inc WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; inc WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; inc WORD PTR [ecx] |
| xacquire lock neg WORD PTR [ecx] |
| lock xacquire neg WORD PTR [ecx] |
| xrelease lock neg WORD PTR [ecx] |
| lock xrelease neg WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; neg WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; neg WORD PTR [ecx] |
| xacquire lock not WORD PTR [ecx] |
| lock xacquire not WORD PTR [ecx] |
| xrelease lock not WORD PTR [ecx] |
| lock xrelease not WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; not WORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; not WORD PTR [ecx] |
| |
| # Tests for op regl/m32 |
| xacquire lock dec DWORD PTR [ecx] |
| lock xacquire dec DWORD PTR [ecx] |
| xrelease lock dec DWORD PTR [ecx] |
| lock xrelease dec DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; dec DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; dec DWORD PTR [ecx] |
| xacquire lock inc DWORD PTR [ecx] |
| lock xacquire inc DWORD PTR [ecx] |
| xrelease lock inc DWORD PTR [ecx] |
| lock xrelease inc DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; inc DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; inc DWORD PTR [ecx] |
| xacquire lock neg DWORD PTR [ecx] |
| lock xacquire neg DWORD PTR [ecx] |
| xrelease lock neg DWORD PTR [ecx] |
| lock xrelease neg DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; neg DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; neg DWORD PTR [ecx] |
| xacquire lock not DWORD PTR [ecx] |
| lock xacquire not DWORD PTR [ecx] |
| xrelease lock not DWORD PTR [ecx] |
| lock xrelease not DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; not DWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; not DWORD PTR [ecx] |
| |
| # Tests for op m64 |
| xacquire lock cmpxchg8b QWORD PTR [ecx] |
| lock xacquire cmpxchg8b QWORD PTR [ecx] |
| xrelease lock cmpxchg8b QWORD PTR [ecx] |
| lock xrelease cmpxchg8b QWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf2; cmpxchg8b QWORD PTR [ecx] |
| .byte 0xf0; .byte 0xf3; cmpxchg8b QWORD PTR [ecx] |
| |
| # Tests for op regb, regb/m8 |
| xacquire lock cmpxchg BYTE PTR [ecx],cl |
| lock xacquire cmpxchg BYTE PTR [ecx],cl |
| xrelease lock cmpxchg BYTE PTR [ecx],cl |
| lock xrelease cmpxchg BYTE PTR [ecx],cl |
| .byte 0xf0; .byte 0xf2; cmpxchg BYTE PTR [ecx],cl |
| .byte 0xf0; .byte 0xf3; cmpxchg BYTE PTR [ecx],cl |
| xacquire lock xadd BYTE PTR [ecx],cl |
| lock xacquire xadd BYTE PTR [ecx],cl |
| xrelease lock xadd BYTE PTR [ecx],cl |
| lock xrelease xadd BYTE PTR [ecx],cl |
| .byte 0xf0; .byte 0xf2; xadd BYTE PTR [ecx],cl |
| .byte 0xf0; .byte 0xf3; xadd BYTE PTR [ecx],cl |
