diff options
| author | Anas Nashif <anas.nashif@intel.com> | 2012-05-15 22:27:48 +0100 |
|---|---|---|
| committer | Anas Nashif <anas.nashif@intel.com> | 2012-05-15 22:27:48 +0100 |
| commit | b9fad1ab2ad3bd87bff05c4688c978d582ada438 (patch) | |
| tree | 4a373f8dd867d20e67510de7cfe447a4b58c1a70 /test | |
| parent | 65c26d26fb72cec0d43d199c72ed27513d17f4c9 (diff) | |
| download | nasm-b9fad1ab2ad3bd87bff05c4688c978d582ada438.tar.gz nasm-b9fad1ab2ad3bd87bff05c4688c978d582ada438.tar.bz2 nasm-b9fad1ab2ad3bd87bff05c4688c978d582ada438.zip | |
Upstream version 2.08rc7
Diffstat (limited to 'test')
116 files changed, 15264 insertions, 0 deletions
diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..8b51359 --- /dev/null +++ b/test/Makefile @@ -0,0 +1,91 @@ +.SUFFIXES: .bin .o .o64 .obj .obj64 .exe .asm .lst .pl + +NASM = ../nasm +NASMOPT = -Ox -I../misc $(OPT) +PERL = perl +TESTS = $(wildcard *.asm) + +%.bin: %.asm $(NASM) + $(NASM) $(NASMOPT) -f bin -o $@ -l $*.lst $< + +%.ith: %.asm $(NASM) + $(NASM) $(NASMOPT) -f ith -o $@ -l $*.lst $< + +%.srec: %.asm $(NASM) + $(NASM) $(NASMOPT) -f srec -o $@ -l $*.lst $< + +%.o: %.asm $(NASM) + $(NASM) $(NASMOPT) -f elf32 -o $@ -l $*.lst $< + +%.o64: %.asm $(NASM) + $(NASM) $(NASMOPT) -f elf64 -o $@ -l $*.lst $< + +%.obj: %.asm $(NASM) + $(NASM) $(NASMOPT) -f obj -o $@ -l $*.lst $< + +%.coff: %.asm $(NASM) + $(NASM) $(NASMOPT) -f coff -o $@ -l $*.lst $< + +%.win32: %.asm $(NASM) + $(NASM) $(NASMOPT) -f win32 -o $@ -l $*.lst $< + +%.win64: %.asm $(NASM) + $(NASM) $(NASMOPT) -f win64 -o $@ -l $*.lst $< + +%.mo32: %.asm $(NASM) + $(NASM) $(NASMOPT) -f macho32 -o $@ -l $*.lst $< + +%.mo64: %.asm $(NASM) + $(NASM) $(NASMOPT) -f macho64 -o $@ -l $*.lst $< + +%.dbg: %.asm $(NASM) + $(NASM) $(NASMOPT) -f dbg -o $@ -l $*.lst $< + +%.asm: %.pl + $(PERL) $< > $@ + +all: + +golden: performtest.pl $(TESTS) + $(PERL) performtest.pl --golden --nasm='$(NASM)' $(TESTS) + +test: performtest.pl $(NASM) $(TESTS) + $(PERL) performtest.pl --nasm='$(NASM)' $(TESTS) + +diff: performtest.pl $(NASM) $(TESTS) + $(PERL) performtest.pl --diff --nasm='$(NASM)' $(TESTS) + +clean: + rm -f *.com *.o *.o64 *.obj *.win32 *.win64 *.exe *.lst *.bin + rm -f *.dbg *.coff *.ith *.srec *.mo32 *.mo64 + rm -rf testresults + rm -f elftest elftest64 + +spotless: clean + rm -rf golden + +# +# Test for ELF32 shared libraries; assumes an x86 Linux system +# +elfso.o: elfso.asm $(NASM) + $(NASM) $(NASMOPT) -f elf32 -F stabs -o $@ -l $*.lst $< + +elfso.so: elfso.o + $(LD) -m elf_i386 -shared -o $@ $< + +elftest: elftest.c elfso.so + $(CC) -g -m32 -o $@ $^ + -env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH ./elftest + +# +# Test for ELF64 shared libraries; assumes an x86-64 Linux system +# +elf64so.o: elf64so.asm $(NASM) + $(NASM) $(NASMOPT) -f elf64 -F dwarf -o $@ -l $*.lst $< + +elf64so.so: elf64so.o + $(LD) -shared -o $@ $< + +elftest64: elftest64.c elf64so.so + $(CC) -g -o $@ $^ + -env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH ./elftest64 diff --git a/test/_file_.asm b/test/_file_.asm new file mode 100644 index 0000000..f633feb --- /dev/null +++ b/test/_file_.asm @@ -0,0 +1,5 @@ +;Testname=bin; Arguments=-fbin -o_file_.bin; Files=stdout stderr _file_.bin + db __FILE__, `\r\n` + db __FILE__, `\r\n` + dw __LINE__ + dw __LINE__ diff --git a/test/_version.asm b/test/_version.asm new file mode 100644 index 0000000..d20a74d --- /dev/null +++ b/test/_version.asm @@ -0,0 +1,2 @@ +;Testname=version; Arguments=-v; Files=stdout +;Dummy test to record version numbers diff --git a/test/a32offs.asm b/test/a32offs.asm new file mode 100644 index 0000000..4d17e0e --- /dev/null +++ b/test/a32offs.asm @@ -0,0 +1,9 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -oa32offs.bin; Files=a32offs.bin stdout stderr +;Testname=optimized; Arguments=-Ox -fbin -oa32offs.bin; Files=a32offs.bin stdout stderr + bits 16 +foo: a32 loop foo +bar: loop bar, ecx + + bits 32 +baz: a16 loop baz +qux: loop qux, cx diff --git a/test/absolute.asm b/test/absolute.asm new file mode 100644 index 0000000..31c8178 --- /dev/null +++ b/test/absolute.asm @@ -0,0 +1,40 @@ +;Testname=bin; Arguments=-fbin -oabsolute.bin; Files=stdout stderr absolute.bin + org 7c00h +init_foo: + jmp init_bar + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + +init_bar: + mov [b1],dl + mov [b2],edx + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + nop + ret + + absolute init_bar+7 +b1: resb 1 +b2: resd 6 + diff --git a/test/addr64x.asm b/test/addr64x.asm new file mode 100644 index 0000000..c7a64f5 --- /dev/null +++ b/test/addr64x.asm @@ -0,0 +1,18 @@ +;Testname=O0; Arguments=-O0 -fbin -oaddr64.bin; Files=stdout stderr addr64.bin +;Testname=O1; Arguments=-O1 -fbin -oaddr64.bin; Files=stdout stderr addr64.bin +;Testname=Ox; Arguments=-Ox -fbin -oaddr64.bin; Files=stdout stderr addr64.bin + bits 64 + mov rdx,[rax] + mov eax,[byte rsp+0x01] + mov eax,[byte rsp-0x01] + mov eax,[byte rsp+0xFF] + mov eax,[byte rsp-0xFF] + mov eax,[rsp+0x08] + mov eax,[rsp-0x01] + mov eax,[rsp+0xFF] + mov eax,[rsp-0xFF] + mov rax,[rsp+56] + mov [rsi],dl + mov byte [rsi],'-' + mov [rsi],al + mov byte [rsi],' ' diff --git a/test/align13.asm b/test/align13.asm new file mode 100644 index 0000000..556373f --- /dev/null +++ b/test/align13.asm @@ -0,0 +1,16 @@ +; Test of non-power-of-2 alignment + + bits 32 + + inc eax + inc eax + align 13 + inc eax + inc eax + align 13 + inc eax + inc eax + align 13 + align 13 ;should do nothing + inc eax + inc eax diff --git a/test/align13s.asm b/test/align13s.asm new file mode 100644 index 0000000..dab21a2 --- /dev/null +++ b/test/align13s.asm @@ -0,0 +1,16 @@ +; Test of non-power-of-2 alignment +%use smartalign + + bits 32 + + inc eax + inc eax + align 13 + inc eax + inc eax + align 13 + inc eax + inc eax + align 13 + inc eax + inc eax diff --git a/test/alonesym-obj.asm b/test/alonesym-obj.asm new file mode 100644 index 0000000..6be4d5d --- /dev/null +++ b/test/alonesym-obj.asm @@ -0,0 +1,163 @@ +section DOS32DATA align=16 public use32 FLAT class=DOS32DATA + + global sym0000 + global sym0001 + global sym0002 + global sym0003 + global sym0004 + global sym0005 + global sym0006 + global sym0007 + global sym0008 + global sym0009 + global sym0010 + global sym0011 + global sym0012 + global sym0013 + global sym0014 + global sym0015 + global sym0016 + global sym0017 + global sym0018 + global sym0019 + global sym0020 + global sym0021 + global sym0022 + global sym0023 + global sym0024 + global sym0025 + global sym0026 + global sym0027 + global sym0028 + global sym0029 + global sym0030 + global sym0031 + global sym0032 + global sym0033 + global sym0034 + global sym0035 + global sym0036 + global sym0037 + global sym0038 + global sym0039 + global sym0040 + global sym0041 + global sym0042 + global sym0043 + global sym0044 + global sym0045 + global sym0046 + global sym0047 + global sym0048 + global sym0049 + global sym0050 + global sym0051 + global sym0052 + global sym0053 + global sym0054 + global sym0055 + global sym0056 + global sym0057 + global sym0058 + global sym0059 + global sym0060 + global sym0061 + global sym0062 + global sym0063 + global sym0064 + global sym0065 + global sym0066 + global sym0067 + global sym0068 + global sym0069 + global sym0070 + global sym0071 + global sym0072 + global sym0073 + global sym0074 + global sym0075 + global sym0076 + global sym0077 + global s + + + resb 20000h +sym0000 resd 1 +sym0001 resd 1 +sym0002 resd 1 +sym0003 resd 1 +sym0004 resd 1 +sym0005 resd 1 +sym0006 resd 1 +sym0007 resd 1 +sym0008 resd 1 +sym0009 resd 1 +sym0010 resd 1 +sym0011 resd 1 +sym0012 resd 1 +sym0013 resd 1 +sym0014 resd 1 +sym0015 resd 1 +sym0016 resd 1 +sym0017 resd 1 +sym0018 resd 1 +sym0019 resd 1 +sym0020 resd 1 +sym0021 resd 1 +sym0022 resd 1 +sym0023 resd 1 +sym0024 resd 1 +sym0025 resd 1 +sym0026 resd 1 +sym0027 resd 1 +sym0028 resd 1 +sym0029 resd 1 +sym0030 resd 1 +sym0031 resd 1 +sym0032 resd 1 +sym0033 resd 1 +sym0034 resd 1 +sym0035 resd 1 +sym0036 resd 1 +sym0037 resd 1 +sym0038 resd 1 +sym0039 resd 1 +sym0040 resd 1 +sym0041 resd 1 +sym0042 resd 1 +sym0043 resd 1 +sym0044 resd 1 +sym0045 resd 1 +sym0046 resd 1 +sym0047 resd 1 +sym0048 resd 1 +sym0049 resd 1 +sym0050 resd 1 +sym0051 resd 1 +sym0052 resd 1 +sym0053 resd 1 +sym0054 resd 1 +sym0055 resd 1 +sym0056 resd 1 +sym0057 resd 1 +sym0058 resd 1 +sym0059 resd 1 +sym0060 resd 1 +sym0061 resd 1 +sym0062 resd 1 +sym0063 resd 1 +sym0064 resd 1 +sym0065 resd 1 +sym0066 resd 1 +sym0067 resd 1 +sym0068 resd 1 +sym0069 resd 1 +sym0070 resd 1 +sym0071 resd 1 +sym0072 resd 1 +sym0073 resd 1 +sym0074 resd 1 +sym0075 resd 1 +sym0076 resd 1 +sym0077 resd 1 +s resd 1 diff --git a/test/andbyte.asm b/test/andbyte.asm new file mode 100644 index 0000000..3d3b1c1 --- /dev/null +++ b/test/andbyte.asm @@ -0,0 +1,15 @@ +;Testname=test; Arguments=-fbin -oandbyte.bin; Files=stdout stderr andbyte.bin +;Testname=otest; Arguments=-Ox -fbin -oandbyte.bin; Files=stdout stderr andbyte.bin + + bits 16 + + add sp, byte -0x10 + add sp, -0x10 + adc sp, byte -0x10 + adc sp, -0x10 + and sp, byte -0x10 + and sp, -0x10 + sbb sp, byte -0x10 + sbb sp, -0x10 + sub sp, byte -0x10 + sub sp, -0x10 diff --git a/test/aoutso.asm b/test/aoutso.asm new file mode 100644 index 0000000..aab35a5 --- /dev/null +++ b/test/aoutso.asm @@ -0,0 +1,99 @@ +;Testname=unoptimized; Arguments=-O0 -faoutb -oaoutso.o; Files=stdout stderr aoutso.o +;Testname=optimized; Arguments=-Ox -faoutb -oaoutso.o; Files=stdout stderr aoutso.o + +; test source file for assembling to NetBSD/FreeBSD a.out shared library +; build with: +; nasm -f aoutb aoutso.asm +; ld -Bshareable -o aoutso.so aoutso.o +; test with: +; cc -o aoutso aouttest.c aoutso.so +; ./aoutso + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section + + BITS 32 + EXTERN __GLOBAL_OFFSET_TABLE_ + GLOBAL _lrotate:function ; [1] + GLOBAL _greet:function ; [1] + GLOBAL _asmstr:data _asmstr.end-_asmstr ; [2] + GLOBAL _textptr:data 4 ; [2] + GLOBAL _selfptr:data 4 ; [2] + GLOBAL _integer:data 4 ; [3] + EXTERN _printf ; [10] + COMMON _commvar 4 ; [7] + + SECTION .text + +; prototype: long lrotate(long x, int num); +_lrotate: ; [1] + push ebp + mov ebp,esp + mov eax,[ebp+8] + mov ecx,[ebp+12] +.label rol eax,1 ; [4] [8] + loop .label ; [9] [12] + mov esp,ebp + pop ebp + ret + +; prototype: void greet(void); +_greet push ebx ; we'll use EBX for GOT, so save it + call .getgot +.getgot: pop ebx + add ebx,__GLOBAL_OFFSET_TABLE_ + $$ - .getgot wrt ..gotpc + mov eax,[ebx+_integer wrt ..got] ; [14] + mov eax,[eax] + inc eax + mov [ebx+localint wrt ..gotoff],eax ; [14] + mov eax,[ebx+_commvar wrt ..got] + push dword [eax] + mov eax,[ebx+localptr wrt ..gotoff] ; [13] + push dword [eax] + mov eax,[ebx+_integer wrt ..got] ; [1] [14] + push dword [eax] + lea eax,[ebx+_printfstr wrt ..gotoff] + push eax ; [13] + call _printf wrt ..plt ; [11] + add esp,16 + pop ebx + ret + + SECTION .data + +; a string +_asmstr db 'hello, world', 0 ; [2] +.end + +; a string for Printf +_printfstr db "integer==%d, localint==%d, commvar=%d" + db 10, 0 + +; some pointers +localptr dd localint ; [5] [17] +_textptr dd _greet wrt ..sym ; [15] +_selfptr dd _selfptr wrt ..sym ; [16] + + SECTION .bss + +; an integer +_integer resd 1 ; [3] + +; a local integer +localint resd 1 ; [6] diff --git a/test/aouttest.asm b/test/aouttest.asm new file mode 100644 index 0000000..10d0e10 --- /dev/null +++ b/test/aouttest.asm @@ -0,0 +1,86 @@ +;Testname=unoptimized; Arguments=-O0 -faout -oaouttest.o; Files=stdout stderr aouttest.o +;Testname=optimized; Arguments=-Ox -faout -oaouttest.o; Files=stdout stderr aouttest.o + +; test source file for assembling to a.out +; build with: +; nasm -f aout aouttest.asm +; gcc -o aouttest aouttest.c aouttest.o +; (assuming your gcc is a.out) + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section + + BITS 32 + GLOBAL _lrotate ; [1] + GLOBAL _greet ; [1] + GLOBAL _asmstr ; [2] + GLOBAL _textptr ; [2] + GLOBAL _selfptr ; [2] + GLOBAL _integer ; [3] + EXTERN _printf ; [10] + COMMON _commvar 4 ; [7] + + SECTION .text + +; prototype: long lrotate(long x, int num); +_lrotate: ; [1] + push ebp + mov ebp,esp + mov eax,[ebp+8] + mov ecx,[ebp+12] +.label rol eax,1 ; [4] [8] + loop .label ; [9] [12] + mov esp,ebp + pop ebp + ret + +; prototype: void greet(void); +_greet mov eax,[_integer] ; [14] + inc eax + mov [localint],eax ; [14] + push dword [_commvar] + mov eax,[localptr] ; [13] + push dword [eax] + push dword [_integer] ; [1] [14] + push dword _printfstr ; [13] + call _printf ; [11] + add esp,16 + ret + + SECTION .data + +; a string +_asmstr db 'hello, world', 0 ; [2] + +; a string for Printf +_printfstr db "integer==%d, localint==%d, commvar=%d" + db 10, 0 + +; some pointers +localptr dd localint ; [5] [17] +_textptr dd _greet ; [15] +_selfptr dd _selfptr ; [16] + + SECTION .bss + +; an integer +_integer resd 1 ; [3] + +; a local integer +localint resd 1 ; [6] diff --git a/test/aouttest.c b/test/aouttest.c new file mode 100644 index 0000000..2514ce1 --- /dev/null +++ b/test/aouttest.c @@ -0,0 +1,36 @@ +/* + * test source file for assembling to a.out + * build with: + * nasm -f aout aouttest.asm + * gcc -o aouttest aouttest.c aouttest.o + * (assuming your gcc is a.out) + */ + +#include <stdio.h> +#include <inttypes.h> + +extern int lrotate(int32_t, int); +extern void greet(void); +extern int8_t asmstr[]; +extern void *selfptr; +extern void *textptr; +extern int integer, commvar; + +int main(void) +{ + + printf("Testing lrotate: should get 0x00400000, 0x00000001\n"); + printf("lrotate(0x00040000, 4) = 0x%08lx\n", lrotate(0x40000, 4)); + printf("lrotate(0x00040000, 14) = 0x%08lx\n", lrotate(0x40000, 14)); + + printf("This string should read `hello, world': `%s'\n", asmstr); + + printf("The integers here should be 1234, 1235 and 4321:\n"); + integer = 1234; + commvar = 4321; + greet(); + + printf("These pointers should be equal: %p and %p\n", &greet, textptr); + + printf("So should these: %p and %p\n", selfptr, &selfptr); +} diff --git a/test/avx.asm b/test/avx.asm new file mode 100644 index 0000000..9e5e15b --- /dev/null +++ b/test/avx.asm @@ -0,0 +1,53 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -oavx.bin; Files=stdout stderr avx.bin +;Testname=optimized; Arguments=-Ox -fbin -oavx.bin; Files=stdout stderr avx.bin + + bits 64 + blendvpd xmm2,xmm1,xmm0 + + vblendvpd xmm2,xmm1,xmm0,xmm0 + vblendvpd xmm2,xmm1,xmm0 + vblendvpd ymm2,ymm1,ymm0,ymm0 + vblendvpd ymm2,ymm1,ymm0 + + vcvtsi2sd xmm9,xmm10,ecx + vcvtsi2sd xmm9,xmm10,rcx + vcvtsi2sd xmm9,xmm10,dword [rdi] + vcvtsi2sd xmm9,xmm10,qword [rdi] + + vpermil2ps xmm0,xmm1,[rdi],xmm3,0 + vpermil2ps xmm0,xmm1,xmm2,[rdi],1 + vpermil2ps ymm0,ymm1,ymm2,ymm3,2 + vpermil2ps ymm0,ymm1,ymm2,[rdi],3 + vpermil2ps ymm0,ymm1,[rdi],ymm3,2 + vpermil2ps ymm0,ymm1,ymm2,[rdi],3 + + vpextrb [rax],xmm1,0x33 + vpextrw [rax],xmm1,0x33 + vpextrd [rax],xmm1,0x33 + vpextrq [rax],xmm1,0x33 + vpextrb rax,xmm1,0x33 + vpextrw rax,xmm1,0x33 + vpextrd rax,xmm1,0x33 + vpextrq rax,xmm1,0x33 + vpextrb eax,xmm1,0x33 + vpextrw eax,xmm1,0x33 + vpextrd eax,xmm1,0x33 +; vpextrq eax,xmm1,0x33 + + vcvtpd2ps xmm0,xmm1 + vcvtpd2ps xmm0,oword [rsi] + vcvtpd2ps xmm0,ymm1 + vcvtpd2ps xmm0,yword [rsi] +; vcvtpd2ps xmm0,[rsi] + + vcvtpd2dq xmm0,xmm1 + vcvtpd2dq xmm0,oword [rsi] + vcvtpd2dq xmm0,ymm1 + vcvtpd2dq xmm0,yword [rsi] +; vcvtpd2dq xmm0,[rsi] + + vcvttpd2dq xmm0,xmm1 + vcvttpd2dq xmm0,oword [rsi] + vcvttpd2dq xmm0,ymm1 + vcvttpd2dq xmm0,yword [rsi] +; vcvttpd2dq xmm0,[rsi] diff --git a/test/avx005.asm b/test/avx005.asm new file mode 100644 index 0000000..0876514 --- /dev/null +++ b/test/avx005.asm @@ -0,0 +1,529 @@ +;Testname=avx005; Arguments=-fbin -oavx005.bin -Ox; Files=stdout stderr avx005.bin + +%define regxmm xmm0 +%define regymm ymm0 +%define mem [0] +%define imm 3 + +%macro x 1+.nolist + %1 ; comment this line if RELAXed variants are not supported +%endmacro + + VFMADDSUB132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB132PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB132PS regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB132PS regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADDSUB132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB132PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB132PD regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB132PD regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD132PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD132PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD132PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD132PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD132PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD132PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD132PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADD132PS regymm,regymm,mem ; VEX_FMA,SY + VFMADD132PS regymm,regymm,regymm ; VEX_FMA + +x VFMADD312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD132PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADD132PD regymm,regymm,mem ; VEX_FMA,SY + VFMADD132PD regymm,regymm,regymm ; VEX_FMA + +x VFMADD312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD132SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMADD132SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD312SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMADD312SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMADD132SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMADD132SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD312SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMADD312SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB132PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB132PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUB132PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUB312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB132PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB132PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUB132PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUB312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB132SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMSUB132SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB312SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMSUB312SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB132SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMSUB132SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB312SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMSUB312SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD132PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD132PS regymm,regymm,mem ; VEX_FMA,SY + VFNMADD132PS regymm,regymm,regymm ; VEX_FMA + +x VFNMADD312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD132PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD132PD regymm,regymm,mem ; VEX_FMA,SY + VFNMADD132PD regymm,regymm,regymm ; VEX_FMA + +x VFNMADD312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD132SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMADD132SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD312SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMADD312SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD132SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMADD132SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD312SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMADD312SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB132PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB132PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB132PS regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB132PS regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB312PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB312PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB312PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB312PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB132PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB132PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB132PD regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB132PD regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB312PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB312PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB312PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB312PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB132SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMSUB132SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB312SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMSUB312SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB132SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMSUB132SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB312SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMSUB312SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMADDSUB213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB213PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB213PS regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB213PS regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADDSUB213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB213PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB213PD regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB213PD regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD213PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD213PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD213PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD213PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD213PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD213PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD213PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADD213PS regymm,regymm,mem ; VEX_FMA,SY + VFMADD213PS regymm,regymm,regymm ; VEX_FMA + +x VFMADD123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD213PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADD213PD regymm,regymm,mem ; VEX_FMA,SY + VFMADD213PD regymm,regymm,regymm ; VEX_FMA + +x VFMADD123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD213SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMADD213SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD123SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMADD123SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMADD213SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMADD213SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD123SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMADD123SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB213PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB213PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUB213PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUB123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB213PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB213PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUB213PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUB123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB213SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMSUB213SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB123SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMSUB123SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB213SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMSUB213SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB123SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMSUB123SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD213PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD213PS regymm,regymm,mem ; VEX_FMA,SY + VFNMADD213PS regymm,regymm,regymm ; VEX_FMA + +x VFNMADD123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD213PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD213PD regymm,regymm,mem ; VEX_FMA,SY + VFNMADD213PD regymm,regymm,regymm ; VEX_FMA + +x VFNMADD123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD213SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMADD213SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD123SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMADD123SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD213SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMADD213SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD123SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMADD123SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB213PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB213PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB213PS regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB213PS regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB123PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB123PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB123PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB123PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB213PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB213PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB213PD regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB213PD regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB123PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB123PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB123PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB123PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB213SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMSUB213SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB123SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMSUB123SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB213SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMSUB213SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB123SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMSUB123SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMADDSUB231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB231PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB231PS regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB231PS regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADDSUB231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADDSUB231PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADDSUB231PD regymm,regymm,mem ; VEX_FMA,SY + VFMADDSUB231PD regymm,regymm,regymm ; VEX_FMA + +x VFMADDSUB321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADDSUB321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADDSUB321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADDSUB321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD231PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD231PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD231PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUBADD231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUBADD231PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUBADD231PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUBADD231PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUBADD321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUBADD321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUBADD321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUBADD321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD231PS regxmm,regxmm,regxmm ; VEX_FMA + VFMADD231PS regymm,regymm,mem ; VEX_FMA,SY + VFMADD231PS regymm,regymm,regymm ; VEX_FMA + +x VFMADD321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMADD231PD regxmm,regxmm,regxmm ; VEX_FMA + VFMADD231PD regymm,regymm,mem ; VEX_FMA,SY + VFMADD231PD regymm,regymm,regymm ; VEX_FMA + +x VFMADD321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMADD321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMADD321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMADD321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMADD231SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMADD231SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD321SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMADD321SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMADD231SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMADD231SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMADD321SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMADD321SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB231PS regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB231PS regymm,regymm,mem ; VEX_FMA,SY + VFMSUB231PS regymm,regymm,regymm ; VEX_FMA + +x VFMSUB321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFMSUB231PD regxmm,regxmm,regxmm ; VEX_FMA + VFMSUB231PD regymm,regymm,mem ; VEX_FMA,SY + VFMSUB231PD regymm,regymm,regymm ; VEX_FMA + +x VFMSUB321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFMSUB321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFMSUB321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFMSUB321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFMSUB231SS regxmm,regxmm,mem ; VEX_FMA,SD + VFMSUB231SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB321SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFMSUB321SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFMSUB231SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFMSUB231SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFMSUB321SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFMSUB321SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD231PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD231PS regymm,regymm,mem ; VEX_FMA,SY + VFNMADD231PS regymm,regymm,regymm ; VEX_FMA + +x VFNMADD321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMADD231PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMADD231PD regymm,regymm,mem ; VEX_FMA,SY + VFNMADD231PD regymm,regymm,regymm ; VEX_FMA + +x VFNMADD321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMADD321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMADD321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMADD321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMADD231SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMADD231SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD321SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMADD321SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMADD231SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMADD231SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMADD321SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMADD321SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB231PS regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB231PS regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB231PS regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB231PS regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB321PS regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB321PS regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB321PS regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB321PS regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB231PD regxmm,regxmm,mem ; VEX_FMA,SO + VFNMSUB231PD regxmm,regxmm,regxmm ; VEX_FMA + VFNMSUB231PD regymm,regymm,mem ; VEX_FMA,SY + VFNMSUB231PD regymm,regymm,regymm ; VEX_FMA + +x VFNMSUB321PD regxmm,regxmm,mem ; VEX_FMA,RELAX,SO +x VFNMSUB321PD regxmm,regxmm,regxmm ; VEX_FMA,RELAX +x VFNMSUB321PD regymm,regymm,mem ; VEX_FMA,RELAX,SY +x VFNMSUB321PD regymm,regymm,regymm ; VEX_FMA,RELAX + + VFNMSUB231SS regxmm,regxmm,mem ; VEX_FMA,SD + VFNMSUB231SS regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB321SS regxmm,regxmm,mem ; VEX_FMA,RELAX,SD +x VFNMSUB321SS regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VFNMSUB231SD regxmm,regxmm,mem ; VEX_FMA,SQ + VFNMSUB231SD regxmm,regxmm,regxmm ; VEX_FMA + +x VFNMSUB321SD regxmm,regxmm,mem ; VEX_FMA,RELAX,SQ +x VFNMSUB321SD regxmm,regxmm,regxmm ; VEX_FMA,RELAX + + VPCLMULLQLQDQ regxmm,regxmm,mem ; PCLMUL,VEX_AVX,SO + VPCLMULLQLQDQ regxmm,regxmm,regxmm ; PCLMUL,VEX_AVX + VPCLMULHQLQDQ regxmm,regxmm,mem ; PCLMUL,VEX_AVX,SO + VPCLMULHQLQDQ regxmm,regxmm,regxmm ; PCLMUL,VEX_AVX + VPCLMULLQHQDQ regxmm,regxmm,mem ; PCLMUL,VEX_AVX,SO + VPCLMULLQHQDQ regxmm,regxmm,regxmm ; PCLMUL,VEX_AVX + VPCLMULHQHQDQ regxmm,regxmm,mem ; PCLMUL,VEX_AVX,SO + VPCLMULHQHQDQ regxmm,regxmm,regxmm ; PCLMUL,VEX_AVX + VPCLMULQDQ regxmm,regxmm,mem,imm ; PCLMUL,VEX_AVX,SB3,SO + VPCLMULQDQ regxmm,regxmm,regxmm,imm ; PCLMUL,VEX_AVX,SB3 + +; EOF + + diff --git a/test/bcd.asm b/test/bcd.asm new file mode 100644 index 0000000..bb45ca6 --- /dev/null +++ b/test/bcd.asm @@ -0,0 +1,21 @@ + dt 765432109876543210p + dt -765432109876543210p + dt +765432109876543210p + dt 123p + dt -456p + dt +789p + dt 98765432109876543210p + dt 123.0 + dt 0x123p+44 + dt 789p + + dt 0p765432109876543210 + dt -0p765432109876543210 + dt +0p765432109876543210 + dt 0p123 + dt -0p456 + dt +0p789 + dt 0p98765432109876543210 + dt 123.0 + dt 0x123p+44 + dt 0p789 diff --git a/test/binexe.asm b/test/binexe.asm new file mode 100644 index 0000000..2a9eb6e --- /dev/null +++ b/test/binexe.asm @@ -0,0 +1,35 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -obinexe.exe -i../misc/; Files=stdout stderr binexe.exe +;Testname=optimized; Arguments=-Ox -fbin -obinexe.exe -i../misc/; Files=stdout stderr binexe.exe + +; Demonstration of how to write an entire .EXE format program by using +; the `exebin.mac' macro package. +; To build: +; nasm -fbin binexe.asm -o binexe.exe -ipath +; (where `path' is such as to allow the %include directive to find +; exebin.mac) +; To test: +; binexe +; (should print `hello, world') + +%include "exebin.mac" + + EXE_begin + EXE_stack 64 ; demonstrates overriding the 0x800 default + + section .text + + mov ax,cs + mov ds,ax + + mov dx,hello + mov ah,9 + int 0x21 + + mov ax,0x4c00 + int 0x21 + + section .data + +hello: db 'hello, world', 13, 10, '$' + + EXE_end diff --git a/test/bintest.asm b/test/bintest.asm new file mode 100644 index 0000000..57a3b2d --- /dev/null +++ b/test/bintest.asm @@ -0,0 +1,59 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -obintest.bin; Files=stdout stderr bintest.bin +;Testname=optimized; Arguments=-Ox -fbin -obintest.bin; Files=stdout stderr bintest.bin + +; test source file for assembling to binary files +; build with: +; nasm -f bin -o bintest.com bintest.asm + +; When run (as a DOS .COM file), this program should print +; hello, world +; on two successive lines, then exit cleanly. + +; This file should test the following: +; [1] Define a text-section symbol +; [2] Define a data-section symbol +; [3] Define a BSS-section symbol +; [4] Define a NASM local label +; [5] Reference a NASM local label +; [6] Reference a text-section symbol in the text section +; [7] Reference a data-section symbol in the text section +; [8] Reference a BSS-section symbol in the text section +; [9] Reference a text-section symbol in the data section +; [10] Reference a data-section symbol in the data section +; [11] Reference a BSS-section symbol in the data section + + BITS 16 + ORG 0x100 + + SECTION .text + + jmp start ; [6] + +endX mov ax,0x4c00 ; [1] + int 0x21 + +start mov byte [bss_sym],',' ; [1] [8] + mov bx,[bssptr] ; [7] + mov al,[bx] + mov bx,[dataptr] ; [7] + mov [bx],al + mov cx,2 +.loop mov dx,datasym ; [1] [4] [7] + mov ah,9 + push cx + int 0x21 + pop cx + loop .loop ; [5] [6] + mov bx,[textptr] ; [7] + jmp bx + + SECTION .data + +datasym db 'hello world', 13, 10, '$' ; [2] +bssptr dw bss_sym ; [2] [11] +dataptr dw datasym+5 ; [2] [10] +textptr dw endX ; [2] [9] + + SECTION .bss + +bss_sym resb 1 ; [3] diff --git a/test/bisect.sh b/test/bisect.sh new file mode 100755 index 0000000..98bdb37 --- /dev/null +++ b/test/bisect.sh @@ -0,0 +1,22 @@ +#!/bin/sh + +# Usage: + +# Make a test and a golden file, read ./performtest.pl --help + +# cd nasm +# cp -r test somewhere (copy test dir out of the tree) +# git bisect start HEAD nasm-2.07 (where HEAD is bad and nasm-2.07 is good) +# git bisect run somewhere/test/bisect.sh br2148476 (what you want to test) + +# Done + + +# Slow but sure +./autogen.sh +./configure +make + +NASMDIR=$(pwd) +cd $(dirname "$0") +./performtest.pl "--nasm=$NASMDIR/nasm" "$1.asm" --verbose diff --git a/test/br1879590.asm b/test/br1879590.asm new file mode 100644 index 0000000..23e3872 --- /dev/null +++ b/test/br1879590.asm @@ -0,0 +1,25 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -obr1879590.bin; Files=stdout stderr br1879590.bin +;Testname=optimized; Arguments=-Ox -fbin -obr1879590.bin; Files=stdout stderr br1879590.bin + + bits 32 + + pavgb mm0,[ebx] + pavgb mm0,qword [ebx] + pavgw mm0,[ebx] + pavgw mm0,qword [ebx] + pavgb xmm0,[ebx] + pavgb xmm0,oword [ebx] + pavgw xmm0,[ebx] + pavgw xmm0,oword [ebx] + + bits 64 + + pavgb mm0,[rbx] + pavgb mm0,qword [rbx] + pavgw mm0,[rbx] + pavgw mm0,qword [rbx] + pavgb xmm0,[rbx] + pavgb xmm0,oword [rbx] + pavgw xmm0,[rbx] + pavgw xmm0,oword [rbx] + diff --git a/test/br2003451.asm b/test/br2003451.asm new file mode 100644 index 0000000..fb309a9 --- /dev/null +++ b/test/br2003451.asm @@ -0,0 +1,15 @@ + cpu 8086 + org 0 + + ; MOV r/m16,imm16 + ; (imm16 given as number) + mov word [bx], 10h + + ; MOV r/m16,imm16 + ; (imm16 given as label) + mov word [bx], label + + align 10h + + ; This label is at address 10h +label: diff --git a/test/br2030823.asm b/test/br2030823.asm new file mode 100644 index 0000000..ce7ba43 --- /dev/null +++ b/test/br2030823.asm @@ -0,0 +1,5 @@ + bits 64 + VFMADDPD xmm0, xmm1, [0], xmm3 + VFMADDPD xmm0, xmm1, xmm2, [0] + VFMADDPD ymm0, ymm1, [0], ymm3 + VFMADDPD ymm0, ymm1, ymm2, [0] diff --git a/test/br2148476.asm b/test/br2148476.asm new file mode 100644 index 0000000..b1ff0e8 --- /dev/null +++ b/test/br2148476.asm @@ -0,0 +1,221 @@ +;Testname=test; Arguments=-fbin -obr2148476.bin; Files=stdout stderr br2148476.bin + + bits 64 + + cvtdq2pd xmm0, xmm1 + cvtdq2pd xmm0, [rdi] + cvtdq2pd xmm0, qword [rdi] + + cvtdq2ps xmm0, xmm1 + cvtdq2ps xmm0, [rdi] + cvtdq2ps xmm0, oword [rdi] + + cvtpd2dq xmm0, xmm1 + cvtpd2dq xmm0, [rdi] + cvtpd2dq xmm0, oword [rdi] + + cvtpd2pi mm0, xmm1 + cvtpd2pi mm0, [rdi] + cvtpd2pi mm0, oword [rdi] + + cvtpd2ps xmm0, xmm1 + cvtpd2ps xmm0, [rdi] + cvtpd2ps xmm0, oword [rdi] + + cvtpi2pd xmm0, mm1 + cvtpi2pd xmm0, [rdi] + cvtpi2pd xmm0, qword [rdi] + + cvtpi2ps xmm0, mm1 + cvtpi2ps xmm0, [rdi] + cvtpi2ps xmm0, qword [rdi] + + cvtps2dq xmm0, xmm1 + cvtps2dq xmm0, [rdi] + cvtps2dq xmm0, oword [rdi] + + cvtps2pd xmm0, xmm1 + cvtps2pd xmm0, [rdi] + cvtps2pd xmm0, qword [rdi] + + cvtps2pi mm0, xmm1 + cvtps2pi mm0, [rdi] + cvtps2pi mm0, qword [rdi] + + cvtsd2si eax, xmm1 + cvtsd2si eax, [rdi] + cvtsd2si eax, qword [rdi] + cvtsd2si rax, xmm1 + cvtsd2si rax, [rdi] + cvtsd2si rax, qword [rdi] + + cvtsd2ss xmm0, xmm1 + cvtsd2ss xmm0, [rdi] + cvtsd2ss xmm0, qword [rdi] + + cvtsi2sd xmm0, eax + cvtsi2sd xmm0, [rdi] ; Compatibility + cvtsi2sd xmm0, dword [rdi] + cvtsi2sd xmm0, rax + cvtsi2sd xmm0, qword [rdi] + + cvtsi2ss xmm0, eax + cvtsi2ss xmm0, [rdi] ; Compatibility + cvtsi2ss xmm0, dword [rdi] + cvtsi2ss xmm0, rax + cvtsi2ss xmm0, qword [rdi] + + cvtss2sd xmm0, xmm1 + cvtss2sd xmm0, [rdi] + cvtss2sd xmm0, dword [rdi] + + cvtss2si eax, xmm1 + cvtss2si eax, [rdi] + cvtss2si eax, dword [rdi] + cvtss2si rax, xmm1 + cvtss2si rax, [rdi] + cvtss2si rax, dword [rdi] + + cvttpd2dq xmm0, xmm1 + cvttpd2dq xmm0, [rdi] + cvttpd2dq xmm0, oword [rdi] + + cvttpd2pi mm0, xmm1 + cvttpd2pi mm0, [rdi] + cvttpd2pi mm0, oword [rdi] + + cvttps2dq xmm0, xmm1 + cvttps2dq xmm0, [rdi] + cvttps2dq xmm0, oword [rdi] + + cvttps2pi mm0, xmm1 + cvttps2pi mm0, [rdi] + cvttps2pi mm0, qword [rdi] + + cvttsd2si eax, xmm1 + cvttsd2si eax, [rdi] ; Compatibility + cvttsd2si eax, qword [rdi] + cvttsd2si rax, xmm1 + cvttsd2si rax, [rdi] + cvttsd2si rax, qword [rdi] + + cvttss2si eax, xmm1 + cvttss2si eax, [rdi] ; Compatibility + cvttss2si eax, dword [rdi] + cvttss2si rax, xmm1 + cvttss2si rax, [rdi] + cvttss2si rax, dword [rdi] + + vcvtdq2pd xmm0, xmm1 + vcvtdq2pd xmm0, [rdi] + vcvtdq2pd xmm0, qword [rdi] + vcvtdq2pd ymm0, xmm1 + vcvtdq2pd ymm0, [rdi] + vcvtdq2pd ymm0, oword [rdi] + + vcvtdq2ps xmm0, xmm1 + vcvtdq2ps xmm0, [rdi] + vcvtdq2ps xmm0, oword [rdi] + vcvtdq2ps ymm0, ymm1 + vcvtdq2ps ymm0, [rdi] + vcvtdq2ps ymm0, yword [rdi] + + vcvtpd2dq xmm0, xmm1 + vcvtpd2dq xmm0, oword [rdi] + vcvtpd2dq xmm0, ymm1 + vcvtpd2dq xmm0, yword [rdi] + + vcvtpd2ps xmm0, xmm1 + vcvtpd2ps xmm0, oword [rdi] + vcvtpd2ps xmm0, ymm1 + vcvtpd2ps xmm0, yword [rdi] + + vcvtps2dq xmm0, xmm1 + vcvtps2dq xmm0, [rdi] + vcvtps2dq xmm0, oword [rdi] + vcvtps2dq ymm0, ymm1 + vcvtps2dq ymm0, [rdi] + vcvtps2dq ymm0, yword [rdi] + + vcvtps2pd xmm0, xmm1 + vcvtps2pd xmm0, [rdi] + vcvtps2pd xmm0, qword [rdi] + vcvtps2pd ymm0, xmm1 + vcvtps2pd ymm0, [rdi] + vcvtps2pd ymm0, oword [rdi] + + vcvtsd2si eax, xmm1 + vcvtsd2si eax, [rdi] + vcvtsd2si eax, qword [rdi] + vcvtsd2si rax, xmm1 + vcvtsd2si rax, [rdi] + vcvtsd2si rax, qword [rdi] + + vcvtsd2ss xmm0, xmm1 + vcvtsd2ss xmm0, [rdi] + vcvtsd2ss xmm0, qword [rdi] + vcvtsd2ss xmm0, xmm1, xmm2 + vcvtsd2ss xmm0, xmm1, [rdi] + vcvtsd2ss xmm0, xmm1, qword [rdi] + + vcvtsi2sd xmm0, eax + vcvtsi2sd xmm0, [rdi] ; Compatibility + vcvtsi2sd xmm0, dword [rdi] + vcvtsi2sd xmm0, rax + vcvtsi2sd xmm0, qword [rdi] + vcvtsi2sd xmm0, xmm1, eax + vcvtsi2sd xmm0, xmm1, [rdi] ; Compatibility + vcvtsi2sd xmm0, xmm1, dword [rdi] + vcvtsi2sd xmm0, xmm1, rax + vcvtsi2sd xmm0, xmm1, qword [rdi] + + vcvtsi2ss xmm0, eax + vcvtsi2ss xmm0, [rdi] ; Compatibility + vcvtsi2ss xmm0, dword [rdi] + vcvtsi2ss xmm0, rax + vcvtsi2ss xmm0, qword [rdi] + vcvtsi2ss xmm0, xmm1, eax + vcvtsi2ss xmm0, xmm1, [rdi] ; Compatibility + vcvtsi2ss xmm0, xmm1, dword [rdi] + vcvtsi2ss xmm0, xmm1, rax + vcvtsi2ss xmm0, xmm1, qword [rdi] + + vcvtss2sd xmm0, xmm1 + vcvtss2sd xmm0, [rdi] + vcvtss2sd xmm0, dword [rdi] + vcvtss2sd xmm0, xmm1, xmm2 + vcvtss2sd xmm0, xmm1, [rdi] + vcvtss2sd xmm0, xmm1, dword [rdi] + + vcvtss2si eax, xmm1 + vcvtss2si eax, [rdi] + vcvtss2si eax, dword [rdi] + vcvtss2si rax, xmm1 + vcvtss2si rax, [rdi] + vcvtss2si rax, dword [rdi] + + vcvttpd2dq xmm0, xmm1 + vcvttpd2dq xmm0, oword [rdi] + vcvttpd2dq xmm0, ymm1 + vcvttpd2dq xmm0, yword [rdi] + + vcvttps2dq xmm0, xmm1 + vcvttps2dq xmm0, [rdi] + vcvttps2dq xmm0, oword [rdi] + vcvttps2dq ymm0, ymm1 + vcvttps2dq ymm0, [rdi] + vcvttps2dq ymm0, yword [rdi] + + vcvttsd2si eax, xmm1 + vcvttsd2si eax, [rdi] ; Compatibility + vcvttsd2si eax, qword [rdi] + vcvttsd2si rax, xmm1 + vcvttsd2si rax, [rdi] + vcvttsd2si rax, qword [rdi] + + vcvttss2si eax, xmm1 + vcvttss2si eax, [rdi] ; Compatibility + vcvttss2si eax, dword [rdi] + vcvttss2si rax, xmm1 + vcvttss2si rax, [rdi] + vcvttss2si rax, dword [rdi] diff --git a/test/br2222615.asm b/test/br2222615.asm new file mode 100644 index 0000000..7acef6c --- /dev/null +++ b/test/br2222615.asm @@ -0,0 +1,19 @@ +;Testname=noerror; Arguments=-fbin -obr2222615.bin; Files=stdout stderr br2222615.bin +;Testname=error; Arguments=-DERROR -fbin -obr2222615.bin; Files=stdout stderr br2222615.bin + +%macro bluttan 0 + nop +%endmacro + +%ifnmacro bluttan + %error "bluttan is a macro" +%endif + +%ifmacro blej + %error "blej is not a macro" +%endif + +%ifdef ERROR + %ifnmacro + %endif +%endif diff --git a/test/br560575.asm b/test/br560575.asm new file mode 100644 index 0000000..a252db6 --- /dev/null +++ b/test/br560575.asm @@ -0,0 +1,17 @@ +;Testname=aout; Arguments=-faout -obr560575.o; Files=stderr stdout br560575.o +;Testname=aoutb; Arguments=-faoutb -obr560575.o; Files=stderr stdout br560575.o +;Testname=coff; Arguments=-fcoff -obr560575.o; Files=stderr stdout br560575.o +;Testname=elf32; Arguments=-felf32 -obr560575.o; Files=stderr stdout br560575.o +;Testname=elf64; Arguments=-felf64 -obr560575.o; Files=stderr stdout br560575.o +;Testname=as86; Arguments=-fas86 -obr560575.o; Files=stderr stdout br560575.o +;Testname=win32; Arguments=-fwin32 -obr560575.o; Files=stderr stdout br560575.o +;Testname=win64; Arguments=-fwin64 -obr560575.o; Files=stderr stdout br560575.o +;Testname=rdf; Arguments=-frdf -obr560575.o; Files=stderr stdout br560575.o +;Testname=ieee; Arguments=-fieee -obr560575.o; Files=stderr stdout br560575.o +;Testname=macho; Arguments=-fmacho -obr560575.o; Files=stderr stdout br560575.o + +;Test for bug report 560575 - Using SEG with non-relocatable values doesn't work +; + dw seg ~1 + dw seg "a" + dw seg 'a' diff --git a/test/br560873.asm b/test/br560873.asm new file mode 100644 index 0000000..2133492 --- /dev/null +++ b/test/br560873.asm @@ -0,0 +1,27 @@ +;Testname=unoptimized; Arguments=-O0 -frdf -obr560873.rdf; Files=stdout stderr br560873.rdf +;Testname=optimized; Arguments=-Ox -frdf -obr560873.rdf; Files=stdout stderr br560873.rdf + +label: + bits 16 + call far dword label + mov [label],ax + mov [label],eax + mov [word label],ax + mov [word label],eax + mov [dword label],ax + mov [dword label],eax + push 3700 + push word 3700 + push dword 3700 + + bits 32 + call far word label + mov [label],ax + mov [label],eax + mov [word label],ax + mov [word label],eax + mov [dword label],ax + mov [dword label],eax + push 3700 + push word 3700 + push dword 3700 diff --git a/test/br890790.asm b/test/br890790.asm new file mode 100644 index 0000000..a002382 --- /dev/null +++ b/test/br890790.asm @@ -0,0 +1,7 @@ +;Testname=test; Arguments=-fbin -obr890790.bin; Files=stdout stderr br890790.bin +%rep 5 + db 0 + %include "br890790_i.asm" +%endrep + +db 1 diff --git a/test/br890790_i.asm b/test/br890790_i.asm new file mode 100644 index 0000000..7ff797f --- /dev/null +++ b/test/br890790_i.asm @@ -0,0 +1 @@ +db 2 diff --git a/test/changed.asm b/test/changed.asm new file mode 100644 index 0000000..7ea2cc4 --- /dev/null +++ b/test/changed.asm @@ -0,0 +1,383 @@ +;This file demonstrates many of the differences between NASM version X and NASM +;version 0.97 +; +; changed.asm is copyright (C) 1998 John S. Fine +; +; It may be redistributed under the same conditions as NASM as described in +; LICENSE file in the NASM archive +;_________________________________ +; +; nasm changed.asm -l changed.lst +; +; When assembled without any -d switches, it includes examples which: +; Work correctly in version X +; and Work incorrectly and/or display warnings in version 0.97 +; and Do not prevent the generation of output in version 0.97 +; +; Not all the differences can be seen in the .lst file. I suggest that you use +; "ndisasm changes" to examine the code actually generated. +;_________________________________ +; +; nasm changed.asm -l changed.lst -doldmsg +; +; When assembled with -doldmsg, it adds examples which: +; Work correctly in version X +; and Generate error messages in version 0.97 and do not generate output +;_________________________________ +; +; nasm changed.asm -l changed.lst -doldcrash +; +; When assembled with -doldcrash, it adds examples which: +; Work correctly in version X +; and Cause NASM to crash in version 0.97 +;_________________________________ +; +; nasm changed.asm -l changed.lst -dnewmsg +; +; When assembled with -dnewmsg, it adds examples which: +; Generate error messages in version X +; and Generate wrong output without warning or error message in version 0.97 +;----------------------------------------------------------------------------- + +; Please note that I have reported the name of the person who made the +; correction based on very limited information. In several cases, I am sure I +; will identify the wrong author. Please send me any corrections; I don't +; intend to insult or exclude anyone. + +;----------------------------------------------------------------------------- +; Bug fixed by Simon in assemble() +; +; The following generated "call next" / "call next-1" instead of +; two copies of "call next" +; + times 2 a16 call next +next: + +;----------------------------------------------------------------------------- +; Bug fixed by John in parse_line() (and other routines) +; +; This used to jmp to prior.1, when it should be here.1 +; +prior: +.1: +here: jmp .1 +.1: + +;----------------------------------------------------------------------------- +; Bug fixed by John in assemble() +; +; Strings used in dq and dt were not zero filled correctly +; + dq 'b' + + +;----------------------------------------------------------------------------- +; Bug fixed by Simon in isn_names[] +; +; Was not recognised as an instruction +; + int01 ; Instead of INT1 + +;----------------------------------------------------------------------------- +; Bug fixed by Jim Hague in ??? +; +; Forward references were instruction level rather than per operand +; + shr word [forwardref],1 +forwardref: + +;----------------------------------------------------------------------------- +; Bug fixed by John in preproc.c +; +; It used to silently discard id characters appended to a multi-line +; macro parameter (such as the x in %1x below). +; +%macro xxx 1 +%1: nop +%{1}x: jmp %1x +%endmacro +xxx yyy + +;----------------------------------------------------------------------------- +; Bug added by John in preproc.c 0.98-J4, removed by John in 0.98-J5 +; +; Tested here to make sure it stays removed +; +%macro TestElse 1 +%if %1=0 +%elif %1=1 +nop +%endif +%endmacro +TestElse 1 + +%ifdef oldmsg +;*************************************************************** +; +; The following examples will generate error messages in 0.97 and will generate +; correct output in the new version. + +;----------------------------------------------------------------------------- +; Bug fixed by Simon in isns.dat +; +; The optional "near" was not permitted on JMP and CALL +; + jmp near here + +;----------------------------------------------------------------------------- +; Feature added by Simon in stdscan() +; +; You can now use the numeric value of strings in %assign +; +%assign xxx 'ABCD' + dd xxx + +;----------------------------------------------------------------------------- +; Feature added by John in add_vectors() +; +; Stranger address expressions are now supported as long as they resolve to +; something valid. +; + mov ax, [eax + ebx + ecx - eax] + +;----------------------------------------------------------------------------- +; Bug fixed by Simon in ??? +; +; The EQU directive affected local labels in a way that was inconsistent +; between passes +; +.local: +neither equ $ + jmp .local + +;----------------------------------------------------------------------------- +; Feature added by Jules in parse_line +; +; You can override a size specifier +; +%define arg1 dword [bp+4] + cmp word arg1, 2 + +;----------------------------------------------------------------------------- +; Bug fixed by John in preproc.c +; +; You could not use a label on the same line with a macro invocation, if the +; macro definition began with a preprocessor directive. +; + struc mytype +.long resd 1 + endstruc + +lbl istruc mytype + at mytype.long, dd 'ABCD' + iend + +;----------------------------------------------------------------------------- +; Warning removed by John in preproc.c +; +; In order to allow macros that extend the definition of instructions, I +; disabled the warning on a multi-line macro referencing itself. +; +%endif ;NASM 0.97 doesn't handle %0 etc. inside false %if +%macro push 1-* ; +%rep %0 ; +push %1 ; +%rotate 1 ; +%endrep ; +%endmacro ; +%ifdef oldmsg ; + + push ax,bx + +;----------------------------------------------------------------------------- +; Warning removed by John in preproc.c +; +; To support other types of macros that extend the definition of instructions, +; I disabled the warning on a multi-line macro called with the wrong number of +; parameters. PUSH and POP can be extended equally well by either method, but +; other intruction extensions may need one method or the other, so I made both +; work. +; +; Note that neither of these warnings was really needed, because a later stage +; of NASM would almost always give an adequate error message if the macro use +; really was wrong. +; +%endif +%macro pop 2-* +%rep %0 +pop %1 +%rotate 1 +%endrep +%endmacro +%ifdef oldmsg + + pop ax,bx +%endif + + +%ifdef newmsg ;*************************************************************** + +;----------------------------------------------------------------------------- +; Bug fixed by John in parse_line() (and other routines) +; +; This invalid code used to assemble without errors +; +myself equ myself+1 + jmp myself + +;----------------------------------------------------------------------------- +; Change made by John in preproc.c +; +; In 0.97, an id that appears as a label on a macro invocation was always +; prepended to the first line of the macro expansion. That caused several +; bugs, but also could be used in tricks like the arg macro in c16.mac and +; c32.mac. +; +; In version X, an id that appears as a label on a macro invocation will +; normally be defined as a label for the address at which the macro is +; invoked, regardless of whether the first line of the macro expansion is +; something that can take a label. The new token %00 may be used for any +; of the situations in which the old prepend behavior was doing something +; tricky but useful. %00 can also be used more than once and in places +; other than the start of the expansion. +; +%endif +%assign arg_off 0 + +%imacro arg 0-1 2 ;arg defined the old way + equ arg_off +%assign arg_off %1+arg_off +%endmacro + +%ifdef newmsg +arg_example arg +%endif + +%imacro arg2 0-1 2 ;arg defined the new way +%00 equ arg_off +%assign arg_off %1+arg_off +%endmacro + +%ifdef oldmsg +arg_example2 arg2 + +;----------------------------------------------------------------------------- +; Change made by Jules and John in INSNS.DAT +; +; Various instruction in which the size of an immediate is built-in to the +; instruction set, now allow you to redundantly specify that size as long +; as you specify it correctly +; + AAD byte 5 + AAM byte 5 + BT bx, byte 3 + BTC cx, byte 4 + BTR dx, byte 5 + BTS si, byte 6 + IN eax, byte 0x40 + INT byte 21h + OUT byte 70h, ax + RET word 2 + RETN word 2 + RETF word 4 + +; note "ENTER" has not been changed yet. + +;----------------------------------------------------------------------------- +; Enhancement by hpa in insns.dat et al +; +; Simplified adding new instructions, and added some missing instructions +; + int03 ; Instead of INT3 + ud1 ; No documented mnemonic for this one + ud2 + sysenter + sysexit + syscall + sysret + fxsave [ebx] + fxrstor [es:ebx+esi*4+0x3000] + +;----------------------------------------------------------------------------- +; Enhancement by hpa in insns.dat et al +; +; Actually make SSE work, and use the -p option to ndisasm to select +; one of several aliased opcodes +; + sqrtps xmm0,[ebx+10] ; SSE opcode + paddsiw mm0,[ebx+10] ; Cyrix opcode with the same byte seq. + +;----------------------------------------------------------------------------- +; Enhancement by hpa in preproc.c +; +; Support %undef to remoce a single-line macro +; +%define TEST_ME 42 +%ifndef TEST_ME +%error "TEST_ME not defined after %define" +%endif + +%undef TEST_ME +%ifdef TEST_ME +%error "TEST_ME defined after %undef" +%endif + +;----------------------------------------------------------------------------- +; Bug fix by hpa in insns.dat +; +; PSHUFW and PINSRW weren't handling the implicit sizes correctly; all of +; the entries below are (or should be) legal +; + pshufw mm2, mm1, 3 + pshufw mm3,[ebx],2 + pshufw mm7,[0+edi*8],1 + + pshufw mm2, mm1, byte 3 + pshufw mm3,[ebx],byte 2 + pshufw mm7,[0+edi*8],byte 1 + + pshufw mm2, mm1, 3 + pshufw mm3, qword [ebx], 2 + pshufw mm7, qword [0+edi*8], 1 + + pshufw mm2, mm1, byte 3 + pshufw mm3, qword [ebx], byte 2 + pshufw mm7, qword [0+edi*8], byte 1 + + pinsrw mm1, [esi], 1 + pinsrw mm1, word [esi], 1 + pinsrw mm1, [esi], byte 1 + pinsrw mm1, word [esi], byte 1 + + +%endif ; oldmsg + +%ifdef oldcrash ;************************************************************* + +This_label_is_256_characters_long__There_used_to_be_a_bug_in_stdscan_which_made_it_crash_when_it_did_a_keyword_search_on_any_label_longer_than_255_characters__Now_anything_longer_than_MAX_KEYWORD_is_always_a_symbol__It_will_not_even_try_a_keyword_search___ + +;----------------------------------------------------------------------------- +; Bug fixed by John in preproc.c +; +; Builds of NASM that prohibit dereferencing a NULL pointer used to crash if a +; macro that started with a blank line was invoked with a label +; +%macro empty_macro 0 + +%endm + +emlabel empty_macro + jmp emlabel + +;----------------------------------------------------------------------------- +; Enhancement by Conan Brink in preproc.c +; +; Allow %rep to be nested +; +%rep 4 +%rep 5 + nop +%endrep +%endrep + +%endif diff --git a/test/cofftest.asm b/test/cofftest.asm new file mode 100644 index 0000000..6b845e2 --- /dev/null +++ b/test/cofftest.asm @@ -0,0 +1,85 @@ +;Cannot be automatically tested because it differs every time, +;I guess because of a date/time field. + +; test source file for assembling to COFF +; build with (under DJGPP, for example): +; nasm -f coff cofftest.asm +; gcc -o cofftest cofftest.c cofftest.o + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section + + BITS 32 + GLOBAL _lrotate ; [1] + GLOBAL _greet ; [1] + GLOBAL _asmstr ; [2] + GLOBAL _textptr ; [2] + GLOBAL _selfptr ; [2] + GLOBAL _integer ; [3] + EXTERN _printf ; [10] + COMMON _commvar 4 ; [7] + + SECTION .text + +; prototype: long lrotate(long x, int num); +_lrotate: ; [1] + push ebp + mov ebp,esp + mov eax,[ebp+8] + mov ecx,[ebp+12] +.label rol eax,1 ; [4] [8] + loop .label ; [9] [12] + mov esp,ebp + pop ebp + ret + +; prototype: void greet(void); +_greet mov eax,[_integer] ; [14] + inc eax + mov [localint],eax ; [14] + push dword [_commvar] + mov eax,[localptr] ; [13] + push dword [eax] + push dword [_integer] ; [1] [14] + push dword _printfstr ; [13] + call _printf ; [11] + add esp,16 + ret + + SECTION .data + +; a string +_asmstr db 'hello, world', 0 ; [2] + +; a string for Printf +_printfstr db "integer==%d, localint==%d, commvar=%d" + db 10, 0 + +; some pointers +localptr dd localint ; [5] [17] +_textptr dd _greet ; [15] +_selfptr dd _selfptr ; [16] + + SECTION .bss + +; an integer +_integer resd 1 ; [3] + +; a local integer +localint resd 1 ; [6] diff --git a/test/cofftest.c b/test/cofftest.c new file mode 100644 index 0000000..77f610f --- /dev/null +++ b/test/cofftest.c @@ -0,0 +1,35 @@ +/* + * test source file for assembling to COFF + * build with (under DJGPP, for example): + * nasm -f coff cofftest.asm + * gcc -o cofftest cofftest.c cofftest.o + */ + +#include <stdio.h> +#include <inttypes.h> + +extern int lrotate(int32_t, int); +extern void greet(void); +extern int8_t asmstr[]; +extern void *selfptr; +extern void *textptr; +extern int integer, commvar; + +int main(void) +{ + + printf("Testing lrotate: should get 0x00400000, 0x00000001\n"); + printf("lrotate(0x00040000, 4) = 0x%08lx\n", lrotate(0x40000, 4)); + printf("lrotate(0x00040000, 14) = 0x%08lx\n", lrotate(0x40000, 14)); + + printf("This string should read `hello, world': `%s'\n", asmstr); + + printf("The integers here should be 1234, 1235 and 4321:\n"); + integer = 1234; + commvar = 4321; + greet(); + + printf("These pointers should be equal: %p and %p\n", &greet, textptr); + + printf("So should these: %p and %p\n", selfptr, &selfptr); +} diff --git a/test/crc32.asm b/test/crc32.asm new file mode 100644 index 0000000..c1ddb29 --- /dev/null +++ b/test/crc32.asm @@ -0,0 +1,37 @@ +;Testname=test; Arguments=-fbin -ocrc32.bin; Files=stdout stderr crc32.bin + + bits 16 + + crc32 eax,cl + crc32 eax,byte [di] + crc32 eax,cx + crc32 eax,word [di] + crc32 eax,ecx + crc32 eax,dword [di] + + bits 32 + align 16 + + crc32 eax,cl + crc32 eax,byte [edi] + crc32 eax,cx + crc32 eax,word [edi] + crc32 eax,ecx + crc32 eax,dword [edi] + + bits 64 + align 16 + + crc32 eax,cl + crc32 eax,byte [rdi] + crc32 eax,r9b + crc32 eax,cx + crc32 eax,word [rdi] + crc32 eax,ecx + crc32 eax,dword [rdi] + crc32 rax,cl + crc32 rax,byte [rdi] + crc32 rax,r9b + crc32 rax,rcx + crc32 rax,qword [rdi] + crc32 rax,r9 diff --git a/test/dtbcd.asm b/test/dtbcd.asm new file mode 100644 index 0000000..fcccff6 --- /dev/null +++ b/test/dtbcd.asm @@ -0,0 +1,72 @@ +; +; This is a macro to generate packed BCD constants. +; It is obsoleted by "dt" with a packed BCD value with a "p" +; suffix, but it is included here as a rest of nested %rep. +; +%macro dtbcd 1-*.nolist + %push dtbcd + %rep %0 + %defstr %$abc %1 + %substr %$sign %$abc 1 + %if %$sign == '-' + %substr %$abc %$abc 2,-1 + %xdefine %$sign 0x80 + %elif %$sign == '+' + %substr %$abc %$abc 2,-1 + %xdefine %$sign 0x00 + %else + %xdefine %$sign 0x00 + %endif + %strlen %$abclen %$abc + %defstr %$abclen_str %$abclen + %assign %$pos %$abclen + %assign %$bc 0 + %assign %$ld -1 + %rep %$abclen + %substr %$chr %$abc %$pos + %assign %$pos %$pos-1 + %if %$chr >= '0' && %$chr <= '9' + %if %$ld < 0 + %assign %$ld %$chr-'0' + %assign %$bc %$bc+1 + %if %$bc > 9 + %warning "too many digits in BCD constant" + %exitrep + %endif + %else + db %$ld+((%$chr-'0') << 4) + %assign %$ld -1 + %endif + %elif %$chr == '_' + ; Do nothing... + %else + %error "invalid character in BCD constant" + %exitrep + %endif + %endrep + %if %$ld >= 0 + db %$ld + %endif + %rep 9-%$bc + db 0 + %endrep + db %$sign + %rotate 1 + %endrep + %pop +%endmacro + + dtbcd 123, -456, +789 + dt 123p, -456p, +789p + dtbcd 765432109876543210 + dt 765432109876543210p + dtbcd -765432109876543210 + dt -765432109876543210p + dtbcd +765_432_109_876_543_210 + dt +765_432_109_876_543_210p + dtbcd -765_432_109_876_543_210 + dt -765_432_109_876_543_210p + + ;; Both of these should warn... + dtbcd 8_765_432_109_876_543_210 + dt 8_765_432_109_876_543_210p diff --git a/test/elf64so.asm b/test/elf64so.asm new file mode 100644 index 0000000..f1b2346 --- /dev/null +++ b/test/elf64so.asm @@ -0,0 +1,118 @@ +; test source file for assembling to ELF64 shared library +; build with: +; nasm -f elf64 elf64so.asm +; ld -shared -o elf64so.so elf64so.o +; test with: +; gcc -o elf64so elftest64.c ./elf64so.so +; ./elf64so + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section + + BITS 64 + GLOBAL lrotate:function ; [1] + GLOBAL greet_s:function ; [1] + GLOBAL greet_m:function ; [1] + GLOBAL asmstr:data asmstr.end-asmstr ; [2] + GLOBAL textptr:data 8 ; [2] + GLOBAL selfptr:data 8 ; [2] + GLOBAL useless:data 8 ; [3] + GLOBAL integer:data 8 ; [3] + EXTERN printf ; [10] + COMMON commvar 8:8 ; [7] + EXTERN _GLOBAL_OFFSET_TABLE_ + + SECTION .text + +; prototype: long lrotate(long x, int num); +lrotate: ; [1] + push rbp + mov rbp,rsp + mov rax,rdi + mov rcx,rsi +.label rol rax,1 ; [4] [8] + loop .label ; [9] [12] + mov rsp,rbp + pop rbp + ret + +;; prototype: void greet_*(void); +;; +;; Arguments are: rdi - rsi - rdx - rcx - r8 - r9 +;; Registers: rbx, rbp, r12-r15 are saved +;; greet_s() is Small PIC model, greet_m() is Medium PIC model +;; (Large model cannot be linked with other code) +;; +greet_s: + ;; This instruction is useless, this is only a test... + cmp qword [rel integer wrt ..got],0 + mov rax,[rel commvar wrt ..got] ; &commvar + mov rcx,[rax] ; commvar + mov rax,[rel integer wrt ..got] ; &integer + mov rsi,[rax] + lea rdx,[rsi+1] + mov [rel localint],rdx ; localint = integer+1 + mov rax,[rel localptr] ; localptr + mov rdx,[rax] ; *localptr = localint + lea rdi,[rel printfstr] + xor eax,eax ; No fp arguments + jmp printf wrt ..plt ; [10] + +greet_m: + push r15 ; Used by convention... + lea r15,[rel _GLOBAL_OFFSET_TABLE_] + mov rax,[rel commvar wrt ..got] ; &commvar + mov rcx,[rax] ; commvar + mov rax,[rel integer wrt ..got] ; &integer + mov rsi,[rax] + lea rdx,[rsi+1] + mov rax,localint wrt ..gotoff ; &localint - r15 + mov [rax+r15],rdx ; localint = integer+1 + mov rax,localptr wrt ..gotoff ; &localptr - r15 + mov rax,[rax+r15] ; localptr + mov rdx,[rax] ; *localptr = localint + mov rdi,printfstr wrt ..gotoff ; &printfstr - r15 + add rdi,r15 ; &printfstr + xor eax,eax ; No fp arguments + pop r15 + jmp printf wrt ..plt ; [10] + + SECTION .data + +; a string +asmstr db 'hello, world', 0 ; [2] +.end: + +; a string for Printf +printfstr db "integer=%ld, localint=%ld, commvar=%ld", 10, 0 + +; some pointers +localptr dq localint ; [5] [17] +textptr dq greet_s wrt ..sym ; [15] +selfptr dq selfptr wrt ..sym ; [16] + + SECTION .bss +; a useless symbol +useless resq 1 + +; an integer +integer resq 1 ; [3] + +; a local integer +localint resq 1 ; [6] diff --git a/test/elfso.asm b/test/elfso.asm new file mode 100644 index 0000000..e72497b --- /dev/null +++ b/test/elfso.asm @@ -0,0 +1,100 @@ +;Testname=unoptimized; Arguments=-O0 -felf -oelfso.o; Files=stdout stderr elfso.o +;Testname=optimized; Arguments=-Ox -felf -oelfso.o; Files=stdout stderr elfso.o + +; test source file for assembling to ELF shared library +; build with: +; nasm -f elf elfso.asm +; ld -shared -o elfso.so elfso.o +; test with: +; gcc -o elfso elftest.c ./elfso.so +; ./elfso +; (assuming your gcc is ELF, and you're running bash) + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section + + BITS 32 + GLOBAL lrotate:function ; [1] + GLOBAL greet:function ; [1] + GLOBAL asmstr:data asmstr.end-asmstr ; [2] + GLOBAL textptr:data 4 ; [2] + GLOBAL selfptr:data 4 ; [2] + GLOBAL integer:data 4 ; [3] + EXTERN printf ; [10] + COMMON commvar 4:4 ; [7] + EXTERN _GLOBAL_OFFSET_TABLE_ + + SECTION .text + +; prototype: long lrotate(long x, int num); +lrotate: ; [1] + push ebp + mov ebp,esp + mov eax,[ebp+8] + mov ecx,[ebp+12] +.label rol eax,1 ; [4] [8] + loop .label ; [9] [12] + mov esp,ebp + pop ebp + ret + +; prototype: void greet(void); +greet push ebx ; we'll use EBX for GOT, so save it + call .getgot +.getgot: pop ebx + add ebx,_GLOBAL_OFFSET_TABLE_ + $$ - .getgot wrt ..gotpc + mov eax,[ebx+integer wrt ..got] ; [14] + mov eax,[eax] + inc eax + mov [ebx+localint wrt ..gotoff],eax ; [14] + mov eax,[ebx+commvar wrt ..got] + push dword [eax] + mov eax,[ebx+localptr wrt ..gotoff] ; [13] + push dword [eax] + mov eax,[ebx+integer wrt ..got] ; [1] [14] + push dword [eax] + lea eax,[ebx+printfstr wrt ..gotoff] + push eax ; [13] + call printf wrt ..plt ; [11] + add esp,16 + pop ebx + ret + + SECTION .data + +; a string +asmstr db 'hello, world', 0 ; [2] +.end + +; a string for Printf +printfstr db "integer==%d, localint==%d, commvar=%d" + db 10, 0 + +; some pointers +localptr dd localint ; [5] [17] +textptr dd greet wrt ..sym ; [15] +selfptr dd selfptr wrt ..sym ; [16] + + SECTION .bss + +; an integer +integer resd 1 ; [3] + +; a local integer +localint resd 1 ; [6] diff --git a/test/elftest.asm b/test/elftest.asm new file mode 100644 index 0000000..fcfb362 --- /dev/null +++ b/test/elftest.asm @@ -0,0 +1,87 @@ +; test source file for assembling to ELF +; build with: +; nasm -f elf elftest.asm +; gcc -o elftest elftest.c elftest.o +; (assuming your gcc is ELF) + +; This file should test the following: +; [1] Define and export a global text-section symbol +; [2] Define and export a global data-section symbol +; [3] Define and export a global BSS-section symbol +; [4] Define a non-global text-section symbol +; [5] Define a non-global data-section symbol +; [6] Define a non-global BSS-section symbol +; [7] Define a COMMON symbol +; [8] Define a NASM local label +; [9] Reference a NASM local label +; [10] Import an external symbol +; [11] Make a PC-relative call to an external symbol +; [12] Reference a text-section symbol in the text section +; [13] Reference a data-section symbol in the text section +; [14] Reference a BSS-section symbol in the text section +; [15] Reference a text-section symbol in the data section +; [16] Reference a data-section symbol in the data section +; [17] Reference a BSS-section symbol in the data section +; [18] Define a non-global rodata-section symbol + + BITS 32 + GLOBAL lrotate ; [1] + GLOBAL greet ; [1] + GLOBAL asmstr ; [2] + GLOBAL textptr ; [2] + GLOBAL selfptr ; [2] + GLOBAL integer ; [3] + EXTERN printf ; [10] + COMMON commvar 4 ; [7] + + SECTION .text + +; prototype: long lrotate(long x, int num); +lrotate: ; [1] + push ebp + mov ebp,esp + mov eax,[ebp+8] + mov ecx,[ebp+12] +.label rol eax,1 ; [4] [8] + loop .label ; [9] [12] + mov esp,ebp + pop ebp + ret + +; prototype: void greet(void); +greet mov eax,[integer] ; [14] + inc eax + mov [localint],eax ; [14] + push dword [commvar] + mov eax,[localptr] ; [13] + push dword [eax] + push dword [integer] ; [1] [14] + push dword printfstr ; [13] + call printf ; [11] + add esp,16 + ret + + SECTION .data + +; a string +asmstr db 'hello, world', 0 ; [2] + +; a string for Printf +printfstr db "integer==%d, localint==%d, commvar=%d" + db 10, 0 + +; some pointers +localptr dd localint ; [5] [17] +textptr dd greet ; [15] +selfptr dd selfptr ; [16] + + SECTION .bss + +; an integer +integer resd 1 ; [3] + +; a local integer +localint resd 1 ; [6] + + SECTION .rodata +readonly dd readonly ; [18] diff --git a/test/elftest.c b/test/elftest.c new file mode 100644 index 0000000..42b3f7e --- /dev/null +++ b/test/elftest.c @@ -0,0 +1,38 @@ +/* + * test source file for assembling to ELF + * build with: + * nasm -f elf elftest.asm + * gcc -o elftest elftest.c elftest.o + * (assuming your gcc is ELF) + */ + +#include <stdio.h> +#include <inttypes.h> + +extern int lrotate(int32_t, int); +extern void greet(void); +extern int8_t asmstr[]; +extern void *selfptr; +extern void *textptr; +extern int integer, commvar; + +int main(void) +{ + + printf("Testing lrotate: should get 0x00400000, 0x00000001\n"); + printf("lrotate(0x00040000, 4) = 0x%08lx\n", lrotate(0x40000, 4)); + printf("lrotate(0x00040000, 14) = 0x%08lx\n", lrotate(0x40000, 14)); + + printf("This string should read `hello, world': `%s'\n", asmstr); + + printf("The integers here should be 1234, 1235 and 4321:\n"); + integer = 1234; + commvar = 4321; + greet(); + + printf("These pointers should be equal: %p and %p\n", &greet, textptr); + + printf("So should these: %p and %p\n", selfptr, &selfptr); + + return 0; +} diff --git a/test/elftest64.c b/test/elftest64.c new file mode 100644 index 0000000..1f3dec1 --- /dev/null +++ b/test/elftest64.c @@ -0,0 +1,43 @@ +/* + * build with: + * nasm -f elf64 elf64so.asm + * ld -shared -o elf64so.so elf64so.o + * test with: + * gcc -o elf64so elftest64.c ./elf64so.so + * ./elf64so + */ + +#include <stdio.h> +#include <inttypes.h> + +extern long lrotate(long, int); +extern void greet_s(void); +extern void greet_m(void); +extern int8_t asmstr[]; +extern void *selfptr; +extern void *textptr; +extern long integer; +long commvar; + +int main(void) +{ + + printf("Testing lrotate: should get 0x00400000, 0x00000001\n"); + printf("lrotate(0x00040000, 4) = 0x%08lx\n", lrotate(0x40000, 4)); + printf("lrotate(0x00040000, 46) = 0x%08lx\n", lrotate(0x40000, 46)); + + printf("This string should read `hello, world': `%s'\n", asmstr); + + printf("&integer = %p, &commvar = %p\n", &integer, &commvar); + printf("The integers here should be 1234, 1235 and 4321:\n"); + integer = 1234; + commvar = 4321; + greet_s(); + greet_m(); + + printf("These pointers should be equal: %p and %p\n", &greet_s, textptr); + + printf("So should these: %p and %p\n", selfptr, &selfptr); + + return 0; +} diff --git a/test/elif.asm b/test/elif.asm new file mode 100644 index 0000000..49e6668 --- /dev/null +++ b/test/elif.asm @@ -0,0 +1,39 @@ +;Testname=unoptimized; Arguments=-O0 -fobj -oelif.obj; Files=stdout stderr elif.obj +;Testname=optimized; Arguments=-Ox -fobj -oelif.obj; Files=stdout stderr elif.obj + +%macro DosPrintMsg 1+ +%ifnid %1 +section .data +%%str_to_print:db %1 +section .text + mov dx,%%str_to_print + mov ah,9 + int 0x21 +%else + mov dx,(%1) + mov ah,9 + int 0x21 +%endif +%endmacro + +%macro DosExit 1 +%if (%1) == 0 +;use short-form return 0 exit + int 0x20 +%elif ((%1) < 256) && ((%1) > 0) + mov ax,0x4C00 | (%1) + int 0x21 +%else +%error Invalid return value +%endif +%endmacro + +org 0x100 + DosPrintMsg predefined_str + DosPrintMsg "Using string with macro-defined label",10,0 + DosExit 0 + DosExit 1 + DosExit 256 + +section .data +predefined_str:db "Using string with predefined label",10,0 diff --git a/test/expimp.asm b/test/expimp.asm new file mode 100644 index 0000000..89e32a1 --- /dev/null +++ b/test/expimp.asm @@ -0,0 +1,90 @@ +;Testname=O0; Arguments=-O0 -fbin -oexpimp.bin; Files=stdout stderr expimp.bin +;Testname=O1; Arguments=-O1 -fbin -oexpimp.bin; Files=stdout stderr expimp.bin +;Testname=Ox; Arguments=-Ox -fbin -oexpimp.bin; Files=stdout stderr expimp.bin +;Testname=error-O0; Arguments=-O0 -fbin -oexpimp.bin -DERROR; Files=stdout stderr expimp.bin +;Testname=error-Ox; Arguments=-Ox -fbin -oexpimp.bin -DERROR; Files=stdout stderr expimp.bin + +; +; Test of explicitly and implicitly sized operands +; + BITS 32 + + add esi,2 ; Implicit + add esi,123456h ; Implicit + add esi,byte 2 ; Explicit + add esi,dword 2 ; Explicit + add esi,dword 123456h ; Explicit + add esi,byte 123456h ; Explicit Truncation + + add esi,strict 2 ; Implicit Strict + add esi,strict 123456h ; Implicit Strict + add esi,strict byte 2 ; Explicit Strict + add esi,strict dword 2 ; Explicit Strict + add esi,strict dword 123456h ; Explicit Strict + add esi,strict byte 123456h ; Explicit Strict Truncation + + add eax,2 ; Implicit + add eax,123456h ; Implicit + add eax,byte 2 ; Explicit + add eax,dword 2 ; Explicit + add eax,dword 123456h ; Explicit + add eax,byte 123456h ; Explicit Truncation + + add eax,strict 2 ; Implicit Strict + add eax,strict 123456h ; Implicit Strict + add eax,strict byte 2 ; Explicit Strict + add eax,strict dword 2 ; Explicit Strict + add eax,strict dword 123456h ; Explicit Strict + add eax,strict byte 123456h ; Explicit Strict Truncation + + imul dx,3 ; Implicit + imul dx,byte 3 ; Explicit + imul dx,word 3 ; Explicit + imul dx,strict byte 3 ; Explicit Strict + imul dx,strict word 3 ; Explicit Strict + +; +; Same thing with branches +; +start: + jmp short start ; Explicit + jmp near start ; Explicit + jmp word start ; Explicit + jmp dword start ; Explicit + jmp short forward ; Explicit + jmp near forward ; Explicit + jmp word forward ; Explicit + jmp dword forward ; Explicit +%ifdef ERROR + jmp short faraway ; Explicit (ERROR) +%endif + jmp near faraway ; Explicit + jmp word faraway ; Explicit + jmp dword faraway ; Explicit + jmp start ; Implicit + jmp forward ; Implicit + jmp faraway ; Implicit + + jmp strict short start ; Explicit Strict + jmp strict near start ; Explicit Strict + jmp strict word start ; Explicit Strict + jmp strict dword start ; Explicit Strict + jmp strict short forward ; Explicit Strict + jmp strict near forward ; Explicit Strict + jmp strict word forward ; Explicit Strict + jmp strict dword forward ; Explicit Strict +%ifdef ERROR + jmp strict short faraway ; Explicit (ERROR) +%endif + jmp strict near faraway ; Explicit Strict + jmp strict word faraway ; Explicit Strict + jmp strict dword faraway ; Explicit Strict + jmp strict start ; Implicit Strict + jmp strict forward ; Implicit Strict + jmp strict faraway ; Implicit Strict +forward: + + times 256 nop +faraway: + + diff --git a/test/far64.asm b/test/far64.asm new file mode 100644 index 0000000..e18bca4 --- /dev/null +++ b/test/far64.asm @@ -0,0 +1,10 @@ +;Testname=test; Arguments=-fbin -ofar64.bin; Files=stdout stderr far64.bin +; BR 2039212 + bits 64 + + call qword far [rax] + jmp qword far [rax] + call dword far [rax] + jmp dword far [rax] + call far [rax] + jmp far [rax] diff --git a/test/float.asm b/test/float.asm new file mode 100644 index 0000000..88519b2 --- /dev/null +++ b/test/float.asm @@ -0,0 +1,186 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -ofloat.bin; Files=stdout stderr float.bin +;Testname=optimized; Arguments=-Ox -fbin -ofloat.bin; Files=stdout stderr float.bin + +; +; Test of floating-point formats +; + +; 8-bit + db 1.0 + db +1.0 + db -1.0 + db 1.5 + db +1.5 + db -1.5 + db 0.0 + db +0.0 + db -0.0 + db 1.83203125 + db +1.83203125 + db -1.83203125 + db 1.83203125e1 + db +1.83203125e1 + db -1.83203125e1 + db 1.83203125e-1 + db +1.83203125e-1 + db -1.83203125e-1 + db 1.13203125e-2 ; Denormal! + db +1.13203125e-2 ; Denormal! + db -1.13203125e-2 ; Denormal! + db __Infinity__ + db +__Infinity__ + db -__Infinity__ + db __NaN__ + db __QNaN__ + db __SNaN__ + db 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 + +; 16-bit + dw 1.0 + dw +1.0 + dw -1.0 + dw 1.5 + dw +1.5 + dw -1.5 + dw 0.0 + dw +0.0 + dw -0.0 + dw 1.83203125 + dw +1.83203125 + dw -1.83203125 + dw 1.83203125e3 + dw +1.83203125e3 + dw -1.83203125e3 + dw 1.83203125e-3 + dw +1.83203125e-3 + dw -1.83203125e-3 + dw 1.83203125e-6 ; Denormal! + dw +1.83203125e-6 ; Denormal! + dw -1.83203125e-6 ; Denormal! + dw __Infinity__ + dw +__Infinity__ + dw -__Infinity__ + dw __NaN__ + dw __QNaN__ + dw __SNaN__ + dw 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 + +; 32-bit + dd 1.0 + dd +1.0 + dd -1.0 + dd 1.5 + dd +1.5 + dd -1.5 + dd 0.0 + dd +0.0 + dd -0.0 + dd 1.83203125 + dd +1.83203125 + dd -1.83203125 + dd 1.83203125e15 + dd +1.83203125e15 + dd -1.83203125e15 + dd 1.83203125e-15 + dd +1.83203125e-15 + dd -1.83203125e-15 + dd 1.83203125e-40 ; Denormal! + dd +1.83203125e-40 ; Denormal! + dd -1.83203125e-40 ; Denormal! + dd __Infinity__ + dd +__Infinity__ + dd -__Infinity__ + dd __NaN__ + dd __QNaN__ + dd __SNaN__ + dd 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 + +; 64-bit + dq 1.0 + dq +1.0 + dq -1.0 + dq 1.5 + dq +1.5 + dq -1.5 + dq 0.0 + dq +0.0 + dq -0.0 + dq 1.83203125 + dq +1.83203125 + dq -1.83203125 + dq 1.83203125e300 + dq +1.83203125e300 + dq -1.83203125e300 + dq 1.83203125e-300 + dq +1.83203125e-300 + dq -1.83203125e-300 + dq 1.83203125e-320 ; Denormal! + dq +1.83203125e-320 ; Denormal! + dq -1.83203125e-320 ; Denormal! + dq __Infinity__ + dq +__Infinity__ + dq -__Infinity__ + dq __NaN__ + dq __QNaN__ + dq __SNaN__ + dq 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 + +; 80-bit + dt 1.0 + dt +1.0 + dt -1.0 + dt 1.5 + dt +1.5 + dt -1.5 + dt 0.0 + dt +0.0 + dt -0.0 + dt 1.83203125 + dt +1.83203125 + dt -1.83203125 + dt 1.83203125e+4000 + dt +1.83203125e+4000 + dt -1.83203125e+4000 + dt 1.83203125e-4000 + dt +1.83203125e-4000 + dt -1.83203125e-4000 + dt 1.83203125e-4940 ; Denormal! + dt +1.83203125e-4940 ; Denormal! + dt -1.83203125e-4940 ; Denormal! + dt __Infinity__ + dt +__Infinity__ + dt -__Infinity__ + dt __NaN__ + dt __QNaN__ + dt __SNaN__ + dt 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 + +; 128-bit + do 1.0 + do +1.0 + do -1.0 + do 1.5 + do +1.5 + do -1.5 + do 0.0 + do +0.0 + do -0.0 + do 1.83203125 + do +1.83203125 + do -1.83203125 + do 1.83203125e+4000 + do +1.83203125e+4000 + do -1.83203125e+4000 + do 1.83203125e-4000 + do +1.83203125e-4000 + do -1.83203125e-4000 + do 1.83203125e-4940 ; Denormal! + do +1.83203125e-4940 ; Denormal! + do -1.83203125e-4940 ; Denormal! + do __Infinity__ + do +__Infinity__ + do -__Infinity__ + do __NaN__ + do __QNaN__ + do __SNaN__ + do 3.1415926535_8979323846_2643383279_5028841971_6939937510_5 diff --git a/test/float8.asm b/test/float8.asm new file mode 100644 index 0000000..d59abec --- /dev/null +++ b/test/float8.asm @@ -0,0 +1,135 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -ofloat8.bin; Files=stdout stderr float8.bin +;Testname=optimized; Arguments=-Ox -fbin -ofloat8.bin; Files=stdout stderr float8.bin + +; Test of 8-bit floating-point constants + + ; Zero + db 0.0 ; 00h + + ; Denorms + db 0.001953125 ; 01h + db 0.00390625 ; 02h + db 0.005859375 ; 03h + db 0.0078125 ; 04h + db 0.009765625 ; 05h + db 0.01171875 ; 06h + db 0.013671875 ; 07h + + ; Normals + db 0.015625 ; 08h + db 0.017578125 ; 09h + db 0.01953125 ; 0Ah + db 0.021484375 ; 0Bh + db 0.0234375 ; 0Ch + db 0.025390625 ; 0Dh + db 0.02734375 ; 0Eh + db 0.029296875 ; 0Fh + db 0.03125 ; 10h + db 0.03515625 ; 11h + db 0.0390625 ; 12h + db 0.04296875 ; 13h + db 0.046875 ; 14h + db 0.05078125 ; 15h + db 0.0546875 ; 16h + db 0.05859375 ; 17h + db 0.0625 ; 18h + db 0.0703125 ; 19h + db 0.078125 ; 1Ah + db 0.0859375 ; 1Bh + db 0.09375 ; 1Ch + db 0.1015625 ; 1Dh + db 0.109375 ; 1Eh + db 0.1171875 ; 1Fh + db 0.125 ; 20h + db 0.140625 ; 21h + db 0.15625 ; 22h + db 0.171875 ; 23h + db 0.1875 ; 24h + db 0.203125 ; 25h + db 0.21875 ; 26h + db 0.234375 ; 27h + db 0.25 ; 28h + db 0.28125 ; 29h + db 0.3125 ; 2Ah + db 0.34375 ; 2Bh + db 0.375 ; 2Ch + db 0.40625 ; 2Dh + db 0.4375 ; 2Eh + db 0.46875 ; 2Fh + db 0.5 ; 30h + db 0.5625 ; 31h + db 0.625 ; 32h + db 0.6875 ; 33h + db 0.75 ; 34h + db 0.8125 ; 35h + db 0.875 ; 36h + db 0.9375 ; 37h + db 1.0 ; 38h + db 1.125 ; 39h + db 1.25 ; 3Ah + db 1.375 ; 3Bh + db 1.5 ; 3Ch + db 1.625 ; 3Dh + db 1.75 ; 3Eh + db 1.875 ; 3Fh + db 2.0 ; 40h + db 2.25 ; 41h + db 2.5 ; 42h + db 2.75 ; 43h + db 3.0 ; 44h + db 3.25 ; 45h + db 3.5 ; 46h + db 3.75 ; 47h + db 4.0 ; 48h + db 4.5 ; 49h + db 5.0 ; 4Ah + db 5.5 ; 4Bh + db 6.0 ; 4Ch + db 6.5 ; 4Dh + db 7.0 ; 4Eh + db 7.5 ; 4Fh + db 8.0 ; 50h + db 9.0 ; 51h + db 10.0 ; 52h + db 11.0 ; 53h + db 12.0 ; 54h + db 13.0 ; 55h + db 14.0 ; 56h + db 15.0 ; 57h + db 16.0 ; 58h + db 18.0 ; 59h + db 20.0 ; 5Ah + db 22.0 ; 5Bh + db 24.0 ; 5Ch + db 26.0 ; 5Dh + db 28.0 ; 5Eh + db 30.0 ; 5Fh + db 32.0 ; 60h + db 36.0 ; 61h + db 40.0 ; 62h + db 44.0 ; 63h + db 48.0 ; 64h + db 52.0 ; 65h + db 56.0 ; 66h + db 60.0 ; 67h + db 64.0 ; 68h + db 72.0 ; 69h + db 80.0 ; 6Ah + db 88.0 ; 6Bh + db 96.0 ; 6Ch + db 104.0 ; 6Dh + db 112.0 ; 6Eh + db 120.0 ; 6Fh + db 128.0 ; 70h + db 144.0 ; 71h + db 160.0 ; 72h + db 176.0 ; 73h + db 192.0 ; 74h + db 208.0 ; 75h + db 224.0 ; 76h + db 240.0 ; 77h + + ; Exceptionals + db __Infinity__ ; 78h + db __SNaN__ ; 79h + db __QNaN__ ; 7Ch diff --git a/test/floatb.asm b/test/floatb.asm new file mode 100644 index 0000000..dc0422e --- /dev/null +++ b/test/floatb.asm @@ -0,0 +1,35 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -ofloatb.bin; Files=stdout stderr floatb.bin +;Testname=optimized; Arguments=-Ox -fbin -ofloatb.bin; Files=stdout stderr floatb.bin + + ;; Known problematic floating-point numbers and their proper + ;; encoding... + + bits 64 + + dd 1.1e10 + dd 0x5023e9ac ; Should be... + + dd 50.40e9 + dd 0x513bc130 ; Should be... + + dq 1.4e23 + dq 0x44bda56a4b0835c0 + + dq 50.48e21 + dq 0x44a5610d7502feae + + dt 1.2e28 + dq 0x9b18ab5df7180b6c + dw 0x405c + + dt 50.46e25 + dq 0xd0b29a67e95dcb60 + dw 0x4057 + + ;; Way too big numbers, should overflow to +Inf + dd 1.0E646456955 + dd 1.0E646456956 + dd 1.0E2147483646 + dd 1.0E2147483647 + dd 1.0E2147483648 + dd 1.0E2147483649 diff --git a/test/floatexp.asm b/test/floatexp.asm new file mode 100644 index 0000000..2bc359e --- /dev/null +++ b/test/floatexp.asm @@ -0,0 +1,382 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -ofloatexp.bin; Files=stdout stderr floatexp.bin +;Testname=optimized; Arguments=-Ox -fbin -ofloatexp.bin; Files=stdout stderr floatexp.bin + + bits 64 +; +; Test of floating-point formats +; + +; 8-bit + mov al,__float8__(1.0) + mov al,__float8__(+1.0) + mov al,__float8__(-1.0) + mov al,__float8__(0.0) + mov al,__float8__(+0.0) + mov al,__float8__(-0.0) + mov al,__float8__(1.83203125) + mov al,__float8__(+1.83203125) + mov al,__float8__(-1.83203125) + mov al,__float8__(1.83203125e1) + mov al,__float8__(+1.83203125e1) + mov al,__float8__(-1.83203125e1) + mov al,__float8__(1.83203125e-1) + mov al,__float8__(+1.83203125e-1) + mov al,__float8__(-1.83203125e-1) + mov al,__float8__(1.13203125e-2) ; Denormal! + mov al,__float8__(+1.13203125e-2) ; Denormal! + mov al,__float8__(-1.13203125e-2) ; Denormal! + mov al,__float8__(__Infinity__) + mov al,__float8__(+__Infinity__) + mov al,__float8__(-__Infinity__) + mov al,__float8__(__NaN__) + mov al,__float8__(__QNaN__) + mov al,__float8__(__SNaN__) + +; 16-bit + mov ax,__float16__(1.0) + mov ax,__float16__(+1.0) + mov ax,__float16__(-1.0) + mov ax,__float16__(0.0) + mov ax,__float16__(+0.0) + mov ax,__float16__(-0.0) + mov ax,__float16__(1.83203125) + mov ax,__float16__(+1.83203125) + mov ax,__float16__(-1.83203125) + mov ax,__float16__(1.83203125e3) + mov ax,__float16__(+1.83203125e3) + mov ax,__float16__(-1.83203125e3) + mov ax,__float16__(1.83203125e-3) + mov ax,__float16__(+1.83203125e-3) + mov ax,__float16__(-1.83203125e-3) + mov ax,__float16__(1.83203125e-6) ; Denormal! + mov ax,__float16__(+1.83203125e-6) ; Denormal! + mov ax,__float16__(-1.83203125e-6) ; Denormal! + mov ax,__float16__(__Infinity__) + mov ax,__float16__(+__Infinity__) + mov ax,__float16__(-__Infinity__) + mov ax,__float16__(__NaN__) + mov ax,__float16__(__QNaN__) + mov ax,__float16__(__SNaN__) + +; 32-bit + mov eax,__float32__(1.0) + mov eax,__float32__(+1.0) + mov eax,__float32__(-1.0) + mov eax,__float32__(0.0) + mov eax,__float32__(+0.0) + mov eax,__float32__(-0.0) + mov eax,__float32__(1.83203125) + mov eax,__float32__(+1.83203125) + mov eax,__float32__(-1.83203125) + mov eax,__float32__(1.83203125e15) + mov eax,__float32__(+1.83203125e15) + mov eax,__float32__(-1.83203125e15) + mov eax,__float32__(1.83203125e-15) + mov eax,__float32__(+1.83203125e-15) + mov eax,__float32__(-1.83203125e-15) + mov eax,__float32__(1.83203125e-40) ; Denormal! + mov eax,__float32__(+1.83203125e-40) ; Denormal! + mov eax,__float32__(-1.83203125e-40) ; Denormal! + mov eax,__float32__(__Infinity__) + mov eax,__float32__(+__Infinity__) + mov eax,__float32__(-__Infinity__) + mov eax,__float32__(__NaN__) + mov eax,__float32__(__QNaN__) + mov eax,__float32__(__SNaN__) + +; 64-bit + mov rax,__float64__(1.0) + mov rax,__float64__(+1.0) + mov rax,__float64__(-1.0) + mov rax,__float64__(0.0) + mov rax,__float64__(+0.0) + mov rax,__float64__(-0.0) + mov rax,__float64__(1.83203125) + mov rax,__float64__(+1.83203125) + mov rax,__float64__(-1.83203125) + mov rax,__float64__(1.83203125e300) + mov rax,__float64__(+1.83203125e300) + mov rax,__float64__(-1.83203125e300) + mov rax,__float64__(1.83203125e-300) + mov rax,__float64__(+1.83203125e-300) + mov rax,__float64__(-1.83203125e-300) + mov rax,__float64__(1.83203125e-320) ; Denormal! + mov rax,__float64__(+1.83203125e-320) ; Denormal! + mov rax,__float64__(-1.83203125e-320) ; Denormal! + mov rax,__float64__(__Infinity__) + mov rax,__float64__(+__Infinity__) + mov rax,__float64__(-__Infinity__) + mov rax,__float64__(__NaN__) + mov rax,__float64__(__QNaN__) + mov rax,__float64__(__SNaN__) + +; 80-bit + mov rax,__float80m__(1.0) + mov ax,__float80e__(1.0) + mov rax,__float80m__(+1.0) + mov ax,__float80e__(+1.0) + mov rax,__float80m__(-1.0) + mov ax,__float80e__(-1.0) + mov rax,__float80m__(0.0) + mov ax,__float80e__(0.0) + mov rax,__float80m__(+0.0) + mov ax,__float80e__(+0.0) + mov rax,__float80m__(-0.0) + mov ax,__float80e__(-0.0) + mov rax,__float80m__(1.83203125) + mov ax,__float80e__(1.83203125) + mov rax,__float80m__(+1.83203125) + mov ax,__float80e__(+1.83203125) + mov rax,__float80m__(-1.83203125) + mov ax,__float80e__(-1.83203125) + mov rax,__float80m__(1.83203125e+4000) + mov ax,__float80e__(1.83203125e+4000) + mov rax,__float80m__(+1.83203125e+4000) + mov ax,__float80e__(+1.83203125e+4000) + mov rax,__float80m__(-1.83203125e+4000) + mov ax,__float80e__(-1.83203125e+4000) + mov rax,__float80m__(1.83203125e-4000) + mov ax,__float80e__(1.83203125e-4000) + mov rax,__float80m__(+1.83203125e-4000) + mov ax,__float80e__(+1.83203125e-4000) + mov rax,__float80m__(-1.83203125e-4000) + mov ax,__float80e__(-1.83203125e-4000) + mov rax,__float80m__(1.83203125e-4940) ; Denormal! + mov ax,__float80e__(1.83203125e-4940) ; Denormal! + mov rax,__float80m__(+1.83203125e-4940) ; Denormal! + mov ax,__float80e__(+1.83203125e-4940) ; Denormal! + mov rax,__float80m__(-1.83203125e-4940) ; Denormal! + mov ax,__float80e__(-1.83203125e-4940) ; Denormal! + mov rax,__float80m__(__Infinity__) + mov ax,__float80e__(__Infinity__) + mov rax,__float80m__(+__Infinity__) + mov ax,__float80e__(+__Infinity__) + mov rax,__float80m__(-__Infinity__) + mov ax,__float80e__(-__Infinity__) + mov rax,__float80m__(__NaN__) + mov ax,__float80e__(__NaN__) + mov rax,__float80m__(__QNaN__) + mov ax,__float80e__(__QNaN__) + mov rax,__float80m__(__SNaN__) + mov ax,__float80e__(__SNaN__) + +; 128-bit + mov rax,__float128l__(1.0) + mov rax,__float128h__(1.0) + mov rax,__float128l__(+1.0) + mov rax,__float128h__(+1.0) + mov rax,__float128l__(-1.0) + mov rax,__float128h__(-1.0) + mov rax,__float128l__(0.0) + mov rax,__float128h__(0.0) + mov rax,__float128l__(+0.0) + mov rax,__float128h__(+0.0) + mov rax,__float128l__(-0.0) + mov rax,__float128h__(-0.0) + mov rax,__float128l__(1.83203125) + mov rax,__float128h__(1.83203125) + mov rax,__float128l__(+1.83203125) + mov rax,__float128h__(+1.83203125) + mov rax,__float128l__(-1.83203125) + mov rax,__float128h__(-1.83203125) + mov rax,__float128l__(1.83203125e+4000) + mov rax,__float128h__(1.83203125e+4000) + mov rax,__float128l__(+1.83203125e+4000) + mov rax,__float128h__(+1.83203125e+4000) + mov rax,__float128l__(-1.83203125e+4000) + mov rax,__float128h__(-1.83203125e+4000) + mov rax,__float128l__(1.83203125e-4000) + mov rax,__float128h__(1.83203125e-4000) + mov rax,__float128l__(+1.83203125e-4000) + mov rax,__float128h__(+1.83203125e-4000) + mov rax,__float128l__(-1.83203125e-4000) + mov rax,__float128h__(-1.83203125e-4000) + mov rax,__float128l__(1.83203125e-4940) ; Denormal! + mov rax,__float128h__(1.83203125e-4940) ; Denormal! + mov rax,__float128l__(+1.83203125e-4940) ; Denormal! + mov rax,__float128h__(+1.83203125e-4940) ; Denormal! + mov rax,__float128l__(-1.83203125e-4940) ; Denormal! + mov rax,__float128h__(-1.83203125e-4940) ; Denormal! + mov rax,__float128l__(__Infinity__) + mov rax,__float128h__(__Infinity__) + mov rax,__float128l__(+__Infinity__) + mov rax,__float128h__(+__Infinity__) + mov rax,__float128l__(-__Infinity__) + mov rax,__float128h__(-__Infinity__) + mov rax,__float128l__(__NaN__) + mov rax,__float128h__(__NaN__) + mov rax,__float128l__(__QNaN__) + mov rax,__float128h__(__QNaN__) + mov rax,__float128l__(__SNaN__) + mov rax,__float128h__(__SNaN__) + +; +; Test hexadecimal floating-point numbers +; + +; 16-bit + mov ax,__float16__(1.0) + mov ax,__float16__(0x1.0) + mov ax,__float16__(2.0) + mov ax,__float16__(0x2.0) + mov ax,__float16__(0x1.0p+1) + mov ax,__float16__(0x1.0p-1) + mov ax,__float16__(0x0.0) + mov ax,__float16__(0x1.23456789) + mov ax,__float16__(0x0.123456789) + mov ax,__float16__(0x0.0000123456789) + mov ax,__float16__(0x1.23456789p10) + mov ax,__float16__(0x1.23456789p+10) + mov ax,__float16__(0x1.23456789p-10) + mov ax,__float16__(0x0.123456789p10) + mov ax,__float16__(0x0.123456789p+10) + mov ax,__float16__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov ax,__float16__(0x0.0000123456789) + mov ax,__float16__(0x0.0000123456789p+10) + mov ax,__float16__(0x0.0000123456789p-10) + +; 32-bit + mov eax,__float32__(1.0) + mov eax,__float32__(0x1.0) + mov eax,__float32__(2.0) + mov eax,__float32__(0x2.0) + mov eax,__float32__(0x1.0p+1) + mov eax,__float32__(0x1.0p-1) + mov eax,__float32__(0x0.0) + mov eax,__float32__(0x1.23456789) + mov eax,__float32__(0x0.123456789) + mov eax,__float32__(0x0.0000123456789) + mov eax,__float32__(0x1.23456789p10) + mov eax,__float32__(0x1.23456789p+10) + mov eax,__float32__(0x1.23456789p-10) + mov eax,__float32__(0x0.123456789p10) + mov eax,__float32__(0x0.123456789p+10) + mov eax,__float32__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov eax,__float32__(0x0.0000123456789) + mov eax,__float32__(0x0.0000123456789p+10) + mov eax,__float32__(0x0.0000123456789p-10) + mov eax,__float32__(0x123456789.0) + mov eax,__float32__(0x0000123456789.0) + mov eax,__float32__(0x123456789.0p+0) + mov eax,__float32__(0x123456789.0p+64) + +; 64-bit + mov rax,__float64__(1.0) + mov rax,__float64__(0x1.0) + mov rax,__float64__(2.0) + mov rax,__float64__(0x2.0) + mov rax,__float64__(0x1.0p+1) + mov rax,__float64__(0x1.0p-1) + mov rax,__float64__(0x0.0) + mov rax,__float64__(0x1.23456789) + mov rax,__float64__(0x0.123456789) + mov rax,__float64__(0x0.0000123456789) + mov rax,__float64__(0x1.23456789p10) + mov rax,__float64__(0x1.23456789p+10) + mov rax,__float64__(0x1.23456789p-10) + mov rax,__float64__(0x0.123456789p10) + mov rax,__float64__(0x0.123456789p+10) + mov rax,__float64__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov rax,__float64__(0x0.0000123456789) + mov rax,__float64__(0x0.0000123456789p+10) + mov rax,__float64__(0x0.0000123456789p-10) + mov rax,__float64__(0x123456789.0) + mov rax,__float64__(0x0000123456789.0) + mov rax,__float64__(0x123456789.0p+0) + mov rax,__float64__(0x123456789.0p+300) + +; 80-bit + mov rax,__float80m__(1.0) + mov ax,__float80e__(1.0) + mov rax,__float80m__(0x1.0) + mov ax,__float80e__(0x1.0) + mov rax,__float80m__(2.0) + mov ax,__float80e__(2.0) + mov rax,__float80m__(0x2.0) + mov ax,__float80e__(0x2.0) + mov rax,__float80m__(0x1.0p+1) + mov ax,__float80e__(0x1.0p+1) + mov rax,__float80m__(0x1.0p-1) + mov ax,__float80e__(0x1.0p-1) + mov rax,__float80m__(0x0.0) + mov ax,__float80e__(0x0.0) + mov rax,__float80m__(0x1.23456789) + mov ax,__float80e__(0x1.23456789) + mov rax,__float80m__(0x0.123456789) + mov ax,__float80e__(0x0.123456789) + mov rax,__float80m__(0x0.0000123456789) + mov ax,__float80e__(0x0.0000123456789) + mov rax,__float80m__(0x1.23456789p10) + mov ax,__float80e__(0x1.23456789p10) + mov rax,__float80m__(0x1.23456789p+10) + mov ax,__float80e__(0x1.23456789p+10) + mov rax,__float80m__(0x1.23456789p-10) + mov ax,__float80e__(0x1.23456789p-10) + mov rax,__float80m__(0x0.123456789p10) + mov ax,__float80e__(0x0.123456789p10) + mov rax,__float80m__(0x0.123456789p+10) + mov ax,__float80e__(0x0.123456789p+10) + mov rax,__float80m__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov ax,__float80e__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov rax,__float80m__(0x0.0000123456789) + mov ax,__float80e__(0x0.0000123456789) + mov rax,__float80m__(0x0.0000123456789p+10) + mov ax,__float80e__(0x0.0000123456789p+10) + mov rax,__float80m__(0x0.0000123456789p-10) + mov ax,__float80e__(0x0.0000123456789p-10) + mov rax,__float80m__(0x123456789.0) + mov ax,__float80e__(0x123456789.0) + mov rax,__float80m__(0x0000123456789.0) + mov ax,__float80e__(0x0000123456789.0) + mov rax,__float80m__(0x123456789.0p+0) + mov ax,__float80e__(0x123456789.0p+0) + mov rax,__float80m__(0x123456789.0p+1024) + mov ax,__float80e__(0x123456789.0p+1024) + +; 128-bit + mov rax,__float128l__(1.0) + mov rax,__float128h__(1.0) + mov rax,__float128l__(0x1.0) + mov rax,__float128h__(0x1.0) + mov rax,__float128l__(2.0) + mov rax,__float128h__(2.0) + mov rax,__float128l__(0x2.0) + mov rax,__float128h__(0x2.0) + mov rax,__float128l__(0x1.0p+1) + mov rax,__float128h__(0x1.0p+1) + mov rax,__float128l__(0x1.0p-1) + mov rax,__float128h__(0x1.0p-1) + mov rax,__float128l__(0x0.0) + mov rax,__float128h__(0x0.0) + mov rax,__float128l__(0x1.23456789) + mov rax,__float128h__(0x1.23456789) + mov rax,__float128l__(0x0.123456789) + mov rax,__float128h__(0x0.123456789) + mov rax,__float128l__(0x0.0000123456789) + mov rax,__float128h__(0x0.0000123456789) + mov rax,__float128l__(0x1.23456789p10) + mov rax,__float128h__(0x1.23456789p10) + mov rax,__float128l__(0x1.23456789p+10) + mov rax,__float128h__(0x1.23456789p+10) + mov rax,__float128l__(0x1.23456789p-10) + mov rax,__float128h__(0x1.23456789p-10) + mov rax,__float128l__(0x0.123456789p10) + mov rax,__float128h__(0x0.123456789p10) + mov rax,__float128l__(0x0.123456789p+10) + mov rax,__float128h__(0x0.123456789p+10) + mov rax,__float128l__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov rax,__float128h__(0x0.123456789abcdef0123456789abcdef012345p-10) + mov rax,__float128l__(0x0.0000123456789) + mov rax,__float128h__(0x0.0000123456789) + mov rax,__float128l__(0x0.0000123456789p+10) + mov rax,__float128h__(0x0.0000123456789p+10) + mov rax,__float128l__(0x0.0000123456789p-10) + mov rax,__float128h__(0x0.0000123456789p-10) + mov rax,__float128l__(0x123456789.0) + mov rax,__float128h__(0x123456789.0) + mov rax,__float128l__(0x0000123456789.0) + mov rax,__float128h__(0x0000123456789.0) + mov rax,__float128l__(0x123456789.0p+0) + mov rax,__float128h__(0x123456789.0p+0) + mov rax,__float128l__(0x123456789.0p+1024) + mov rax,__float128h__(0x123456789.0p+1024) diff --git a/test/floatize.asm b/test/floatize.asm new file mode 100644 index 0000000..cc0bbe9 --- /dev/null +++ b/test/floatize.asm @@ -0,0 +1,19 @@ +;Testname=unoptimized; Arguments=-O0 -fbin -ofloatize.bin; Files=stdout stderr floatize.bin +;Testname=optimized; Arguments=-Ox -fbin -ofloatize.bin; Files=stdout stderr floatize.bin + +%assign x13 13+26 +%assign f16 __float16__(1.6e-7) +%assign f32 __float32__(1.6e-7) +%assign f64 __float64__(1.6e-7) +%assign f80m __float80m__(1.6e-7) +%assign f80e __float80e__(1.6e-7) +%assign f128l __float128l__(1.6e-7) +%assign f128h __float128h__(1.6e-7) + + dw f16 + dd f32 + dq f64 + dq f80m + dw f80e + dq f128l + dq f128h diff --git a/test/floattest.asm b/test/floattest.asm new file mode 100644 index 0000000..3c7ba8b --- /dev/null +++ b/test/floattest.asm @@ -0,0 +1,28 @@ +;Testname=optimized; Arguments=-Ox -felf -ofloattest.o; Files=stdout stderr floattest.o + +; nasm -O99 -f elf32 floattest.asm +; ld -m elf_i386 -o floattest floattest.o -I/lib/ld-linux.so.2 -lc + + global _start + extern printf + + section .text +_start: + + fld qword [num1] + fadd qword [num2] + sub esp, 8 + fstp qword [esp] + push fmt + call printf + add esp, 4*3 + + mov eax, 1 + xor ebx, ebx + int 80h + + section .data +num1 dq 41.5 +num2 dq 0.5 + +fmt db "%f", 10, 0 diff --git a/test/floatx.asm b/test/floatx.asm new file mode 100644 index 0000000..7368e50 --- /dev/null +++ b/test/floatx.asm @@ -0,0 +1,525 @@ +; +; floatx.asm +; +; Test hexadecimal floating-point numbers + +%define Inf __Infinity__ +%define NaN __QNaN__ + +; 16-bit + dw 1.0 + dw 0x1.0 + dw 2.0 + dw 0x2.0 + dw 0x1.0p+1 + dw 0x1.0p-1 + dw 0x0.0 + dw 0x1.23456789 + dw 0x0.123456789 + dw 0x0.0000123456789 + dw 0x1.23456789p10 + dw 0x1.23456789p+10 + dw 0x1.23456789p-10 + dw 0x0.123456789p10 + dw 0x0.123456789p+10 + dw 0x0.123456789abcdef0123456789abcdef012345p-10 + dw 0x0.0000123456789 + dw 0x0.0000123456789p+10 + dw 0x0.0000123456789p-10 + dw 0x1.0p-25 ; Underflow + dw 0x1.01p-25 ; Rounds to denorm + dw 0x1.0p-24 ; Smallest denorm + dw 0x1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm + dw 0x1.0p-15 ; Denorm + dw 0x1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal + dw 0x1.0p-14 ; Smallest non-denorm + dw 0x1.0p+15 ; Biggest possible exponent + dw 0x1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity + dw Inf ; Infinity + dw NaN + +; 32-bit + dd 1.0 + dd 0x1.0 + dd 2.0 + dd 0x2.0 + dd 0x1.0p+1 + dd 0x1.0p-1 + dd 0x0.0 + dd 0x1.23456789 + dd 0x0.123456789 + dd 0x0.0000123456789 + dd 0x1.23456789p10 + dd 0x1.23456789p+10 + dd 0x1.23456789p-10 + dd 0x0.123456789p10 + dd 0x0.123456789p+10 + dd 0x0.123456789abcdef0123456789abcdef012345p-10 + dd 0x0.0000123456789 + dd 0x0.0000123456789p+10 + dd 0x0.0000123456789p-10 + dd 0x123456789.0 + dd 0x0000123456789.0 + dd 0x123456789.0p+0 + dd 0x123456789.0p+64 + dd 0x1.0p-150 ; Underflow + dd 0x1.01p-150 ; Rounds to denorm + dd 0x1.0p-149 ; Smallest denorm + dd 0x1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm + dd 0x1.0p-127 ; Denorm + dd 0x1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal + dd 0x1.0p-126 ; Smallest non-denorm + dd 0x1.0p+127 ; Biggest possible exponent + dd 0x1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity + dd Inf ; Infinity + dd NaN + +; 64-bit + dq 1.0 + dq 0x1.0 + dq 2.0 + dq 0x2.0 + dq 0x1.0p+1 + dq 0x1.0p-1 + dq 0x0.0 + dq 0x1.23456789 + dq 0x0.123456789 + dq 0x0.0000123456789 + dq 0x1.23456789p10 + dq 0x1.23456789p+10 + dq 0x1.23456789p-10 + dq 0x0.123456789p10 + dq 0x0.123456789p+10 + dq 0x0.123456789abcdef0123456789abcdef012345p-10 + dq 0x0.0000123456789 + dq 0x0.0000123456789p+10 + dq 0x0.0000123456789p-10 + dq 0x123456789.0 + dq 0x0000123456789.0 + dq 0x123456789.0p+0 + dq 0x123456789.0p+300 + dq 0x1.0p-1075 ; Underflow + dq 0x1.01p-1075 ; Rounds to denorm + dq 0x1.0p-1074 ; Smallest denorm + dq 0x1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm + dq 0x1.0p-1023 ; Denorm + dq 0x1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal + dq 0x1.0p-1022 ; Smallest non-denorm + dq 0x1.0p+1023 ; Biggest possible exponent + dq 0x1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity + dq Inf ; Infinity + dq NaN + +; 80-bit + dt 1.0 + dt 0x1.0 + dt 2.0 + dt 0x2.0 + dt 0x1.0p+1 + dt 0x1.0p-1 + dt 0x0.0 + dt 0x1.23456789 + dt 0x0.123456789 + dt 0x0.0000123456789 + dt 0x1.23456789p10 + dt 0x1.23456789p+10 + dt 0x1.23456789p-10 + dt 0x0.123456789p10 + dt 0x0.123456789p+10 + dt 0x0.123456789abcdef0123456789abcdef012345p-10 + dt 0x0.0000123456789 + dt 0x0.0000123456789p+10 + dt 0x0.0000123456789p-10 + dt 0x123456789.0 + dt 0x0000123456789.0 + dt 0x123456789.0p+0 + dt 0x123456789.0p+1024 + dt 0x1.0p-16446 ; Underflow + dt 0x1.01p-16446 ; Rounds to denorm + dt 0x1.0p-16445 ; Smallest denorm + dt 0x1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + dt 0x1.0p-16383 ; Denorm + dt 0x1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal + dt 0x1.0p-16382 ; Smallest non-denorm + dt 0x1.0p+16383 ; Biggest possible exponent + dt 0x1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + dt Inf ; Infinity + dt NaN + +; 128-bit + do 1.0 + do 0x1.0 + do 2.0 + do 0x2.0 + do 0x1.0p+1 + do 0x1.0p-1 + do 0x0.0 + do 0x1.23456789 + do 0x0.123456789 + do 0x0.0000123456789 + do 0x1.23456789p10 + do 0x1.23456789p+10 + do 0x1.23456789p-10 + do 0x0.123456789p10 + do 0x0.123456789p+10 + do 0x0.123456789abcdef0123456789abcdef012345p-10 + do 0x0.0000123456789 + do 0x0.0000123456789p+10 + do 0x0.0000123456789p-10 + do 0x123456789.0 + do 0x0000123456789.0 + do 0x123456789.0p+0 + do 0x123456789.0p+1024 + do 0x1.0p-16495 ; Underflow + do 0x1.01p-16495 ; Rounds to denorm + do 0x1.0p-16494 ; Smallest denorm + do 0x1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + do 0x1.0p-16383 ; Denorm + do 0x1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal + do 0x1.0p-16382 ; Smallest non-denorm + do 0x1.0p+16383 ; Biggest possible exponent + do 0x1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + do Inf ; Infinity + do NaN + +; 16-bit + dw 1.0 + dw 0h1.0 + dw 2.0 + dw 0h2.0 + dw 0h1.0p+1 + dw 0h1.0p-1 + dw 0h0.0 + dw 0h1.23456789 + dw 0h0.123456789 + dw 0h0.0000123456789 + dw 0h1.23456789p10 + dw 0h1.23456789p+10 + dw 0h1.23456789p-10 + dw 0h0.123456789p10 + dw 0h0.123456789p+10 + dw 0h0.123456789abcdef0123456789abcdef012345p-10 + dw 0h0.0000123456789 + dw 0h0.0000123456789p+10 + dw 0h0.0000123456789p-10 + dw 0h1.0p-25 ; Underflow + dw 0h1.0p-24 ; Smallest denorm + dw 0h1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm + dw 0h1.0p-15 ; Denorm + dw 0h1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal + dw 0h1.0p-14 ; Smallest non-denorm + dw 0h1.0p+15 ; Biggest possible exponent + dw 0h1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity + dw Inf ; Infinity + dw NaN + +; 32-bit + dd 1.0 + dd 0h1.0 + dd 2.0 + dd 0h2.0 + dd 0h1.0p+1 + dd 0h1.0p-1 + dd 0h0.0 + dd 0h1.23456789 + dd 0h0.123456789 + dd 0h0.0000123456789 + dd 0h1.23456789p10 + dd 0h1.23456789p+10 + dd 0h1.23456789p-10 + dd 0h0.123456789p10 + dd 0h0.123456789p+10 + dd 0h0.123456789abcdef0123456789abcdef012345p-10 + dd 0h0.0000123456789 + dd 0h0.0000123456789p+10 + dd 0h0.0000123456789p-10 + dd 0h123456789.0 + dd 0h0000123456789.0 + dd 0h123456789.0p+0 + dd 0h123456789.0p+64 + dd 0h1.0p-150 ; Underflow + dd 0h1.0p-149 ; Smallest denorm + dd 0h1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm + dd 0h1.0p-127 ; Denorm + dd 0h1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal + dd 0h1.0p-126 ; Smallest non-denorm + dd 0h1.0p+127 ; Biggest possible exponent + dd 0h1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity + dd Inf ; Infinity + dd NaN + +; 64-bit + dq 1.0 + dq 0h1.0 + dq 2.0 + dq 0h2.0 + dq 0h1.0p+1 + dq 0h1.0p-1 + dq 0h0.0 + dq 0h1.23456789 + dq 0h0.123456789 + dq 0h0.0000123456789 + dq 0h1.23456789p10 + dq 0h1.23456789p+10 + dq 0h1.23456789p-10 + dq 0h0.123456789p10 + dq 0h0.123456789p+10 + dq 0h0.123456789abcdef0123456789abcdef012345p-10 + dq 0h0.0000123456789 + dq 0h0.0000123456789p+10 + dq 0h0.0000123456789p-10 + dq 0h123456789.0 + dq 0h0000123456789.0 + dq 0h123456789.0p+0 + dq 0h123456789.0p+300 + dq 0h1.0p-1075 ; Underflow + dq 0h1.0p-1074 ; Smallest denorm + dq 0h1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm + dq 0h1.0p-1023 ; Denorm + dq 0h1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal + dq 0h1.0p-1022 ; Smallest non-denorm + dq 0h1.0p+1023 ; Biggest possible exponent + dq 0h1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity + dq Inf ; Infinity + dq NaN + +; 80-bit + dt 1.0 + dt 0h1.0 + dt 2.0 + dt 0h2.0 + dt 0h1.0p+1 + dt 0h1.0p-1 + dt 0h0.0 + dt 0h1.23456789 + dt 0h0.123456789 + dt 0h0.0000123456789 + dt 0h1.23456789p10 + dt 0h1.23456789p+10 + dt 0h1.23456789p-10 + dt 0h0.123456789p10 + dt 0h0.123456789p+10 + dt 0h0.123456789abcdef0123456789abcdef012345p-10 + dt 0h0.0000123456789 + dt 0h0.0000123456789p+10 + dt 0h0.0000123456789p-10 + dt 0h123456789.0 + dt 0h0000123456789.0 + dt 0h123456789.0p+0 + dt 0h123456789.0p+1024 + dt 0h1.0p-16446 ; Underflow + dt 0h1.0p-16445 ; Smallest denorm + dt 0h1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + dt 0h1.0p-16383 ; Denorm + dt 0h1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal + dt 0h1.0p-16382 ; Smallest non-denorm + dt 0h1.0p+16383 ; Biggest possible exponent + dt 0h1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + dt Inf ; Infinity + dt NaN + +; 128-bit + do 1.0 + do 0h1.0 + do 2.0 + do 0h2.0 + do 0h1.0p+1 + do 0h1.0p-1 + do 0h0.0 + do 0h1.23456789 + do 0h0.123456789 + do 0h0.0000123456789 + do 0h1.23456789p10 + do 0h1.23456789p+10 + do 0h1.23456789p-10 + do 0h0.123456789p10 + do 0h0.123456789p+10 + do 0h0.123456789abcdef0123456789abcdef012345p-10 + do 0h0.0000123456789 + do 0h0.0000123456789p+10 + do 0h0.0000123456789p-10 + do 0h123456789.0 + do 0h0000123456789.0 + do 0h123456789.0p+0 + do 0h123456789.0p+1024 + do 0h1.0p-16495 ; Underflow + do 0h1.0p-16494 ; Smallest denorm + do 0h1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + do 0h1.0p-16383 ; Denorm + do 0h1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal + do 0h1.0p-16382 ; Smallest non-denorm + do 0h1.0p+16383 ; Biggest possible exponent + do 0h1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + do Inf ; Infinity + do NaN + +; 16-bit + dw 1.0 + dw $1.0 + dw 2.0 + dw $2.0 + dw $1.0p+1 + dw $1.0p-1 + dw $0.0 + dw $1.23456789 + dw $0.123456789 + dw $0.0000123456789 + dw $1.23456789p10 + dw $1.23456789p+10 + dw $1.23456789p-10 + dw $0.123456789p10 + dw $0.123456789p+10 + dw $0.123456789abcdef0123456789abcdef012345p-10 + dw $0.0000123456789 + dw $0.0000123456789p+10 + dw $0.0000123456789p-10 + dw $1.0p-25 ; Underflow + dw $1.0p-24 ; Smallest denorm + dw $1.ffffffffffffffffffffffffffffp-16 ; Rounds to denorm + dw $1.0p-15 ; Denorm + dw $1.ffffffffffffffffffffffffffffp-15 ; Rounds to normal + dw $1.0p-14 ; Smallest non-denorm + dw $1.0p+15 ; Biggest possible exponent + dw $1.ffffffffffffffffffffffffffffp+15 ; Rounds to infinity + dw Inf ; Infinity + dw NaN + +; 32-bit + dd 1.0 + dd $1.0 + dd 2.0 + dd $2.0 + dd $1.0p+1 + dd $1.0p-1 + dd $0.0 + dd $1.23456789 + dd $0.123456789 + dd $0.0000123456789 + dd $1.23456789p10 + dd $1.23456789p+10 + dd $1.23456789p-10 + dd $0.123456789p10 + dd $0.123456789p+10 + dd $0.123456789abcdef0123456789abcdef012345p-10 + dd $0.0000123456789 + dd $0.0000123456789p+10 + dd $0.0000123456789p-10 + dd $123456789.0 + dd $0000123456789.0 + dd $123456789.0p+0 + dd $123456789.0p+64 + dd $1.0p-150 ; Underflow + dd $1.0p-149 ; Smallest denorm + dd $1.ffffffffffffffffffffffffffffp-128 ; Rounds to denorm + dd $1.0p-127 ; Denorm + dd $1.ffffffffffffffffffffffffffffp-127 ; Rounds to normal + dd $1.0p-126 ; Smallest non-denorm + dd $1.0p+127 ; Biggest possible exponent + dd $1.ffffffffffffffffffffffffffffp+127 ; Rounds to infinity + dd Inf ; Infinity + dd NaN + +; 64-bit + dq 1.0 + dq $1.0 + dq 2.0 + dq $2.0 + dq $1.0p+1 + dq $1.0p-1 + dq $0.0 + dq $1.23456789 + dq $0.123456789 + dq $0.0000123456789 + dq $1.23456789p10 + dq $1.23456789p+10 + dq $1.23456789p-10 + dq $0.123456789p10 + dq $0.123456789p+10 + dq $0.123456789abcdef0123456789abcdef012345p-10 + dq $0.0000123456789 + dq $0.0000123456789p+10 + dq $0.0000123456789p-10 + dq $123456789.0 + dq $0000123456789.0 + dq $123456789.0p+0 + dq $123456789.0p+300 + dq $1.0p-1075 ; Underflow + dq $1.0p-1074 ; Smallest denorm + dq $1.ffffffffffffffffffffffffffffp-1024 ; Rounds to denorm + dq $1.0p-1023 ; Denorm + dq $1.ffffffffffffffffffffffffffffp-1023 ; Rounds to normal + dq $1.0p-1022 ; Smallest non-denorm + dq $1.0p+1023 ; Biggest possible exponent + dq $1.ffffffffffffffffffffffffffffp+1023 ; Rounds to infinity + dq Inf ; Infinity + dq NaN + +; 80-bit + dt 1.0 + dt $1.0 + dt 2.0 + dt $2.0 + dt $1.0p+1 + dt $1.0p-1 + dt $0.0 + dt $1.23456789 + dt $0.123456789 + dt $0.0000123456789 + dt $1.23456789p10 + dt $1.23456789p+10 + dt $1.23456789p-10 + dt $0.123456789p10 + dt $0.123456789p+10 + dt $0.123456789abcdef0123456789abcdef012345p-10 + dt $0.0000123456789 + dt $0.0000123456789p+10 + dt $0.0000123456789p-10 + dt $123456789.0 + dt $0000123456789.0 + dt $123456789.0p+0 + dt $123456789.0p+1024 + dt $1.0p-16446 ; Underflow + dt $1.0p-16445 ; Smallest denorm + dt $1.ffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + dt $1.0p-16383 ; Denorm + dt $1.ffffffffffffffffffffffffffffp-16383 ; Rounds to normal + dt $1.0p-16382 ; Smallest non-denorm + dt $1.0p+16383 ; Biggest possible exponent + dt $1.ffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + dt Inf ; Infinity + dt NaN + +; 128-bit + do 1.0 + do $1.0 + do 2.0 + do $2.0 + do $1.0p+1 + do $1.0p-1 + do $0.0 + do $1.23456789 + do $0.123456789 + do $0.0000123456789 + do $1.23456789p10 + do $1.23456789p+10 + do $1.23456789p-10 + do $0.123456789p10 + do $0.123456789p+10 + do $0.123456789abcdef0123456789abcdef012345p-10 + do $0.0000123456789 + do $0.0000123456789p+10 + do $0.0000123456789p-10 + do $123456789.0 + do $0000123456789.0 + do $123456789.0p+0 + do $123456789.0p+1024 + do $1.0p-16495 ; Underflow + do $1.0p-16494 ; Smallest denorm + do $1.ffffffffffffffffffffffffffffffffp-16384 ; Rounds to denorm + do $1.0p-16383 ; Denorm + do $1.ffffffffffffffffffffffffffffffffp-16383 ; Rounds to normal + do $1.0p-16382 ; Smallest non-denorm + do $1.0p+16383 ; Biggest possible exponent + do $1.ffffffffffffffffffffffffffffffffp+16383 ; Rounds to infinity + do Inf ; Infinity + do NaN diff --git a/test/fpu.asm b/test/fpu.asm new file mode 100644 index 0000000..4051fdd --- /dev/null +++ b/test/fpu.asm @@ -0,0 +1,127 @@ +;Testname=test; Arguments=-fbin -ofpu.bin; Files=stdout stderr fpu.bin + +; relaxed encodings for FPU instructions, which NASM should support +; ----------------------------------------------------------------- + +%define void +%define reg_fpu0 st0 +%define reg_fpu st1 + +; no operands instead of one operand: + + ; F(U)COM(P), FCOM2, FCOMP3, FCOMP5 + + FCOM void + FCOMP void + FUCOM void + FUCOMP void +; FCOM2 void +; FCOMP3 void +; FCOMP5 void + + ; FLD, FST, FSTP, FSTP1, FSTP8, FSTP9 + + FLD void + FST void + FSTP void +; FSTP1 void +; FSTP8 void +; FSTP9 void + + ; FXCH, FXCH4, FXCH7, FFREE, FFREEP + + FXCH void +; FXCH4 void +; FXCH7 void + FFREE void + FFREEP void + +; no operands instead of two operands: + + ; FADD(P), FMUL(P), FSUBR(P), FSUB(P), FDIVR(P), FDIV(P) + + FADD void + FADDP void + FMUL void + FMULP void + FSUBR void + FSUBRP void + FSUB void + FSUBP void + FDIVR void + FDIVRP void + FDIV void + FDIVP void + +; one operand instead of two operands: + + ; FADD, FMUL, FSUB, FSUBR, FDIV, FDIVR + + FADD reg_fpu + FMUL reg_fpu + FSUB reg_fpu + FSUBR reg_fpu + FDIV reg_fpu + FDIVR reg_fpu + + ; FADD, FMUL, FSUBR, FSUB, FDIVR, FDIV (with TO qualifier) + + FADD to reg_fpu + FMUL to reg_fpu + FSUBR to reg_fpu + FSUB to reg_fpu + FDIVR to reg_fpu + FDIV to reg_fpu + + ; FADDP, FMULP, FSUBRP, FSUBP, FDIVRP, FDIVP + + FADDP reg_fpu + FMULP reg_fpu + FSUBRP reg_fpu + FSUBP reg_fpu + FDIVRP reg_fpu + FDIVP reg_fpu + + ; FCMOV(N)B, FCMOV(N)E, FCMOV(N)BE, FCMOV(N)U, and F(U)COMI(P) + + FCMOVB reg_fpu + FCMOVNB reg_fpu + FCMOVE reg_fpu + FCMOVNE reg_fpu + FCMOVBE reg_fpu + FCMOVNBE reg_fpu + FCMOVU reg_fpu + FCMOVNU reg_fpu + FCOMI reg_fpu + FCOMIP reg_fpu + FUCOMI reg_fpu + FUCOMIP reg_fpu + +; two operands instead of one operand: + + ; these don't really exist, and thus are _NOT_ supported: + +; FCOM reg_fpu,reg_fpu0 +; FCOM reg_fpu0,reg_fpu +; FUCOM reg_fpu,reg_fpu0 +; FUCOM reg_fpu0,reg_fpu +; FCOMP reg_fpu,reg_fpu0 +; FCOMP reg_fpu0,reg_fpu +; FUCOMP reg_fpu,reg_fpu0 +; FUCOMP reg_fpu0,reg_fpu + +; FCOM2 reg_fpu,reg_fpu0 +; FCOM2 reg_fpu0,reg_fpu +; FCOMP3 reg_fpu,reg_fpu0 +; FCOMP3 reg_fpu0,reg_fpu +; FCOMP5 reg_fpu,reg_fpu0 +; FCOMP5 reg_fpu0,reg_fpu + +; FXCH reg_fpu,reg_fpu0 +; FXCH reg_fpu0,reg_fpu +; FXCH4 reg_fpu,reg_fpu0 +; FXCH4 reg_fpu0,reg_fpu +; FXCH7 reg_fpu,reg_fpu0 +; FXCH7 reg_fpu0,reg_fpu + +; EOF diff --git a/test/fwdopt.asm b/test/fwdopt.asm new file mode 100644 index 0000000..48dbc3f --- /dev/null +++ b/test/fwdopt.asm @@ -0,0 +1,133 @@ +;Testname=test; Arguments=-fbin -ofwdopt.bin; Files=stdout stderr fwdopt.bin +n0: jmp n1 +n1: jmp n2 +n2: jmp n3 +n3: jmp n4 +n4: jmp n5 +n5: jmp n6 +n6: jmp n7 +n7: jmp n8 +n8: jmp n9 +n9: jmp n10 +n10: jmp n11 +n11: jmp n12 +n12: jmp n13 +n13: jmp n14 +n14: jmp n15 +n15: jmp n16 +n16: jmp n17 +n17: jmp n18 +n18: jmp n19 +n19: jmp n20 +n20: jmp n21 +n21: jmp n22 +n22: jmp n23 +n23: jmp n24 +n24: jmp n25 +n25: jmp n26 +n26: jmp n27 +n27: jmp n28 +n28: jmp n29 +n29: jmp n30 +n30: jmp n31 +n31: jmp n32 +n32: jmp n33 +n33: jmp n34 +n34: jmp n35 +n35: jmp n36 +n36: jmp n37 +n37: jmp n38 +n38: jmp n39 +n39: jmp n40 +n40: jmp n41 +n41: jmp n42 +n42: jmp n43 +n43: jmp n44 +n44: jmp n45 +n45: jmp n46 +n46: jmp n47 +n47: jmp n48 +n48: jmp n49 +n49: jmp n50 +n50: jmp n51 +n51: jmp n52 +n52: jmp n53 +n53: jmp n54 +n54: jmp n55 +n55: jmp n56 +n56: jmp n57 +n57: jmp n58 +n58: jmp n59 +n59: jmp n60 +n60: jmp n61 +n61: jmp n62 +n62: jmp n63 +n63: jmp n64 +n64: jmp n65 +n65: jmp n66 +n66: jmp n67 +n67: jmp n68 +n68: jmp n69 +n69: jmp n70 +n70: jmp n71 +n71: jmp n72 +n72: jmp n73 +n73: jmp n74 +n74: jmp n75 +n75: jmp n76 +n76: jmp n77 +n77: jmp n78 +n78: jmp n79 +n79: jmp n80 +n80: jmp n81 +n81: jmp n82 +n82: jmp n83 +n83: jmp n84 +n84: jmp n85 +n85: jmp n86 +n86: jmp n87 +n87: jmp n88 +n88: jmp n89 +n89: jmp n90 +n90: jmp n91 +n91: jmp n92 +n92: jmp n93 +n93: jmp n94 +n94: jmp n95 +n95: jmp n96 +n96: jmp n97 +n97: jmp n98 +n98: jmp n99 +n99: jmp n100 +n100: jmp n101 +n101: jmp n102 +n102: jmp n103 +n103: jmp n104 +n104: jmp n105 +n105: jmp n106 +n106: jmp n107 +n107: jmp n108 +n108: jmp n109 +n109: jmp n110 +n110: jmp n111 +n111: jmp n112 +n112: jmp n113 +n113: jmp n114 +n114: jmp n115 +n115: jmp n116 +n116: jmp n117 +n117: jmp n118 +n118: jmp n119 +n119: jmp n120 +n120: jmp n121 +n121: jmp n122 +n122: jmp n123 +n123: jmp n124 +n124: jmp n125 +n125: jmp n126 +n126: jmp n127 +n127: jmp n0 + + ;; This should emit exactly 3 NOP bytes + times 260-($-$$) nop + hlt diff --git a/test/fwdoptpp.asm b/test/fwdoptpp.asm new file mode 100644 index 0000000..e1f5dd6 --- /dev/null +++ b/test/fwdoptpp.asm @@ -0,0 +1,150 @@ +;Testname=error; Arguments=-fbin -DERROR -ofwdoptpp.bin; Files=stdout stderr fwdoptpp.bin +;Testname=fatal; Arguments=-fbin -DFATAL -ofwdoptpp.bin; Files=stdout stderr fwdoptpp.bin +;Testname=warning; Arguments=-fbin -DWARNING -ofwdoptpp.bin; Files=stdout stderr fwdoptpp.bin + +%ifndef ERROR + %ifndef FATAL + %ifndef WARNING + %define ERROR 1 + %endif + %endif +%endif + +n0: jmp n1 +n1: jmp n2 +n2: jmp n3 +n3: jmp n4 +n4: jmp n5 +n5: jmp n6 +n6: jmp n7 +n7: jmp n8 +n8: jmp n9 +n9: jmp n10 +n10: jmp n11 +n11: jmp n12 +n12: jmp n13 +n13: jmp n14 +n14: jmp n15 +n15: jmp n16 +n16: jmp n17 +n17: jmp n18 +n18: jmp n19 +n19: jmp n20 +n20: jmp n21 +n21: jmp n22 +n22: jmp n23 +n23: jmp n24 +n24: jmp n25 +n25: jmp n26 +n26: jmp n27 +n27: jmp n28 +n28: jmp n29 +n29: jmp n30 +n30: jmp n31 +n31: jmp n32 +n32: jmp n33 +n33: jmp n34 +n34: jmp n35 +n35: jmp n36 +n36: jmp n37 +n37: jmp n38 +n38: jmp n39 +n39: jmp n40 +n40: jmp n41 +n41: jmp n42 +n42: jmp n43 +n43: jmp n44 +n44: jmp n45 +n45: jmp n46 +n46: jmp n47 +n47: jmp n48 +n48: jmp n49 +n49: jmp n50 +n50: jmp n51 +n51: jmp n52 +n52: jmp n53 +n53: jmp n54 +n54: jmp n55 +n55: jmp n56 +n56: jmp n57 +n57: jmp n58 +n58: jmp n59 +n59: jmp n60 +n60: jmp n61 +n61: jmp n62 +n62: jmp n63 +n63: jmp n64 +n64: jmp n65 +n65: jmp n66 +n66: jmp n67 +n67: jmp n68 +n68: jmp n69 +n69: jmp n70 +n70: jmp n71 +n71: jmp n72 +n72: jmp n73 +n73: jmp n74 +n74: jmp n75 +n75: jmp n76 +n76: jmp n77 +n77: jmp n78 +n78: jmp n79 +n79: jmp n80 +n80: jmp n81 +n81: jmp n82 +n82: jmp n83 +n83: jmp n84 +n84: jmp n85 +n85: jmp n86 +n86: jmp n87 +n87: jmp n88 +n88: jmp n89 +n89: jmp n90 +n90: jmp n91 +n91: jmp n92 +n92: jmp n93 +n93: jmp n94 +n94: jmp n95 +n95: jmp n96 +n96: jmp n97 +n97: jmp n98 +n98: jmp n99 +n99: jmp n100 +n100: jmp n101 +n101: jmp n102 +n102: jmp n103 +n103: jmp n104 +n104: jmp n105 +n105: jmp n106 +n106: jmp n107 +n107: jmp n108 +n108: jmp n109 +n109: jmp n110 +n110: jmp n111 +n111: jmp n112 +n112: jmp n113 +n113: jmp n114 +n114: jmp n115 +n115: jmp n116 +n116: jmp n117 +n117: jmp n118 +n118: jmp n119 +n119: jmp n120 +n120: jmp n121 +n121: jmp n122 +n122: jmp n123 +n123: jmp n124 +n124: jmp n125 +n125: jmp n126 +n126: jmp n127 +n127: jmp n0 + +%if ($-$$) > 257 + %ifdef FATAL + %fatal "Out of space!" + %elifdef ERROR + %error "Out of space!" + %elifdef WARNING + %warning "Out of space!" + %endif +%endif diff --git a/test/gotoff64.asm b/test/gotoff64.asm new file mode 100644 index 0000000..05f5882 --- /dev/null +++ b/test/gotoff64.asm @@ -0,0 +1,25 @@ +;Testname=noerr; Arguments=-felf64 -ogotoff64.o; Files=stdout stderr gotoff64.o +;Testname=err; Arguments=-DERROR -felf64 -ogotoff64.o; Files=stdout stderr gotoff64.o + + bits 64 + default rel + + extern foo + + mov r15,[foo wrt ..got] + lea r12,[foo wrt ..got] +%ifdef ERROR + lea rax,[foo wrt ..gotoff] + mov rax,[foo wrt ..gotoff] +%endif + + default abs + + mov r15,[foo wrt ..got] + lea r12,[foo wrt ..got] + mov rax,[qword foo wrt ..got] +%ifdef ERROR + lea rax,[foo wrt ..gotoff] + mov rax,[foo wrt ..gotoff] +%endif + mov rax,[qword foo wrt ..gotoff] diff --git a/test/ifelse.asm b/test/ifelse.asm new file mode 100644 index 0000000..bbb0d79 --- /dev/null +++ b/test/ifelse.asm @@ -0,0 +1,46 @@ +;Testname=ifelse; Arguments=-fbin -oifelse.bin; Files=stdout stderr ifelse.bin + +;No problems -> db 3 +%if 0 + db 0 +%elif 0 > 0 + db 1 +%elif 1 < 1 + db 2 +%else + db 3 +%endif + +;Garbage after else, elif after else -> db 5 +%if 0 + db 4 +%else trailing garbage + db 5 +%elif 1 + db 6 +%endif + +;Garbage after endif -> +%if 0 + db 7 +%endif trailing garbage + +;else after else -> db 9 +%if 0 + db 8 +%else + db 9 +%else + db 10 +%endif + +;Problem preprocessed out, no warning -> +%if 0 + %if 1 + db 11 + %else + db 12 + %else + db 13 + %endif +%endif diff --git a/test/ifmacro.asm b/test/ifmacro.asm new file mode 100644 index 0000000..53f3d29 --- /dev/null +++ b/test/ifmacro.asm @@ -0,0 +1,413 @@ +;Testname=test; Arguments=-fbin -oifmacro.txt; Files=stdout stderr ifmacro.txt + +; +; ifmacro.asm +; +; Test of the new ifmacro directive +; +; This file produces a human-readable text file when compiled +; with -f bin +; + +%define LF 10 + +%macro dummy 2 + db 'This is a dummy macro, ' + db 'arg1 = ', %1, ', ' + db 'arg2 = ', %2, LF +%endmacro + + dummy 'this', 'that' + +%ifdef CR + db '%ifdef CR', LF +%endif + +%ifdef LF + db '%ifdef LF', LF +%endif + +%ifmacro dummy 1 + db '%ifmacro dummy 1', LF +%endif + +%ifmacro dummy 2 + db '%ifmacro dummy 2', LF +%endif + +%ifmacro dummy 3 + db '%ifmacro dummy 3', LF +%endif + +%ifmacro dummy 1+ + db '%ifmacro dummy 1+', LF +%endif + +%ifmacro dummy 2+ + db '%ifmacro dummy 2+', LF +%endif + +%ifmacro dummy 3+ + db '%ifmacro dummy 3+', LF +%endif + +%ifmacro dummy + db '%ifmacro dummy', LF +%endif + +%ifmacro dummy 0-1 + db '%ifmacro dummy 0-1', LF +%endif + +%ifmacro dummy 1-2 + db '%ifmacro dummy 1-2', LF +%endif + +%ifmacro dummy 2-3 + db '%ifmacro dummy 2-3', LF +%endif + +%ifmacro dummy 3-4 + db '%ifmacro dummy 3-4', LF +%endif + +%ifmacro LF + db '%ifmacro LF', LF +%endif + +%ifndef CR + db '%ifndef CR', LF +%endif + +%ifndef LF + db '%ifndef LF', LF +%endif + +%ifnmacro dummy 1 + db '%ifnmacro dummy 1', LF +%endif + +%ifnmacro dummy 2 + db '%ifnmacro dummy 2', LF +%endif + +%ifnmacro dummy 3 + db '%ifnmacro dummy 3', LF +%endif + +%ifnmacro dummy 1+ + db '%ifnmacro dummy 1+', LF +%endif + +%ifnmacro dummy 2+ + db '%ifnmacro dummy 2+', LF +%endif + +%ifnmacro dummy 3+ + db '%ifnmacro dummy 3+', LF +%endif + +%ifnmacro dummy + db '%ifnmacro dummy', LF +%endif + +%ifnmacro dummy 0-1 + db '%ifnmacro dummy 0-1', LF +%endif + +%ifnmacro dummy 1-2 + db '%ifnmacro dummy 1-2', LF +%endif + +%ifnmacro dummy 2-3 + db '%ifnmacro dummy 2-3', LF +%endif + +%ifnmacro dummy 3-4 + db '%ifnmacro dummy 3-4', LF +%endif + +%ifnmacro LF + db '%ifnmacro LF', LF +%endif + +%if 0 +%elifdef CR + db '%elifdef CR', CR +%endif + +%if 0 +%elifdef LF + db '%elifdef LF', LF +%endif + +%if 0 +%elifmacro dummy 1 + db '%elifmacro dummy 1', LF +%endif + +%if 0 +%elifmacro dummy 2 + db '%elifmacro dummy 2', LF +%endif + +%if 0 +%elifmacro dummy 3 + db '%elifmacro dummy 3', LF +%endif + +%if 0 +%elifmacro dummy 1+ + db '%elifmacro dummy 1+', LF +%endif + +%if 0 +%elifmacro dummy 2+ + db '%elifmacro dummy 2+', LF +%endif + +%if 0 +%elifmacro dummy 3+ + db '%elifmacro dummy 3+', LF +%endif + +%if 0 +%elifmacro dummy + db '%elifmacro dummy', LF +%endif + +%if 0 +%elifmacro dummy 0-1 + db '%elifmacro dummy 0-1', LF +%endif + +%if 0 +%elifmacro dummy 1-2 + db '%elifmacro dummy 1-2', LF +%endif + +%if 0 +%elifmacro dummy 2-3 + db '%elifmacro dummy 2-3', LF +%endif + +%if 0 +%elifmacro dummy 3-4 + db '%elifmacro dummy 3-4', LF +%endif + +%if 0 +%elifmacro LF + db '%elifmacro LF', LF +%endif + +%if 0 +%elifndef CR + db '%elifndef CR', LF +%endif + +%if 0 +%elifndef LF + db '%elifndef LF', LF +%endif + +%if 0 +%elifnmacro dummy 1 + db '%elifnmacro dummy 1', LF +%endif + +%if 0 +%elifnmacro dummy 2 + db '%elifnmacro dummy 2', LF +%endif + +%if 0 +%elifnmacro dummy 3 + db '%elifnmacro dummy 3', LF +%endif + +%if 0 +%elifnmacro dummy 1+ + db '%elifnmacro dummy 1+', LF +%endif + +%if 0 +%elifnmacro dummy 2+ + db '%elifnmacro dummy 2+', LF +%endif + +%if 0 +%elifnmacro dummy 3+ + db '%elifnmacro dummy 3+', LF +%endif + +%if 0 +%elifnmacro dummy + db '%elifnmacro dummy', LF +%endif + +%if 0 +%elifnmacro dummy 0-1 + db '%elifnmacro dummy 0-1', LF +%endif + +%if 0 +%elifnmacro dummy 1-2 + db '%elifnmacro dummy 1-2', LF +%endif + +%if 0 +%elifnmacro dummy 2-3 + db '%elifnmacro dummy 2-3', LF +%endif + +%if 0 +%elifnmacro dummy 3-4 + db '%elifnmacro dummy 3-4', LF +%endif + +%if 0 +%elifnmacro LF + db '%elifnmacro LF', LF +%endif + +%if 1 +%elifdef CR + db 'bad %elifdef CR', LF +%endif + +%if 1 +%elifdef LF + db 'bad %elifdef LF', LF +%endif + +%if 1 +%elifmacro dummy 1 + db 'bad %elifmacro dummy 1', LF +%endif + +%if 1 +%elifmacro dummy 2 + db 'bad %elifmacro dummy 2', LF +%endif + +%if 1 +%elifmacro dummy 3 + db 'bad %elifmacro dummy 3', LF +%endif + +%if 1 +%elifmacro dummy 1+ + db 'bad %elifmacro dummy 1+', LF +%endif + +%if 1 +%elifmacro dummy 2+ + db 'bad %elifmacro dummy 2+', LF +%endif + +%if 1 +%elifmacro dummy 3+ + db 'bad %elifmacro dummy 3+', LF +%endif + +%if 1 +%elifmacro dummy + db 'bad %elifmacro dummy', LF +%endif + +%if 1 +%elifmacro dummy 0-1 + db 'bad %elifmacro dummy 0-1', LF +%endif + +%if 1 +%elifmacro dummy 1-2 + db 'bad %elifmacro dummy 1-2', LF +%endif + +%if 1 +%elifmacro dummy 2-3 + db 'bad %elifmacro dummy 2-3', LF +%endif + +%if 1 +%elifmacro dummy 3-4 + db 'bad %elifmacro dummy 3-4', LF +%endif + +%if 1 +%elifmacro LF + db 'bad %elifmacro LF', LF +%endif + +%if 1 +%elifndef CR + db 'bad %elifndef CR', LF +%endif + +%if 1 +%elifndef LF + db 'bad %elifndef LF', LF +%endif + +%if 1 +%elifnmacro dummy 1 + db 'bad %elifnmacro dummy 1', LF +%endif + +%if 1 +%elifnmacro dummy 2 + db 'bad %elifnmacro dummy 2', LF +%endif + +%if 1 +%elifnmacro dummy 3 + db 'bad %elifnmacro dummy 3', LF +%endif + +%if 1 +%elifnmacro dummy 1+ + db 'bad %elifnmacro dummy 1+', LF +%endif + +%if 1 +%elifnmacro dummy 2+ + db 'bad %elifnmacro dummy 2+', LF +%endif + +%if 1 +%elifnmacro dummy 3+ + db 'bad %elifnmacro dummy 3+', LF +%endif + +%if 1 +%elifnmacro dummy + db 'bad %elifnmacro dummy', LF +%endif + +%if 1 +%elifnmacro dummy 0-1 + db 'bad %elifnmacro dummy 0-1', LF +%endif + +%if 1 +%elifnmacro dummy 1-2 + db 'bad %elifnmacro dummy 1-2', LF +%endif + +%if 1 +%elifnmacro dummy 2-3 + db 'bad %elifnmacro dummy 2-3', LF +%endif + +%if 1 +%elifnmacro dummy 3-4 + db 'bad %elifnmacro dummy 3-4', LF +%endif + +%if 1 +%elifnmacro LF + db 'bad %elifnmacro LF', LF +%endif + diff --git a/test/iftoken.asm b/test/iftoken.asm new file mode 100644 index 0000000..7a0fec4 --- /dev/null +++ b/test/iftoken.asm @@ -0,0 +1,317 @@ +;Testname=test; Arguments=-fbin -oiftoken.txt; Files=stdout stderr iftoken.txt + +%define ZMACRO +%define NMACRO 1 +%define TMACRO 1 2 + db 'N "":' +%iftoken + db ' token' +%else + db ' ntoken' +%endif +%ifempty + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "":' +%iftoken ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "ZMACRO":' +%iftoken ZMACRO + db ' token' +%else + db ' ntoken' +%endif +%ifempty ZMACRO + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "ZMACRO":' +%iftoken ZMACRO ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty ZMACRO ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "NMACRO":' +%iftoken NMACRO + db ' token' +%else + db ' ntoken' +%endif +%ifempty NMACRO + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "NMACRO":' +%iftoken NMACRO ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty NMACRO ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "TMACRO":' +%iftoken TMACRO + db ' token' +%else + db ' ntoken' +%endif +%ifempty TMACRO + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "TMACRO":' +%iftoken TMACRO ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty TMACRO ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "1":' +%iftoken 1 + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1 + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "1":' +%iftoken 1 ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1 ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "+1":' +%iftoken +1 + db ' token' +%else + db ' ntoken' +%endif +%ifempty +1 + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "+1":' +%iftoken +1 ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty +1 ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "1 2":' +%iftoken 1 2 + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1 2 + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "1 2":' +%iftoken 1 2 ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1 2 ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "1,2":' +%iftoken 1,2 + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1,2 + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "1,2":' +%iftoken 1,2 ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty 1,2 ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "foo":' +%iftoken foo + db ' token' +%else + db ' ntoken' +%endif +%ifempty foo + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "foo":' +%iftoken foo ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty foo ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "foo bar":' +%iftoken foo bar + db ' token' +%else + db ' ntoken' +%endif +%ifempty foo bar + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "foo bar":' +%iftoken foo bar ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty foo bar ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "%":' +%iftoken % + db ' token' +%else + db ' ntoken' +%endif +%ifempty % + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "%":' +%iftoken % ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty % ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "+foo":' +%iftoken +foo + db ' token' +%else + db ' ntoken' +%endif +%ifempty +foo + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "+foo":' +%iftoken +foo ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty +foo ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'N "<<":' +%iftoken << + db ' token' +%else + db ' ntoken' +%endif +%ifempty << + db ' empty' +%else + db ' nempty' +%endif + db 10 + db 'C "<<":' +%iftoken << ; With a comment! + db ' token' +%else + db ' ntoken' +%endif +%ifempty << ; With a comment! + db ' empty' +%else + db ' nempty' +%endif + db 10 diff --git a/test/iftoken.pl b/test/iftoken.pl new file mode 100755 index 0000000..925dd40 --- /dev/null +++ b/test/iftoken.pl @@ -0,0 +1,32 @@ +#!/usr/bin/perl + +@list = ('', 'ZMACRO', 'NMACRO', 'TMACRO', '1', '+1', '1 2', '1,2', + 'foo', 'foo bar', '%', '+foo', '<<'); +@tests = ('token', 'empty'); + +print ";Testname=test; Arguments=-fbin -oiftoken.txt; Files=stdout stderr iftoken.txt" +print "%define ZMACRO\n"; +print "%define NMACRO 1\n"; +print "%define TMACRO 1 2\n"; + +foreach $x (@list) { + print "\tdb 'N \"$x\":'\n"; + foreach $t (@tests) { + print "%if$t $x\n"; + print "\tdb ' $t'\n"; + print "%else\n"; + print "\tdb ' n$t'\n"; + print "%endif\n"; + } + print "\tdb 10\n"; + + print "\tdb 'C \"$x\":'\n"; + foreach $t (@tests) { + print "%if$t $x ; With a comment!\n"; + print "\tdb ' $t'\n"; + print "%else\n"; + print "\tdb ' n$t'\n"; + print "%endif\n"; + } + print "\tdb 10\n"; +} diff --git a/test/imacro.asm b/test/imacro.asm new file mode 100644 index 0000000..bc397cc --- /dev/null +++ b/test/imacro.asm @@ -0,0 +1,8 @@ +;Testname=test; Arguments=-fbin -oimacro.bin; Files=stdout stderr imacro.bin + +%imacro Zero 1 + xor %1,%1 +%endmacro + + Zero eax + zero eax diff --git a/test/imm64.asm b/test/imm64.asm new file mode 100644 index 0000000..ac50c62 --- /dev/null +++ b/test/imm64.asm @@ -0,0 +1,7 @@ + bits 64 + mov rax,11223344h + mov rax,dword 11223344h + mov eax,11223344h + mov [rax],dword 11223344h ; 32-bit operation + mov qword [rax],11223344h + mov qword [rax],dword 11223344h diff --git a/test/immwarn.asm b/test/immwarn.asm new file mode 100644 index 0000000..8bffbfa --- /dev/null +++ b/test/immwarn.asm @@ -0,0 +1,91 @@ +;Testname=onowarn; Arguments=-Ox -DOPT=1 -DWARN=0 -fbin -oimmwarn.bin; Files=stdout stderr immwarn.bin +;Testname=owarn; Arguments=-Ox -DOPT=1 -DWARN=1 -fbin -oimmwarn.bin; Files=stdout stderr immwarn.bin +;Testname=nowarn; Arguments=-O0 -DOPT=0 -DWARN=0 -fbin -oimmwarn.bin; Files=stdout stderr immwarn.bin +;Testname=warn; Arguments=-O0 -DOPT=1 -DWARN=1 -fbin -oimmwarn.bin; Files=stdout stderr immwarn.bin + +%ifndef WARN + %define WARN 1 +%endif + + bits 16 + push 1 +%if WARN + push 0ffffffffh +%endif + push -1 + push 0ffffh + push byte 0FFFFh + + add ax,0FFFFh +%if WARN + add ax,0FFFFFFFFh +%endif + add ax,-1 + add ax,byte 0FFFFh +%if WARN + add ax,byte 0FFFFFFFFh +%endif + add ax,-1 + + add cx,0FFFFh +%if WARN + add cx,0FFFFFFFFh +%endif + add cx,-1 + add cx,byte 0FFFFh +%if WARN + add cx,byte 0FFFFFFFFh +%endif + add cx,-1 + + bits 32 + push 1 + push 0ffffffffh + push -1 + push 0ffffh + + push byte 1 +%if WARN + push byte 0ffffh +%endif + push byte -1 + + push word 1 + push word 0ffffh + push word -1 + + push dword 1 + push dword 0ffffffffh + push dword -1 + + add eax,0FFFFh + add eax,0FFFFFFFFh + add eax,-1 + + add ecx,0FFFFh + add ecx,0FFFFFFFFh + add ecx,-1 + + bits 64 + mov eax,7fffffffh + mov eax,80000000h + mov rax,7fffffffh + mov rax,80000000h +%if WARN + mov rax,dword 80000000h +%endif + add rcx,0FFFFh +%if WARN + add rcx,0FFFFFFFFh +%endif + add rcx,-1 + + add ecx,0FFFFh + add ecx,0FFFFFFFFh + add ecx,-1 + + push byte 1 +%if WARN + push byte 0ffffffffh +%endif + push byte -1 diff --git a/test/imul.asm b/test/imul.asm new file mode 100644 index 0000000..d30d25f --- /dev/null +++ b/test/imul.asm @@ -0,0 +1,117 @@ +;Testname=nowarn; Arguments=-fbin -oimul.bin; Files=stdout stderr imul.bin +;Testname=warn; Arguments=-DWARN -fbin -oimul.bin; Files=stdout stderr imul.bin + +%macro test 1-3 5 -2 + bits %1 + +%undef MEM +%if %1 == 16 + %define MEM [di] +%elif %1 == 32 + %define MEM [edi] +%elif %1 == 64 + %define MEM [rdi] +%endif + + imul al + imul byte MEM + imul ax + imul word MEM + imul eax + imul dword MEM +%if %1 == 64 + imul rdx + imul qword MEM +%endif + + imul ax,cx + imul ax,MEM + imul ax,word MEM + imul eax,ecx + imul eax,MEM + imul eax,dword MEM +%if %1 == 64 + imul rax,rcx + imul rax,MEM + imul rax,qword MEM +%endif + + imul ax,cx,%2 + imul ax,cx,byte %2 + imul ax,MEM,%2 + imul ax,word MEM,%2 + imul eax,ecx,%2 + imul eax,ecx,byte %2 + imul eax,MEM,%2 + imul eax,dword MEM,%2 +%if %1 == 64 + imul rax,rcx,%2 + imul rax,rcx,byte %2 + imul rax,MEM,%2 + imul rax,qword MEM,%2 +%endif + + imul ax,%2 + imul ax,byte %2 + imul eax,%2 + imul eax,byte %2 +%if %1 == 64 + imul rax,%2 + imul rax,byte %2 +%endif + + imul ax,cx,0x1234 + imul ax,MEM,0x1234 + imul ax,word MEM,0x1234 + imul eax,ecx,0x12345678 + imul eax,MEM,0x12345678 + imul eax,dword MEM,0x12345678 +%if %1 == 64 + imul rax,rcx,0x12345678 + imul rax,MEM,0x12345678 + imul rax,qword MEM,0x12345678 +%endif + + imul ax,0x1234 + imul eax,0x12345678 +%if %1 == 64 + imul rax,0x12345678 +%endif + + imul ax,cx,0xfffe + imul ax,MEM,0xfffe + imul ax,word MEM,0xfffe + imul ax,cx,0xfe + imul ax,MEM,0xfe + imul ax,word MEM,0xfe + imul eax,ecx,0xfffffffe + imul eax,MEM,0xfffffffe + imul eax,dword MEM,0xfffffffe + imul eax,ecx,0xfffe + imul eax,MEM,0xfffe + imul eax,dword MEM,0xfffe +%if %1 == 64 + imul rax,rcx,%3 + imul rax,MEM,%3 + imul rax,qword MEM,%3 + imul rax,rcx,0xfffe + imul rax,MEM,0xfffe + imul rax,qword MEM,0xfffe +%endif + + imul ax,0xfffe + imul eax,0xfffffffe +%if %1 == 64 + imul rax,%3 +%endif +%endmacro + + test 16 + test 32 + test 64 + +%ifdef WARN + test 16,0x999 + test 32,0x999999 + test 64,0x999999999,0xfffffffe +%endif diff --git a/test/inc1.asm b/test/inc1.asm new file mode 100644 index 0000000..0e1058b --- /dev/null +++ b/test/inc1.asm @@ -0,0 +1,6 @@ +; This file is part of the include test. +; See inctest.asm for build instructions. + +message: db 'hello, world',13,10,'$' + +%include "inc2.asm" diff --git a/test/inc2.asm b/test/inc2.asm new file mode 100644 index 0000000..c3ba2f7 --- /dev/null +++ b/test/inc2.asm @@ -0,0 +1,8 @@ +; This file is part of the include test. +; See inctest.asm for build instructions. + +_main: mov dx,message + mov ah,9 + int 21h + mov ax,4c00h + int 21h diff --git a/test/inctest.asm b/test/inctest.asm new file mode 100644 index 0000000..35f2910 --- /dev/null +++ b/test/inctest.asm @@ -0,0 +1,15 @@ +;Testname=test; Arguments=-fbin -oinctest.com; Files=stdout stderr inctest.com + +; This file, plus inc1.asm and inc2.asm, test NASM's file inclusion +; mechanism. +; +; This produces a DOS .COM file: to assemble, use +; nasm -f bin inctest.asm -o inctest.com +; and when run, it should print `hello, world'. + + BITS 16 + ORG 0x100 + + jmp _main + +%include "inc1.asm" diff --git a/test/insnlbl.asm b/test/insnlbl.asm new file mode 100644 index 0000000..e456372 --- /dev/null +++ b/test/insnlbl.asm @@ -0,0 +1,12 @@ +;Testname=test; Arguments=-fbin -oinsnlbl.bin; Files=stdout stderr insnlbl.bin + +; +; Test "instruction as label" -- make opcodes legal as labels if +; they are followed by a colon. +; + +do: jmp dq+2 + dw do, add, sub, dq +add: jmp add-2 +sub: jmp do+2 +dq: dw $-sub diff --git a/test/invlpga.asm b/test/invlpga.asm new file mode 100644 index 0000000..21ab4b4 --- /dev/null +++ b/test/invlpga.asm @@ -0,0 +1,11 @@ +;Testname=unoptimized; Arguments=-fbin -oinvlpga.bin; Files=stdout stderr invlpga.bin +;Testname=optimized; Arguments=-fbin -oinvlpga.bin -Ox; Files=stdout stderr invlpga.bin + + bits 32 + invlpga + invlpga ax,ecx + invlpga eax,ecx + bits 64 + invlpga + invlpga eax,ecx + invlpga rax,ecx diff --git a/test/jmp64.asm b/test/jmp64.asm new file mode 100644 index 0000000..f007b9e --- /dev/null +++ b/test/jmp64.asm @@ -0,0 +1,15 @@ +;Testname=test; Arguments=-fbin -ojmp64.bin; Files=stdout stderr jmp64.bin + + bits 64 + jmp rcx + jmp [rax] + jmp qword [rax] + jmp far [rax] + jmp far dword [rax] + jmp far qword [rax] + call rcx + call [rax] + call qword [rax] + call far [rax] + call far dword [rax] + call far qword [rax] diff --git a/test/lar_lsl.asm b/test/lar_lsl.asm new file mode 100644 index 0000000..a0a9c0e --- /dev/null +++ b/test/lar_lsl.asm @@ -0,0 +1,124 @@ +;Testname=test; Arguments=-fbin -olar_lsl.bin; Files=stdout stderr lar_lsl.bin + +; LAR/LSL +;--------- + +; 1x ; = invalid due to lack of REX +; 3x ; = invalid due to Mw + +%macro m 1 + + bits 16 + + %1 ax, ax + %1 ax,eax +; %1 ax,rax + + %1 eax, ax + %1 eax,eax +; %1 eax,rax + +; %1 rax, ax +; %1 rax,eax +; %1 rax,rax + + %1 ax, [0] + %1 ax, word [0] +;;; %1 ax,dword [0] +; %1 ax,qword [0] + + %1 eax, [0] + %1 eax, word [0] +;;; %1 eax,dword [0] +; %1 eax,qword [0] + +; %1 rax, [0] +; %1 rax, word [0] +; %1 rax,dword [0] +; %1 rax,qword [0] + + bits 32 + + %1 ax, ax + %1 ax,eax +; %1 ax,rax + + %1 eax, ax + %1 eax,eax +; %1 eax,rax + +; %1 rax, ax +; %1 rax,eax +; %1 rax,rax + + %1 ax, [0] + %1 ax, word [0] +;;; %1 ax,dword [0] +; %1 ax,qword [0] + + %1 eax, [0] + %1 eax, word [0] +;;; %1 eax,dword [0] +; %1 eax,qword [0] + +; %1 rax, [0] +; %1 rax, word [0] +; %1 rax,dword [0] +; %1 rax,qword [0] + + bits 64 + + %1 ax, ax + %1 ax,eax + %1 ax,rax ; $TODO: shouldn't emit REX.W $ + + %1 eax, ax + %1 eax,eax + %1 eax,rax ; $TODO: shouldn't emit REX.W $ + + %1 rax, ax + %1 rax,eax + %1 rax,rax + + %1 ax, [0] + %1 ax, word [0] +;;; %1 ax,dword [0] +;;; %1 ax,qword [0] + + %1 eax, [0] + %1 eax, word [0] +;;; %1 eax,dword [0] +;;; %1 eax,qword [0] + + %1 rax, [0] + %1 rax, word [0] +;;; %1 rax,dword [0] +;;; %1 rax,qword [0] + +%endmacro + +m lar + +m lsl + +bits 16 +lar ax,[ si] +lar ax,[esi] +bits 32 +lar ax,[ si] +lar ax,[esi] +bits 64 +lar ax,[esi] +lar ax,[rsi] + +bits 16 +lsl ax,[ si] +lsl ax,[esi] +bits 32 +lsl ax,[ si] +lsl ax,[esi] +bits 64 +lar ax,[esi] +lsl ax,[rsi] + +; EOF diff --git a/test/larlsl.asm b/test/larlsl.asm new file mode 100644 index 0000000..cddaac7 --- /dev/null +++ b/test/larlsl.asm @@ -0,0 +1,23 @@ +;Testname=test; Arguments=-fbin -olarlsl.bin; Files=stdout stderr larlsl.bin + + bits 64 + + lar ax,bx + lar ax,[rsi] + lar ax,word [rsi] + lar eax,bx + lar eax,[rsi] + lar eax,word [rsi] + lar rax,bx + lar rax,[rsi] + lar rax,word [rsi] + + lsl ax,bx + lsl ax,[rsi] + lsl ax,word [rsi] + lsl eax,bx + lsl eax,[rsi] + lsl eax,word [rsi] + lsl rax,bx + lsl rax,[rsi] + lsl rax,word [rsi] diff --git a/test/lnxhello.asm b/test/lnxhello.asm new file mode 100644 index 0000000..1aa5a5f --- /dev/null +++ b/test/lnxhello.asm @@ -0,0 +1,54 @@ +;Testname=aout; Arguments=-faout -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=aoutb; Arguments=-faoutb -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=as86; Arguments=-fas86 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=elf32; Arguments=-felf32 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o + +; +; Assembly "Hello, World!" for Linux +; + + +; Properly defined in <sys/syscall.h> +%define SYS_exit 1 +%define SYS_write 4 + + section .text + + global _start +_start: + ; gdb doesn't like to stop at the entry point address, so + ; we put a nop here for pure convenience + nop + + +write_hello: + mov edx, hello_len + mov ecx, hello + +.loop: + mov eax, SYS_write + mov ebx, 1 ; stdout + int 80h + + cmp eax, -4096 + ja error + + add ecx, eax + sub edx, eax + jnz .loop + +ok: + mov eax, SYS_exit + xor ebx, ebx + int 80h + hlt + +error: + mov eax, SYS_exit + mov ebx, 1 ; Error + int 80h + hlt + + section .rodata +hello: db "Hello, World!", 10 +hello_len equ $-hello diff --git a/test/local.asm b/test/local.asm new file mode 100644 index 0000000..8a42bb8 --- /dev/null +++ b/test/local.asm @@ -0,0 +1,19 @@ +;Testname=test; Arguments=-fbin -olocal.bin; Files=stdout stderr local.bin + bits 32 + +%push bluttan + +%define %$localsize 0 + +%stacksize flat +%local l1:qword, l2:dword, l3:dword, l4:qword +%arg a1:qword, a2:dword, a3:dword, a4:qword + + mov eax,[a1] + mov ebx,[a2] + mov ecx,[a3] + mov edx,[a4] + mov [l1],eax + mov [l2],ebx + mov [l3],ecx + mov [l4],edx diff --git a/test/loopoffs.asm b/test/loopoffs.asm new file mode 100644 index 0000000..54ef4ac --- /dev/null +++ b/test/loopoffs.asm @@ -0,0 +1,12 @@ +;Testname=unoptimized; Arguments=-fbin -oloopoffs.bin -O0; Files=stdout stderr loopoffs.bin +;Testname=optimized; Arguments=-fbin -oloopoffs.bin -Ox; Files=stdout stderr loopoffs.bin + bits 16 +delay: loop delay + loop $ +delay2: a32 loop delay2 + a32 loop $ +delay3: loop delay3,ecx + loop $,ecx +delay4: a32 loop delay4,ecx + a32 loop $,ecx +
\ No newline at end of file diff --git a/test/macro-defaults.asm b/test/macro-defaults.asm new file mode 100644 index 0000000..047f205 --- /dev/null +++ b/test/macro-defaults.asm @@ -0,0 +1,64 @@ +;Testname=warning; Arguments=-fbin -omacdef.bin -w+macro-defaults; Files=stdout stderr macdef.bin +;Testname=nonwarning; Arguments=-fbin -omacdef.bin -w-macro-defaults; Files=stdout stderr macdef.bin + +%MACRO mmac_fix 1 a + ; While defined to take one parameter, any invocation will + ; see two, due to the default parameter. + %warning %0 %1 %2 %3 %4 %5 +%ENDMACRO +mmac_fix one + +%MACRO mmac_var 1-2 a,b + ; While defined to take one or two parameters, invocations + ; will see three, due to the default parameters. + %warning %0 %1 %2 %3 %4 %5 +%ENDMACRO +mmac_var one +mmac_var one,two + +%MACRO mmac_plus 1-2+ a,b + ; This does not warn. Although this looks like two default + ; parameters, it ends up being only one: the "+" limits it + ; to two parameters; if invoked without a second parameter + ; the second parameter will be "a,b". + %warning %0 %1 %2 %3 %4 %5 + ;Check rotating behaviour +%ENDMACRO +mmac_plus one +mmac_plus one,two +mmac_plus one,two,three + +%MACRO mmac_star 1-* a,b + ; This does not warn. Because the "*" extends the range of + ; parameters to infinity, the "a,b" default parameters can + ; not exceed that range. + %warning %0 %1 %2 %3 %4 %5 +%ENDMACRO +mmac_star one +mmac_star one,two +mmac_star one,two,three + +%MACRO mmac_rotate 0-* a,b + %warning %0 %1 %2 %3 %4 %5 + ;%rotate should rotate all parameters + %rotate 1 + %warning %0 %1 %2 %3 %4 %5 +%ENDMACRO +mmac_rotate +mmac_rotate one +mmac_rotate one,two +mmac_rotate one,two,three + +;Scope / evaluation time test +%define I 0 +%assign J 0 +%xdefine K 0 + +%MACRO mmac_scope 0 I J K + %warning %1 %2 %3 +%ENDMACRO + +%define I 1 +%assign J 1 +%xdefine K 1 +mmac_scope diff --git a/test/mmxsize.asm b/test/mmxsize.asm new file mode 100644 index 0000000..0a47839 --- /dev/null +++ b/test/mmxsize.asm @@ -0,0 +1,38 @@ +;Testname=unoptimized; Arguments=-fbin -ommxsize.bin -O0; Files=stdout stderr mmxsize.bin +;Testname=optimized; Arguments=-fbin -ommxsize.bin -Ox; Files=stdout stderr mmxsize.bin + bits 32 + movd mm0,eax + movd mm0,[foo] + movq mm0,[foo] + movd mm0,dword [foo] + movq mm0,qword [foo] + movmskps eax,xmm1 + movmskpd eax,xmm1 + nop + movd xmm0,eax + movd xmm0,[foo] + movq xmm0,[foo] + movd xmm0,dword [foo] + movq xmm0,qword [foo] + nop + + bits 64 + movd mm0,eax + movq mm0,[foo] + movd mm0,dword [foo] + movq mm0,qword [foo] + movq mm0,rax + movmskps eax,xmm1 + movmskpd eax,xmm1 + nop + movd xmm0,eax + movq xmm0,[foo] + movd xmm0,dword [foo] + movq xmm0,qword [foo] + movq xmm0,rax + movmskps rax,xmm1 + movmskpd rax,xmm1 + nop + + section .bss +foo resq 1 diff --git a/test/movimm.asm b/test/movimm.asm new file mode 100644 index 0000000..c34c166 --- /dev/null +++ b/test/movimm.asm @@ -0,0 +1,28 @@ +;Testname=unoptimized; Arguments=-fbin -omovimm.bin -O0; Files=stdout stderr movimm.bin +;Testname=optimized; Arguments=-fbin -omovimm.bin -Ox; Files=stdout stderr movimm.bin + bits 64 + + mov rax,1234567890abcdefh + mov eax,1234567890abcdefh + mov rax,dword 1234567890abcdefh + mov rax,qword 1234567890abcdefh + mov dword [rsi],1234567890abcdefh + mov qword [rsi],1234567890abcdefh + mov dword [rsi],dword 1234567890abcdefh + mov qword [rsi],dword 1234567890abcdefh +; mov qword [rsi],qword 1234567890abcdefh ; Error +; mov [rsi],qword 1234567890abcdefh ; Error + mov [rsi],dword 1234567890abcdefh + + ; The optimizer probably should compact these forms, doesn't yet? + mov rax,12345678h + mov eax,12345678h + mov rax,dword 12345678h + mov rax,qword 12345678h + mov dword [rsi],12345678h + mov qword [rsi],12345678h + mov dword [rsi],dword 12345678h + mov qword [rsi],dword 12345678h +; mov qword [rsi],qword 12345678h ; Error +; mov [rsi],qword 12345678h ; Error + mov [rsi],dword 12345678h diff --git a/test/movnti.asm b/test/movnti.asm new file mode 100644 index 0000000..920f327 --- /dev/null +++ b/test/movnti.asm @@ -0,0 +1,10 @@ +;Testname=test; Arguments=-fbin -omovnti.bin; Files=stdout stderr movnti.bin +; BR 2028995 + + bits 16 + movnti [si],eax + bits 32 + movnti [esi],eax + bits 64 + movnti [rsi],eax + movnti [rsi],rax diff --git a/test/multisection.asm b/test/multisection.asm new file mode 100644 index 0000000..34e7f7d --- /dev/null +++ b/test/multisection.asm @@ -0,0 +1,96 @@ +;Testname=aout; Arguments=-faout -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=aoutb; Arguments=-faoutb -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=as86; Arguments=-fas86 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=elf32; Arguments=-felf32 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=elf64; Arguments=-felf64 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=obj; Arguments=-fobj -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=rdf; Arguments=-frdf -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=win32; Arguments=-fwin32 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o +;Testname=win64; Arguments=-fwin64 -olnxhello.o -Ox; Files=stdout stderr lnxhello.o + +; To test where code that is placed before any explicit SECTION +; gets placed, and what happens if a .text section has an ORG +;statement, uncomment the following lines. +; +; times 10h nop +; +;section .text +;org 0x300 +; times 20h inc ax + +; let's see which of these sections can be placed in the specified order. + +section .appspecific +section .data +section .stringdata +section .mytext +section .code +section .extra_code + + +section .stringdata +mystr1: db "Hello, this is string 1", 13, 10, '$' + +section .extra_code +org 0x200 +bits 16 +more: + mov si, asciz1 + mov ah, 0x0E + xor bx, bx +.print: + lodsb + test al, al + jz .end + int 0x10 + jmp short .print +.end: + + xor ax, ax + int 0x16 + + mov ax, 0x4c00 + int 0x21 + +section .appspecific +asciz1: db "This is string 2", 0 + +section .code +org 0x100 +bits 16 + +start: + mov dx, mystr1 + mov ah, 9 + int 0x21 + + xor ax, ax + int 0x16 + + jmp more + +section .text + xor eax,eax + times 50h nop + +section .mytext + + xor ebx,ebx + +section .data + db 95h,95h,95h,95h,95h,95h,95h,95h + +section .hmm + resd 2 + +section .bss + resd 8 + +section .final1 + inc ax + +section .final2 + inc bx + +section .final3 + inc cx diff --git a/test/nasmformat.asm b/test/nasmformat.asm new file mode 100644 index 0000000..ea19b92 --- /dev/null +++ b/test/nasmformat.asm @@ -0,0 +1,17 @@ +;Testname=obj; Arguments=-fobj -onasmfomat.o; Files=stdout stderr nasmfomat.o +;Testname=bin; Arguments=-fbin -onasmfomat.o; Files=stdout stderr nasmfomat.o +;Testname=rdf; Arguments=-frdf -onasmfomat.o; Files=stdout stderr nasmfomat.o + +%if __OUTPUT_FORMAT__ == 'bin' + +db 'This is binary format file' + +%elif __OUTPUT_FORMAT__ == 'obj' + +db 'This is object format file' + +%else + +db 'This is some other format file' + +%endif diff --git a/test/new b/test/new new file mode 100755 index 0000000..403b4fb --- /dev/null +++ b/test/new @@ -0,0 +1,9 @@ +#!/bin/sh +for f; do + if [ -e "$f".asm ]; then + # For safety... + echo "$0: $f already exists" 1>&2 + exit 1 + fi + echo ";Testname=test; Arguments=-fbin -o$f.bin; Files=stdout stderr $f.bin" > "$f".asm +done diff --git a/test/nop.asm b/test/nop.asm new file mode 100644 index 0000000..71b7f7b --- /dev/null +++ b/test/nop.asm @@ -0,0 +1,17 @@ +;Testname=unoptimized; Arguments=-fbin -onop.bin; Files=stdout stderr nop.bin +;Testname=optimized; Arguments=-fbin -onop.bin -Ox; Files=stdout stderr nop.bin + + bits 64 + + nop + o64 nop + pause + o64 pause + + xchg ax,ax + xchg eax,eax + xchg rax,rax + + rep xchg ax,ax + rep xchg eax,eax + rep xchg rax,rax diff --git a/test/nullfile.asm b/test/nullfile.asm new file mode 100644 index 0000000..83e306e --- /dev/null +++ b/test/nullfile.asm @@ -0,0 +1,4 @@ +;Testname=test; Arguments=-fbin -onull.bin; Files=stdout stderr null.bin +; +; A file that produces no output has been known to occationally crash NASM. +; diff --git a/test/objexe.asm b/test/objexe.asm new file mode 100644 index 0000000..9959f40 --- /dev/null +++ b/test/objexe.asm @@ -0,0 +1,30 @@ +; Demonstration of how to write an entire .EXE format program as a .OBJ +; file to be linked. Tested with the VAL free linker. +; To build: +; nasm -fobj objexe.asm +; val objexe.obj,objexe.exe; +; To test: +; objexe +; (should print `hello, world') + + segment code + +..start: mov ax,data + mov ds,ax + mov ax,stack + mov ss,ax + mov sp,stacktop + + mov dx,hello + mov ah,9 + int 0x21 + + mov ax,0x4c00 + int 0x21 + + segment data +hello: db 'hello, world', 13, 10, '$' + + segment stack stack + resb 64 +stacktop: diff --git a/test/objlink.c b/test/objlink.c new file mode 100644 index 0000000..b767b01 --- /dev/null +++ b/test/objlink.c @@ -0,0 +1,33 @@ +/* + * test source file for assembling to Microsoft 16-bit .OBJ + * build with (16-bit Microsoft C): + * nasm -f obj objtest.asm + * cl /AL objtest.obj objlink.c + * other compilers should work too, provided they handle large + * model in the same way as MS C + */ + +#include <stdio.h> +#include <inttypes.h> + +int8_t text[] = "hello, world\n"; + +extern void function(int8_t *); +extern int bsssym, commvar; +extern void *selfptr; +extern void *selfptr2; + +int main(void) +{ + printf("these should be identical: %p, %p\n", + (int32_t)selfptr, (int32_t)&selfptr); + printf("these should be equivalent but different: %p, %p\n", + (int32_t)selfptr2, (int32_t)&selfptr2); + printf("you should see \"hello, world\" twice:\n"); + bsssym = 0xF00D; + commvar = 0xD00F; + function(text); + printf("this should be 0xF00E: 0x%X\n", bsssym); + printf("this should be 0xD00E: 0x%X\n", commvar); + return 0; +} diff --git a/test/objtest.asm b/test/objtest.asm new file mode 100644 index 0000000..03b7f9e --- /dev/null +++ b/test/objtest.asm @@ -0,0 +1,85 @@ +;Testname=unoptimized; Arguments=-O0 -fobj -oobj.o; Files=stdout stderr obj.o +;Testname=optimized; Arguments=-Ox -fobj -oobj.o; Files=stdout stderr obj.o + +; test source file for assembling to Microsoft 16-bit .OBJ +; build with (16-bit Microsoft C): +; nasm -f obj objtest.asm +; cl /AL objtest.obj objlink.c +; other compilers should work too, provided they handle large +; model in the same way as MS C + +; This file should test the following: +; [1] Define and export a global symbol +; [2] Define a non-global symbol +; [3] Define a common symbol +; [4] Define a NASM local label +; [5] Reference a NASM local label +; [6] Import an external symbol +; [7] Make a PC-relative relocated reference +; [8] Reference a symbol in the same section as itself +; [9] Reference a symbol in a different segment from itself +; [10] Define a segment group +; [11] Take the offset of a symbol in a grouped segment w.r.t. its segment +; [12] Reserve uninitialised data space in a segment +; [13] Directly take the segment address of a segment +; [14] Directly take the segment address of a group +; [15] Use SEG on a non-external +; [16] Use SEG on an external + + bits 16 + + global _bsssym ; [1] + global _function ; [1] + global _selfptr ; [1] + global _selfptr2 ; [1] + common _commvar 2 ; [3] + extern _printf ; [6] + + group mygroup mybss mydata ; [10] + group mygroup2 mycode mycode2 ; [10] + + segment mycode private + +_function push bp + mov bp,sp + push ds + mov ax,mygroup ; [14] + mov ds,ax + inc word [_bsssym] ; [9] + mov ax,seg _commvar + mov ds,ax + dec word [_commvar] + pop ds + mov ax,[bp+6] + mov dx,[bp+8] + push dx + push ax + push dx + push ax + call far [cs:.printf] ; [5] [8] + pop ax + pop ax + call trampoline ; [7] + pop ax + pop ax + mov sp,bp + pop bp + retf + +.printf dw _printf, seg _printf ; [2] [4] [16] + + segment mycode2 private + +trampoline: pop ax + push cs + push ax + jmp far _printf + + segment mybss private + +_bsssym resw 64 ; [12] + + segment mydata private + +_selfptr dw _selfptr, seg _selfptr ; [8] [15] +_selfptr2 dw _selfptr2 wrt mydata, mydata ; [11] [13] diff --git a/test/optimization.asm b/test/optimization.asm new file mode 100644 index 0000000..d78209d --- /dev/null +++ b/test/optimization.asm @@ -0,0 +1,104 @@ +;Testname=O0; Arguments=-O0 -fbin -ooptimization.bin; Files=stdout stderr optimization.bin +;Testname=O1; Arguments=-O1 -fbin -ooptimization.bin; Files=stdout stderr optimization.bin +;Testname=Ox; Arguments=-Ox -fbin -ooptimization.bin; Files=stdout stderr optimization.bin + +BITS 32 + +; Simple +jmp foo +times 124 nop +foo: + +; Must start short to converge optimally +jmp car +times 127 nop +car: + +; Always near +jmp cdr +times 128 nop +cdr: + + +; Simple +add eax, quux2 - quux1 +quux1: +times 127 nop +quux2: + +; Must start short +corge1: +add eax, corge2 - corge1 +times 127 - 3 nop +corge2: + + +; Simple +lea eax, [bolug2-bolug1] +bolug1: +times 127 nop +bolug2: + +; Must start short +calog1: +lea eax, [calog2-calog1] +times 127 - 3 nop +calog2: + + +; Simple +lea eax, [eax+dolug2-dolug1] +dolug1: +times 127 nop +dolug2: + +; Must start short +ealog1: +lea eax, [eax+ealog2-ealog1] +times 127 - 3 nop +ealog2: + +; Must stay long! +lea eax, [eax+folug2-folug1] +folug1: +times 128 nop +folug2: + +; Must stay long! +galog1: +lea eax, [eax+galog2-galog1] +times 128 - 3 nop +galog2: + +; Sbyte tests... +onetwentysix equ 126 +onetwentynine equ 129 + +add eax,onetwentyseven ; sbyte (forward) +add eax,onetwentyeight ; not sbyte (forward) +add eax,onetwentyseven ; sbyte (forward) +add eax,onetwentysix ; sbyte (backward) +add eax,onetwentynine ; not sbyte (backward) +add ecx,onetwentyseven ; sbyte (forward) +add ecx,onetwentyeight ; not sbyte (forward) +add ecx,onetwentyseven ; sbyte (forward) +add ecx,onetwentysix ; sbyte (backward) +add ecx,onetwentynine ; not sbyte (backward) + +onetwentyseven equ 127 +onetwentyeight equ 128 + +; Simple +add eax, holug2-holug1 +holug1: +times 127 nop +holug2: + +; Must start short +ialog1: +add eax, ialog2-ialog1 +times 127 - 3 nop +ialog2: + +; Do not confuse forward references and segmentless addresses! +jmp 12345 diff --git a/test/org.asm b/test/org.asm new file mode 100644 index 0000000..792c39a --- /dev/null +++ b/test/org.asm @@ -0,0 +1,18 @@ +;Testname=elf64; Arguments=-Ox -felf64 -oorg.o; Files=stdout stderr org.o +;Testname=win64; Arguments=-Ox -fwin64 -oorg.o; Files=stdout stderr org.o + +; +; Simple test of a 64-bit org directive +; + bits 64 + org 0xffffffffffff0000 + +hello: jmp there + nop + nop +there: + add rax,[rsp+rbx] + inc eax + + section .data +there_ptr dq there diff --git a/test/perf/label.pl b/test/perf/label.pl new file mode 100755 index 0000000..9b59768 --- /dev/null +++ b/test/perf/label.pl @@ -0,0 +1,18 @@ +#!/usr/bin/perl +# +# Generate a test case for label lookup performance +# + +($len) = @ARGV; +$len = 100000 unless ($len); + +print "\tbits 32\n"; +print "\tsection .data\n"; +print "\n"; + +for ($i = 0; $i < $len; $i++) { + print "l$i:\n"; + for ($j = 0; $j < 8; $j++) { + print "\tdd l", int(rand($i+1)), "\n"; + } +} diff --git a/test/perf/macro.pl b/test/perf/macro.pl new file mode 100755 index 0000000..b729805 --- /dev/null +++ b/test/perf/macro.pl @@ -0,0 +1,18 @@ +#!/usr/bin/perl +# +# Generate a test case for macro lookup performance +# + +($len) = @ARGV; +$len = 100000 unless ($len); + +print "\tbits 32\n"; +print "\tsection .data\n"; +print "\n"; + +for ($i = 0; $i < $len; $i++) { + print "%define m$i $i\n"; + for ($j = 0; $j < 8; $j++) { + print "\tdd m", int(rand($i+1)), "\n"; + } +} diff --git a/test/perf/token.pl b/test/perf/token.pl new file mode 100755 index 0000000..4a9e3ae --- /dev/null +++ b/test/perf/token.pl @@ -0,0 +1,23 @@ +#!/usr/bin/perl +# +# Generate a test case for token lookup performance +# + +@insns = qw(add sub adc sbb and or xor mov); +@regs = qw(eax ebx ecx edx esp ebp esi edi); + +srand(0); +sub pickone(@) { + return $_[int(rand(scalar @_))]; +} + +($len) = @ARGV; +$len = 1000000 unless ($len); + +print "\tbits 32\n"; +print "\n"; + +for ($i = 0; $i < $len; $i++) { + print "\t", pickone(@insns), " ", + pickone(@regs), ",", pickone(@regs), "\n"; +} diff --git a/test/performtest.pl b/test/performtest.pl new file mode 100755 index 0000000..f7865b3 --- /dev/null +++ b/test/performtest.pl @@ -0,0 +1,192 @@ +#!/usr/bin/perl +#Perform tests on nasm + +use strict; +use warnings; + +use Getopt::Long qw(GetOptions); +use Pod::Usage qw(pod2usage); + +use File::Basename qw(fileparse); +use File::Compare qw(compare compare_text); +use File::Copy qw(move); +use File::Path qw(mkpath rmtree); + +#sub debugprint { print (pop() . "\n"); } + sub debugprint { } + +my $globalresult = 0; + +#Process one testfile +sub perform { + my ($clean, $diff, $golden, $nasm, $quiet, $testpath) = @_; + my ($stdoutfile, $stderrfile) = ("stdout", "stderr"); + + my ($testname, $ignoredpath, $ignoredsuffix) = fileparse($testpath, ".asm"); + debugprint $testname; + + my $outputdir = $golden ? "golden" : "testresults"; + + mkdir "$outputdir" unless -d "$outputdir"; + + if ($clean) { + rmtree "$outputdir/$testname"; + return; + } + + if(-d "$outputdir/$testname") { + rmtree "$outputdir/$testname"; + } + + open(TESTFILE, '<', $testpath) or (warn "Can't open $testpath\n", return); + TEST: + while(<TESTFILE>) { + #See if there is a test case + last unless /Testname=(.*);\s*Arguments=(.*);\s*Files=(.*)/; + my ($subname, $arguments, $files) = ($1, $2, $3); + debugprint("$subname | $arguments | $files"); + + #Call nasm with this test case + system("$nasm $arguments $testpath > $stdoutfile 2> $stderrfile"); + debugprint("$nasm $arguments $testpath > $stdoutfile 2> $stderrfile ----> $?"); + + #Move the output to the test dir + mkpath("$outputdir/$testname/$subname"); + foreach(split / /,$files) { + if (-f $_) { + move($_, "$outputdir/$testname/$subname/$_") or die $! + } + } + unlink ("$stdoutfile", "$stderrfile"); #Just to be sure + + if($golden) { + print "Test $testname/$subname created.\n" unless $quiet; + } else { + #Compare them with the golden files + my $result = 0; + my @failedfiles = (); + foreach(split / /, $files) { + if(-f "$outputdir/$testname/$subname/$_") { + my $temp; + if($_ eq $stdoutfile or $_ eq $stderrfile) { + #Compare stdout and stderr in text mode so line ending changes won't matter + $temp = compare_text("$outputdir/$testname/$subname/$_", "golden/$testname/$subname/$_", + sub { my ($a, $b) = @_; + $a =~ s/\r//g; + $b =~ s/\r//g; + $a ne $b; } ); + } else { + $temp = compare("$outputdir/$testname/$subname/$_", "golden/$testname/$subname/$_"); + } + + if($temp == 1) { + #different + $result = 1; + $globalresult = 1; + push @failedfiles, $_; + } elsif($temp == -1) { + #error + print "Can't compare at $testname/$subname file $_\n"; + next TEST; + } + } elsif (-f "golden/$testname/$subname/$_") { + #File exists in golden but not in output + $result = 1; + $globalresult = 1; + push @failedfiles, $_; + } + } + + if($result == 0) { + print "Test $testname/$subname succeeded.\n" unless $quiet; + } elsif ($result == 1) { + print "Test $testname/$subname failed on @failedfiles.\n"; + if($diff) { + for(@failedfiles) { + if($_ eq $stdoutfile or $_ eq $stderrfile) { + system "diff -u golden/$testname/$subname/$_ $outputdir/$testname/$subname/$_"; + print "\n"; + } + } + } + } else { + die "Impossible result"; + } + } + } + close(TESTFILE); +} + +my $nasm; +my $clean = 0; +my $diff = 0; +my $golden = 0; +my $help = 0; +my $verbose = 0; + +GetOptions('clean' => \$clean, + 'diff'=> \$diff, + 'golden' => \$golden, + 'help' => \$help, + 'verbose' => \$verbose, + 'nasm=s' => \$nasm + ) or pod2usage(); + +pod2usage() if $help; +die "Please specify either --nasm or --clean. Use --help for help.\n" +unless $nasm or $clean; +die "Please specify the test files, e.g. *.asm\n" unless @ARGV; + +unless (!defined $nasm or -x $nasm) { + warn "Warning: $nasm may not be executable. Expect problems.\n\n"; + sleep 5; +} + +perform($clean, $diff, $golden, $nasm, ! $verbose, $_) foreach @ARGV; +exit $globalresult; + +__END__ + +=head1 NAME + +performtest.pl - NASM regression tester based on golden files + +=head1 SYNOPSIS + +performtest.pl [options] [testfile.asm ...] + +Runs NASM on the specified test files and compare the results +with "golden" output files. + + Options: + --clean Clean up test results (or golden files with --golden) + --diff Execute diff when stdout or stderr don't match + --golden Create golden files + --help Get this help + --nasm=file Specify the file name for the NASM executable, e.g. ../nasm + --verbose Get more output + + If --clean is not specified, --nasm is required. + + testfile.asm ...: + One or more files that NASM should be tested with, + often *.asm in the test directory. + It should contain one or more option lines at the start, + in the following format: + +;Testname=<testname>; Arguments=<arguments to nasm>; Files=<output files> + + If no such lines are found at the start, the file is skipped. + testname should ideally describe the arguments, eg. unoptimized for -O0. + arguments can be an optimization level (-O), an output format (-f), + an output file specifier (-o) etc. + The output files should be a space seperated list of files that will + be checked for regressions. This should often be the output file + and the special files stdout and stderr. + +Any mismatch could be a regression, +but it doesn't have to be. COFF files have a timestamp which +makes this method useless. ELF files have a comment section +with the current version of NASM, so they will change each version number. + +=cut diff --git a/test/pinsr16.asm b/test/pinsr16.asm new file mode 100644 index 0000000..0159839 --- /dev/null +++ b/test/pinsr16.asm @@ -0,0 +1,53 @@ +;Testname=test; Arguments=-O0 -fbin -opinsr16.bin; Files=stdout stderr pinsr16.bin + bits 16 + + pinsrw mm0,eax,0 + pinsrw mm1,si,0 + pinsrw mm2,[bx],0 + pinsrw mm3,word [bx],0 + + pinsrb xmm0,eax,0 + pinsrb xmm1,sil,0 +; pinsrb xmm1,bh,0 + pinsrb xmm2,[bx],0 + pinsrb xmm3,byte [bx],0 + + pinsrw xmm0,eax,0 + pinsrw xmm1,si,0 + pinsrw xmm2,[bx],0 + pinsrw xmm3,word [bx],0 + + pinsrd xmm0,eax,0 + pinsrd xmm1,esi,0 + pinsrd xmm2,[bx],0 + pinsrd xmm3,dword [bx],0 + + vpinsrb xmm0,eax,0 + vpinsrb xmm1,bl,0 + vpinsrb xmm2,[bx],0 + vpinsrb xmm3,byte [bx],0 + + vpinsrw xmm0,eax,0 + vpinsrw xmm1,si,0 + vpinsrw xmm2,[bx],0 + vpinsrw xmm3,word [bx],0 + + vpinsrd xmm0,eax,0 + vpinsrd xmm1,esi,0 + vpinsrd xmm2,[bx],0 + vpinsrd xmm3,dword [bx],0 + + vpinsrb xmm4,xmm0,eax,0 + vpinsrb xmm5,xmm1,bl,0 + vpinsrb xmm6,xmm2,[bx],0 + vpinsrb xmm7,xmm3,byte [bx],0 + + vpinsrw xmm4,xmm0,eax,0 + vpinsrw xmm5,xmm1,si,0 + vpinsrw xmm6,xmm2,[bx],0 + vpinsrw xmm7,xmm3,word [bx],0 + + vpinsrd xmm4,xmm0,eax,0 + vpinsrd xmm5,xmm1,esi,0 + vpinsrd xmm6,xmm2,[bx],0 + vpinsrd xmm7,xmm3,dword [bx],0 diff --git a/test/pinsr32.asm b/test/pinsr32.asm new file mode 100644 index 0000000..24b3e58 --- /dev/null +++ b/test/pinsr32.asm @@ -0,0 +1,53 @@ +;Testname=test; Arguments=-O0 -fbin -opinsr32.bin; Files=stdout stderr pinsr32.bin + bits 32 + + pinsrw mm0,eax,0 + pinsrw mm1,si,0 + pinsrw mm2,[ecx],0 + pinsrw mm3,word [ecx],0 + + pinsrb xmm0,eax,0 + pinsrb xmm1,sil,0 +; pinsrb xmm1,bh,0 + pinsrb xmm2,[ecx],0 + pinsrb xmm3,byte [ecx],0 + + pinsrw xmm0,eax,0 + pinsrw xmm1,si,0 + pinsrw xmm2,[ecx],0 + pinsrw xmm3,word [ecx],0 + + pinsrd xmm0,eax,0 + pinsrd xmm1,esi,0 + pinsrd xmm2,[ecx],0 + pinsrd xmm3,dword [ecx],0 + + vpinsrb xmm0,eax,0 + vpinsrb xmm1,bl,0 + vpinsrb xmm2,[ecx],0 + vpinsrb xmm3,byte [ecx],0 + + vpinsrw xmm0,eax,0 + vpinsrw xmm1,si,0 + vpinsrw xmm2,[ecx],0 + vpinsrw xmm3,word [ecx],0 + + vpinsrd xmm0,eax,0 + vpinsrd xmm1,esi,0 + vpinsrd xmm2,[ecx],0 + vpinsrd xmm3,dword [ecx],0 + + vpinsrb xmm4,xmm0,eax,0 + vpinsrb xmm5,xmm1,bl,0 + vpinsrb xmm6,xmm2,[ecx],0 + vpinsrb xmm7,xmm3,byte [ecx],0 + + vpinsrw xmm4,xmm0,eax,0 + vpinsrw xmm5,xmm1,si,0 + vpinsrw xmm6,xmm2,[ecx],0 + vpinsrw xmm7,xmm3,word [ecx],0 + + vpinsrd xmm4,xmm0,eax,0 + vpinsrd xmm5,xmm1,esi,0 + vpinsrd xmm6,xmm2,[ecx],0 + vpinsrd xmm7,xmm3,dword [ecx],0 diff --git a/test/pinsr64.asm b/test/pinsr64.asm new file mode 100644 index 0000000..8eedfdd --- /dev/null +++ b/test/pinsr64.asm @@ -0,0 +1,68 @@ +;Testname=test; Arguments=-O0 -fbin -opinsr64.bin; Files=stdout stderr pinsr64.bin + bits 64 + + pinsrw mm0,eax,0 + pinsrw mm1,si,0 + pinsrw mm2,[rcx],0 + pinsrw mm3,word [rcx],0 + + pinsrb xmm0,eax,0 + pinsrb xmm1,sil,0 +; pinsrb xmm1,bh,0 + pinsrb xmm2,[rcx],0 + pinsrb xmm3,byte [rcx],0 + + pinsrw xmm0,eax,0 + pinsrw xmm1,si,0 + pinsrw xmm2,[rcx],0 + pinsrw xmm3,word [rcx],0 + + pinsrd xmm0,eax,0 + pinsrd xmm1,esi,0 + pinsrd xmm2,[rcx],0 + pinsrd xmm3,dword [rcx],0 + + pinsrq xmm0,rax,0 + pinsrq xmm1,rsi,0 + pinsrq xmm2,[rcx],0 + pinsrq xmm3,qword [rcx],0 + + vpinsrb xmm0,eax,0 + vpinsrb xmm1,sil,0 + vpinsrb xmm2,[rcx],0 + vpinsrb xmm3,byte [rcx],0 + + vpinsrw xmm0,eax,0 + vpinsrw xmm1,si,0 + vpinsrw xmm2,[rcx],0 + vpinsrw xmm3,word [rcx],0 + + vpinsrd xmm0,eax,0 + vpinsrd xmm1,esi,0 + vpinsrd xmm2,[rcx],0 + vpinsrd xmm3,dword [rcx],0 + + vpinsrq xmm0,rax,0 + vpinsrq xmm1,rsi,0 + vpinsrq xmm2,[rcx],0 + vpinsrq xmm3,qword [rcx],0 + + vpinsrb xmm4,xmm0,eax,0 + vpinsrb xmm5,xmm1,sil,0 + vpinsrb xmm6,xmm2,[rcx],0 + vpinsrb xmm7,xmm3,byte [rcx],0 + + vpinsrw xmm4,xmm0,eax,0 + vpinsrw xmm5,xmm1,si,0 + vpinsrw xmm6,xmm2,[rcx],0 + vpinsrw xmm7,xmm3,word [rcx],0 + + vpinsrd xmm4,xmm0,eax,0 + vpinsrd xmm5,xmm1,esi,0 + vpinsrd xmm6,xmm2,[rcx],0 + vpinsrd xmm7,xmm3,dword [rcx],0 + + vpinsrq xmm4,xmm0,rax,0 + vpinsrq xmm5,xmm1,rsi,0 + vpinsrq xmm6,xmm2,[rcx],0 + vpinsrq xmm7,xmm3,qword [rdx],0 diff --git a/test/popcnt.asm b/test/popcnt.asm new file mode 100644 index 0000000..0009619 --- /dev/null +++ b/test/popcnt.asm @@ -0,0 +1,32 @@ +;Testname=test; Arguments=-fbin -opopcnt.bin; Files=stdout stderr popcnt.bin + + bits 16 + + popcnt ax,cx + popcnt ax,[si] + popcnt ax,word [si] + popcnt eax,ecx + popcnt eax,[si] + popcnt eax,dword [si] + + bits 32 + + popcnt ax,cx + popcnt ax,[esi] + popcnt ax,word [esi] + popcnt eax,ecx + popcnt eax,[esi] + popcnt eax,dword [esi] + + bits 64 + + popcnt ax,cx + popcnt ax,[rsi] + popcnt ax,word [rsi] + popcnt eax,ecx + popcnt eax,[rsi] + popcnt eax,dword [rsi] + popcnt rax,rcx + popcnt rax,[rsi] + popcnt rax,qword [rsi] +
\ No newline at end of file diff --git a/test/ppindirect.asm b/test/ppindirect.asm new file mode 100644 index 0000000..0a30d07 --- /dev/null +++ b/test/ppindirect.asm @@ -0,0 +1,42 @@ +;Testname=test; Arguments=-E -o ppindirect.out; Files=ppindirect.out + +; Fun tests of the preprocessor indirection mode... + +%assign foo1 11 +%assign foo11 1111 +%assign foo2 22 +%assign foo22 2222 +%assign foo3 33 +%assign foo33 3333 +%assign n 2 +foo%[foo%[n]]*100 +foo%[n]*100 +%assign foo%[foo%[n]] foo%[foo%[n]]*100 +;%assign foo%[n] foo%[n]*100 + + foo1 + foo2 + foo3 + foo11 + foo22 + foo33 + +%define foo33bar 999999 + %[foo%[foo3]bar] + +%assign bctr 0 +%macro bluttan 0 +%assign bctr bctr+1 +%assign bluttan%[bctr] bctr +%defstr bstr bluttan%[bctr] + bluttan%[bctr] + bstr +%endmacro + +%rep 20 + bluttan +%endrep +%rep 20 + bluttan%[bctr] +%assign bctr bctr-1 +%endrep diff --git a/test/pushseg.asm b/test/pushseg.asm new file mode 100644 index 0000000..7bd7c95 --- /dev/null +++ b/test/pushseg.asm @@ -0,0 +1,17 @@ +;Testname=test; Arguments=-fbin -opushseg.bin; Files=stdout stderr pushseg.bin + + bits 16 + + push cs + push ds + push es + push ss + push fs + push gs + + pop gs + pop fs + pop ss + pop es + pop ds + pop cs ; 8086 only, does not disassemble diff --git a/test/r13.asm b/test/r13.asm new file mode 100644 index 0000000..88079e1 --- /dev/null +++ b/test/r13.asm @@ -0,0 +1,15 @@ +;Testname=test; Arguments=-fbin -or13.bin; Files=stdout stderr r13.bin + + bits 64 + mov rax,[rbx] + mov rax,[rbx*4] + mov rax,[rbx+rbx*2] + mov rax,[r13+rbx*2] + mov rax,[rbp] + mov rax,[rbp*4] + mov rax,[rbp+rbp*2] + mov rax,[rbp+r13*2] + mov rax,[r13] + mov rax,[r13*4] + mov rax,[r13+rbp*2] + mov rax,[r13+r13*2] diff --git a/test/radix.asm b/test/radix.asm new file mode 100644 index 0000000..1c56457 --- /dev/null +++ b/test/radix.asm @@ -0,0 +1,54 @@ +;Testname=test; Arguments=-fbin -oradix.bin; Files=stdout stderr radix.bin + + ;; Integer constants... + + dd 1010_0101 ; Decimal + dd 01010_0101 ; Decimal (*not* octal!) + dd 0d1010_0101 ; Decimal + dd 0t1010_0101 ; Decimal + dd 1010_0101d ; Decimal + dd 1010_0101t ; Decimal + + dd 0b1010_0101 ; Binary + dd 0y1010_0101 ; Binary + dd 1010_0101b ; Binary + dd 1010_0101y ; Binary + + dd 0o1010_0101 ; Octal + dd 0q1010_0101 ; Octal + dd 1010_0101o ; Octal + dd 1010_0101q ; Octal + + dd 0h1010_0101 ; Hex + dd 0x1010_0101 ; Hex + dd 1010_0101h ; Hex + dd 1010_0101x ; Hex + dd $1010_0101 ; Hex + + db 0h ; Zero! + db 0x ; Zero! + db 0b ; Zero! + db 0dh ; Hex + db 0bh ; Hex + db 0dx ; Hex + db 0bx ; Hex + db 0hd ; Hex + db 0hb ; Hex + db 0xd ; Hex + db 0xb ; Hex + + ;; Floating-point constants + ;; All of these should output B4A21147 + dd 3.7282705e+4 ; Decimal + dd 00003.7282705e+4 ; Decimal + dd 0d3.7282705e+4 ; Decimal + dd 0t3.7282705e+4 ; Decimal + + dd 0x1.23456789p+15 ; Hex + dd 0h1.23456789p+15 ; Hex + + dd 0o1.10642547422p+15 ; Octal + dd 0q1.10642547422p+15 ; Octal + + dd 0b1.0010_0011_0100_0101_0110_0111_1000_1001p+15 ; Binary + dd 0y1.0010_0011_0100_0101_0110_0111_1000_1001p+15 ; Binary diff --git a/test/riprel.asm b/test/riprel.asm new file mode 100644 index 0000000..757a8dd --- /dev/null +++ b/test/riprel.asm @@ -0,0 +1,5357 @@ +;Testname=unoptimized; Arguments=-fbin -oriprel.bin -O0; Files=stdout stderr riprel.bin +;Testname=optimized; Arguments=-fbin -oriprel.bin -Ox; Files=stdout stderr riprel.bin + bits 64 + + default abs + + mov al,[foo] + mov bl,[foo] + mov ax,[foo] + mov bx,[foo] + mov eax,[foo] + mov ebx,[foo] + mov rax,[foo] + mov rbx,[foo] + mov al,[0xaaaaaaaaaaaaaaaa] + mov bl,[0xaaaaaaaaaaaaaaaa] + mov ax,[0xaaaaaaaaaaaaaaaa] + mov bx,[0xaaaaaaaaaaaaaaaa] + mov eax,[0xaaaaaaaaaaaaaaaa] + mov ebx,[0xaaaaaaaaaaaaaaaa] + mov rax,[0xaaaaaaaaaaaaaaaa] + mov rbx,[0xaaaaaaaaaaaaaaaa] + mov al,[0xbbbbbbbb] + mov bl,[0xbbbbbbbb] + mov ax,[0xbbbbbbbb] + mov bx,[0xbbbbbbbb] + mov eax,[0xbbbbbbbb] + mov ebx,[0xbbbbbbbb] + mov rax,[0xbbbbbbbb] + mov rbx,[0xbbbbbbbb] + mov al,[0xffffffffcccccccc] + mov bl,[0xffffffffcccccccc] + mov ax,[0xffffffffcccccccc] + mov bx,[0xffffffffcccccccc] + mov eax,[0xffffffffcccccccc] + mov ebx,[0xffffffffcccccccc] + mov rax,[0xffffffffcccccccc] + mov rbx,[0xffffffffcccccccc] + + mov al,[dword foo] + mov bl,[dword foo] + mov ax,[dword foo] + mov bx,[dword foo] + mov eax,[dword foo] + mov ebx,[dword foo] + mov rax,[dword foo] + mov rbx,[dword foo] + mov al,[dword 0xaaaaaaaaaaaaaaaa] + mov bl,[dword 0xaaaaaaaaaaaaaaaa] + mov ax,[dword 0xaaaaaaaaaaaaaaaa] + mov bx,[dword 0xaaaaaaaaaaaaaaaa] + mov eax,[dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[dword 0xaaaaaaaaaaaaaaaa] + mov rax,[dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[dword 0xaaaaaaaaaaaaaaaa] + mov al,[dword 0xbbbbbbbb] + mov bl,[dword 0xbbbbbbbb] + mov ax,[dword 0xbbbbbbbb] + mov bx,[dword 0xbbbbbbbb] + mov eax,[dword 0xbbbbbbbb] + mov ebx,[dword 0xbbbbbbbb] + mov rax,[dword 0xbbbbbbbb] + mov rbx,[dword 0xbbbbbbbb] + mov al,[dword 0xffffffffcccccccc] + mov bl,[dword 0xffffffffcccccccc] + mov ax,[dword 0xffffffffcccccccc] + mov bx,[dword 0xffffffffcccccccc] + mov eax,[dword 0xffffffffcccccccc] + mov ebx,[dword 0xffffffffcccccccc] + mov rax,[dword 0xffffffffcccccccc] + mov rbx,[dword 0xffffffffcccccccc] + + mov al,[qword foo] + mov bl,[qword foo] + mov ax,[qword foo] + mov bx,[qword foo] + mov eax,[qword foo] + mov ebx,[qword foo] + mov rax,[qword foo] + mov rbx,[qword foo] + mov al,[qword 0xaaaaaaaaaaaaaaaa] + mov bl,[qword 0xaaaaaaaaaaaaaaaa] + mov ax,[qword 0xaaaaaaaaaaaaaaaa] + mov bx,[qword 0xaaaaaaaaaaaaaaaa] + mov eax,[qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[qword 0xaaaaaaaaaaaaaaaa] + mov rax,[qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[qword 0xaaaaaaaaaaaaaaaa] + mov al,[qword 0xbbbbbbbb] + mov bl,[qword 0xbbbbbbbb] + mov ax,[qword 0xbbbbbbbb] + mov bx,[qword 0xbbbbbbbb] + mov eax,[qword 0xbbbbbbbb] + mov ebx,[qword 0xbbbbbbbb] + mov rax,[qword 0xbbbbbbbb] + mov rbx,[qword 0xbbbbbbbb] + mov al,[qword 0xffffffffcccccccc] + mov bl,[qword 0xffffffffcccccccc] + mov ax,[qword 0xffffffffcccccccc] + mov bx,[qword 0xffffffffcccccccc] + mov eax,[qword 0xffffffffcccccccc] + mov ebx,[qword 0xffffffffcccccccc] + mov rax,[qword 0xffffffffcccccccc] + mov rbx,[qword 0xffffffffcccccccc] + + mov al,[a64 foo] + mov bl,[a64 foo] + mov ax,[a64 foo] + mov bx,[a64 foo] + mov eax,[a64 foo] + mov ebx,[a64 foo] + mov rax,[a64 foo] + mov rbx,[a64 foo] + mov al,[a64 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 0xaaaaaaaaaaaaaaaa] + mov al,[a64 0xbbbbbbbb] + mov bl,[a64 0xbbbbbbbb] + mov ax,[a64 0xbbbbbbbb] + mov bx,[a64 0xbbbbbbbb] + mov eax,[a64 0xbbbbbbbb] + mov ebx,[a64 0xbbbbbbbb] + mov rax,[a64 0xbbbbbbbb] + mov rbx,[a64 0xbbbbbbbb] + mov al,[a64 0xffffffffcccccccc] + mov bl,[a64 0xffffffffcccccccc] + mov ax,[a64 0xffffffffcccccccc] + mov bx,[a64 0xffffffffcccccccc] + mov eax,[a64 0xffffffffcccccccc] + mov ebx,[a64 0xffffffffcccccccc] + mov rax,[a64 0xffffffffcccccccc] + mov rbx,[a64 0xffffffffcccccccc] + + mov al,[a64 dword foo] + mov bl,[a64 dword foo] + mov ax,[a64 dword foo] + mov bx,[a64 dword foo] + mov eax,[a64 dword foo] + mov ebx,[a64 dword foo] + mov rax,[a64 dword foo] + mov rbx,[a64 dword foo] + mov al,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword 0xbbbbbbbb] + mov bl,[a64 dword 0xbbbbbbbb] + mov ax,[a64 dword 0xbbbbbbbb] + mov bx,[a64 dword 0xbbbbbbbb] + mov eax,[a64 dword 0xbbbbbbbb] + mov ebx,[a64 dword 0xbbbbbbbb] + mov rax,[a64 dword 0xbbbbbbbb] + mov rbx,[a64 dword 0xbbbbbbbb] + mov al,[a64 dword 0xffffffffcccccccc] + mov bl,[a64 dword 0xffffffffcccccccc] + mov ax,[a64 dword 0xffffffffcccccccc] + mov bx,[a64 dword 0xffffffffcccccccc] + mov eax,[a64 dword 0xffffffffcccccccc] + mov ebx,[a64 dword 0xffffffffcccccccc] + mov rax,[a64 dword 0xffffffffcccccccc] + mov rbx,[a64 dword 0xffffffffcccccccc] + + mov al,[a64 qword foo] + mov bl,[a64 qword foo] + mov ax,[a64 qword foo] + mov bx,[a64 qword foo] + mov eax,[a64 qword foo] + mov ebx,[a64 qword foo] + mov rax,[a64 qword foo] + mov rbx,[a64 qword foo] + mov al,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword 0xbbbbbbbb] + mov bl,[a64 qword 0xbbbbbbbb] + mov ax,[a64 qword 0xbbbbbbbb] + mov bx,[a64 qword 0xbbbbbbbb] + mov eax,[a64 qword 0xbbbbbbbb] + mov ebx,[a64 qword 0xbbbbbbbb] + mov rax,[a64 qword 0xbbbbbbbb] + mov rbx,[a64 qword 0xbbbbbbbb] + mov al,[a64 qword 0xffffffffcccccccc] + mov bl,[a64 qword 0xffffffffcccccccc] + mov ax,[a64 qword 0xffffffffcccccccc] + mov bx,[a64 qword 0xffffffffcccccccc] + mov eax,[a64 qword 0xffffffffcccccccc] + mov ebx,[a64 qword 0xffffffffcccccccc] + mov rax,[a64 qword 0xffffffffcccccccc] + mov rbx,[a64 qword 0xffffffffcccccccc] + + mov al,[a32 foo] + mov bl,[a32 foo] + mov ax,[a32 foo] + mov bx,[a32 foo] + mov eax,[a32 foo] + mov ebx,[a32 foo] + mov rax,[a32 foo] + mov rbx,[a32 foo] + mov al,[a32 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 0xaaaaaaaaaaaaaaaa] + mov al,[a32 0xbbbbbbbb] + mov bl,[a32 0xbbbbbbbb] + mov ax,[a32 0xbbbbbbbb] + mov bx,[a32 0xbbbbbbbb] + mov eax,[a32 0xbbbbbbbb] + mov ebx,[a32 0xbbbbbbbb] + mov rax,[a32 0xbbbbbbbb] + mov rbx,[a32 0xbbbbbbbb] + mov al,[a32 0xffffffffcccccccc] + mov bl,[a32 0xffffffffcccccccc] + mov ax,[a32 0xffffffffcccccccc] + mov bx,[a32 0xffffffffcccccccc] + mov eax,[a32 0xffffffffcccccccc] + mov ebx,[a32 0xffffffffcccccccc] + mov rax,[a32 0xffffffffcccccccc] + mov rbx,[a32 0xffffffffcccccccc] + + mov al,[a32 dword foo] + mov bl,[a32 dword foo] + mov ax,[a32 dword foo] + mov bx,[a32 dword foo] + mov eax,[a32 dword foo] + mov ebx,[a32 dword foo] + mov rax,[a32 dword foo] + mov rbx,[a32 dword foo] + mov al,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword 0xbbbbbbbb] + mov bl,[a32 dword 0xbbbbbbbb] + mov ax,[a32 dword 0xbbbbbbbb] + mov bx,[a32 dword 0xbbbbbbbb] + mov eax,[a32 dword 0xbbbbbbbb] + mov ebx,[a32 dword 0xbbbbbbbb] + mov rax,[a32 dword 0xbbbbbbbb] + mov rbx,[a32 dword 0xbbbbbbbb] + mov al,[a32 dword 0xffffffffcccccccc] + mov bl,[a32 dword 0xffffffffcccccccc] + mov ax,[a32 dword 0xffffffffcccccccc] + mov bx,[a32 dword 0xffffffffcccccccc] + mov eax,[a32 dword 0xffffffffcccccccc] + mov ebx,[a32 dword 0xffffffffcccccccc] + mov rax,[a32 dword 0xffffffffcccccccc] + mov rbx,[a32 dword 0xffffffffcccccccc] + + mov al,[a32 qword foo] + mov bl,[a32 qword foo] + mov ax,[a32 qword foo] + mov bx,[a32 qword foo] + mov eax,[a32 qword foo] + mov ebx,[a32 qword foo] + mov rax,[a32 qword foo] + mov rbx,[a32 qword foo] + mov al,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword 0xbbbbbbbb] + mov bl,[a32 qword 0xbbbbbbbb] + mov ax,[a32 qword 0xbbbbbbbb] + mov bx,[a32 qword 0xbbbbbbbb] + mov eax,[a32 qword 0xbbbbbbbb] + mov ebx,[a32 qword 0xbbbbbbbb] + mov rax,[a32 qword 0xbbbbbbbb] + mov rbx,[a32 qword 0xbbbbbbbb] + mov al,[a32 qword 0xffffffffcccccccc] + mov bl,[a32 qword 0xffffffffcccccccc] + mov ax,[a32 qword 0xffffffffcccccccc] + mov bx,[a32 qword 0xffffffffcccccccc] + mov eax,[a32 qword 0xffffffffcccccccc] + mov ebx,[a32 qword 0xffffffffcccccccc] + mov rax,[a32 qword 0xffffffffcccccccc] + mov rbx,[a32 qword 0xffffffffcccccccc] + + mov al,[abs foo] + mov bl,[abs foo] + mov ax,[abs foo] + mov bx,[abs foo] + mov eax,[abs foo] + mov ebx,[abs foo] + mov rax,[abs foo] + mov rbx,[abs foo] + mov al,[abs 0xaaaaaaaaaaaaaaaa] + mov bl,[abs 0xaaaaaaaaaaaaaaaa] + mov ax,[abs 0xaaaaaaaaaaaaaaaa] + mov bx,[abs 0xaaaaaaaaaaaaaaaa] + mov eax,[abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs 0xaaaaaaaaaaaaaaaa] + mov rax,[abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs 0xaaaaaaaaaaaaaaaa] + mov al,[abs 0xbbbbbbbb] + mov bl,[abs 0xbbbbbbbb] + mov ax,[abs 0xbbbbbbbb] + mov bx,[abs 0xbbbbbbbb] + mov eax,[abs 0xbbbbbbbb] + mov ebx,[abs 0xbbbbbbbb] + mov rax,[abs 0xbbbbbbbb] + mov rbx,[abs 0xbbbbbbbb] + mov al,[abs 0xffffffffcccccccc] + mov bl,[abs 0xffffffffcccccccc] + mov ax,[abs 0xffffffffcccccccc] + mov bx,[abs 0xffffffffcccccccc] + mov eax,[abs 0xffffffffcccccccc] + mov ebx,[abs 0xffffffffcccccccc] + mov rax,[abs 0xffffffffcccccccc] + mov rbx,[abs 0xffffffffcccccccc] + + mov al,[abs dword foo] + mov bl,[abs dword foo] + mov ax,[abs dword foo] + mov bx,[abs dword foo] + mov eax,[abs dword foo] + mov ebx,[abs dword foo] + mov rax,[abs dword foo] + mov rbx,[abs dword foo] + mov al,[abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[abs dword 0xbbbbbbbb] + mov bl,[abs dword 0xbbbbbbbb] + mov ax,[abs dword 0xbbbbbbbb] + mov bx,[abs dword 0xbbbbbbbb] + mov eax,[abs dword 0xbbbbbbbb] + mov ebx,[abs dword 0xbbbbbbbb] + mov rax,[abs dword 0xbbbbbbbb] + mov rbx,[abs dword 0xbbbbbbbb] + mov al,[abs dword 0xffffffffcccccccc] + mov bl,[abs dword 0xffffffffcccccccc] + mov ax,[abs dword 0xffffffffcccccccc] + mov bx,[abs dword 0xffffffffcccccccc] + mov eax,[abs dword 0xffffffffcccccccc] + mov ebx,[abs dword 0xffffffffcccccccc] + mov rax,[abs dword 0xffffffffcccccccc] + mov rbx,[abs dword 0xffffffffcccccccc] + + mov al,[abs qword foo] + mov bl,[abs qword foo] + mov ax,[abs qword foo] + mov bx,[abs qword foo] + mov eax,[abs qword foo] + mov ebx,[abs qword foo] + mov rax,[abs qword foo] + mov rbx,[abs qword foo] + mov al,[abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[abs qword 0xbbbbbbbb] + mov bl,[abs qword 0xbbbbbbbb] + mov ax,[abs qword 0xbbbbbbbb] + mov bx,[abs qword 0xbbbbbbbb] + mov eax,[abs qword 0xbbbbbbbb] + mov ebx,[abs qword 0xbbbbbbbb] + mov rax,[abs qword 0xbbbbbbbb] + mov rbx,[abs qword 0xbbbbbbbb] + mov al,[abs qword 0xffffffffcccccccc] + mov bl,[abs qword 0xffffffffcccccccc] + mov ax,[abs qword 0xffffffffcccccccc] + mov bx,[abs qword 0xffffffffcccccccc] + mov eax,[abs qword 0xffffffffcccccccc] + mov ebx,[abs qword 0xffffffffcccccccc] + mov rax,[abs qword 0xffffffffcccccccc] + mov rbx,[abs qword 0xffffffffcccccccc] + + mov al,[a64 abs foo] + mov bl,[a64 abs foo] + mov ax,[a64 abs foo] + mov bx,[a64 abs foo] + mov eax,[a64 abs foo] + mov ebx,[a64 abs foo] + mov rax,[a64 abs foo] + mov rbx,[a64 abs foo] + mov al,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs 0xbbbbbbbb] + mov bl,[a64 abs 0xbbbbbbbb] + mov ax,[a64 abs 0xbbbbbbbb] + mov bx,[a64 abs 0xbbbbbbbb] + mov eax,[a64 abs 0xbbbbbbbb] + mov ebx,[a64 abs 0xbbbbbbbb] + mov rax,[a64 abs 0xbbbbbbbb] + mov rbx,[a64 abs 0xbbbbbbbb] + mov al,[a64 abs 0xffffffffcccccccc] + mov bl,[a64 abs 0xffffffffcccccccc] + mov ax,[a64 abs 0xffffffffcccccccc] + mov bx,[a64 abs 0xffffffffcccccccc] + mov eax,[a64 abs 0xffffffffcccccccc] + mov ebx,[a64 abs 0xffffffffcccccccc] + mov rax,[a64 abs 0xffffffffcccccccc] + mov rbx,[a64 abs 0xffffffffcccccccc] + + mov al,[a64 abs dword foo] + mov bl,[a64 abs dword foo] + mov ax,[a64 abs dword foo] + mov bx,[a64 abs dword foo] + mov eax,[a64 abs dword foo] + mov ebx,[a64 abs dword foo] + mov rax,[a64 abs dword foo] + mov rbx,[a64 abs dword foo] + mov al,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword 0xbbbbbbbb] + mov bl,[a64 abs dword 0xbbbbbbbb] + mov ax,[a64 abs dword 0xbbbbbbbb] + mov bx,[a64 abs dword 0xbbbbbbbb] + mov eax,[a64 abs dword 0xbbbbbbbb] + mov ebx,[a64 abs dword 0xbbbbbbbb] + mov rax,[a64 abs dword 0xbbbbbbbb] + mov rbx,[a64 abs dword 0xbbbbbbbb] + mov al,[a64 abs dword 0xffffffffcccccccc] + mov bl,[a64 abs dword 0xffffffffcccccccc] + mov ax,[a64 abs dword 0xffffffffcccccccc] + mov bx,[a64 abs dword 0xffffffffcccccccc] + mov eax,[a64 abs dword 0xffffffffcccccccc] + mov ebx,[a64 abs dword 0xffffffffcccccccc] + mov rax,[a64 abs dword 0xffffffffcccccccc] + mov rbx,[a64 abs dword 0xffffffffcccccccc] + + mov al,[a64 abs qword foo] + mov bl,[a64 abs qword foo] + mov ax,[a64 abs qword foo] + mov bx,[a64 abs qword foo] + mov eax,[a64 abs qword foo] + mov ebx,[a64 abs qword foo] + mov rax,[a64 abs qword foo] + mov rbx,[a64 abs qword foo] + mov al,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword 0xbbbbbbbb] + mov bl,[a64 abs qword 0xbbbbbbbb] + mov ax,[a64 abs qword 0xbbbbbbbb] + mov bx,[a64 abs qword 0xbbbbbbbb] + mov eax,[a64 abs qword 0xbbbbbbbb] + mov ebx,[a64 abs qword 0xbbbbbbbb] + mov rax,[a64 abs qword 0xbbbbbbbb] + mov rbx,[a64 abs qword 0xbbbbbbbb] + mov al,[a64 abs qword 0xffffffffcccccccc] + mov bl,[a64 abs qword 0xffffffffcccccccc] + mov ax,[a64 abs qword 0xffffffffcccccccc] + mov bx,[a64 abs qword 0xffffffffcccccccc] + mov eax,[a64 abs qword 0xffffffffcccccccc] + mov ebx,[a64 abs qword 0xffffffffcccccccc] + mov rax,[a64 abs qword 0xffffffffcccccccc] + mov rbx,[a64 abs qword 0xffffffffcccccccc] + + mov al,[a32 abs foo] + mov bl,[a32 abs foo] + mov ax,[a32 abs foo] + mov bx,[a32 abs foo] + mov eax,[a32 abs foo] + mov ebx,[a32 abs foo] + mov rax,[a32 abs foo] + mov rbx,[a32 abs foo] + mov al,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs 0xbbbbbbbb] + mov bl,[a32 abs 0xbbbbbbbb] + mov ax,[a32 abs 0xbbbbbbbb] + mov bx,[a32 abs 0xbbbbbbbb] + mov eax,[a32 abs 0xbbbbbbbb] + mov ebx,[a32 abs 0xbbbbbbbb] + mov rax,[a32 abs 0xbbbbbbbb] + mov rbx,[a32 abs 0xbbbbbbbb] + mov al,[a32 abs 0xffffffffcccccccc] + mov bl,[a32 abs 0xffffffffcccccccc] + mov ax,[a32 abs 0xffffffffcccccccc] + mov bx,[a32 abs 0xffffffffcccccccc] + mov eax,[a32 abs 0xffffffffcccccccc] + mov ebx,[a32 abs 0xffffffffcccccccc] + mov rax,[a32 abs 0xffffffffcccccccc] + mov rbx,[a32 abs 0xffffffffcccccccc] + + mov al,[a32 abs dword foo] + mov bl,[a32 abs dword foo] + mov ax,[a32 abs dword foo] + mov bx,[a32 abs dword foo] + mov eax,[a32 abs dword foo] + mov ebx,[a32 abs dword foo] + mov rax,[a32 abs dword foo] + mov rbx,[a32 abs dword foo] + mov al,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword 0xbbbbbbbb] + mov bl,[a32 abs dword 0xbbbbbbbb] + mov ax,[a32 abs dword 0xbbbbbbbb] + mov bx,[a32 abs dword 0xbbbbbbbb] + mov eax,[a32 abs dword 0xbbbbbbbb] + mov ebx,[a32 abs dword 0xbbbbbbbb] + mov rax,[a32 abs dword 0xbbbbbbbb] + mov rbx,[a32 abs dword 0xbbbbbbbb] + mov al,[a32 abs dword 0xffffffffcccccccc] + mov bl,[a32 abs dword 0xffffffffcccccccc] + mov ax,[a32 abs dword 0xffffffffcccccccc] + mov bx,[a32 abs dword 0xffffffffcccccccc] + mov eax,[a32 abs dword 0xffffffffcccccccc] + mov ebx,[a32 abs dword 0xffffffffcccccccc] + mov rax,[a32 abs dword 0xffffffffcccccccc] + mov rbx,[a32 abs dword 0xffffffffcccccccc] + + mov al,[a32 abs qword foo] + mov bl,[a32 abs qword foo] + mov ax,[a32 abs qword foo] + mov bx,[a32 abs qword foo] + mov eax,[a32 abs qword foo] + mov ebx,[a32 abs qword foo] + mov rax,[a32 abs qword foo] + mov rbx,[a32 abs qword foo] + mov al,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword 0xbbbbbbbb] + mov bl,[a32 abs qword 0xbbbbbbbb] + mov ax,[a32 abs qword 0xbbbbbbbb] + mov bx,[a32 abs qword 0xbbbbbbbb] + mov eax,[a32 abs qword 0xbbbbbbbb] + mov ebx,[a32 abs qword 0xbbbbbbbb] + mov rax,[a32 abs qword 0xbbbbbbbb] + mov rbx,[a32 abs qword 0xbbbbbbbb] + mov al,[a32 abs qword 0xffffffffcccccccc] + mov bl,[a32 abs qword 0xffffffffcccccccc] + mov ax,[a32 abs qword 0xffffffffcccccccc] + mov bx,[a32 abs qword 0xffffffffcccccccc] + mov eax,[a32 abs qword 0xffffffffcccccccc] + mov ebx,[a32 abs qword 0xffffffffcccccccc] + mov rax,[a32 abs qword 0xffffffffcccccccc] + mov rbx,[a32 abs qword 0xffffffffcccccccc] + + mov al,[rel foo] + mov bl,[rel foo] + mov ax,[rel foo] + mov bx,[rel foo] + mov eax,[rel foo] + mov ebx,[rel foo] + mov rax,[rel foo] + mov rbx,[rel foo] + mov al,[rel 0xaaaaaaaaaaaaaaaa] + mov bl,[rel 0xaaaaaaaaaaaaaaaa] + mov ax,[rel 0xaaaaaaaaaaaaaaaa] + mov bx,[rel 0xaaaaaaaaaaaaaaaa] + mov eax,[rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel 0xaaaaaaaaaaaaaaaa] + mov rax,[rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel 0xaaaaaaaaaaaaaaaa] + mov al,[rel 0xbbbbbbbb] + mov bl,[rel 0xbbbbbbbb] + mov ax,[rel 0xbbbbbbbb] + mov bx,[rel 0xbbbbbbbb] + mov eax,[rel 0xbbbbbbbb] + mov ebx,[rel 0xbbbbbbbb] + mov rax,[rel 0xbbbbbbbb] + mov rbx,[rel 0xbbbbbbbb] + mov al,[rel 0xffffffffcccccccc] + mov bl,[rel 0xffffffffcccccccc] + mov ax,[rel 0xffffffffcccccccc] + mov bx,[rel 0xffffffffcccccccc] + mov eax,[rel 0xffffffffcccccccc] + mov ebx,[rel 0xffffffffcccccccc] + mov rax,[rel 0xffffffffcccccccc] + mov rbx,[rel 0xffffffffcccccccc] + + mov al,[rel dword foo] + mov bl,[rel dword foo] + mov ax,[rel dword foo] + mov bx,[rel dword foo] + mov eax,[rel dword foo] + mov ebx,[rel dword foo] + mov rax,[rel dword foo] + mov rbx,[rel dword foo] + mov al,[rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[rel dword 0xbbbbbbbb] + mov bl,[rel dword 0xbbbbbbbb] + mov ax,[rel dword 0xbbbbbbbb] + mov bx,[rel dword 0xbbbbbbbb] + mov eax,[rel dword 0xbbbbbbbb] + mov ebx,[rel dword 0xbbbbbbbb] + mov rax,[rel dword 0xbbbbbbbb] + mov rbx,[rel dword 0xbbbbbbbb] + mov al,[rel dword 0xffffffffcccccccc] + mov bl,[rel dword 0xffffffffcccccccc] + mov ax,[rel dword 0xffffffffcccccccc] + mov bx,[rel dword 0xffffffffcccccccc] + mov eax,[rel dword 0xffffffffcccccccc] + mov ebx,[rel dword 0xffffffffcccccccc] + mov rax,[rel dword 0xffffffffcccccccc] + mov rbx,[rel dword 0xffffffffcccccccc] + + mov al,[rel qword foo] + mov bl,[rel qword foo] + mov ax,[rel qword foo] + mov bx,[rel qword foo] + mov eax,[rel qword foo] + mov ebx,[rel qword foo] + mov rax,[rel qword foo] + mov rbx,[rel qword foo] + mov al,[rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[rel qword 0xbbbbbbbb] + mov bl,[rel qword 0xbbbbbbbb] + mov ax,[rel qword 0xbbbbbbbb] + mov bx,[rel qword 0xbbbbbbbb] + mov eax,[rel qword 0xbbbbbbbb] + mov ebx,[rel qword 0xbbbbbbbb] + mov rax,[rel qword 0xbbbbbbbb] + mov rbx,[rel qword 0xbbbbbbbb] + mov al,[rel qword 0xffffffffcccccccc] + mov bl,[rel qword 0xffffffffcccccccc] + mov ax,[rel qword 0xffffffffcccccccc] + mov bx,[rel qword 0xffffffffcccccccc] + mov eax,[rel qword 0xffffffffcccccccc] + mov ebx,[rel qword 0xffffffffcccccccc] + mov rax,[rel qword 0xffffffffcccccccc] + mov rbx,[rel qword 0xffffffffcccccccc] + + mov al,[a64 rel foo] + mov bl,[a64 rel foo] + mov ax,[a64 rel foo] + mov bx,[a64 rel foo] + mov eax,[a64 rel foo] + mov ebx,[a64 rel foo] + mov rax,[a64 rel foo] + mov rbx,[a64 rel foo] + mov al,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel 0xbbbbbbbb] + mov bl,[a64 rel 0xbbbbbbbb] + mov ax,[a64 rel 0xbbbbbbbb] + mov bx,[a64 rel 0xbbbbbbbb] + mov eax,[a64 rel 0xbbbbbbbb] + mov ebx,[a64 rel 0xbbbbbbbb] + mov rax,[a64 rel 0xbbbbbbbb] + mov rbx,[a64 rel 0xbbbbbbbb] + mov al,[a64 rel 0xffffffffcccccccc] + mov bl,[a64 rel 0xffffffffcccccccc] + mov ax,[a64 rel 0xffffffffcccccccc] + mov bx,[a64 rel 0xffffffffcccccccc] + mov eax,[a64 rel 0xffffffffcccccccc] + mov ebx,[a64 rel 0xffffffffcccccccc] + mov rax,[a64 rel 0xffffffffcccccccc] + mov rbx,[a64 rel 0xffffffffcccccccc] + + mov al,[a64 rel dword foo] + mov bl,[a64 rel dword foo] + mov ax,[a64 rel dword foo] + mov bx,[a64 rel dword foo] + mov eax,[a64 rel dword foo] + mov ebx,[a64 rel dword foo] + mov rax,[a64 rel dword foo] + mov rbx,[a64 rel dword foo] + mov al,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword 0xbbbbbbbb] + mov bl,[a64 rel dword 0xbbbbbbbb] + mov ax,[a64 rel dword 0xbbbbbbbb] + mov bx,[a64 rel dword 0xbbbbbbbb] + mov eax,[a64 rel dword 0xbbbbbbbb] + mov ebx,[a64 rel dword 0xbbbbbbbb] + mov rax,[a64 rel dword 0xbbbbbbbb] + mov rbx,[a64 rel dword 0xbbbbbbbb] + mov al,[a64 rel dword 0xffffffffcccccccc] + mov bl,[a64 rel dword 0xffffffffcccccccc] + mov ax,[a64 rel dword 0xffffffffcccccccc] + mov bx,[a64 rel dword 0xffffffffcccccccc] + mov eax,[a64 rel dword 0xffffffffcccccccc] + mov ebx,[a64 rel dword 0xffffffffcccccccc] + mov rax,[a64 rel dword 0xffffffffcccccccc] + mov rbx,[a64 rel dword 0xffffffffcccccccc] + + mov al,[a64 rel qword foo] + mov bl,[a64 rel qword foo] + mov ax,[a64 rel qword foo] + mov bx,[a64 rel qword foo] + mov eax,[a64 rel qword foo] + mov ebx,[a64 rel qword foo] + mov rax,[a64 rel qword foo] + mov rbx,[a64 rel qword foo] + mov al,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword 0xbbbbbbbb] + mov bl,[a64 rel qword 0xbbbbbbbb] + mov ax,[a64 rel qword 0xbbbbbbbb] + mov bx,[a64 rel qword 0xbbbbbbbb] + mov eax,[a64 rel qword 0xbbbbbbbb] + mov ebx,[a64 rel qword 0xbbbbbbbb] + mov rax,[a64 rel qword 0xbbbbbbbb] + mov rbx,[a64 rel qword 0xbbbbbbbb] + mov al,[a64 rel qword 0xffffffffcccccccc] + mov bl,[a64 rel qword 0xffffffffcccccccc] + mov ax,[a64 rel qword 0xffffffffcccccccc] + mov bx,[a64 rel qword 0xffffffffcccccccc] + mov eax,[a64 rel qword 0xffffffffcccccccc] + mov ebx,[a64 rel qword 0xffffffffcccccccc] + mov rax,[a64 rel qword 0xffffffffcccccccc] + mov rbx,[a64 rel qword 0xffffffffcccccccc] + + mov al,[a32 rel foo] + mov bl,[a32 rel foo] + mov ax,[a32 rel foo] + mov bx,[a32 rel foo] + mov eax,[a32 rel foo] + mov ebx,[a32 rel foo] + mov rax,[a32 rel foo] + mov rbx,[a32 rel foo] + mov al,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel 0xbbbbbbbb] + mov bl,[a32 rel 0xbbbbbbbb] + mov ax,[a32 rel 0xbbbbbbbb] + mov bx,[a32 rel 0xbbbbbbbb] + mov eax,[a32 rel 0xbbbbbbbb] + mov ebx,[a32 rel 0xbbbbbbbb] + mov rax,[a32 rel 0xbbbbbbbb] + mov rbx,[a32 rel 0xbbbbbbbb] + mov al,[a32 rel 0xffffffffcccccccc] + mov bl,[a32 rel 0xffffffffcccccccc] + mov ax,[a32 rel 0xffffffffcccccccc] + mov bx,[a32 rel 0xffffffffcccccccc] + mov eax,[a32 rel 0xffffffffcccccccc] + mov ebx,[a32 rel 0xffffffffcccccccc] + mov rax,[a32 rel 0xffffffffcccccccc] + mov rbx,[a32 rel 0xffffffffcccccccc] + + mov al,[a32 rel dword foo] + mov bl,[a32 rel dword foo] + mov ax,[a32 rel dword foo] + mov bx,[a32 rel dword foo] + mov eax,[a32 rel dword foo] + mov ebx,[a32 rel dword foo] + mov rax,[a32 rel dword foo] + mov rbx,[a32 rel dword foo] + mov al,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword 0xbbbbbbbb] + mov bl,[a32 rel dword 0xbbbbbbbb] + mov ax,[a32 rel dword 0xbbbbbbbb] + mov bx,[a32 rel dword 0xbbbbbbbb] + mov eax,[a32 rel dword 0xbbbbbbbb] + mov ebx,[a32 rel dword 0xbbbbbbbb] + mov rax,[a32 rel dword 0xbbbbbbbb] + mov rbx,[a32 rel dword 0xbbbbbbbb] + mov al,[a32 rel dword 0xffffffffcccccccc] + mov bl,[a32 rel dword 0xffffffffcccccccc] + mov ax,[a32 rel dword 0xffffffffcccccccc] + mov bx,[a32 rel dword 0xffffffffcccccccc] + mov eax,[a32 rel dword 0xffffffffcccccccc] + mov ebx,[a32 rel dword 0xffffffffcccccccc] + mov rax,[a32 rel dword 0xffffffffcccccccc] + mov rbx,[a32 rel dword 0xffffffffcccccccc] + + mov al,[a32 rel qword foo] + mov bl,[a32 rel qword foo] + mov ax,[a32 rel qword foo] + mov bx,[a32 rel qword foo] + mov eax,[a32 rel qword foo] + mov ebx,[a32 rel qword foo] + mov rax,[a32 rel qword foo] + mov rbx,[a32 rel qword foo] + mov al,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword 0xbbbbbbbb] + mov bl,[a32 rel qword 0xbbbbbbbb] + mov ax,[a32 rel qword 0xbbbbbbbb] + mov bx,[a32 rel qword 0xbbbbbbbb] + mov eax,[a32 rel qword 0xbbbbbbbb] + mov ebx,[a32 rel qword 0xbbbbbbbb] + mov rax,[a32 rel qword 0xbbbbbbbb] + mov rbx,[a32 rel qword 0xbbbbbbbb] + mov al,[a32 rel qword 0xffffffffcccccccc] + mov bl,[a32 rel qword 0xffffffffcccccccc] + mov ax,[a32 rel qword 0xffffffffcccccccc] + mov bx,[a32 rel qword 0xffffffffcccccccc] + mov eax,[a32 rel qword 0xffffffffcccccccc] + mov ebx,[a32 rel qword 0xffffffffcccccccc] + mov rax,[a32 rel qword 0xffffffffcccccccc] + mov rbx,[a32 rel qword 0xffffffffcccccccc] + + mov al,[fs:foo] + mov bl,[fs:foo] + mov ax,[fs:foo] + mov bx,[fs:foo] + mov eax,[fs:foo] + mov ebx,[fs:foo] + mov rax,[fs:foo] + mov rbx,[fs:foo] + mov al,[fs:0xaaaaaaaaaaaaaaaa] + mov bl,[fs:0xaaaaaaaaaaaaaaaa] + mov ax,[fs:0xaaaaaaaaaaaaaaaa] + mov bx,[fs:0xaaaaaaaaaaaaaaaa] + mov eax,[fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[fs:0xaaaaaaaaaaaaaaaa] + mov rax,[fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[fs:0xaaaaaaaaaaaaaaaa] + mov al,[fs:0xbbbbbbbb] + mov bl,[fs:0xbbbbbbbb] + mov ax,[fs:0xbbbbbbbb] + mov bx,[fs:0xbbbbbbbb] + mov eax,[fs:0xbbbbbbbb] + mov ebx,[fs:0xbbbbbbbb] + mov rax,[fs:0xbbbbbbbb] + mov rbx,[fs:0xbbbbbbbb] + mov al,[fs:0xffffffffcccccccc] + mov bl,[fs:0xffffffffcccccccc] + mov ax,[fs:0xffffffffcccccccc] + mov bx,[fs:0xffffffffcccccccc] + mov eax,[fs:0xffffffffcccccccc] + mov ebx,[fs:0xffffffffcccccccc] + mov rax,[fs:0xffffffffcccccccc] + mov rbx,[fs:0xffffffffcccccccc] + + mov al,[dword fs:foo] + mov bl,[dword fs:foo] + mov ax,[dword fs:foo] + mov bx,[dword fs:foo] + mov eax,[dword fs:foo] + mov ebx,[dword fs:foo] + mov rax,[dword fs:foo] + mov rbx,[dword fs:foo] + mov al,[dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[dword fs:0xbbbbbbbb] + mov bl,[dword fs:0xbbbbbbbb] + mov ax,[dword fs:0xbbbbbbbb] + mov bx,[dword fs:0xbbbbbbbb] + mov eax,[dword fs:0xbbbbbbbb] + mov ebx,[dword fs:0xbbbbbbbb] + mov rax,[dword fs:0xbbbbbbbb] + mov rbx,[dword fs:0xbbbbbbbb] + mov al,[dword fs:0xffffffffcccccccc] + mov bl,[dword fs:0xffffffffcccccccc] + mov ax,[dword fs:0xffffffffcccccccc] + mov bx,[dword fs:0xffffffffcccccccc] + mov eax,[dword fs:0xffffffffcccccccc] + mov ebx,[dword fs:0xffffffffcccccccc] + mov rax,[dword fs:0xffffffffcccccccc] + mov rbx,[dword fs:0xffffffffcccccccc] + + mov al,[qword fs:foo] + mov bl,[qword fs:foo] + mov ax,[qword fs:foo] + mov bx,[qword fs:foo] + mov eax,[qword fs:foo] + mov ebx,[qword fs:foo] + mov rax,[qword fs:foo] + mov rbx,[qword fs:foo] + mov al,[qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[qword fs:0xbbbbbbbb] + mov bl,[qword fs:0xbbbbbbbb] + mov ax,[qword fs:0xbbbbbbbb] + mov bx,[qword fs:0xbbbbbbbb] + mov eax,[qword fs:0xbbbbbbbb] + mov ebx,[qword fs:0xbbbbbbbb] + mov rax,[qword fs:0xbbbbbbbb] + mov rbx,[qword fs:0xbbbbbbbb] + mov al,[qword fs:0xffffffffcccccccc] + mov bl,[qword fs:0xffffffffcccccccc] + mov ax,[qword fs:0xffffffffcccccccc] + mov bx,[qword fs:0xffffffffcccccccc] + mov eax,[qword fs:0xffffffffcccccccc] + mov ebx,[qword fs:0xffffffffcccccccc] + mov rax,[qword fs:0xffffffffcccccccc] + mov rbx,[qword fs:0xffffffffcccccccc] + + mov al,[a64 fs:foo] + mov bl,[a64 fs:foo] + mov ax,[a64 fs:foo] + mov bx,[a64 fs:foo] + mov eax,[a64 fs:foo] + mov ebx,[a64 fs:foo] + mov rax,[a64 fs:foo] + mov rbx,[a64 fs:foo] + mov al,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 fs:0xbbbbbbbb] + mov bl,[a64 fs:0xbbbbbbbb] + mov ax,[a64 fs:0xbbbbbbbb] + mov bx,[a64 fs:0xbbbbbbbb] + mov eax,[a64 fs:0xbbbbbbbb] + mov ebx,[a64 fs:0xbbbbbbbb] + mov rax,[a64 fs:0xbbbbbbbb] + mov rbx,[a64 fs:0xbbbbbbbb] + mov al,[a64 fs:0xffffffffcccccccc] + mov bl,[a64 fs:0xffffffffcccccccc] + mov ax,[a64 fs:0xffffffffcccccccc] + mov bx,[a64 fs:0xffffffffcccccccc] + mov eax,[a64 fs:0xffffffffcccccccc] + mov ebx,[a64 fs:0xffffffffcccccccc] + mov rax,[a64 fs:0xffffffffcccccccc] + mov rbx,[a64 fs:0xffffffffcccccccc] + + mov al,[a64 dword fs:foo] + mov bl,[a64 dword fs:foo] + mov ax,[a64 dword fs:foo] + mov bx,[a64 dword fs:foo] + mov eax,[a64 dword fs:foo] + mov ebx,[a64 dword fs:foo] + mov rax,[a64 dword fs:foo] + mov rbx,[a64 dword fs:foo] + mov al,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword fs:0xbbbbbbbb] + mov bl,[a64 dword fs:0xbbbbbbbb] + mov ax,[a64 dword fs:0xbbbbbbbb] + mov bx,[a64 dword fs:0xbbbbbbbb] + mov eax,[a64 dword fs:0xbbbbbbbb] + mov ebx,[a64 dword fs:0xbbbbbbbb] + mov rax,[a64 dword fs:0xbbbbbbbb] + mov rbx,[a64 dword fs:0xbbbbbbbb] + mov al,[a64 dword fs:0xffffffffcccccccc] + mov bl,[a64 dword fs:0xffffffffcccccccc] + mov ax,[a64 dword fs:0xffffffffcccccccc] + mov bx,[a64 dword fs:0xffffffffcccccccc] + mov eax,[a64 dword fs:0xffffffffcccccccc] + mov ebx,[a64 dword fs:0xffffffffcccccccc] + mov rax,[a64 dword fs:0xffffffffcccccccc] + mov rbx,[a64 dword fs:0xffffffffcccccccc] + + mov al,[a64 qword fs:foo] + mov bl,[a64 qword fs:foo] + mov ax,[a64 qword fs:foo] + mov bx,[a64 qword fs:foo] + mov eax,[a64 qword fs:foo] + mov ebx,[a64 qword fs:foo] + mov rax,[a64 qword fs:foo] + mov rbx,[a64 qword fs:foo] + mov al,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword fs:0xbbbbbbbb] + mov bl,[a64 qword fs:0xbbbbbbbb] + mov ax,[a64 qword fs:0xbbbbbbbb] + mov bx,[a64 qword fs:0xbbbbbbbb] + mov eax,[a64 qword fs:0xbbbbbbbb] + mov ebx,[a64 qword fs:0xbbbbbbbb] + mov rax,[a64 qword fs:0xbbbbbbbb] + mov rbx,[a64 qword fs:0xbbbbbbbb] + mov al,[a64 qword fs:0xffffffffcccccccc] + mov bl,[a64 qword fs:0xffffffffcccccccc] + mov ax,[a64 qword fs:0xffffffffcccccccc] + mov bx,[a64 qword fs:0xffffffffcccccccc] + mov eax,[a64 qword fs:0xffffffffcccccccc] + mov ebx,[a64 qword fs:0xffffffffcccccccc] + mov rax,[a64 qword fs:0xffffffffcccccccc] + mov rbx,[a64 qword fs:0xffffffffcccccccc] + + mov al,[a32 fs:foo] + mov bl,[a32 fs:foo] + mov ax,[a32 fs:foo] + mov bx,[a32 fs:foo] + mov eax,[a32 fs:foo] + mov ebx,[a32 fs:foo] + mov rax,[a32 fs:foo] + mov rbx,[a32 fs:foo] + mov al,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 fs:0xbbbbbbbb] + mov bl,[a32 fs:0xbbbbbbbb] + mov ax,[a32 fs:0xbbbbbbbb] + mov bx,[a32 fs:0xbbbbbbbb] + mov eax,[a32 fs:0xbbbbbbbb] + mov ebx,[a32 fs:0xbbbbbbbb] + mov rax,[a32 fs:0xbbbbbbbb] + mov rbx,[a32 fs:0xbbbbbbbb] + mov al,[a32 fs:0xffffffffcccccccc] + mov bl,[a32 fs:0xffffffffcccccccc] + mov ax,[a32 fs:0xffffffffcccccccc] + mov bx,[a32 fs:0xffffffffcccccccc] + mov eax,[a32 fs:0xffffffffcccccccc] + mov ebx,[a32 fs:0xffffffffcccccccc] + mov rax,[a32 fs:0xffffffffcccccccc] + mov rbx,[a32 fs:0xffffffffcccccccc] + + mov al,[a32 dword fs:foo] + mov bl,[a32 dword fs:foo] + mov ax,[a32 dword fs:foo] + mov bx,[a32 dword fs:foo] + mov eax,[a32 dword fs:foo] + mov ebx,[a32 dword fs:foo] + mov rax,[a32 dword fs:foo] + mov rbx,[a32 dword fs:foo] + mov al,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword fs:0xbbbbbbbb] + mov bl,[a32 dword fs:0xbbbbbbbb] + mov ax,[a32 dword fs:0xbbbbbbbb] + mov bx,[a32 dword fs:0xbbbbbbbb] + mov eax,[a32 dword fs:0xbbbbbbbb] + mov ebx,[a32 dword fs:0xbbbbbbbb] + mov rax,[a32 dword fs:0xbbbbbbbb] + mov rbx,[a32 dword fs:0xbbbbbbbb] + mov al,[a32 dword fs:0xffffffffcccccccc] + mov bl,[a32 dword fs:0xffffffffcccccccc] + mov ax,[a32 dword fs:0xffffffffcccccccc] + mov bx,[a32 dword fs:0xffffffffcccccccc] + mov eax,[a32 dword fs:0xffffffffcccccccc] + mov ebx,[a32 dword fs:0xffffffffcccccccc] + mov rax,[a32 dword fs:0xffffffffcccccccc] + mov rbx,[a32 dword fs:0xffffffffcccccccc] + + mov al,[a32 qword fs:foo] + mov bl,[a32 qword fs:foo] + mov ax,[a32 qword fs:foo] + mov bx,[a32 qword fs:foo] + mov eax,[a32 qword fs:foo] + mov ebx,[a32 qword fs:foo] + mov rax,[a32 qword fs:foo] + mov rbx,[a32 qword fs:foo] + mov al,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword fs:0xbbbbbbbb] + mov bl,[a32 qword fs:0xbbbbbbbb] + mov ax,[a32 qword fs:0xbbbbbbbb] + mov bx,[a32 qword fs:0xbbbbbbbb] + mov eax,[a32 qword fs:0xbbbbbbbb] + mov ebx,[a32 qword fs:0xbbbbbbbb] + mov rax,[a32 qword fs:0xbbbbbbbb] + mov rbx,[a32 qword fs:0xbbbbbbbb] + mov al,[a32 qword fs:0xffffffffcccccccc] + mov bl,[a32 qword fs:0xffffffffcccccccc] + mov ax,[a32 qword fs:0xffffffffcccccccc] + mov bx,[a32 qword fs:0xffffffffcccccccc] + mov eax,[a32 qword fs:0xffffffffcccccccc] + mov ebx,[a32 qword fs:0xffffffffcccccccc] + mov rax,[a32 qword fs:0xffffffffcccccccc] + mov rbx,[a32 qword fs:0xffffffffcccccccc] + + mov al,[abs fs:foo] + mov bl,[abs fs:foo] + mov ax,[abs fs:foo] + mov bx,[abs fs:foo] + mov eax,[abs fs:foo] + mov ebx,[abs fs:foo] + mov rax,[abs fs:foo] + mov rbx,[abs fs:foo] + mov al,[abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs fs:0xbbbbbbbb] + mov bl,[abs fs:0xbbbbbbbb] + mov ax,[abs fs:0xbbbbbbbb] + mov bx,[abs fs:0xbbbbbbbb] + mov eax,[abs fs:0xbbbbbbbb] + mov ebx,[abs fs:0xbbbbbbbb] + mov rax,[abs fs:0xbbbbbbbb] + mov rbx,[abs fs:0xbbbbbbbb] + mov al,[abs fs:0xffffffffcccccccc] + mov bl,[abs fs:0xffffffffcccccccc] + mov ax,[abs fs:0xffffffffcccccccc] + mov bx,[abs fs:0xffffffffcccccccc] + mov eax,[abs fs:0xffffffffcccccccc] + mov ebx,[abs fs:0xffffffffcccccccc] + mov rax,[abs fs:0xffffffffcccccccc] + mov rbx,[abs fs:0xffffffffcccccccc] + + mov al,[abs dword fs:foo] + mov bl,[abs dword fs:foo] + mov ax,[abs dword fs:foo] + mov bx,[abs dword fs:foo] + mov eax,[abs dword fs:foo] + mov ebx,[abs dword fs:foo] + mov rax,[abs dword fs:foo] + mov rbx,[abs dword fs:foo] + mov al,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs dword fs:0xbbbbbbbb] + mov bl,[abs dword fs:0xbbbbbbbb] + mov ax,[abs dword fs:0xbbbbbbbb] + mov bx,[abs dword fs:0xbbbbbbbb] + mov eax,[abs dword fs:0xbbbbbbbb] + mov ebx,[abs dword fs:0xbbbbbbbb] + mov rax,[abs dword fs:0xbbbbbbbb] + mov rbx,[abs dword fs:0xbbbbbbbb] + mov al,[abs dword fs:0xffffffffcccccccc] + mov bl,[abs dword fs:0xffffffffcccccccc] + mov ax,[abs dword fs:0xffffffffcccccccc] + mov bx,[abs dword fs:0xffffffffcccccccc] + mov eax,[abs dword fs:0xffffffffcccccccc] + mov ebx,[abs dword fs:0xffffffffcccccccc] + mov rax,[abs dword fs:0xffffffffcccccccc] + mov rbx,[abs dword fs:0xffffffffcccccccc] + + mov al,[abs qword fs:foo] + mov bl,[abs qword fs:foo] + mov ax,[abs qword fs:foo] + mov bx,[abs qword fs:foo] + mov eax,[abs qword fs:foo] + mov ebx,[abs qword fs:foo] + mov rax,[abs qword fs:foo] + mov rbx,[abs qword fs:foo] + mov al,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs qword fs:0xbbbbbbbb] + mov bl,[abs qword fs:0xbbbbbbbb] + mov ax,[abs qword fs:0xbbbbbbbb] + mov bx,[abs qword fs:0xbbbbbbbb] + mov eax,[abs qword fs:0xbbbbbbbb] + mov ebx,[abs qword fs:0xbbbbbbbb] + mov rax,[abs qword fs:0xbbbbbbbb] + mov rbx,[abs qword fs:0xbbbbbbbb] + mov al,[abs qword fs:0xffffffffcccccccc] + mov bl,[abs qword fs:0xffffffffcccccccc] + mov ax,[abs qword fs:0xffffffffcccccccc] + mov bx,[abs qword fs:0xffffffffcccccccc] + mov eax,[abs qword fs:0xffffffffcccccccc] + mov ebx,[abs qword fs:0xffffffffcccccccc] + mov rax,[abs qword fs:0xffffffffcccccccc] + mov rbx,[abs qword fs:0xffffffffcccccccc] + + mov al,[a64 abs fs:foo] + mov bl,[a64 abs fs:foo] + mov ax,[a64 abs fs:foo] + mov bx,[a64 abs fs:foo] + mov eax,[a64 abs fs:foo] + mov ebx,[a64 abs fs:foo] + mov rax,[a64 abs fs:foo] + mov rbx,[a64 abs fs:foo] + mov al,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs fs:0xbbbbbbbb] + mov bl,[a64 abs fs:0xbbbbbbbb] + mov ax,[a64 abs fs:0xbbbbbbbb] + mov bx,[a64 abs fs:0xbbbbbbbb] + mov eax,[a64 abs fs:0xbbbbbbbb] + mov ebx,[a64 abs fs:0xbbbbbbbb] + mov rax,[a64 abs fs:0xbbbbbbbb] + mov rbx,[a64 abs fs:0xbbbbbbbb] + mov al,[a64 abs fs:0xffffffffcccccccc] + mov bl,[a64 abs fs:0xffffffffcccccccc] + mov ax,[a64 abs fs:0xffffffffcccccccc] + mov bx,[a64 abs fs:0xffffffffcccccccc] + mov eax,[a64 abs fs:0xffffffffcccccccc] + mov ebx,[a64 abs fs:0xffffffffcccccccc] + mov rax,[a64 abs fs:0xffffffffcccccccc] + mov rbx,[a64 abs fs:0xffffffffcccccccc] + + mov al,[a64 abs dword fs:foo] + mov bl,[a64 abs dword fs:foo] + mov ax,[a64 abs dword fs:foo] + mov bx,[a64 abs dword fs:foo] + mov eax,[a64 abs dword fs:foo] + mov ebx,[a64 abs dword fs:foo] + mov rax,[a64 abs dword fs:foo] + mov rbx,[a64 abs dword fs:foo] + mov al,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword fs:0xbbbbbbbb] + mov bl,[a64 abs dword fs:0xbbbbbbbb] + mov ax,[a64 abs dword fs:0xbbbbbbbb] + mov bx,[a64 abs dword fs:0xbbbbbbbb] + mov eax,[a64 abs dword fs:0xbbbbbbbb] + mov ebx,[a64 abs dword fs:0xbbbbbbbb] + mov rax,[a64 abs dword fs:0xbbbbbbbb] + mov rbx,[a64 abs dword fs:0xbbbbbbbb] + mov al,[a64 abs dword fs:0xffffffffcccccccc] + mov bl,[a64 abs dword fs:0xffffffffcccccccc] + mov ax,[a64 abs dword fs:0xffffffffcccccccc] + mov bx,[a64 abs dword fs:0xffffffffcccccccc] + mov eax,[a64 abs dword fs:0xffffffffcccccccc] + mov ebx,[a64 abs dword fs:0xffffffffcccccccc] + mov rax,[a64 abs dword fs:0xffffffffcccccccc] + mov rbx,[a64 abs dword fs:0xffffffffcccccccc] + + mov al,[a64 abs qword fs:foo] + mov bl,[a64 abs qword fs:foo] + mov ax,[a64 abs qword fs:foo] + mov bx,[a64 abs qword fs:foo] + mov eax,[a64 abs qword fs:foo] + mov ebx,[a64 abs qword fs:foo] + mov rax,[a64 abs qword fs:foo] + mov rbx,[a64 abs qword fs:foo] + mov al,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword fs:0xbbbbbbbb] + mov bl,[a64 abs qword fs:0xbbbbbbbb] + mov ax,[a64 abs qword fs:0xbbbbbbbb] + mov bx,[a64 abs qword fs:0xbbbbbbbb] + mov eax,[a64 abs qword fs:0xbbbbbbbb] + mov ebx,[a64 abs qword fs:0xbbbbbbbb] + mov rax,[a64 abs qword fs:0xbbbbbbbb] + mov rbx,[a64 abs qword fs:0xbbbbbbbb] + mov al,[a64 abs qword fs:0xffffffffcccccccc] + mov bl,[a64 abs qword fs:0xffffffffcccccccc] + mov ax,[a64 abs qword fs:0xffffffffcccccccc] + mov bx,[a64 abs qword fs:0xffffffffcccccccc] + mov eax,[a64 abs qword fs:0xffffffffcccccccc] + mov ebx,[a64 abs qword fs:0xffffffffcccccccc] + mov rax,[a64 abs qword fs:0xffffffffcccccccc] + mov rbx,[a64 abs qword fs:0xffffffffcccccccc] + + mov al,[a32 abs fs:foo] + mov bl,[a32 abs fs:foo] + mov ax,[a32 abs fs:foo] + mov bx,[a32 abs fs:foo] + mov eax,[a32 abs fs:foo] + mov ebx,[a32 abs fs:foo] + mov rax,[a32 abs fs:foo] + mov rbx,[a32 abs fs:foo] + mov al,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs fs:0xbbbbbbbb] + mov bl,[a32 abs fs:0xbbbbbbbb] + mov ax,[a32 abs fs:0xbbbbbbbb] + mov bx,[a32 abs fs:0xbbbbbbbb] + mov eax,[a32 abs fs:0xbbbbbbbb] + mov ebx,[a32 abs fs:0xbbbbbbbb] + mov rax,[a32 abs fs:0xbbbbbbbb] + mov rbx,[a32 abs fs:0xbbbbbbbb] + mov al,[a32 abs fs:0xffffffffcccccccc] + mov bl,[a32 abs fs:0xffffffffcccccccc] + mov ax,[a32 abs fs:0xffffffffcccccccc] + mov bx,[a32 abs fs:0xffffffffcccccccc] + mov eax,[a32 abs fs:0xffffffffcccccccc] + mov ebx,[a32 abs fs:0xffffffffcccccccc] + mov rax,[a32 abs fs:0xffffffffcccccccc] + mov rbx,[a32 abs fs:0xffffffffcccccccc] + + mov al,[a32 abs dword fs:foo] + mov bl,[a32 abs dword fs:foo] + mov ax,[a32 abs dword fs:foo] + mov bx,[a32 abs dword fs:foo] + mov eax,[a32 abs dword fs:foo] + mov ebx,[a32 abs dword fs:foo] + mov rax,[a32 abs dword fs:foo] + mov rbx,[a32 abs dword fs:foo] + mov al,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword fs:0xbbbbbbbb] + mov bl,[a32 abs dword fs:0xbbbbbbbb] + mov ax,[a32 abs dword fs:0xbbbbbbbb] + mov bx,[a32 abs dword fs:0xbbbbbbbb] + mov eax,[a32 abs dword fs:0xbbbbbbbb] + mov ebx,[a32 abs dword fs:0xbbbbbbbb] + mov rax,[a32 abs dword fs:0xbbbbbbbb] + mov rbx,[a32 abs dword fs:0xbbbbbbbb] + mov al,[a32 abs dword fs:0xffffffffcccccccc] + mov bl,[a32 abs dword fs:0xffffffffcccccccc] + mov ax,[a32 abs dword fs:0xffffffffcccccccc] + mov bx,[a32 abs dword fs:0xffffffffcccccccc] + mov eax,[a32 abs dword fs:0xffffffffcccccccc] + mov ebx,[a32 abs dword fs:0xffffffffcccccccc] + mov rax,[a32 abs dword fs:0xffffffffcccccccc] + mov rbx,[a32 abs dword fs:0xffffffffcccccccc] + + mov al,[a32 abs qword fs:foo] + mov bl,[a32 abs qword fs:foo] + mov ax,[a32 abs qword fs:foo] + mov bx,[a32 abs qword fs:foo] + mov eax,[a32 abs qword fs:foo] + mov ebx,[a32 abs qword fs:foo] + mov rax,[a32 abs qword fs:foo] + mov rbx,[a32 abs qword fs:foo] + mov al,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword fs:0xbbbbbbbb] + mov bl,[a32 abs qword fs:0xbbbbbbbb] + mov ax,[a32 abs qword fs:0xbbbbbbbb] + mov bx,[a32 abs qword fs:0xbbbbbbbb] + mov eax,[a32 abs qword fs:0xbbbbbbbb] + mov ebx,[a32 abs qword fs:0xbbbbbbbb] + mov rax,[a32 abs qword fs:0xbbbbbbbb] + mov rbx,[a32 abs qword fs:0xbbbbbbbb] + mov al,[a32 abs qword fs:0xffffffffcccccccc] + mov bl,[a32 abs qword fs:0xffffffffcccccccc] + mov ax,[a32 abs qword fs:0xffffffffcccccccc] + mov bx,[a32 abs qword fs:0xffffffffcccccccc] + mov eax,[a32 abs qword fs:0xffffffffcccccccc] + mov ebx,[a32 abs qword fs:0xffffffffcccccccc] + mov rax,[a32 abs qword fs:0xffffffffcccccccc] + mov rbx,[a32 abs qword fs:0xffffffffcccccccc] + + mov al,[rel fs:foo] + mov bl,[rel fs:foo] + mov ax,[rel fs:foo] + mov bx,[rel fs:foo] + mov eax,[rel fs:foo] + mov ebx,[rel fs:foo] + mov rax,[rel fs:foo] + mov rbx,[rel fs:foo] + mov al,[rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel fs:0xbbbbbbbb] + mov bl,[rel fs:0xbbbbbbbb] + mov ax,[rel fs:0xbbbbbbbb] + mov bx,[rel fs:0xbbbbbbbb] + mov eax,[rel fs:0xbbbbbbbb] + mov ebx,[rel fs:0xbbbbbbbb] + mov rax,[rel fs:0xbbbbbbbb] + mov rbx,[rel fs:0xbbbbbbbb] + mov al,[rel fs:0xffffffffcccccccc] + mov bl,[rel fs:0xffffffffcccccccc] + mov ax,[rel fs:0xffffffffcccccccc] + mov bx,[rel fs:0xffffffffcccccccc] + mov eax,[rel fs:0xffffffffcccccccc] + mov ebx,[rel fs:0xffffffffcccccccc] + mov rax,[rel fs:0xffffffffcccccccc] + mov rbx,[rel fs:0xffffffffcccccccc] + + mov al,[rel dword fs:foo] + mov bl,[rel dword fs:foo] + mov ax,[rel dword fs:foo] + mov bx,[rel dword fs:foo] + mov eax,[rel dword fs:foo] + mov ebx,[rel dword fs:foo] + mov rax,[rel dword fs:foo] + mov rbx,[rel dword fs:foo] + mov al,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel dword fs:0xbbbbbbbb] + mov bl,[rel dword fs:0xbbbbbbbb] + mov ax,[rel dword fs:0xbbbbbbbb] + mov bx,[rel dword fs:0xbbbbbbbb] + mov eax,[rel dword fs:0xbbbbbbbb] + mov ebx,[rel dword fs:0xbbbbbbbb] + mov rax,[rel dword fs:0xbbbbbbbb] + mov rbx,[rel dword fs:0xbbbbbbbb] + mov al,[rel dword fs:0xffffffffcccccccc] + mov bl,[rel dword fs:0xffffffffcccccccc] + mov ax,[rel dword fs:0xffffffffcccccccc] + mov bx,[rel dword fs:0xffffffffcccccccc] + mov eax,[rel dword fs:0xffffffffcccccccc] + mov ebx,[rel dword fs:0xffffffffcccccccc] + mov rax,[rel dword fs:0xffffffffcccccccc] + mov rbx,[rel dword fs:0xffffffffcccccccc] + + mov al,[rel qword fs:foo] + mov bl,[rel qword fs:foo] + mov ax,[rel qword fs:foo] + mov bx,[rel qword fs:foo] + mov eax,[rel qword fs:foo] + mov ebx,[rel qword fs:foo] + mov rax,[rel qword fs:foo] + mov rbx,[rel qword fs:foo] + mov al,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel qword fs:0xbbbbbbbb] + mov bl,[rel qword fs:0xbbbbbbbb] + mov ax,[rel qword fs:0xbbbbbbbb] + mov bx,[rel qword fs:0xbbbbbbbb] + mov eax,[rel qword fs:0xbbbbbbbb] + mov ebx,[rel qword fs:0xbbbbbbbb] + mov rax,[rel qword fs:0xbbbbbbbb] + mov rbx,[rel qword fs:0xbbbbbbbb] + mov al,[rel qword fs:0xffffffffcccccccc] + mov bl,[rel qword fs:0xffffffffcccccccc] + mov ax,[rel qword fs:0xffffffffcccccccc] + mov bx,[rel qword fs:0xffffffffcccccccc] + mov eax,[rel qword fs:0xffffffffcccccccc] + mov ebx,[rel qword fs:0xffffffffcccccccc] + mov rax,[rel qword fs:0xffffffffcccccccc] + mov rbx,[rel qword fs:0xffffffffcccccccc] + + mov al,[a64 rel fs:foo] + mov bl,[a64 rel fs:foo] + mov ax,[a64 rel fs:foo] + mov bx,[a64 rel fs:foo] + mov eax,[a64 rel fs:foo] + mov ebx,[a64 rel fs:foo] + mov rax,[a64 rel fs:foo] + mov rbx,[a64 rel fs:foo] + mov al,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel fs:0xbbbbbbbb] + mov bl,[a64 rel fs:0xbbbbbbbb] + mov ax,[a64 rel fs:0xbbbbbbbb] + mov bx,[a64 rel fs:0xbbbbbbbb] + mov eax,[a64 rel fs:0xbbbbbbbb] + mov ebx,[a64 rel fs:0xbbbbbbbb] + mov rax,[a64 rel fs:0xbbbbbbbb] + mov rbx,[a64 rel fs:0xbbbbbbbb] + mov al,[a64 rel fs:0xffffffffcccccccc] + mov bl,[a64 rel fs:0xffffffffcccccccc] + mov ax,[a64 rel fs:0xffffffffcccccccc] + mov bx,[a64 rel fs:0xffffffffcccccccc] + mov eax,[a64 rel fs:0xffffffffcccccccc] + mov ebx,[a64 rel fs:0xffffffffcccccccc] + mov rax,[a64 rel fs:0xffffffffcccccccc] + mov rbx,[a64 rel fs:0xffffffffcccccccc] + + mov al,[a64 rel dword fs:foo] + mov bl,[a64 rel dword fs:foo] + mov ax,[a64 rel dword fs:foo] + mov bx,[a64 rel dword fs:foo] + mov eax,[a64 rel dword fs:foo] + mov ebx,[a64 rel dword fs:foo] + mov rax,[a64 rel dword fs:foo] + mov rbx,[a64 rel dword fs:foo] + mov al,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword fs:0xbbbbbbbb] + mov bl,[a64 rel dword fs:0xbbbbbbbb] + mov ax,[a64 rel dword fs:0xbbbbbbbb] + mov bx,[a64 rel dword fs:0xbbbbbbbb] + mov eax,[a64 rel dword fs:0xbbbbbbbb] + mov ebx,[a64 rel dword fs:0xbbbbbbbb] + mov rax,[a64 rel dword fs:0xbbbbbbbb] + mov rbx,[a64 rel dword fs:0xbbbbbbbb] + mov al,[a64 rel dword fs:0xffffffffcccccccc] + mov bl,[a64 rel dword fs:0xffffffffcccccccc] + mov ax,[a64 rel dword fs:0xffffffffcccccccc] + mov bx,[a64 rel dword fs:0xffffffffcccccccc] + mov eax,[a64 rel dword fs:0xffffffffcccccccc] + mov ebx,[a64 rel dword fs:0xffffffffcccccccc] + mov rax,[a64 rel dword fs:0xffffffffcccccccc] + mov rbx,[a64 rel dword fs:0xffffffffcccccccc] + + mov al,[a64 rel qword fs:foo] + mov bl,[a64 rel qword fs:foo] + mov ax,[a64 rel qword fs:foo] + mov bx,[a64 rel qword fs:foo] + mov eax,[a64 rel qword fs:foo] + mov ebx,[a64 rel qword fs:foo] + mov rax,[a64 rel qword fs:foo] + mov rbx,[a64 rel qword fs:foo] + mov al,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword fs:0xbbbbbbbb] + mov bl,[a64 rel qword fs:0xbbbbbbbb] + mov ax,[a64 rel qword fs:0xbbbbbbbb] + mov bx,[a64 rel qword fs:0xbbbbbbbb] + mov eax,[a64 rel qword fs:0xbbbbbbbb] + mov ebx,[a64 rel qword fs:0xbbbbbbbb] + mov rax,[a64 rel qword fs:0xbbbbbbbb] + mov rbx,[a64 rel qword fs:0xbbbbbbbb] + mov al,[a64 rel qword fs:0xffffffffcccccccc] + mov bl,[a64 rel qword fs:0xffffffffcccccccc] + mov ax,[a64 rel qword fs:0xffffffffcccccccc] + mov bx,[a64 rel qword fs:0xffffffffcccccccc] + mov eax,[a64 rel qword fs:0xffffffffcccccccc] + mov ebx,[a64 rel qword fs:0xffffffffcccccccc] + mov rax,[a64 rel qword fs:0xffffffffcccccccc] + mov rbx,[a64 rel qword fs:0xffffffffcccccccc] + + mov al,[a32 rel fs:foo] + mov bl,[a32 rel fs:foo] + mov ax,[a32 rel fs:foo] + mov bx,[a32 rel fs:foo] + mov eax,[a32 rel fs:foo] + mov ebx,[a32 rel fs:foo] + mov rax,[a32 rel fs:foo] + mov rbx,[a32 rel fs:foo] + mov al,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel fs:0xbbbbbbbb] + mov bl,[a32 rel fs:0xbbbbbbbb] + mov ax,[a32 rel fs:0xbbbbbbbb] + mov bx,[a32 rel fs:0xbbbbbbbb] + mov eax,[a32 rel fs:0xbbbbbbbb] + mov ebx,[a32 rel fs:0xbbbbbbbb] + mov rax,[a32 rel fs:0xbbbbbbbb] + mov rbx,[a32 rel fs:0xbbbbbbbb] + mov al,[a32 rel fs:0xffffffffcccccccc] + mov bl,[a32 rel fs:0xffffffffcccccccc] + mov ax,[a32 rel fs:0xffffffffcccccccc] + mov bx,[a32 rel fs:0xffffffffcccccccc] + mov eax,[a32 rel fs:0xffffffffcccccccc] + mov ebx,[a32 rel fs:0xffffffffcccccccc] + mov rax,[a32 rel fs:0xffffffffcccccccc] + mov rbx,[a32 rel fs:0xffffffffcccccccc] + + mov al,[a32 rel dword fs:foo] + mov bl,[a32 rel dword fs:foo] + mov ax,[a32 rel dword fs:foo] + mov bx,[a32 rel dword fs:foo] + mov eax,[a32 rel dword fs:foo] + mov ebx,[a32 rel dword fs:foo] + mov rax,[a32 rel dword fs:foo] + mov rbx,[a32 rel dword fs:foo] + mov al,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword fs:0xbbbbbbbb] + mov bl,[a32 rel dword fs:0xbbbbbbbb] + mov ax,[a32 rel dword fs:0xbbbbbbbb] + mov bx,[a32 rel dword fs:0xbbbbbbbb] + mov eax,[a32 rel dword fs:0xbbbbbbbb] + mov ebx,[a32 rel dword fs:0xbbbbbbbb] + mov rax,[a32 rel dword fs:0xbbbbbbbb] + mov rbx,[a32 rel dword fs:0xbbbbbbbb] + mov al,[a32 rel dword fs:0xffffffffcccccccc] + mov bl,[a32 rel dword fs:0xffffffffcccccccc] + mov ax,[a32 rel dword fs:0xffffffffcccccccc] + mov bx,[a32 rel dword fs:0xffffffffcccccccc] + mov eax,[a32 rel dword fs:0xffffffffcccccccc] + mov ebx,[a32 rel dword fs:0xffffffffcccccccc] + mov rax,[a32 rel dword fs:0xffffffffcccccccc] + mov rbx,[a32 rel dword fs:0xffffffffcccccccc] + + mov al,[a32 rel qword fs:foo] + mov bl,[a32 rel qword fs:foo] + mov ax,[a32 rel qword fs:foo] + mov bx,[a32 rel qword fs:foo] + mov eax,[a32 rel qword fs:foo] + mov ebx,[a32 rel qword fs:foo] + mov rax,[a32 rel qword fs:foo] + mov rbx,[a32 rel qword fs:foo] + mov al,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword fs:0xbbbbbbbb] + mov bl,[a32 rel qword fs:0xbbbbbbbb] + mov ax,[a32 rel qword fs:0xbbbbbbbb] + mov bx,[a32 rel qword fs:0xbbbbbbbb] + mov eax,[a32 rel qword fs:0xbbbbbbbb] + mov ebx,[a32 rel qword fs:0xbbbbbbbb] + mov rax,[a32 rel qword fs:0xbbbbbbbb] + mov rbx,[a32 rel qword fs:0xbbbbbbbb] + mov al,[a32 rel qword fs:0xffffffffcccccccc] + mov bl,[a32 rel qword fs:0xffffffffcccccccc] + mov ax,[a32 rel qword fs:0xffffffffcccccccc] + mov bx,[a32 rel qword fs:0xffffffffcccccccc] + mov eax,[a32 rel qword fs:0xffffffffcccccccc] + mov ebx,[a32 rel qword fs:0xffffffffcccccccc] + mov rax,[a32 rel qword fs:0xffffffffcccccccc] + mov rbx,[a32 rel qword fs:0xffffffffcccccccc] + + mov al,[es:foo] + mov bl,[es:foo] + mov ax,[es:foo] + mov bx,[es:foo] + mov eax,[es:foo] + mov ebx,[es:foo] + mov rax,[es:foo] + mov rbx,[es:foo] + mov al,[es:0xaaaaaaaaaaaaaaaa] + mov bl,[es:0xaaaaaaaaaaaaaaaa] + mov ax,[es:0xaaaaaaaaaaaaaaaa] + mov bx,[es:0xaaaaaaaaaaaaaaaa] + mov eax,[es:0xaaaaaaaaaaaaaaaa] + mov ebx,[es:0xaaaaaaaaaaaaaaaa] + mov rax,[es:0xaaaaaaaaaaaaaaaa] + mov rbx,[es:0xaaaaaaaaaaaaaaaa] + mov al,[es:0xbbbbbbbb] + mov bl,[es:0xbbbbbbbb] + mov ax,[es:0xbbbbbbbb] + mov bx,[es:0xbbbbbbbb] + mov eax,[es:0xbbbbbbbb] + mov ebx,[es:0xbbbbbbbb] + mov rax,[es:0xbbbbbbbb] + mov rbx,[es:0xbbbbbbbb] + mov al,[es:0xffffffffcccccccc] + mov bl,[es:0xffffffffcccccccc] + mov ax,[es:0xffffffffcccccccc] + mov bx,[es:0xffffffffcccccccc] + mov eax,[es:0xffffffffcccccccc] + mov ebx,[es:0xffffffffcccccccc] + mov rax,[es:0xffffffffcccccccc] + mov rbx,[es:0xffffffffcccccccc] + + mov al,[dword es:foo] + mov bl,[dword es:foo] + mov ax,[dword es:foo] + mov bx,[dword es:foo] + mov eax,[dword es:foo] + mov ebx,[dword es:foo] + mov rax,[dword es:foo] + mov rbx,[dword es:foo] + mov al,[dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[dword es:0xaaaaaaaaaaaaaaaa] + mov al,[dword es:0xbbbbbbbb] + mov bl,[dword es:0xbbbbbbbb] + mov ax,[dword es:0xbbbbbbbb] + mov bx,[dword es:0xbbbbbbbb] + mov eax,[dword es:0xbbbbbbbb] + mov ebx,[dword es:0xbbbbbbbb] + mov rax,[dword es:0xbbbbbbbb] + mov rbx,[dword es:0xbbbbbbbb] + mov al,[dword es:0xffffffffcccccccc] + mov bl,[dword es:0xffffffffcccccccc] + mov ax,[dword es:0xffffffffcccccccc] + mov bx,[dword es:0xffffffffcccccccc] + mov eax,[dword es:0xffffffffcccccccc] + mov ebx,[dword es:0xffffffffcccccccc] + mov rax,[dword es:0xffffffffcccccccc] + mov rbx,[dword es:0xffffffffcccccccc] + + mov al,[qword es:foo] + mov bl,[qword es:foo] + mov ax,[qword es:foo] + mov bx,[qword es:foo] + mov eax,[qword es:foo] + mov ebx,[qword es:foo] + mov rax,[qword es:foo] + mov rbx,[qword es:foo] + mov al,[qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[qword es:0xaaaaaaaaaaaaaaaa] + mov al,[qword es:0xbbbbbbbb] + mov bl,[qword es:0xbbbbbbbb] + mov ax,[qword es:0xbbbbbbbb] + mov bx,[qword es:0xbbbbbbbb] + mov eax,[qword es:0xbbbbbbbb] + mov ebx,[qword es:0xbbbbbbbb] + mov rax,[qword es:0xbbbbbbbb] + mov rbx,[qword es:0xbbbbbbbb] + mov al,[qword es:0xffffffffcccccccc] + mov bl,[qword es:0xffffffffcccccccc] + mov ax,[qword es:0xffffffffcccccccc] + mov bx,[qword es:0xffffffffcccccccc] + mov eax,[qword es:0xffffffffcccccccc] + mov ebx,[qword es:0xffffffffcccccccc] + mov rax,[qword es:0xffffffffcccccccc] + mov rbx,[qword es:0xffffffffcccccccc] + + mov al,[a64 es:foo] + mov bl,[a64 es:foo] + mov ax,[a64 es:foo] + mov bx,[a64 es:foo] + mov eax,[a64 es:foo] + mov ebx,[a64 es:foo] + mov rax,[a64 es:foo] + mov rbx,[a64 es:foo] + mov al,[a64 es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 es:0xbbbbbbbb] + mov bl,[a64 es:0xbbbbbbbb] + mov ax,[a64 es:0xbbbbbbbb] + mov bx,[a64 es:0xbbbbbbbb] + mov eax,[a64 es:0xbbbbbbbb] + mov ebx,[a64 es:0xbbbbbbbb] + mov rax,[a64 es:0xbbbbbbbb] + mov rbx,[a64 es:0xbbbbbbbb] + mov al,[a64 es:0xffffffffcccccccc] + mov bl,[a64 es:0xffffffffcccccccc] + mov ax,[a64 es:0xffffffffcccccccc] + mov bx,[a64 es:0xffffffffcccccccc] + mov eax,[a64 es:0xffffffffcccccccc] + mov ebx,[a64 es:0xffffffffcccccccc] + mov rax,[a64 es:0xffffffffcccccccc] + mov rbx,[a64 es:0xffffffffcccccccc] + + mov al,[a64 dword es:foo] + mov bl,[a64 dword es:foo] + mov ax,[a64 dword es:foo] + mov bx,[a64 dword es:foo] + mov eax,[a64 dword es:foo] + mov ebx,[a64 dword es:foo] + mov rax,[a64 dword es:foo] + mov rbx,[a64 dword es:foo] + mov al,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword es:0xbbbbbbbb] + mov bl,[a64 dword es:0xbbbbbbbb] + mov ax,[a64 dword es:0xbbbbbbbb] + mov bx,[a64 dword es:0xbbbbbbbb] + mov eax,[a64 dword es:0xbbbbbbbb] + mov ebx,[a64 dword es:0xbbbbbbbb] + mov rax,[a64 dword es:0xbbbbbbbb] + mov rbx,[a64 dword es:0xbbbbbbbb] + mov al,[a64 dword es:0xffffffffcccccccc] + mov bl,[a64 dword es:0xffffffffcccccccc] + mov ax,[a64 dword es:0xffffffffcccccccc] + mov bx,[a64 dword es:0xffffffffcccccccc] + mov eax,[a64 dword es:0xffffffffcccccccc] + mov ebx,[a64 dword es:0xffffffffcccccccc] + mov rax,[a64 dword es:0xffffffffcccccccc] + mov rbx,[a64 dword es:0xffffffffcccccccc] + + mov al,[a64 qword es:foo] + mov bl,[a64 qword es:foo] + mov ax,[a64 qword es:foo] + mov bx,[a64 qword es:foo] + mov eax,[a64 qword es:foo] + mov ebx,[a64 qword es:foo] + mov rax,[a64 qword es:foo] + mov rbx,[a64 qword es:foo] + mov al,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword es:0xbbbbbbbb] + mov bl,[a64 qword es:0xbbbbbbbb] + mov ax,[a64 qword es:0xbbbbbbbb] + mov bx,[a64 qword es:0xbbbbbbbb] + mov eax,[a64 qword es:0xbbbbbbbb] + mov ebx,[a64 qword es:0xbbbbbbbb] + mov rax,[a64 qword es:0xbbbbbbbb] + mov rbx,[a64 qword es:0xbbbbbbbb] + mov al,[a64 qword es:0xffffffffcccccccc] + mov bl,[a64 qword es:0xffffffffcccccccc] + mov ax,[a64 qword es:0xffffffffcccccccc] + mov bx,[a64 qword es:0xffffffffcccccccc] + mov eax,[a64 qword es:0xffffffffcccccccc] + mov ebx,[a64 qword es:0xffffffffcccccccc] + mov rax,[a64 qword es:0xffffffffcccccccc] + mov rbx,[a64 qword es:0xffffffffcccccccc] + + mov al,[a32 es:foo] + mov bl,[a32 es:foo] + mov ax,[a32 es:foo] + mov bx,[a32 es:foo] + mov eax,[a32 es:foo] + mov ebx,[a32 es:foo] + mov rax,[a32 es:foo] + mov rbx,[a32 es:foo] + mov al,[a32 es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 es:0xbbbbbbbb] + mov bl,[a32 es:0xbbbbbbbb] + mov ax,[a32 es:0xbbbbbbbb] + mov bx,[a32 es:0xbbbbbbbb] + mov eax,[a32 es:0xbbbbbbbb] + mov ebx,[a32 es:0xbbbbbbbb] + mov rax,[a32 es:0xbbbbbbbb] + mov rbx,[a32 es:0xbbbbbbbb] + mov al,[a32 es:0xffffffffcccccccc] + mov bl,[a32 es:0xffffffffcccccccc] + mov ax,[a32 es:0xffffffffcccccccc] + mov bx,[a32 es:0xffffffffcccccccc] + mov eax,[a32 es:0xffffffffcccccccc] + mov ebx,[a32 es:0xffffffffcccccccc] + mov rax,[a32 es:0xffffffffcccccccc] + mov rbx,[a32 es:0xffffffffcccccccc] + + mov al,[a32 dword es:foo] + mov bl,[a32 dword es:foo] + mov ax,[a32 dword es:foo] + mov bx,[a32 dword es:foo] + mov eax,[a32 dword es:foo] + mov ebx,[a32 dword es:foo] + mov rax,[a32 dword es:foo] + mov rbx,[a32 dword es:foo] + mov al,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword es:0xbbbbbbbb] + mov bl,[a32 dword es:0xbbbbbbbb] + mov ax,[a32 dword es:0xbbbbbbbb] + mov bx,[a32 dword es:0xbbbbbbbb] + mov eax,[a32 dword es:0xbbbbbbbb] + mov ebx,[a32 dword es:0xbbbbbbbb] + mov rax,[a32 dword es:0xbbbbbbbb] + mov rbx,[a32 dword es:0xbbbbbbbb] + mov al,[a32 dword es:0xffffffffcccccccc] + mov bl,[a32 dword es:0xffffffffcccccccc] + mov ax,[a32 dword es:0xffffffffcccccccc] + mov bx,[a32 dword es:0xffffffffcccccccc] + mov eax,[a32 dword es:0xffffffffcccccccc] + mov ebx,[a32 dword es:0xffffffffcccccccc] + mov rax,[a32 dword es:0xffffffffcccccccc] + mov rbx,[a32 dword es:0xffffffffcccccccc] + + mov al,[a32 qword es:foo] + mov bl,[a32 qword es:foo] + mov ax,[a32 qword es:foo] + mov bx,[a32 qword es:foo] + mov eax,[a32 qword es:foo] + mov ebx,[a32 qword es:foo] + mov rax,[a32 qword es:foo] + mov rbx,[a32 qword es:foo] + mov al,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword es:0xbbbbbbbb] + mov bl,[a32 qword es:0xbbbbbbbb] + mov ax,[a32 qword es:0xbbbbbbbb] + mov bx,[a32 qword es:0xbbbbbbbb] + mov eax,[a32 qword es:0xbbbbbbbb] + mov ebx,[a32 qword es:0xbbbbbbbb] + mov rax,[a32 qword es:0xbbbbbbbb] + mov rbx,[a32 qword es:0xbbbbbbbb] + mov al,[a32 qword es:0xffffffffcccccccc] + mov bl,[a32 qword es:0xffffffffcccccccc] + mov ax,[a32 qword es:0xffffffffcccccccc] + mov bx,[a32 qword es:0xffffffffcccccccc] + mov eax,[a32 qword es:0xffffffffcccccccc] + mov ebx,[a32 qword es:0xffffffffcccccccc] + mov rax,[a32 qword es:0xffffffffcccccccc] + mov rbx,[a32 qword es:0xffffffffcccccccc] + + mov al,[abs es:foo] + mov bl,[abs es:foo] + mov ax,[abs es:foo] + mov bx,[abs es:foo] + mov eax,[abs es:foo] + mov ebx,[abs es:foo] + mov rax,[abs es:foo] + mov rbx,[abs es:foo] + mov al,[abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs es:0xaaaaaaaaaaaaaaaa] + mov al,[abs es:0xbbbbbbbb] + mov bl,[abs es:0xbbbbbbbb] + mov ax,[abs es:0xbbbbbbbb] + mov bx,[abs es:0xbbbbbbbb] + mov eax,[abs es:0xbbbbbbbb] + mov ebx,[abs es:0xbbbbbbbb] + mov rax,[abs es:0xbbbbbbbb] + mov rbx,[abs es:0xbbbbbbbb] + mov al,[abs es:0xffffffffcccccccc] + mov bl,[abs es:0xffffffffcccccccc] + mov ax,[abs es:0xffffffffcccccccc] + mov bx,[abs es:0xffffffffcccccccc] + mov eax,[abs es:0xffffffffcccccccc] + mov ebx,[abs es:0xffffffffcccccccc] + mov rax,[abs es:0xffffffffcccccccc] + mov rbx,[abs es:0xffffffffcccccccc] + + mov al,[abs dword es:foo] + mov bl,[abs dword es:foo] + mov ax,[abs dword es:foo] + mov bx,[abs dword es:foo] + mov eax,[abs dword es:foo] + mov ebx,[abs dword es:foo] + mov rax,[abs dword es:foo] + mov rbx,[abs dword es:foo] + mov al,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[abs dword es:0xbbbbbbbb] + mov bl,[abs dword es:0xbbbbbbbb] + mov ax,[abs dword es:0xbbbbbbbb] + mov bx,[abs dword es:0xbbbbbbbb] + mov eax,[abs dword es:0xbbbbbbbb] + mov ebx,[abs dword es:0xbbbbbbbb] + mov rax,[abs dword es:0xbbbbbbbb] + mov rbx,[abs dword es:0xbbbbbbbb] + mov al,[abs dword es:0xffffffffcccccccc] + mov bl,[abs dword es:0xffffffffcccccccc] + mov ax,[abs dword es:0xffffffffcccccccc] + mov bx,[abs dword es:0xffffffffcccccccc] + mov eax,[abs dword es:0xffffffffcccccccc] + mov ebx,[abs dword es:0xffffffffcccccccc] + mov rax,[abs dword es:0xffffffffcccccccc] + mov rbx,[abs dword es:0xffffffffcccccccc] + + mov al,[abs qword es:foo] + mov bl,[abs qword es:foo] + mov ax,[abs qword es:foo] + mov bx,[abs qword es:foo] + mov eax,[abs qword es:foo] + mov ebx,[abs qword es:foo] + mov rax,[abs qword es:foo] + mov rbx,[abs qword es:foo] + mov al,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[abs qword es:0xbbbbbbbb] + mov bl,[abs qword es:0xbbbbbbbb] + mov ax,[abs qword es:0xbbbbbbbb] + mov bx,[abs qword es:0xbbbbbbbb] + mov eax,[abs qword es:0xbbbbbbbb] + mov ebx,[abs qword es:0xbbbbbbbb] + mov rax,[abs qword es:0xbbbbbbbb] + mov rbx,[abs qword es:0xbbbbbbbb] + mov al,[abs qword es:0xffffffffcccccccc] + mov bl,[abs qword es:0xffffffffcccccccc] + mov ax,[abs qword es:0xffffffffcccccccc] + mov bx,[abs qword es:0xffffffffcccccccc] + mov eax,[abs qword es:0xffffffffcccccccc] + mov ebx,[abs qword es:0xffffffffcccccccc] + mov rax,[abs qword es:0xffffffffcccccccc] + mov rbx,[abs qword es:0xffffffffcccccccc] + + mov al,[a64 abs es:foo] + mov bl,[a64 abs es:foo] + mov ax,[a64 abs es:foo] + mov bx,[a64 abs es:foo] + mov eax,[a64 abs es:foo] + mov ebx,[a64 abs es:foo] + mov rax,[a64 abs es:foo] + mov rbx,[a64 abs es:foo] + mov al,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs es:0xbbbbbbbb] + mov bl,[a64 abs es:0xbbbbbbbb] + mov ax,[a64 abs es:0xbbbbbbbb] + mov bx,[a64 abs es:0xbbbbbbbb] + mov eax,[a64 abs es:0xbbbbbbbb] + mov ebx,[a64 abs es:0xbbbbbbbb] + mov rax,[a64 abs es:0xbbbbbbbb] + mov rbx,[a64 abs es:0xbbbbbbbb] + mov al,[a64 abs es:0xffffffffcccccccc] + mov bl,[a64 abs es:0xffffffffcccccccc] + mov ax,[a64 abs es:0xffffffffcccccccc] + mov bx,[a64 abs es:0xffffffffcccccccc] + mov eax,[a64 abs es:0xffffffffcccccccc] + mov ebx,[a64 abs es:0xffffffffcccccccc] + mov rax,[a64 abs es:0xffffffffcccccccc] + mov rbx,[a64 abs es:0xffffffffcccccccc] + + mov al,[a64 abs dword es:foo] + mov bl,[a64 abs dword es:foo] + mov ax,[a64 abs dword es:foo] + mov bx,[a64 abs dword es:foo] + mov eax,[a64 abs dword es:foo] + mov ebx,[a64 abs dword es:foo] + mov rax,[a64 abs dword es:foo] + mov rbx,[a64 abs dword es:foo] + mov al,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword es:0xbbbbbbbb] + mov bl,[a64 abs dword es:0xbbbbbbbb] + mov ax,[a64 abs dword es:0xbbbbbbbb] + mov bx,[a64 abs dword es:0xbbbbbbbb] + mov eax,[a64 abs dword es:0xbbbbbbbb] + mov ebx,[a64 abs dword es:0xbbbbbbbb] + mov rax,[a64 abs dword es:0xbbbbbbbb] + mov rbx,[a64 abs dword es:0xbbbbbbbb] + mov al,[a64 abs dword es:0xffffffffcccccccc] + mov bl,[a64 abs dword es:0xffffffffcccccccc] + mov ax,[a64 abs dword es:0xffffffffcccccccc] + mov bx,[a64 abs dword es:0xffffffffcccccccc] + mov eax,[a64 abs dword es:0xffffffffcccccccc] + mov ebx,[a64 abs dword es:0xffffffffcccccccc] + mov rax,[a64 abs dword es:0xffffffffcccccccc] + mov rbx,[a64 abs dword es:0xffffffffcccccccc] + + mov al,[a64 abs qword es:foo] + mov bl,[a64 abs qword es:foo] + mov ax,[a64 abs qword es:foo] + mov bx,[a64 abs qword es:foo] + mov eax,[a64 abs qword es:foo] + mov ebx,[a64 abs qword es:foo] + mov rax,[a64 abs qword es:foo] + mov rbx,[a64 abs qword es:foo] + mov al,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword es:0xbbbbbbbb] + mov bl,[a64 abs qword es:0xbbbbbbbb] + mov ax,[a64 abs qword es:0xbbbbbbbb] + mov bx,[a64 abs qword es:0xbbbbbbbb] + mov eax,[a64 abs qword es:0xbbbbbbbb] + mov ebx,[a64 abs qword es:0xbbbbbbbb] + mov rax,[a64 abs qword es:0xbbbbbbbb] + mov rbx,[a64 abs qword es:0xbbbbbbbb] + mov al,[a64 abs qword es:0xffffffffcccccccc] + mov bl,[a64 abs qword es:0xffffffffcccccccc] + mov ax,[a64 abs qword es:0xffffffffcccccccc] + mov bx,[a64 abs qword es:0xffffffffcccccccc] + mov eax,[a64 abs qword es:0xffffffffcccccccc] + mov ebx,[a64 abs qword es:0xffffffffcccccccc] + mov rax,[a64 abs qword es:0xffffffffcccccccc] + mov rbx,[a64 abs qword es:0xffffffffcccccccc] + + mov al,[a32 abs es:foo] + mov bl,[a32 abs es:foo] + mov ax,[a32 abs es:foo] + mov bx,[a32 abs es:foo] + mov eax,[a32 abs es:foo] + mov ebx,[a32 abs es:foo] + mov rax,[a32 abs es:foo] + mov rbx,[a32 abs es:foo] + mov al,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs es:0xbbbbbbbb] + mov bl,[a32 abs es:0xbbbbbbbb] + mov ax,[a32 abs es:0xbbbbbbbb] + mov bx,[a32 abs es:0xbbbbbbbb] + mov eax,[a32 abs es:0xbbbbbbbb] + mov ebx,[a32 abs es:0xbbbbbbbb] + mov rax,[a32 abs es:0xbbbbbbbb] + mov rbx,[a32 abs es:0xbbbbbbbb] + mov al,[a32 abs es:0xffffffffcccccccc] + mov bl,[a32 abs es:0xffffffffcccccccc] + mov ax,[a32 abs es:0xffffffffcccccccc] + mov bx,[a32 abs es:0xffffffffcccccccc] + mov eax,[a32 abs es:0xffffffffcccccccc] + mov ebx,[a32 abs es:0xffffffffcccccccc] + mov rax,[a32 abs es:0xffffffffcccccccc] + mov rbx,[a32 abs es:0xffffffffcccccccc] + + mov al,[a32 abs dword es:foo] + mov bl,[a32 abs dword es:foo] + mov ax,[a32 abs dword es:foo] + mov bx,[a32 abs dword es:foo] + mov eax,[a32 abs dword es:foo] + mov ebx,[a32 abs dword es:foo] + mov rax,[a32 abs dword es:foo] + mov rbx,[a32 abs dword es:foo] + mov al,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword es:0xbbbbbbbb] + mov bl,[a32 abs dword es:0xbbbbbbbb] + mov ax,[a32 abs dword es:0xbbbbbbbb] + mov bx,[a32 abs dword es:0xbbbbbbbb] + mov eax,[a32 abs dword es:0xbbbbbbbb] + mov ebx,[a32 abs dword es:0xbbbbbbbb] + mov rax,[a32 abs dword es:0xbbbbbbbb] + mov rbx,[a32 abs dword es:0xbbbbbbbb] + mov al,[a32 abs dword es:0xffffffffcccccccc] + mov bl,[a32 abs dword es:0xffffffffcccccccc] + mov ax,[a32 abs dword es:0xffffffffcccccccc] + mov bx,[a32 abs dword es:0xffffffffcccccccc] + mov eax,[a32 abs dword es:0xffffffffcccccccc] + mov ebx,[a32 abs dword es:0xffffffffcccccccc] + mov rax,[a32 abs dword es:0xffffffffcccccccc] + mov rbx,[a32 abs dword es:0xffffffffcccccccc] + + mov al,[a32 abs qword es:foo] + mov bl,[a32 abs qword es:foo] + mov ax,[a32 abs qword es:foo] + mov bx,[a32 abs qword es:foo] + mov eax,[a32 abs qword es:foo] + mov ebx,[a32 abs qword es:foo] + mov rax,[a32 abs qword es:foo] + mov rbx,[a32 abs qword es:foo] + mov al,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword es:0xbbbbbbbb] + mov bl,[a32 abs qword es:0xbbbbbbbb] + mov ax,[a32 abs qword es:0xbbbbbbbb] + mov bx,[a32 abs qword es:0xbbbbbbbb] + mov eax,[a32 abs qword es:0xbbbbbbbb] + mov ebx,[a32 abs qword es:0xbbbbbbbb] + mov rax,[a32 abs qword es:0xbbbbbbbb] + mov rbx,[a32 abs qword es:0xbbbbbbbb] + mov al,[a32 abs qword es:0xffffffffcccccccc] + mov bl,[a32 abs qword es:0xffffffffcccccccc] + mov ax,[a32 abs qword es:0xffffffffcccccccc] + mov bx,[a32 abs qword es:0xffffffffcccccccc] + mov eax,[a32 abs qword es:0xffffffffcccccccc] + mov ebx,[a32 abs qword es:0xffffffffcccccccc] + mov rax,[a32 abs qword es:0xffffffffcccccccc] + mov rbx,[a32 abs qword es:0xffffffffcccccccc] + + mov al,[rel es:foo] + mov bl,[rel es:foo] + mov ax,[rel es:foo] + mov bx,[rel es:foo] + mov eax,[rel es:foo] + mov ebx,[rel es:foo] + mov rax,[rel es:foo] + mov rbx,[rel es:foo] + mov al,[rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel es:0xaaaaaaaaaaaaaaaa] + mov al,[rel es:0xbbbbbbbb] + mov bl,[rel es:0xbbbbbbbb] + mov ax,[rel es:0xbbbbbbbb] + mov bx,[rel es:0xbbbbbbbb] + mov eax,[rel es:0xbbbbbbbb] + mov ebx,[rel es:0xbbbbbbbb] + mov rax,[rel es:0xbbbbbbbb] + mov rbx,[rel es:0xbbbbbbbb] + mov al,[rel es:0xffffffffcccccccc] + mov bl,[rel es:0xffffffffcccccccc] + mov ax,[rel es:0xffffffffcccccccc] + mov bx,[rel es:0xffffffffcccccccc] + mov eax,[rel es:0xffffffffcccccccc] + mov ebx,[rel es:0xffffffffcccccccc] + mov rax,[rel es:0xffffffffcccccccc] + mov rbx,[rel es:0xffffffffcccccccc] + + mov al,[rel dword es:foo] + mov bl,[rel dword es:foo] + mov ax,[rel dword es:foo] + mov bx,[rel dword es:foo] + mov eax,[rel dword es:foo] + mov ebx,[rel dword es:foo] + mov rax,[rel dword es:foo] + mov rbx,[rel dword es:foo] + mov al,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[rel dword es:0xbbbbbbbb] + mov bl,[rel dword es:0xbbbbbbbb] + mov ax,[rel dword es:0xbbbbbbbb] + mov bx,[rel dword es:0xbbbbbbbb] + mov eax,[rel dword es:0xbbbbbbbb] + mov ebx,[rel dword es:0xbbbbbbbb] + mov rax,[rel dword es:0xbbbbbbbb] + mov rbx,[rel dword es:0xbbbbbbbb] + mov al,[rel dword es:0xffffffffcccccccc] + mov bl,[rel dword es:0xffffffffcccccccc] + mov ax,[rel dword es:0xffffffffcccccccc] + mov bx,[rel dword es:0xffffffffcccccccc] + mov eax,[rel dword es:0xffffffffcccccccc] + mov ebx,[rel dword es:0xffffffffcccccccc] + mov rax,[rel dword es:0xffffffffcccccccc] + mov rbx,[rel dword es:0xffffffffcccccccc] + + mov al,[rel qword es:foo] + mov bl,[rel qword es:foo] + mov ax,[rel qword es:foo] + mov bx,[rel qword es:foo] + mov eax,[rel qword es:foo] + mov ebx,[rel qword es:foo] + mov rax,[rel qword es:foo] + mov rbx,[rel qword es:foo] + mov al,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[rel qword es:0xbbbbbbbb] + mov bl,[rel qword es:0xbbbbbbbb] + mov ax,[rel qword es:0xbbbbbbbb] + mov bx,[rel qword es:0xbbbbbbbb] + mov eax,[rel qword es:0xbbbbbbbb] + mov ebx,[rel qword es:0xbbbbbbbb] + mov rax,[rel qword es:0xbbbbbbbb] + mov rbx,[rel qword es:0xbbbbbbbb] + mov al,[rel qword es:0xffffffffcccccccc] + mov bl,[rel qword es:0xffffffffcccccccc] + mov ax,[rel qword es:0xffffffffcccccccc] + mov bx,[rel qword es:0xffffffffcccccccc] + mov eax,[rel qword es:0xffffffffcccccccc] + mov ebx,[rel qword es:0xffffffffcccccccc] + mov rax,[rel qword es:0xffffffffcccccccc] + mov rbx,[rel qword es:0xffffffffcccccccc] + + mov al,[a64 rel es:foo] + mov bl,[a64 rel es:foo] + mov ax,[a64 rel es:foo] + mov bx,[a64 rel es:foo] + mov eax,[a64 rel es:foo] + mov ebx,[a64 rel es:foo] + mov rax,[a64 rel es:foo] + mov rbx,[a64 rel es:foo] + mov al,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel es:0xbbbbbbbb] + mov bl,[a64 rel es:0xbbbbbbbb] + mov ax,[a64 rel es:0xbbbbbbbb] + mov bx,[a64 rel es:0xbbbbbbbb] + mov eax,[a64 rel es:0xbbbbbbbb] + mov ebx,[a64 rel es:0xbbbbbbbb] + mov rax,[a64 rel es:0xbbbbbbbb] + mov rbx,[a64 rel es:0xbbbbbbbb] + mov al,[a64 rel es:0xffffffffcccccccc] + mov bl,[a64 rel es:0xffffffffcccccccc] + mov ax,[a64 rel es:0xffffffffcccccccc] + mov bx,[a64 rel es:0xffffffffcccccccc] + mov eax,[a64 rel es:0xffffffffcccccccc] + mov ebx,[a64 rel es:0xffffffffcccccccc] + mov rax,[a64 rel es:0xffffffffcccccccc] + mov rbx,[a64 rel es:0xffffffffcccccccc] + + mov al,[a64 rel dword es:foo] + mov bl,[a64 rel dword es:foo] + mov ax,[a64 rel dword es:foo] + mov bx,[a64 rel dword es:foo] + mov eax,[a64 rel dword es:foo] + mov ebx,[a64 rel dword es:foo] + mov rax,[a64 rel dword es:foo] + mov rbx,[a64 rel dword es:foo] + mov al,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword es:0xbbbbbbbb] + mov bl,[a64 rel dword es:0xbbbbbbbb] + mov ax,[a64 rel dword es:0xbbbbbbbb] + mov bx,[a64 rel dword es:0xbbbbbbbb] + mov eax,[a64 rel dword es:0xbbbbbbbb] + mov ebx,[a64 rel dword es:0xbbbbbbbb] + mov rax,[a64 rel dword es:0xbbbbbbbb] + mov rbx,[a64 rel dword es:0xbbbbbbbb] + mov al,[a64 rel dword es:0xffffffffcccccccc] + mov bl,[a64 rel dword es:0xffffffffcccccccc] + mov ax,[a64 rel dword es:0xffffffffcccccccc] + mov bx,[a64 rel dword es:0xffffffffcccccccc] + mov eax,[a64 rel dword es:0xffffffffcccccccc] + mov ebx,[a64 rel dword es:0xffffffffcccccccc] + mov rax,[a64 rel dword es:0xffffffffcccccccc] + mov rbx,[a64 rel dword es:0xffffffffcccccccc] + + mov al,[a64 rel qword es:foo] + mov bl,[a64 rel qword es:foo] + mov ax,[a64 rel qword es:foo] + mov bx,[a64 rel qword es:foo] + mov eax,[a64 rel qword es:foo] + mov ebx,[a64 rel qword es:foo] + mov rax,[a64 rel qword es:foo] + mov rbx,[a64 rel qword es:foo] + mov al,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword es:0xbbbbbbbb] + mov bl,[a64 rel qword es:0xbbbbbbbb] + mov ax,[a64 rel qword es:0xbbbbbbbb] + mov bx,[a64 rel qword es:0xbbbbbbbb] + mov eax,[a64 rel qword es:0xbbbbbbbb] + mov ebx,[a64 rel qword es:0xbbbbbbbb] + mov rax,[a64 rel qword es:0xbbbbbbbb] + mov rbx,[a64 rel qword es:0xbbbbbbbb] + mov al,[a64 rel qword es:0xffffffffcccccccc] + mov bl,[a64 rel qword es:0xffffffffcccccccc] + mov ax,[a64 rel qword es:0xffffffffcccccccc] + mov bx,[a64 rel qword es:0xffffffffcccccccc] + mov eax,[a64 rel qword es:0xffffffffcccccccc] + mov ebx,[a64 rel qword es:0xffffffffcccccccc] + mov rax,[a64 rel qword es:0xffffffffcccccccc] + mov rbx,[a64 rel qword es:0xffffffffcccccccc] + + mov al,[a32 rel es:foo] + mov bl,[a32 rel es:foo] + mov ax,[a32 rel es:foo] + mov bx,[a32 rel es:foo] + mov eax,[a32 rel es:foo] + mov ebx,[a32 rel es:foo] + mov rax,[a32 rel es:foo] + mov rbx,[a32 rel es:foo] + mov al,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel es:0xbbbbbbbb] + mov bl,[a32 rel es:0xbbbbbbbb] + mov ax,[a32 rel es:0xbbbbbbbb] + mov bx,[a32 rel es:0xbbbbbbbb] + mov eax,[a32 rel es:0xbbbbbbbb] + mov ebx,[a32 rel es:0xbbbbbbbb] + mov rax,[a32 rel es:0xbbbbbbbb] + mov rbx,[a32 rel es:0xbbbbbbbb] + mov al,[a32 rel es:0xffffffffcccccccc] + mov bl,[a32 rel es:0xffffffffcccccccc] + mov ax,[a32 rel es:0xffffffffcccccccc] + mov bx,[a32 rel es:0xffffffffcccccccc] + mov eax,[a32 rel es:0xffffffffcccccccc] + mov ebx,[a32 rel es:0xffffffffcccccccc] + mov rax,[a32 rel es:0xffffffffcccccccc] + mov rbx,[a32 rel es:0xffffffffcccccccc] + + mov al,[a32 rel dword es:foo] + mov bl,[a32 rel dword es:foo] + mov ax,[a32 rel dword es:foo] + mov bx,[a32 rel dword es:foo] + mov eax,[a32 rel dword es:foo] + mov ebx,[a32 rel dword es:foo] + mov rax,[a32 rel dword es:foo] + mov rbx,[a32 rel dword es:foo] + mov al,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword es:0xbbbbbbbb] + mov bl,[a32 rel dword es:0xbbbbbbbb] + mov ax,[a32 rel dword es:0xbbbbbbbb] + mov bx,[a32 rel dword es:0xbbbbbbbb] + mov eax,[a32 rel dword es:0xbbbbbbbb] + mov ebx,[a32 rel dword es:0xbbbbbbbb] + mov rax,[a32 rel dword es:0xbbbbbbbb] + mov rbx,[a32 rel dword es:0xbbbbbbbb] + mov al,[a32 rel dword es:0xffffffffcccccccc] + mov bl,[a32 rel dword es:0xffffffffcccccccc] + mov ax,[a32 rel dword es:0xffffffffcccccccc] + mov bx,[a32 rel dword es:0xffffffffcccccccc] + mov eax,[a32 rel dword es:0xffffffffcccccccc] + mov ebx,[a32 rel dword es:0xffffffffcccccccc] + mov rax,[a32 rel dword es:0xffffffffcccccccc] + mov rbx,[a32 rel dword es:0xffffffffcccccccc] + + mov al,[a32 rel qword es:foo] + mov bl,[a32 rel qword es:foo] + mov ax,[a32 rel qword es:foo] + mov bx,[a32 rel qword es:foo] + mov eax,[a32 rel qword es:foo] + mov ebx,[a32 rel qword es:foo] + mov rax,[a32 rel qword es:foo] + mov rbx,[a32 rel qword es:foo] + mov al,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword es:0xbbbbbbbb] + mov bl,[a32 rel qword es:0xbbbbbbbb] + mov ax,[a32 rel qword es:0xbbbbbbbb] + mov bx,[a32 rel qword es:0xbbbbbbbb] + mov eax,[a32 rel qword es:0xbbbbbbbb] + mov ebx,[a32 rel qword es:0xbbbbbbbb] + mov rax,[a32 rel qword es:0xbbbbbbbb] + mov rbx,[a32 rel qword es:0xbbbbbbbb] + mov al,[a32 rel qword es:0xffffffffcccccccc] + mov bl,[a32 rel qword es:0xffffffffcccccccc] + mov ax,[a32 rel qword es:0xffffffffcccccccc] + mov bx,[a32 rel qword es:0xffffffffcccccccc] + mov eax,[a32 rel qword es:0xffffffffcccccccc] + mov ebx,[a32 rel qword es:0xffffffffcccccccc] + mov rax,[a32 rel qword es:0xffffffffcccccccc] + mov rbx,[a32 rel qword es:0xffffffffcccccccc] + + + default rel + + mov al,[foo] + mov bl,[foo] + mov ax,[foo] + mov bx,[foo] + mov eax,[foo] + mov ebx,[foo] + mov rax,[foo] + mov rbx,[foo] + mov al,[0xaaaaaaaaaaaaaaaa] + mov bl,[0xaaaaaaaaaaaaaaaa] + mov ax,[0xaaaaaaaaaaaaaaaa] + mov bx,[0xaaaaaaaaaaaaaaaa] + mov eax,[0xaaaaaaaaaaaaaaaa] + mov ebx,[0xaaaaaaaaaaaaaaaa] + mov rax,[0xaaaaaaaaaaaaaaaa] + mov rbx,[0xaaaaaaaaaaaaaaaa] + mov al,[0xbbbbbbbb] + mov bl,[0xbbbbbbbb] + mov ax,[0xbbbbbbbb] + mov bx,[0xbbbbbbbb] + mov eax,[0xbbbbbbbb] + mov ebx,[0xbbbbbbbb] + mov rax,[0xbbbbbbbb] + mov rbx,[0xbbbbbbbb] + mov al,[0xffffffffcccccccc] + mov bl,[0xffffffffcccccccc] + mov ax,[0xffffffffcccccccc] + mov bx,[0xffffffffcccccccc] + mov eax,[0xffffffffcccccccc] + mov ebx,[0xffffffffcccccccc] + mov rax,[0xffffffffcccccccc] + mov rbx,[0xffffffffcccccccc] + + mov al,[dword foo] + mov bl,[dword foo] + mov ax,[dword foo] + mov bx,[dword foo] + mov eax,[dword foo] + mov ebx,[dword foo] + mov rax,[dword foo] + mov rbx,[dword foo] + mov al,[dword 0xaaaaaaaaaaaaaaaa] + mov bl,[dword 0xaaaaaaaaaaaaaaaa] + mov ax,[dword 0xaaaaaaaaaaaaaaaa] + mov bx,[dword 0xaaaaaaaaaaaaaaaa] + mov eax,[dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[dword 0xaaaaaaaaaaaaaaaa] + mov rax,[dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[dword 0xaaaaaaaaaaaaaaaa] + mov al,[dword 0xbbbbbbbb] + mov bl,[dword 0xbbbbbbbb] + mov ax,[dword 0xbbbbbbbb] + mov bx,[dword 0xbbbbbbbb] + mov eax,[dword 0xbbbbbbbb] + mov ebx,[dword 0xbbbbbbbb] + mov rax,[dword 0xbbbbbbbb] + mov rbx,[dword 0xbbbbbbbb] + mov al,[dword 0xffffffffcccccccc] + mov bl,[dword 0xffffffffcccccccc] + mov ax,[dword 0xffffffffcccccccc] + mov bx,[dword 0xffffffffcccccccc] + mov eax,[dword 0xffffffffcccccccc] + mov ebx,[dword 0xffffffffcccccccc] + mov rax,[dword 0xffffffffcccccccc] + mov rbx,[dword 0xffffffffcccccccc] + + mov al,[qword foo] + mov bl,[qword foo] + mov ax,[qword foo] + mov bx,[qword foo] + mov eax,[qword foo] + mov ebx,[qword foo] + mov rax,[qword foo] + mov rbx,[qword foo] + mov al,[qword 0xaaaaaaaaaaaaaaaa] + mov bl,[qword 0xaaaaaaaaaaaaaaaa] + mov ax,[qword 0xaaaaaaaaaaaaaaaa] + mov bx,[qword 0xaaaaaaaaaaaaaaaa] + mov eax,[qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[qword 0xaaaaaaaaaaaaaaaa] + mov rax,[qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[qword 0xaaaaaaaaaaaaaaaa] + mov al,[qword 0xbbbbbbbb] + mov bl,[qword 0xbbbbbbbb] + mov ax,[qword 0xbbbbbbbb] + mov bx,[qword 0xbbbbbbbb] + mov eax,[qword 0xbbbbbbbb] + mov ebx,[qword 0xbbbbbbbb] + mov rax,[qword 0xbbbbbbbb] + mov rbx,[qword 0xbbbbbbbb] + mov al,[qword 0xffffffffcccccccc] + mov bl,[qword 0xffffffffcccccccc] + mov ax,[qword 0xffffffffcccccccc] + mov bx,[qword 0xffffffffcccccccc] + mov eax,[qword 0xffffffffcccccccc] + mov ebx,[qword 0xffffffffcccccccc] + mov rax,[qword 0xffffffffcccccccc] + mov rbx,[qword 0xffffffffcccccccc] + + mov al,[a64 foo] + mov bl,[a64 foo] + mov ax,[a64 foo] + mov bx,[a64 foo] + mov eax,[a64 foo] + mov ebx,[a64 foo] + mov rax,[a64 foo] + mov rbx,[a64 foo] + mov al,[a64 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 0xaaaaaaaaaaaaaaaa] + mov al,[a64 0xbbbbbbbb] + mov bl,[a64 0xbbbbbbbb] + mov ax,[a64 0xbbbbbbbb] + mov bx,[a64 0xbbbbbbbb] + mov eax,[a64 0xbbbbbbbb] + mov ebx,[a64 0xbbbbbbbb] + mov rax,[a64 0xbbbbbbbb] + mov rbx,[a64 0xbbbbbbbb] + mov al,[a64 0xffffffffcccccccc] + mov bl,[a64 0xffffffffcccccccc] + mov ax,[a64 0xffffffffcccccccc] + mov bx,[a64 0xffffffffcccccccc] + mov eax,[a64 0xffffffffcccccccc] + mov ebx,[a64 0xffffffffcccccccc] + mov rax,[a64 0xffffffffcccccccc] + mov rbx,[a64 0xffffffffcccccccc] + + mov al,[a64 dword foo] + mov bl,[a64 dword foo] + mov ax,[a64 dword foo] + mov bx,[a64 dword foo] + mov eax,[a64 dword foo] + mov ebx,[a64 dword foo] + mov rax,[a64 dword foo] + mov rbx,[a64 dword foo] + mov al,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword 0xbbbbbbbb] + mov bl,[a64 dword 0xbbbbbbbb] + mov ax,[a64 dword 0xbbbbbbbb] + mov bx,[a64 dword 0xbbbbbbbb] + mov eax,[a64 dword 0xbbbbbbbb] + mov ebx,[a64 dword 0xbbbbbbbb] + mov rax,[a64 dword 0xbbbbbbbb] + mov rbx,[a64 dword 0xbbbbbbbb] + mov al,[a64 dword 0xffffffffcccccccc] + mov bl,[a64 dword 0xffffffffcccccccc] + mov ax,[a64 dword 0xffffffffcccccccc] + mov bx,[a64 dword 0xffffffffcccccccc] + mov eax,[a64 dword 0xffffffffcccccccc] + mov ebx,[a64 dword 0xffffffffcccccccc] + mov rax,[a64 dword 0xffffffffcccccccc] + mov rbx,[a64 dword 0xffffffffcccccccc] + + mov al,[a64 qword foo] + mov bl,[a64 qword foo] + mov ax,[a64 qword foo] + mov bx,[a64 qword foo] + mov eax,[a64 qword foo] + mov ebx,[a64 qword foo] + mov rax,[a64 qword foo] + mov rbx,[a64 qword foo] + mov al,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword 0xbbbbbbbb] + mov bl,[a64 qword 0xbbbbbbbb] + mov ax,[a64 qword 0xbbbbbbbb] + mov bx,[a64 qword 0xbbbbbbbb] + mov eax,[a64 qword 0xbbbbbbbb] + mov ebx,[a64 qword 0xbbbbbbbb] + mov rax,[a64 qword 0xbbbbbbbb] + mov rbx,[a64 qword 0xbbbbbbbb] + mov al,[a64 qword 0xffffffffcccccccc] + mov bl,[a64 qword 0xffffffffcccccccc] + mov ax,[a64 qword 0xffffffffcccccccc] + mov bx,[a64 qword 0xffffffffcccccccc] + mov eax,[a64 qword 0xffffffffcccccccc] + mov ebx,[a64 qword 0xffffffffcccccccc] + mov rax,[a64 qword 0xffffffffcccccccc] + mov rbx,[a64 qword 0xffffffffcccccccc] + + mov al,[a32 foo] + mov bl,[a32 foo] + mov ax,[a32 foo] + mov bx,[a32 foo] + mov eax,[a32 foo] + mov ebx,[a32 foo] + mov rax,[a32 foo] + mov rbx,[a32 foo] + mov al,[a32 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 0xaaaaaaaaaaaaaaaa] + mov al,[a32 0xbbbbbbbb] + mov bl,[a32 0xbbbbbbbb] + mov ax,[a32 0xbbbbbbbb] + mov bx,[a32 0xbbbbbbbb] + mov eax,[a32 0xbbbbbbbb] + mov ebx,[a32 0xbbbbbbbb] + mov rax,[a32 0xbbbbbbbb] + mov rbx,[a32 0xbbbbbbbb] + mov al,[a32 0xffffffffcccccccc] + mov bl,[a32 0xffffffffcccccccc] + mov ax,[a32 0xffffffffcccccccc] + mov bx,[a32 0xffffffffcccccccc] + mov eax,[a32 0xffffffffcccccccc] + mov ebx,[a32 0xffffffffcccccccc] + mov rax,[a32 0xffffffffcccccccc] + mov rbx,[a32 0xffffffffcccccccc] + + mov al,[a32 dword foo] + mov bl,[a32 dword foo] + mov ax,[a32 dword foo] + mov bx,[a32 dword foo] + mov eax,[a32 dword foo] + mov ebx,[a32 dword foo] + mov rax,[a32 dword foo] + mov rbx,[a32 dword foo] + mov al,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword 0xbbbbbbbb] + mov bl,[a32 dword 0xbbbbbbbb] + mov ax,[a32 dword 0xbbbbbbbb] + mov bx,[a32 dword 0xbbbbbbbb] + mov eax,[a32 dword 0xbbbbbbbb] + mov ebx,[a32 dword 0xbbbbbbbb] + mov rax,[a32 dword 0xbbbbbbbb] + mov rbx,[a32 dword 0xbbbbbbbb] + mov al,[a32 dword 0xffffffffcccccccc] + mov bl,[a32 dword 0xffffffffcccccccc] + mov ax,[a32 dword 0xffffffffcccccccc] + mov bx,[a32 dword 0xffffffffcccccccc] + mov eax,[a32 dword 0xffffffffcccccccc] + mov ebx,[a32 dword 0xffffffffcccccccc] + mov rax,[a32 dword 0xffffffffcccccccc] + mov rbx,[a32 dword 0xffffffffcccccccc] + + mov al,[a32 qword foo] + mov bl,[a32 qword foo] + mov ax,[a32 qword foo] + mov bx,[a32 qword foo] + mov eax,[a32 qword foo] + mov ebx,[a32 qword foo] + mov rax,[a32 qword foo] + mov rbx,[a32 qword foo] + mov al,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword 0xbbbbbbbb] + mov bl,[a32 qword 0xbbbbbbbb] + mov ax,[a32 qword 0xbbbbbbbb] + mov bx,[a32 qword 0xbbbbbbbb] + mov eax,[a32 qword 0xbbbbbbbb] + mov ebx,[a32 qword 0xbbbbbbbb] + mov rax,[a32 qword 0xbbbbbbbb] + mov rbx,[a32 qword 0xbbbbbbbb] + mov al,[a32 qword 0xffffffffcccccccc] + mov bl,[a32 qword 0xffffffffcccccccc] + mov ax,[a32 qword 0xffffffffcccccccc] + mov bx,[a32 qword 0xffffffffcccccccc] + mov eax,[a32 qword 0xffffffffcccccccc] + mov ebx,[a32 qword 0xffffffffcccccccc] + mov rax,[a32 qword 0xffffffffcccccccc] + mov rbx,[a32 qword 0xffffffffcccccccc] + + mov al,[abs foo] + mov bl,[abs foo] + mov ax,[abs foo] + mov bx,[abs foo] + mov eax,[abs foo] + mov ebx,[abs foo] + mov rax,[abs foo] + mov rbx,[abs foo] + mov al,[abs 0xaaaaaaaaaaaaaaaa] + mov bl,[abs 0xaaaaaaaaaaaaaaaa] + mov ax,[abs 0xaaaaaaaaaaaaaaaa] + mov bx,[abs 0xaaaaaaaaaaaaaaaa] + mov eax,[abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs 0xaaaaaaaaaaaaaaaa] + mov rax,[abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs 0xaaaaaaaaaaaaaaaa] + mov al,[abs 0xbbbbbbbb] + mov bl,[abs 0xbbbbbbbb] + mov ax,[abs 0xbbbbbbbb] + mov bx,[abs 0xbbbbbbbb] + mov eax,[abs 0xbbbbbbbb] + mov ebx,[abs 0xbbbbbbbb] + mov rax,[abs 0xbbbbbbbb] + mov rbx,[abs 0xbbbbbbbb] + mov al,[abs 0xffffffffcccccccc] + mov bl,[abs 0xffffffffcccccccc] + mov ax,[abs 0xffffffffcccccccc] + mov bx,[abs 0xffffffffcccccccc] + mov eax,[abs 0xffffffffcccccccc] + mov ebx,[abs 0xffffffffcccccccc] + mov rax,[abs 0xffffffffcccccccc] + mov rbx,[abs 0xffffffffcccccccc] + + mov al,[abs dword foo] + mov bl,[abs dword foo] + mov ax,[abs dword foo] + mov bx,[abs dword foo] + mov eax,[abs dword foo] + mov ebx,[abs dword foo] + mov rax,[abs dword foo] + mov rbx,[abs dword foo] + mov al,[abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[abs dword 0xbbbbbbbb] + mov bl,[abs dword 0xbbbbbbbb] + mov ax,[abs dword 0xbbbbbbbb] + mov bx,[abs dword 0xbbbbbbbb] + mov eax,[abs dword 0xbbbbbbbb] + mov ebx,[abs dword 0xbbbbbbbb] + mov rax,[abs dword 0xbbbbbbbb] + mov rbx,[abs dword 0xbbbbbbbb] + mov al,[abs dword 0xffffffffcccccccc] + mov bl,[abs dword 0xffffffffcccccccc] + mov ax,[abs dword 0xffffffffcccccccc] + mov bx,[abs dword 0xffffffffcccccccc] + mov eax,[abs dword 0xffffffffcccccccc] + mov ebx,[abs dword 0xffffffffcccccccc] + mov rax,[abs dword 0xffffffffcccccccc] + mov rbx,[abs dword 0xffffffffcccccccc] + + mov al,[abs qword foo] + mov bl,[abs qword foo] + mov ax,[abs qword foo] + mov bx,[abs qword foo] + mov eax,[abs qword foo] + mov ebx,[abs qword foo] + mov rax,[abs qword foo] + mov rbx,[abs qword foo] + mov al,[abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[abs qword 0xbbbbbbbb] + mov bl,[abs qword 0xbbbbbbbb] + mov ax,[abs qword 0xbbbbbbbb] + mov bx,[abs qword 0xbbbbbbbb] + mov eax,[abs qword 0xbbbbbbbb] + mov ebx,[abs qword 0xbbbbbbbb] + mov rax,[abs qword 0xbbbbbbbb] + mov rbx,[abs qword 0xbbbbbbbb] + mov al,[abs qword 0xffffffffcccccccc] + mov bl,[abs qword 0xffffffffcccccccc] + mov ax,[abs qword 0xffffffffcccccccc] + mov bx,[abs qword 0xffffffffcccccccc] + mov eax,[abs qword 0xffffffffcccccccc] + mov ebx,[abs qword 0xffffffffcccccccc] + mov rax,[abs qword 0xffffffffcccccccc] + mov rbx,[abs qword 0xffffffffcccccccc] + + mov al,[a64 abs foo] + mov bl,[a64 abs foo] + mov ax,[a64 abs foo] + mov bx,[a64 abs foo] + mov eax,[a64 abs foo] + mov ebx,[a64 abs foo] + mov rax,[a64 abs foo] + mov rbx,[a64 abs foo] + mov al,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs 0xbbbbbbbb] + mov bl,[a64 abs 0xbbbbbbbb] + mov ax,[a64 abs 0xbbbbbbbb] + mov bx,[a64 abs 0xbbbbbbbb] + mov eax,[a64 abs 0xbbbbbbbb] + mov ebx,[a64 abs 0xbbbbbbbb] + mov rax,[a64 abs 0xbbbbbbbb] + mov rbx,[a64 abs 0xbbbbbbbb] + mov al,[a64 abs 0xffffffffcccccccc] + mov bl,[a64 abs 0xffffffffcccccccc] + mov ax,[a64 abs 0xffffffffcccccccc] + mov bx,[a64 abs 0xffffffffcccccccc] + mov eax,[a64 abs 0xffffffffcccccccc] + mov ebx,[a64 abs 0xffffffffcccccccc] + mov rax,[a64 abs 0xffffffffcccccccc] + mov rbx,[a64 abs 0xffffffffcccccccc] + + mov al,[a64 abs dword foo] + mov bl,[a64 abs dword foo] + mov ax,[a64 abs dword foo] + mov bx,[a64 abs dword foo] + mov eax,[a64 abs dword foo] + mov ebx,[a64 abs dword foo] + mov rax,[a64 abs dword foo] + mov rbx,[a64 abs dword foo] + mov al,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword 0xbbbbbbbb] + mov bl,[a64 abs dword 0xbbbbbbbb] + mov ax,[a64 abs dword 0xbbbbbbbb] + mov bx,[a64 abs dword 0xbbbbbbbb] + mov eax,[a64 abs dword 0xbbbbbbbb] + mov ebx,[a64 abs dword 0xbbbbbbbb] + mov rax,[a64 abs dword 0xbbbbbbbb] + mov rbx,[a64 abs dword 0xbbbbbbbb] + mov al,[a64 abs dword 0xffffffffcccccccc] + mov bl,[a64 abs dword 0xffffffffcccccccc] + mov ax,[a64 abs dword 0xffffffffcccccccc] + mov bx,[a64 abs dword 0xffffffffcccccccc] + mov eax,[a64 abs dword 0xffffffffcccccccc] + mov ebx,[a64 abs dword 0xffffffffcccccccc] + mov rax,[a64 abs dword 0xffffffffcccccccc] + mov rbx,[a64 abs dword 0xffffffffcccccccc] + + mov al,[a64 abs qword foo] + mov bl,[a64 abs qword foo] + mov ax,[a64 abs qword foo] + mov bx,[a64 abs qword foo] + mov eax,[a64 abs qword foo] + mov ebx,[a64 abs qword foo] + mov rax,[a64 abs qword foo] + mov rbx,[a64 abs qword foo] + mov al,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword 0xbbbbbbbb] + mov bl,[a64 abs qword 0xbbbbbbbb] + mov ax,[a64 abs qword 0xbbbbbbbb] + mov bx,[a64 abs qword 0xbbbbbbbb] + mov eax,[a64 abs qword 0xbbbbbbbb] + mov ebx,[a64 abs qword 0xbbbbbbbb] + mov rax,[a64 abs qword 0xbbbbbbbb] + mov rbx,[a64 abs qword 0xbbbbbbbb] + mov al,[a64 abs qword 0xffffffffcccccccc] + mov bl,[a64 abs qword 0xffffffffcccccccc] + mov ax,[a64 abs qword 0xffffffffcccccccc] + mov bx,[a64 abs qword 0xffffffffcccccccc] + mov eax,[a64 abs qword 0xffffffffcccccccc] + mov ebx,[a64 abs qword 0xffffffffcccccccc] + mov rax,[a64 abs qword 0xffffffffcccccccc] + mov rbx,[a64 abs qword 0xffffffffcccccccc] + + mov al,[a32 abs foo] + mov bl,[a32 abs foo] + mov ax,[a32 abs foo] + mov bx,[a32 abs foo] + mov eax,[a32 abs foo] + mov ebx,[a32 abs foo] + mov rax,[a32 abs foo] + mov rbx,[a32 abs foo] + mov al,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs 0xbbbbbbbb] + mov bl,[a32 abs 0xbbbbbbbb] + mov ax,[a32 abs 0xbbbbbbbb] + mov bx,[a32 abs 0xbbbbbbbb] + mov eax,[a32 abs 0xbbbbbbbb] + mov ebx,[a32 abs 0xbbbbbbbb] + mov rax,[a32 abs 0xbbbbbbbb] + mov rbx,[a32 abs 0xbbbbbbbb] + mov al,[a32 abs 0xffffffffcccccccc] + mov bl,[a32 abs 0xffffffffcccccccc] + mov ax,[a32 abs 0xffffffffcccccccc] + mov bx,[a32 abs 0xffffffffcccccccc] + mov eax,[a32 abs 0xffffffffcccccccc] + mov ebx,[a32 abs 0xffffffffcccccccc] + mov rax,[a32 abs 0xffffffffcccccccc] + mov rbx,[a32 abs 0xffffffffcccccccc] + + mov al,[a32 abs dword foo] + mov bl,[a32 abs dword foo] + mov ax,[a32 abs dword foo] + mov bx,[a32 abs dword foo] + mov eax,[a32 abs dword foo] + mov ebx,[a32 abs dword foo] + mov rax,[a32 abs dword foo] + mov rbx,[a32 abs dword foo] + mov al,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword 0xbbbbbbbb] + mov bl,[a32 abs dword 0xbbbbbbbb] + mov ax,[a32 abs dword 0xbbbbbbbb] + mov bx,[a32 abs dword 0xbbbbbbbb] + mov eax,[a32 abs dword 0xbbbbbbbb] + mov ebx,[a32 abs dword 0xbbbbbbbb] + mov rax,[a32 abs dword 0xbbbbbbbb] + mov rbx,[a32 abs dword 0xbbbbbbbb] + mov al,[a32 abs dword 0xffffffffcccccccc] + mov bl,[a32 abs dword 0xffffffffcccccccc] + mov ax,[a32 abs dword 0xffffffffcccccccc] + mov bx,[a32 abs dword 0xffffffffcccccccc] + mov eax,[a32 abs dword 0xffffffffcccccccc] + mov ebx,[a32 abs dword 0xffffffffcccccccc] + mov rax,[a32 abs dword 0xffffffffcccccccc] + mov rbx,[a32 abs dword 0xffffffffcccccccc] + + mov al,[a32 abs qword foo] + mov bl,[a32 abs qword foo] + mov ax,[a32 abs qword foo] + mov bx,[a32 abs qword foo] + mov eax,[a32 abs qword foo] + mov ebx,[a32 abs qword foo] + mov rax,[a32 abs qword foo] + mov rbx,[a32 abs qword foo] + mov al,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword 0xbbbbbbbb] + mov bl,[a32 abs qword 0xbbbbbbbb] + mov ax,[a32 abs qword 0xbbbbbbbb] + mov bx,[a32 abs qword 0xbbbbbbbb] + mov eax,[a32 abs qword 0xbbbbbbbb] + mov ebx,[a32 abs qword 0xbbbbbbbb] + mov rax,[a32 abs qword 0xbbbbbbbb] + mov rbx,[a32 abs qword 0xbbbbbbbb] + mov al,[a32 abs qword 0xffffffffcccccccc] + mov bl,[a32 abs qword 0xffffffffcccccccc] + mov ax,[a32 abs qword 0xffffffffcccccccc] + mov bx,[a32 abs qword 0xffffffffcccccccc] + mov eax,[a32 abs qword 0xffffffffcccccccc] + mov ebx,[a32 abs qword 0xffffffffcccccccc] + mov rax,[a32 abs qword 0xffffffffcccccccc] + mov rbx,[a32 abs qword 0xffffffffcccccccc] + + mov al,[rel foo] + mov bl,[rel foo] + mov ax,[rel foo] + mov bx,[rel foo] + mov eax,[rel foo] + mov ebx,[rel foo] + mov rax,[rel foo] + mov rbx,[rel foo] + mov al,[rel 0xaaaaaaaaaaaaaaaa] + mov bl,[rel 0xaaaaaaaaaaaaaaaa] + mov ax,[rel 0xaaaaaaaaaaaaaaaa] + mov bx,[rel 0xaaaaaaaaaaaaaaaa] + mov eax,[rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel 0xaaaaaaaaaaaaaaaa] + mov rax,[rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel 0xaaaaaaaaaaaaaaaa] + mov al,[rel 0xbbbbbbbb] + mov bl,[rel 0xbbbbbbbb] + mov ax,[rel 0xbbbbbbbb] + mov bx,[rel 0xbbbbbbbb] + mov eax,[rel 0xbbbbbbbb] + mov ebx,[rel 0xbbbbbbbb] + mov rax,[rel 0xbbbbbbbb] + mov rbx,[rel 0xbbbbbbbb] + mov al,[rel 0xffffffffcccccccc] + mov bl,[rel 0xffffffffcccccccc] + mov ax,[rel 0xffffffffcccccccc] + mov bx,[rel 0xffffffffcccccccc] + mov eax,[rel 0xffffffffcccccccc] + mov ebx,[rel 0xffffffffcccccccc] + mov rax,[rel 0xffffffffcccccccc] + mov rbx,[rel 0xffffffffcccccccc] + + mov al,[rel dword foo] + mov bl,[rel dword foo] + mov ax,[rel dword foo] + mov bx,[rel dword foo] + mov eax,[rel dword foo] + mov ebx,[rel dword foo] + mov rax,[rel dword foo] + mov rbx,[rel dword foo] + mov al,[rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[rel dword 0xbbbbbbbb] + mov bl,[rel dword 0xbbbbbbbb] + mov ax,[rel dword 0xbbbbbbbb] + mov bx,[rel dword 0xbbbbbbbb] + mov eax,[rel dword 0xbbbbbbbb] + mov ebx,[rel dword 0xbbbbbbbb] + mov rax,[rel dword 0xbbbbbbbb] + mov rbx,[rel dword 0xbbbbbbbb] + mov al,[rel dword 0xffffffffcccccccc] + mov bl,[rel dword 0xffffffffcccccccc] + mov ax,[rel dword 0xffffffffcccccccc] + mov bx,[rel dword 0xffffffffcccccccc] + mov eax,[rel dword 0xffffffffcccccccc] + mov ebx,[rel dword 0xffffffffcccccccc] + mov rax,[rel dword 0xffffffffcccccccc] + mov rbx,[rel dword 0xffffffffcccccccc] + + mov al,[rel qword foo] + mov bl,[rel qword foo] + mov ax,[rel qword foo] + mov bx,[rel qword foo] + mov eax,[rel qword foo] + mov ebx,[rel qword foo] + mov rax,[rel qword foo] + mov rbx,[rel qword foo] + mov al,[rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[rel qword 0xbbbbbbbb] + mov bl,[rel qword 0xbbbbbbbb] + mov ax,[rel qword 0xbbbbbbbb] + mov bx,[rel qword 0xbbbbbbbb] + mov eax,[rel qword 0xbbbbbbbb] + mov ebx,[rel qword 0xbbbbbbbb] + mov rax,[rel qword 0xbbbbbbbb] + mov rbx,[rel qword 0xbbbbbbbb] + mov al,[rel qword 0xffffffffcccccccc] + mov bl,[rel qword 0xffffffffcccccccc] + mov ax,[rel qword 0xffffffffcccccccc] + mov bx,[rel qword 0xffffffffcccccccc] + mov eax,[rel qword 0xffffffffcccccccc] + mov ebx,[rel qword 0xffffffffcccccccc] + mov rax,[rel qword 0xffffffffcccccccc] + mov rbx,[rel qword 0xffffffffcccccccc] + + mov al,[a64 rel foo] + mov bl,[a64 rel foo] + mov ax,[a64 rel foo] + mov bx,[a64 rel foo] + mov eax,[a64 rel foo] + mov ebx,[a64 rel foo] + mov rax,[a64 rel foo] + mov rbx,[a64 rel foo] + mov al,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel 0xbbbbbbbb] + mov bl,[a64 rel 0xbbbbbbbb] + mov ax,[a64 rel 0xbbbbbbbb] + mov bx,[a64 rel 0xbbbbbbbb] + mov eax,[a64 rel 0xbbbbbbbb] + mov ebx,[a64 rel 0xbbbbbbbb] + mov rax,[a64 rel 0xbbbbbbbb] + mov rbx,[a64 rel 0xbbbbbbbb] + mov al,[a64 rel 0xffffffffcccccccc] + mov bl,[a64 rel 0xffffffffcccccccc] + mov ax,[a64 rel 0xffffffffcccccccc] + mov bx,[a64 rel 0xffffffffcccccccc] + mov eax,[a64 rel 0xffffffffcccccccc] + mov ebx,[a64 rel 0xffffffffcccccccc] + mov rax,[a64 rel 0xffffffffcccccccc] + mov rbx,[a64 rel 0xffffffffcccccccc] + + mov al,[a64 rel dword foo] + mov bl,[a64 rel dword foo] + mov ax,[a64 rel dword foo] + mov bx,[a64 rel dword foo] + mov eax,[a64 rel dword foo] + mov ebx,[a64 rel dword foo] + mov rax,[a64 rel dword foo] + mov rbx,[a64 rel dword foo] + mov al,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword 0xbbbbbbbb] + mov bl,[a64 rel dword 0xbbbbbbbb] + mov ax,[a64 rel dword 0xbbbbbbbb] + mov bx,[a64 rel dword 0xbbbbbbbb] + mov eax,[a64 rel dword 0xbbbbbbbb] + mov ebx,[a64 rel dword 0xbbbbbbbb] + mov rax,[a64 rel dword 0xbbbbbbbb] + mov rbx,[a64 rel dword 0xbbbbbbbb] + mov al,[a64 rel dword 0xffffffffcccccccc] + mov bl,[a64 rel dword 0xffffffffcccccccc] + mov ax,[a64 rel dword 0xffffffffcccccccc] + mov bx,[a64 rel dword 0xffffffffcccccccc] + mov eax,[a64 rel dword 0xffffffffcccccccc] + mov ebx,[a64 rel dword 0xffffffffcccccccc] + mov rax,[a64 rel dword 0xffffffffcccccccc] + mov rbx,[a64 rel dword 0xffffffffcccccccc] + + mov al,[a64 rel qword foo] + mov bl,[a64 rel qword foo] + mov ax,[a64 rel qword foo] + mov bx,[a64 rel qword foo] + mov eax,[a64 rel qword foo] + mov ebx,[a64 rel qword foo] + mov rax,[a64 rel qword foo] + mov rbx,[a64 rel qword foo] + mov al,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword 0xbbbbbbbb] + mov bl,[a64 rel qword 0xbbbbbbbb] + mov ax,[a64 rel qword 0xbbbbbbbb] + mov bx,[a64 rel qword 0xbbbbbbbb] + mov eax,[a64 rel qword 0xbbbbbbbb] + mov ebx,[a64 rel qword 0xbbbbbbbb] + mov rax,[a64 rel qword 0xbbbbbbbb] + mov rbx,[a64 rel qword 0xbbbbbbbb] + mov al,[a64 rel qword 0xffffffffcccccccc] + mov bl,[a64 rel qword 0xffffffffcccccccc] + mov ax,[a64 rel qword 0xffffffffcccccccc] + mov bx,[a64 rel qword 0xffffffffcccccccc] + mov eax,[a64 rel qword 0xffffffffcccccccc] + mov ebx,[a64 rel qword 0xffffffffcccccccc] + mov rax,[a64 rel qword 0xffffffffcccccccc] + mov rbx,[a64 rel qword 0xffffffffcccccccc] + + mov al,[a32 rel foo] + mov bl,[a32 rel foo] + mov ax,[a32 rel foo] + mov bx,[a32 rel foo] + mov eax,[a32 rel foo] + mov ebx,[a32 rel foo] + mov rax,[a32 rel foo] + mov rbx,[a32 rel foo] + mov al,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel 0xbbbbbbbb] + mov bl,[a32 rel 0xbbbbbbbb] + mov ax,[a32 rel 0xbbbbbbbb] + mov bx,[a32 rel 0xbbbbbbbb] + mov eax,[a32 rel 0xbbbbbbbb] + mov ebx,[a32 rel 0xbbbbbbbb] + mov rax,[a32 rel 0xbbbbbbbb] + mov rbx,[a32 rel 0xbbbbbbbb] + mov al,[a32 rel 0xffffffffcccccccc] + mov bl,[a32 rel 0xffffffffcccccccc] + mov ax,[a32 rel 0xffffffffcccccccc] + mov bx,[a32 rel 0xffffffffcccccccc] + mov eax,[a32 rel 0xffffffffcccccccc] + mov ebx,[a32 rel 0xffffffffcccccccc] + mov rax,[a32 rel 0xffffffffcccccccc] + mov rbx,[a32 rel 0xffffffffcccccccc] + + mov al,[a32 rel dword foo] + mov bl,[a32 rel dword foo] + mov ax,[a32 rel dword foo] + mov bx,[a32 rel dword foo] + mov eax,[a32 rel dword foo] + mov ebx,[a32 rel dword foo] + mov rax,[a32 rel dword foo] + mov rbx,[a32 rel dword foo] + mov al,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword 0xbbbbbbbb] + mov bl,[a32 rel dword 0xbbbbbbbb] + mov ax,[a32 rel dword 0xbbbbbbbb] + mov bx,[a32 rel dword 0xbbbbbbbb] + mov eax,[a32 rel dword 0xbbbbbbbb] + mov ebx,[a32 rel dword 0xbbbbbbbb] + mov rax,[a32 rel dword 0xbbbbbbbb] + mov rbx,[a32 rel dword 0xbbbbbbbb] + mov al,[a32 rel dword 0xffffffffcccccccc] + mov bl,[a32 rel dword 0xffffffffcccccccc] + mov ax,[a32 rel dword 0xffffffffcccccccc] + mov bx,[a32 rel dword 0xffffffffcccccccc] + mov eax,[a32 rel dword 0xffffffffcccccccc] + mov ebx,[a32 rel dword 0xffffffffcccccccc] + mov rax,[a32 rel dword 0xffffffffcccccccc] + mov rbx,[a32 rel dword 0xffffffffcccccccc] + + mov al,[a32 rel qword foo] + mov bl,[a32 rel qword foo] + mov ax,[a32 rel qword foo] + mov bx,[a32 rel qword foo] + mov eax,[a32 rel qword foo] + mov ebx,[a32 rel qword foo] + mov rax,[a32 rel qword foo] + mov rbx,[a32 rel qword foo] + mov al,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword 0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword 0xbbbbbbbb] + mov bl,[a32 rel qword 0xbbbbbbbb] + mov ax,[a32 rel qword 0xbbbbbbbb] + mov bx,[a32 rel qword 0xbbbbbbbb] + mov eax,[a32 rel qword 0xbbbbbbbb] + mov ebx,[a32 rel qword 0xbbbbbbbb] + mov rax,[a32 rel qword 0xbbbbbbbb] + mov rbx,[a32 rel qword 0xbbbbbbbb] + mov al,[a32 rel qword 0xffffffffcccccccc] + mov bl,[a32 rel qword 0xffffffffcccccccc] + mov ax,[a32 rel qword 0xffffffffcccccccc] + mov bx,[a32 rel qword 0xffffffffcccccccc] + mov eax,[a32 rel qword 0xffffffffcccccccc] + mov ebx,[a32 rel qword 0xffffffffcccccccc] + mov rax,[a32 rel qword 0xffffffffcccccccc] + mov rbx,[a32 rel qword 0xffffffffcccccccc] + + mov al,[fs:foo] + mov bl,[fs:foo] + mov ax,[fs:foo] + mov bx,[fs:foo] + mov eax,[fs:foo] + mov ebx,[fs:foo] + mov rax,[fs:foo] + mov rbx,[fs:foo] + mov al,[fs:0xaaaaaaaaaaaaaaaa] + mov bl,[fs:0xaaaaaaaaaaaaaaaa] + mov ax,[fs:0xaaaaaaaaaaaaaaaa] + mov bx,[fs:0xaaaaaaaaaaaaaaaa] + mov eax,[fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[fs:0xaaaaaaaaaaaaaaaa] + mov rax,[fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[fs:0xaaaaaaaaaaaaaaaa] + mov al,[fs:0xbbbbbbbb] + mov bl,[fs:0xbbbbbbbb] + mov ax,[fs:0xbbbbbbbb] + mov bx,[fs:0xbbbbbbbb] + mov eax,[fs:0xbbbbbbbb] + mov ebx,[fs:0xbbbbbbbb] + mov rax,[fs:0xbbbbbbbb] + mov rbx,[fs:0xbbbbbbbb] + mov al,[fs:0xffffffffcccccccc] + mov bl,[fs:0xffffffffcccccccc] + mov ax,[fs:0xffffffffcccccccc] + mov bx,[fs:0xffffffffcccccccc] + mov eax,[fs:0xffffffffcccccccc] + mov ebx,[fs:0xffffffffcccccccc] + mov rax,[fs:0xffffffffcccccccc] + mov rbx,[fs:0xffffffffcccccccc] + + mov al,[dword fs:foo] + mov bl,[dword fs:foo] + mov ax,[dword fs:foo] + mov bx,[dword fs:foo] + mov eax,[dword fs:foo] + mov ebx,[dword fs:foo] + mov rax,[dword fs:foo] + mov rbx,[dword fs:foo] + mov al,[dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[dword fs:0xbbbbbbbb] + mov bl,[dword fs:0xbbbbbbbb] + mov ax,[dword fs:0xbbbbbbbb] + mov bx,[dword fs:0xbbbbbbbb] + mov eax,[dword fs:0xbbbbbbbb] + mov ebx,[dword fs:0xbbbbbbbb] + mov rax,[dword fs:0xbbbbbbbb] + mov rbx,[dword fs:0xbbbbbbbb] + mov al,[dword fs:0xffffffffcccccccc] + mov bl,[dword fs:0xffffffffcccccccc] + mov ax,[dword fs:0xffffffffcccccccc] + mov bx,[dword fs:0xffffffffcccccccc] + mov eax,[dword fs:0xffffffffcccccccc] + mov ebx,[dword fs:0xffffffffcccccccc] + mov rax,[dword fs:0xffffffffcccccccc] + mov rbx,[dword fs:0xffffffffcccccccc] + + mov al,[qword fs:foo] + mov bl,[qword fs:foo] + mov ax,[qword fs:foo] + mov bx,[qword fs:foo] + mov eax,[qword fs:foo] + mov ebx,[qword fs:foo] + mov rax,[qword fs:foo] + mov rbx,[qword fs:foo] + mov al,[qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[qword fs:0xbbbbbbbb] + mov bl,[qword fs:0xbbbbbbbb] + mov ax,[qword fs:0xbbbbbbbb] + mov bx,[qword fs:0xbbbbbbbb] + mov eax,[qword fs:0xbbbbbbbb] + mov ebx,[qword fs:0xbbbbbbbb] + mov rax,[qword fs:0xbbbbbbbb] + mov rbx,[qword fs:0xbbbbbbbb] + mov al,[qword fs:0xffffffffcccccccc] + mov bl,[qword fs:0xffffffffcccccccc] + mov ax,[qword fs:0xffffffffcccccccc] + mov bx,[qword fs:0xffffffffcccccccc] + mov eax,[qword fs:0xffffffffcccccccc] + mov ebx,[qword fs:0xffffffffcccccccc] + mov rax,[qword fs:0xffffffffcccccccc] + mov rbx,[qword fs:0xffffffffcccccccc] + + mov al,[a64 fs:foo] + mov bl,[a64 fs:foo] + mov ax,[a64 fs:foo] + mov bx,[a64 fs:foo] + mov eax,[a64 fs:foo] + mov ebx,[a64 fs:foo] + mov rax,[a64 fs:foo] + mov rbx,[a64 fs:foo] + mov al,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 fs:0xbbbbbbbb] + mov bl,[a64 fs:0xbbbbbbbb] + mov ax,[a64 fs:0xbbbbbbbb] + mov bx,[a64 fs:0xbbbbbbbb] + mov eax,[a64 fs:0xbbbbbbbb] + mov ebx,[a64 fs:0xbbbbbbbb] + mov rax,[a64 fs:0xbbbbbbbb] + mov rbx,[a64 fs:0xbbbbbbbb] + mov al,[a64 fs:0xffffffffcccccccc] + mov bl,[a64 fs:0xffffffffcccccccc] + mov ax,[a64 fs:0xffffffffcccccccc] + mov bx,[a64 fs:0xffffffffcccccccc] + mov eax,[a64 fs:0xffffffffcccccccc] + mov ebx,[a64 fs:0xffffffffcccccccc] + mov rax,[a64 fs:0xffffffffcccccccc] + mov rbx,[a64 fs:0xffffffffcccccccc] + + mov al,[a64 dword fs:foo] + mov bl,[a64 dword fs:foo] + mov ax,[a64 dword fs:foo] + mov bx,[a64 dword fs:foo] + mov eax,[a64 dword fs:foo] + mov ebx,[a64 dword fs:foo] + mov rax,[a64 dword fs:foo] + mov rbx,[a64 dword fs:foo] + mov al,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword fs:0xbbbbbbbb] + mov bl,[a64 dword fs:0xbbbbbbbb] + mov ax,[a64 dword fs:0xbbbbbbbb] + mov bx,[a64 dword fs:0xbbbbbbbb] + mov eax,[a64 dword fs:0xbbbbbbbb] + mov ebx,[a64 dword fs:0xbbbbbbbb] + mov rax,[a64 dword fs:0xbbbbbbbb] + mov rbx,[a64 dword fs:0xbbbbbbbb] + mov al,[a64 dword fs:0xffffffffcccccccc] + mov bl,[a64 dword fs:0xffffffffcccccccc] + mov ax,[a64 dword fs:0xffffffffcccccccc] + mov bx,[a64 dword fs:0xffffffffcccccccc] + mov eax,[a64 dword fs:0xffffffffcccccccc] + mov ebx,[a64 dword fs:0xffffffffcccccccc] + mov rax,[a64 dword fs:0xffffffffcccccccc] + mov rbx,[a64 dword fs:0xffffffffcccccccc] + + mov al,[a64 qword fs:foo] + mov bl,[a64 qword fs:foo] + mov ax,[a64 qword fs:foo] + mov bx,[a64 qword fs:foo] + mov eax,[a64 qword fs:foo] + mov ebx,[a64 qword fs:foo] + mov rax,[a64 qword fs:foo] + mov rbx,[a64 qword fs:foo] + mov al,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword fs:0xbbbbbbbb] + mov bl,[a64 qword fs:0xbbbbbbbb] + mov ax,[a64 qword fs:0xbbbbbbbb] + mov bx,[a64 qword fs:0xbbbbbbbb] + mov eax,[a64 qword fs:0xbbbbbbbb] + mov ebx,[a64 qword fs:0xbbbbbbbb] + mov rax,[a64 qword fs:0xbbbbbbbb] + mov rbx,[a64 qword fs:0xbbbbbbbb] + mov al,[a64 qword fs:0xffffffffcccccccc] + mov bl,[a64 qword fs:0xffffffffcccccccc] + mov ax,[a64 qword fs:0xffffffffcccccccc] + mov bx,[a64 qword fs:0xffffffffcccccccc] + mov eax,[a64 qword fs:0xffffffffcccccccc] + mov ebx,[a64 qword fs:0xffffffffcccccccc] + mov rax,[a64 qword fs:0xffffffffcccccccc] + mov rbx,[a64 qword fs:0xffffffffcccccccc] + + mov al,[a32 fs:foo] + mov bl,[a32 fs:foo] + mov ax,[a32 fs:foo] + mov bx,[a32 fs:foo] + mov eax,[a32 fs:foo] + mov ebx,[a32 fs:foo] + mov rax,[a32 fs:foo] + mov rbx,[a32 fs:foo] + mov al,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 fs:0xbbbbbbbb] + mov bl,[a32 fs:0xbbbbbbbb] + mov ax,[a32 fs:0xbbbbbbbb] + mov bx,[a32 fs:0xbbbbbbbb] + mov eax,[a32 fs:0xbbbbbbbb] + mov ebx,[a32 fs:0xbbbbbbbb] + mov rax,[a32 fs:0xbbbbbbbb] + mov rbx,[a32 fs:0xbbbbbbbb] + mov al,[a32 fs:0xffffffffcccccccc] + mov bl,[a32 fs:0xffffffffcccccccc] + mov ax,[a32 fs:0xffffffffcccccccc] + mov bx,[a32 fs:0xffffffffcccccccc] + mov eax,[a32 fs:0xffffffffcccccccc] + mov ebx,[a32 fs:0xffffffffcccccccc] + mov rax,[a32 fs:0xffffffffcccccccc] + mov rbx,[a32 fs:0xffffffffcccccccc] + + mov al,[a32 dword fs:foo] + mov bl,[a32 dword fs:foo] + mov ax,[a32 dword fs:foo] + mov bx,[a32 dword fs:foo] + mov eax,[a32 dword fs:foo] + mov ebx,[a32 dword fs:foo] + mov rax,[a32 dword fs:foo] + mov rbx,[a32 dword fs:foo] + mov al,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword fs:0xbbbbbbbb] + mov bl,[a32 dword fs:0xbbbbbbbb] + mov ax,[a32 dword fs:0xbbbbbbbb] + mov bx,[a32 dword fs:0xbbbbbbbb] + mov eax,[a32 dword fs:0xbbbbbbbb] + mov ebx,[a32 dword fs:0xbbbbbbbb] + mov rax,[a32 dword fs:0xbbbbbbbb] + mov rbx,[a32 dword fs:0xbbbbbbbb] + mov al,[a32 dword fs:0xffffffffcccccccc] + mov bl,[a32 dword fs:0xffffffffcccccccc] + mov ax,[a32 dword fs:0xffffffffcccccccc] + mov bx,[a32 dword fs:0xffffffffcccccccc] + mov eax,[a32 dword fs:0xffffffffcccccccc] + mov ebx,[a32 dword fs:0xffffffffcccccccc] + mov rax,[a32 dword fs:0xffffffffcccccccc] + mov rbx,[a32 dword fs:0xffffffffcccccccc] + + mov al,[a32 qword fs:foo] + mov bl,[a32 qword fs:foo] + mov ax,[a32 qword fs:foo] + mov bx,[a32 qword fs:foo] + mov eax,[a32 qword fs:foo] + mov ebx,[a32 qword fs:foo] + mov rax,[a32 qword fs:foo] + mov rbx,[a32 qword fs:foo] + mov al,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword fs:0xbbbbbbbb] + mov bl,[a32 qword fs:0xbbbbbbbb] + mov ax,[a32 qword fs:0xbbbbbbbb] + mov bx,[a32 qword fs:0xbbbbbbbb] + mov eax,[a32 qword fs:0xbbbbbbbb] + mov ebx,[a32 qword fs:0xbbbbbbbb] + mov rax,[a32 qword fs:0xbbbbbbbb] + mov rbx,[a32 qword fs:0xbbbbbbbb] + mov al,[a32 qword fs:0xffffffffcccccccc] + mov bl,[a32 qword fs:0xffffffffcccccccc] + mov ax,[a32 qword fs:0xffffffffcccccccc] + mov bx,[a32 qword fs:0xffffffffcccccccc] + mov eax,[a32 qword fs:0xffffffffcccccccc] + mov ebx,[a32 qword fs:0xffffffffcccccccc] + mov rax,[a32 qword fs:0xffffffffcccccccc] + mov rbx,[a32 qword fs:0xffffffffcccccccc] + + mov al,[abs fs:foo] + mov bl,[abs fs:foo] + mov ax,[abs fs:foo] + mov bx,[abs fs:foo] + mov eax,[abs fs:foo] + mov ebx,[abs fs:foo] + mov rax,[abs fs:foo] + mov rbx,[abs fs:foo] + mov al,[abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs fs:0xbbbbbbbb] + mov bl,[abs fs:0xbbbbbbbb] + mov ax,[abs fs:0xbbbbbbbb] + mov bx,[abs fs:0xbbbbbbbb] + mov eax,[abs fs:0xbbbbbbbb] + mov ebx,[abs fs:0xbbbbbbbb] + mov rax,[abs fs:0xbbbbbbbb] + mov rbx,[abs fs:0xbbbbbbbb] + mov al,[abs fs:0xffffffffcccccccc] + mov bl,[abs fs:0xffffffffcccccccc] + mov ax,[abs fs:0xffffffffcccccccc] + mov bx,[abs fs:0xffffffffcccccccc] + mov eax,[abs fs:0xffffffffcccccccc] + mov ebx,[abs fs:0xffffffffcccccccc] + mov rax,[abs fs:0xffffffffcccccccc] + mov rbx,[abs fs:0xffffffffcccccccc] + + mov al,[abs dword fs:foo] + mov bl,[abs dword fs:foo] + mov ax,[abs dword fs:foo] + mov bx,[abs dword fs:foo] + mov eax,[abs dword fs:foo] + mov ebx,[abs dword fs:foo] + mov rax,[abs dword fs:foo] + mov rbx,[abs dword fs:foo] + mov al,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs dword fs:0xbbbbbbbb] + mov bl,[abs dword fs:0xbbbbbbbb] + mov ax,[abs dword fs:0xbbbbbbbb] + mov bx,[abs dword fs:0xbbbbbbbb] + mov eax,[abs dword fs:0xbbbbbbbb] + mov ebx,[abs dword fs:0xbbbbbbbb] + mov rax,[abs dword fs:0xbbbbbbbb] + mov rbx,[abs dword fs:0xbbbbbbbb] + mov al,[abs dword fs:0xffffffffcccccccc] + mov bl,[abs dword fs:0xffffffffcccccccc] + mov ax,[abs dword fs:0xffffffffcccccccc] + mov bx,[abs dword fs:0xffffffffcccccccc] + mov eax,[abs dword fs:0xffffffffcccccccc] + mov ebx,[abs dword fs:0xffffffffcccccccc] + mov rax,[abs dword fs:0xffffffffcccccccc] + mov rbx,[abs dword fs:0xffffffffcccccccc] + + mov al,[abs qword fs:foo] + mov bl,[abs qword fs:foo] + mov ax,[abs qword fs:foo] + mov bx,[abs qword fs:foo] + mov eax,[abs qword fs:foo] + mov ebx,[abs qword fs:foo] + mov rax,[abs qword fs:foo] + mov rbx,[abs qword fs:foo] + mov al,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[abs qword fs:0xbbbbbbbb] + mov bl,[abs qword fs:0xbbbbbbbb] + mov ax,[abs qword fs:0xbbbbbbbb] + mov bx,[abs qword fs:0xbbbbbbbb] + mov eax,[abs qword fs:0xbbbbbbbb] + mov ebx,[abs qword fs:0xbbbbbbbb] + mov rax,[abs qword fs:0xbbbbbbbb] + mov rbx,[abs qword fs:0xbbbbbbbb] + mov al,[abs qword fs:0xffffffffcccccccc] + mov bl,[abs qword fs:0xffffffffcccccccc] + mov ax,[abs qword fs:0xffffffffcccccccc] + mov bx,[abs qword fs:0xffffffffcccccccc] + mov eax,[abs qword fs:0xffffffffcccccccc] + mov ebx,[abs qword fs:0xffffffffcccccccc] + mov rax,[abs qword fs:0xffffffffcccccccc] + mov rbx,[abs qword fs:0xffffffffcccccccc] + + mov al,[a64 abs fs:foo] + mov bl,[a64 abs fs:foo] + mov ax,[a64 abs fs:foo] + mov bx,[a64 abs fs:foo] + mov eax,[a64 abs fs:foo] + mov ebx,[a64 abs fs:foo] + mov rax,[a64 abs fs:foo] + mov rbx,[a64 abs fs:foo] + mov al,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs fs:0xbbbbbbbb] + mov bl,[a64 abs fs:0xbbbbbbbb] + mov ax,[a64 abs fs:0xbbbbbbbb] + mov bx,[a64 abs fs:0xbbbbbbbb] + mov eax,[a64 abs fs:0xbbbbbbbb] + mov ebx,[a64 abs fs:0xbbbbbbbb] + mov rax,[a64 abs fs:0xbbbbbbbb] + mov rbx,[a64 abs fs:0xbbbbbbbb] + mov al,[a64 abs fs:0xffffffffcccccccc] + mov bl,[a64 abs fs:0xffffffffcccccccc] + mov ax,[a64 abs fs:0xffffffffcccccccc] + mov bx,[a64 abs fs:0xffffffffcccccccc] + mov eax,[a64 abs fs:0xffffffffcccccccc] + mov ebx,[a64 abs fs:0xffffffffcccccccc] + mov rax,[a64 abs fs:0xffffffffcccccccc] + mov rbx,[a64 abs fs:0xffffffffcccccccc] + + mov al,[a64 abs dword fs:foo] + mov bl,[a64 abs dword fs:foo] + mov ax,[a64 abs dword fs:foo] + mov bx,[a64 abs dword fs:foo] + mov eax,[a64 abs dword fs:foo] + mov ebx,[a64 abs dword fs:foo] + mov rax,[a64 abs dword fs:foo] + mov rbx,[a64 abs dword fs:foo] + mov al,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword fs:0xbbbbbbbb] + mov bl,[a64 abs dword fs:0xbbbbbbbb] + mov ax,[a64 abs dword fs:0xbbbbbbbb] + mov bx,[a64 abs dword fs:0xbbbbbbbb] + mov eax,[a64 abs dword fs:0xbbbbbbbb] + mov ebx,[a64 abs dword fs:0xbbbbbbbb] + mov rax,[a64 abs dword fs:0xbbbbbbbb] + mov rbx,[a64 abs dword fs:0xbbbbbbbb] + mov al,[a64 abs dword fs:0xffffffffcccccccc] + mov bl,[a64 abs dword fs:0xffffffffcccccccc] + mov ax,[a64 abs dword fs:0xffffffffcccccccc] + mov bx,[a64 abs dword fs:0xffffffffcccccccc] + mov eax,[a64 abs dword fs:0xffffffffcccccccc] + mov ebx,[a64 abs dword fs:0xffffffffcccccccc] + mov rax,[a64 abs dword fs:0xffffffffcccccccc] + mov rbx,[a64 abs dword fs:0xffffffffcccccccc] + + mov al,[a64 abs qword fs:foo] + mov bl,[a64 abs qword fs:foo] + mov ax,[a64 abs qword fs:foo] + mov bx,[a64 abs qword fs:foo] + mov eax,[a64 abs qword fs:foo] + mov ebx,[a64 abs qword fs:foo] + mov rax,[a64 abs qword fs:foo] + mov rbx,[a64 abs qword fs:foo] + mov al,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword fs:0xbbbbbbbb] + mov bl,[a64 abs qword fs:0xbbbbbbbb] + mov ax,[a64 abs qword fs:0xbbbbbbbb] + mov bx,[a64 abs qword fs:0xbbbbbbbb] + mov eax,[a64 abs qword fs:0xbbbbbbbb] + mov ebx,[a64 abs qword fs:0xbbbbbbbb] + mov rax,[a64 abs qword fs:0xbbbbbbbb] + mov rbx,[a64 abs qword fs:0xbbbbbbbb] + mov al,[a64 abs qword fs:0xffffffffcccccccc] + mov bl,[a64 abs qword fs:0xffffffffcccccccc] + mov ax,[a64 abs qword fs:0xffffffffcccccccc] + mov bx,[a64 abs qword fs:0xffffffffcccccccc] + mov eax,[a64 abs qword fs:0xffffffffcccccccc] + mov ebx,[a64 abs qword fs:0xffffffffcccccccc] + mov rax,[a64 abs qword fs:0xffffffffcccccccc] + mov rbx,[a64 abs qword fs:0xffffffffcccccccc] + + mov al,[a32 abs fs:foo] + mov bl,[a32 abs fs:foo] + mov ax,[a32 abs fs:foo] + mov bx,[a32 abs fs:foo] + mov eax,[a32 abs fs:foo] + mov ebx,[a32 abs fs:foo] + mov rax,[a32 abs fs:foo] + mov rbx,[a32 abs fs:foo] + mov al,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs fs:0xbbbbbbbb] + mov bl,[a32 abs fs:0xbbbbbbbb] + mov ax,[a32 abs fs:0xbbbbbbbb] + mov bx,[a32 abs fs:0xbbbbbbbb] + mov eax,[a32 abs fs:0xbbbbbbbb] + mov ebx,[a32 abs fs:0xbbbbbbbb] + mov rax,[a32 abs fs:0xbbbbbbbb] + mov rbx,[a32 abs fs:0xbbbbbbbb] + mov al,[a32 abs fs:0xffffffffcccccccc] + mov bl,[a32 abs fs:0xffffffffcccccccc] + mov ax,[a32 abs fs:0xffffffffcccccccc] + mov bx,[a32 abs fs:0xffffffffcccccccc] + mov eax,[a32 abs fs:0xffffffffcccccccc] + mov ebx,[a32 abs fs:0xffffffffcccccccc] + mov rax,[a32 abs fs:0xffffffffcccccccc] + mov rbx,[a32 abs fs:0xffffffffcccccccc] + + mov al,[a32 abs dword fs:foo] + mov bl,[a32 abs dword fs:foo] + mov ax,[a32 abs dword fs:foo] + mov bx,[a32 abs dword fs:foo] + mov eax,[a32 abs dword fs:foo] + mov ebx,[a32 abs dword fs:foo] + mov rax,[a32 abs dword fs:foo] + mov rbx,[a32 abs dword fs:foo] + mov al,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword fs:0xbbbbbbbb] + mov bl,[a32 abs dword fs:0xbbbbbbbb] + mov ax,[a32 abs dword fs:0xbbbbbbbb] + mov bx,[a32 abs dword fs:0xbbbbbbbb] + mov eax,[a32 abs dword fs:0xbbbbbbbb] + mov ebx,[a32 abs dword fs:0xbbbbbbbb] + mov rax,[a32 abs dword fs:0xbbbbbbbb] + mov rbx,[a32 abs dword fs:0xbbbbbbbb] + mov al,[a32 abs dword fs:0xffffffffcccccccc] + mov bl,[a32 abs dword fs:0xffffffffcccccccc] + mov ax,[a32 abs dword fs:0xffffffffcccccccc] + mov bx,[a32 abs dword fs:0xffffffffcccccccc] + mov eax,[a32 abs dword fs:0xffffffffcccccccc] + mov ebx,[a32 abs dword fs:0xffffffffcccccccc] + mov rax,[a32 abs dword fs:0xffffffffcccccccc] + mov rbx,[a32 abs dword fs:0xffffffffcccccccc] + + mov al,[a32 abs qword fs:foo] + mov bl,[a32 abs qword fs:foo] + mov ax,[a32 abs qword fs:foo] + mov bx,[a32 abs qword fs:foo] + mov eax,[a32 abs qword fs:foo] + mov ebx,[a32 abs qword fs:foo] + mov rax,[a32 abs qword fs:foo] + mov rbx,[a32 abs qword fs:foo] + mov al,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword fs:0xbbbbbbbb] + mov bl,[a32 abs qword fs:0xbbbbbbbb] + mov ax,[a32 abs qword fs:0xbbbbbbbb] + mov bx,[a32 abs qword fs:0xbbbbbbbb] + mov eax,[a32 abs qword fs:0xbbbbbbbb] + mov ebx,[a32 abs qword fs:0xbbbbbbbb] + mov rax,[a32 abs qword fs:0xbbbbbbbb] + mov rbx,[a32 abs qword fs:0xbbbbbbbb] + mov al,[a32 abs qword fs:0xffffffffcccccccc] + mov bl,[a32 abs qword fs:0xffffffffcccccccc] + mov ax,[a32 abs qword fs:0xffffffffcccccccc] + mov bx,[a32 abs qword fs:0xffffffffcccccccc] + mov eax,[a32 abs qword fs:0xffffffffcccccccc] + mov ebx,[a32 abs qword fs:0xffffffffcccccccc] + mov rax,[a32 abs qword fs:0xffffffffcccccccc] + mov rbx,[a32 abs qword fs:0xffffffffcccccccc] + + mov al,[rel fs:foo] + mov bl,[rel fs:foo] + mov ax,[rel fs:foo] + mov bx,[rel fs:foo] + mov eax,[rel fs:foo] + mov ebx,[rel fs:foo] + mov rax,[rel fs:foo] + mov rbx,[rel fs:foo] + mov al,[rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel fs:0xbbbbbbbb] + mov bl,[rel fs:0xbbbbbbbb] + mov ax,[rel fs:0xbbbbbbbb] + mov bx,[rel fs:0xbbbbbbbb] + mov eax,[rel fs:0xbbbbbbbb] + mov ebx,[rel fs:0xbbbbbbbb] + mov rax,[rel fs:0xbbbbbbbb] + mov rbx,[rel fs:0xbbbbbbbb] + mov al,[rel fs:0xffffffffcccccccc] + mov bl,[rel fs:0xffffffffcccccccc] + mov ax,[rel fs:0xffffffffcccccccc] + mov bx,[rel fs:0xffffffffcccccccc] + mov eax,[rel fs:0xffffffffcccccccc] + mov ebx,[rel fs:0xffffffffcccccccc] + mov rax,[rel fs:0xffffffffcccccccc] + mov rbx,[rel fs:0xffffffffcccccccc] + + mov al,[rel dword fs:foo] + mov bl,[rel dword fs:foo] + mov ax,[rel dword fs:foo] + mov bx,[rel dword fs:foo] + mov eax,[rel dword fs:foo] + mov ebx,[rel dword fs:foo] + mov rax,[rel dword fs:foo] + mov rbx,[rel dword fs:foo] + mov al,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel dword fs:0xbbbbbbbb] + mov bl,[rel dword fs:0xbbbbbbbb] + mov ax,[rel dword fs:0xbbbbbbbb] + mov bx,[rel dword fs:0xbbbbbbbb] + mov eax,[rel dword fs:0xbbbbbbbb] + mov ebx,[rel dword fs:0xbbbbbbbb] + mov rax,[rel dword fs:0xbbbbbbbb] + mov rbx,[rel dword fs:0xbbbbbbbb] + mov al,[rel dword fs:0xffffffffcccccccc] + mov bl,[rel dword fs:0xffffffffcccccccc] + mov ax,[rel dword fs:0xffffffffcccccccc] + mov bx,[rel dword fs:0xffffffffcccccccc] + mov eax,[rel dword fs:0xffffffffcccccccc] + mov ebx,[rel dword fs:0xffffffffcccccccc] + mov rax,[rel dword fs:0xffffffffcccccccc] + mov rbx,[rel dword fs:0xffffffffcccccccc] + + mov al,[rel qword fs:foo] + mov bl,[rel qword fs:foo] + mov ax,[rel qword fs:foo] + mov bx,[rel qword fs:foo] + mov eax,[rel qword fs:foo] + mov ebx,[rel qword fs:foo] + mov rax,[rel qword fs:foo] + mov rbx,[rel qword fs:foo] + mov al,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[rel qword fs:0xbbbbbbbb] + mov bl,[rel qword fs:0xbbbbbbbb] + mov ax,[rel qword fs:0xbbbbbbbb] + mov bx,[rel qword fs:0xbbbbbbbb] + mov eax,[rel qword fs:0xbbbbbbbb] + mov ebx,[rel qword fs:0xbbbbbbbb] + mov rax,[rel qword fs:0xbbbbbbbb] + mov rbx,[rel qword fs:0xbbbbbbbb] + mov al,[rel qword fs:0xffffffffcccccccc] + mov bl,[rel qword fs:0xffffffffcccccccc] + mov ax,[rel qword fs:0xffffffffcccccccc] + mov bx,[rel qword fs:0xffffffffcccccccc] + mov eax,[rel qword fs:0xffffffffcccccccc] + mov ebx,[rel qword fs:0xffffffffcccccccc] + mov rax,[rel qword fs:0xffffffffcccccccc] + mov rbx,[rel qword fs:0xffffffffcccccccc] + + mov al,[a64 rel fs:foo] + mov bl,[a64 rel fs:foo] + mov ax,[a64 rel fs:foo] + mov bx,[a64 rel fs:foo] + mov eax,[a64 rel fs:foo] + mov ebx,[a64 rel fs:foo] + mov rax,[a64 rel fs:foo] + mov rbx,[a64 rel fs:foo] + mov al,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel fs:0xbbbbbbbb] + mov bl,[a64 rel fs:0xbbbbbbbb] + mov ax,[a64 rel fs:0xbbbbbbbb] + mov bx,[a64 rel fs:0xbbbbbbbb] + mov eax,[a64 rel fs:0xbbbbbbbb] + mov ebx,[a64 rel fs:0xbbbbbbbb] + mov rax,[a64 rel fs:0xbbbbbbbb] + mov rbx,[a64 rel fs:0xbbbbbbbb] + mov al,[a64 rel fs:0xffffffffcccccccc] + mov bl,[a64 rel fs:0xffffffffcccccccc] + mov ax,[a64 rel fs:0xffffffffcccccccc] + mov bx,[a64 rel fs:0xffffffffcccccccc] + mov eax,[a64 rel fs:0xffffffffcccccccc] + mov ebx,[a64 rel fs:0xffffffffcccccccc] + mov rax,[a64 rel fs:0xffffffffcccccccc] + mov rbx,[a64 rel fs:0xffffffffcccccccc] + + mov al,[a64 rel dword fs:foo] + mov bl,[a64 rel dword fs:foo] + mov ax,[a64 rel dword fs:foo] + mov bx,[a64 rel dword fs:foo] + mov eax,[a64 rel dword fs:foo] + mov ebx,[a64 rel dword fs:foo] + mov rax,[a64 rel dword fs:foo] + mov rbx,[a64 rel dword fs:foo] + mov al,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword fs:0xbbbbbbbb] + mov bl,[a64 rel dword fs:0xbbbbbbbb] + mov ax,[a64 rel dword fs:0xbbbbbbbb] + mov bx,[a64 rel dword fs:0xbbbbbbbb] + mov eax,[a64 rel dword fs:0xbbbbbbbb] + mov ebx,[a64 rel dword fs:0xbbbbbbbb] + mov rax,[a64 rel dword fs:0xbbbbbbbb] + mov rbx,[a64 rel dword fs:0xbbbbbbbb] + mov al,[a64 rel dword fs:0xffffffffcccccccc] + mov bl,[a64 rel dword fs:0xffffffffcccccccc] + mov ax,[a64 rel dword fs:0xffffffffcccccccc] + mov bx,[a64 rel dword fs:0xffffffffcccccccc] + mov eax,[a64 rel dword fs:0xffffffffcccccccc] + mov ebx,[a64 rel dword fs:0xffffffffcccccccc] + mov rax,[a64 rel dword fs:0xffffffffcccccccc] + mov rbx,[a64 rel dword fs:0xffffffffcccccccc] + + mov al,[a64 rel qword fs:foo] + mov bl,[a64 rel qword fs:foo] + mov ax,[a64 rel qword fs:foo] + mov bx,[a64 rel qword fs:foo] + mov eax,[a64 rel qword fs:foo] + mov ebx,[a64 rel qword fs:foo] + mov rax,[a64 rel qword fs:foo] + mov rbx,[a64 rel qword fs:foo] + mov al,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword fs:0xbbbbbbbb] + mov bl,[a64 rel qword fs:0xbbbbbbbb] + mov ax,[a64 rel qword fs:0xbbbbbbbb] + mov bx,[a64 rel qword fs:0xbbbbbbbb] + mov eax,[a64 rel qword fs:0xbbbbbbbb] + mov ebx,[a64 rel qword fs:0xbbbbbbbb] + mov rax,[a64 rel qword fs:0xbbbbbbbb] + mov rbx,[a64 rel qword fs:0xbbbbbbbb] + mov al,[a64 rel qword fs:0xffffffffcccccccc] + mov bl,[a64 rel qword fs:0xffffffffcccccccc] + mov ax,[a64 rel qword fs:0xffffffffcccccccc] + mov bx,[a64 rel qword fs:0xffffffffcccccccc] + mov eax,[a64 rel qword fs:0xffffffffcccccccc] + mov ebx,[a64 rel qword fs:0xffffffffcccccccc] + mov rax,[a64 rel qword fs:0xffffffffcccccccc] + mov rbx,[a64 rel qword fs:0xffffffffcccccccc] + + mov al,[a32 rel fs:foo] + mov bl,[a32 rel fs:foo] + mov ax,[a32 rel fs:foo] + mov bx,[a32 rel fs:foo] + mov eax,[a32 rel fs:foo] + mov ebx,[a32 rel fs:foo] + mov rax,[a32 rel fs:foo] + mov rbx,[a32 rel fs:foo] + mov al,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel fs:0xbbbbbbbb] + mov bl,[a32 rel fs:0xbbbbbbbb] + mov ax,[a32 rel fs:0xbbbbbbbb] + mov bx,[a32 rel fs:0xbbbbbbbb] + mov eax,[a32 rel fs:0xbbbbbbbb] + mov ebx,[a32 rel fs:0xbbbbbbbb] + mov rax,[a32 rel fs:0xbbbbbbbb] + mov rbx,[a32 rel fs:0xbbbbbbbb] + mov al,[a32 rel fs:0xffffffffcccccccc] + mov bl,[a32 rel fs:0xffffffffcccccccc] + mov ax,[a32 rel fs:0xffffffffcccccccc] + mov bx,[a32 rel fs:0xffffffffcccccccc] + mov eax,[a32 rel fs:0xffffffffcccccccc] + mov ebx,[a32 rel fs:0xffffffffcccccccc] + mov rax,[a32 rel fs:0xffffffffcccccccc] + mov rbx,[a32 rel fs:0xffffffffcccccccc] + + mov al,[a32 rel dword fs:foo] + mov bl,[a32 rel dword fs:foo] + mov ax,[a32 rel dword fs:foo] + mov bx,[a32 rel dword fs:foo] + mov eax,[a32 rel dword fs:foo] + mov ebx,[a32 rel dword fs:foo] + mov rax,[a32 rel dword fs:foo] + mov rbx,[a32 rel dword fs:foo] + mov al,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword fs:0xbbbbbbbb] + mov bl,[a32 rel dword fs:0xbbbbbbbb] + mov ax,[a32 rel dword fs:0xbbbbbbbb] + mov bx,[a32 rel dword fs:0xbbbbbbbb] + mov eax,[a32 rel dword fs:0xbbbbbbbb] + mov ebx,[a32 rel dword fs:0xbbbbbbbb] + mov rax,[a32 rel dword fs:0xbbbbbbbb] + mov rbx,[a32 rel dword fs:0xbbbbbbbb] + mov al,[a32 rel dword fs:0xffffffffcccccccc] + mov bl,[a32 rel dword fs:0xffffffffcccccccc] + mov ax,[a32 rel dword fs:0xffffffffcccccccc] + mov bx,[a32 rel dword fs:0xffffffffcccccccc] + mov eax,[a32 rel dword fs:0xffffffffcccccccc] + mov ebx,[a32 rel dword fs:0xffffffffcccccccc] + mov rax,[a32 rel dword fs:0xffffffffcccccccc] + mov rbx,[a32 rel dword fs:0xffffffffcccccccc] + + mov al,[a32 rel qword fs:foo] + mov bl,[a32 rel qword fs:foo] + mov ax,[a32 rel qword fs:foo] + mov bx,[a32 rel qword fs:foo] + mov eax,[a32 rel qword fs:foo] + mov ebx,[a32 rel qword fs:foo] + mov rax,[a32 rel qword fs:foo] + mov rbx,[a32 rel qword fs:foo] + mov al,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword fs:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword fs:0xbbbbbbbb] + mov bl,[a32 rel qword fs:0xbbbbbbbb] + mov ax,[a32 rel qword fs:0xbbbbbbbb] + mov bx,[a32 rel qword fs:0xbbbbbbbb] + mov eax,[a32 rel qword fs:0xbbbbbbbb] + mov ebx,[a32 rel qword fs:0xbbbbbbbb] + mov rax,[a32 rel qword fs:0xbbbbbbbb] + mov rbx,[a32 rel qword fs:0xbbbbbbbb] + mov al,[a32 rel qword fs:0xffffffffcccccccc] + mov bl,[a32 rel qword fs:0xffffffffcccccccc] + mov ax,[a32 rel qword fs:0xffffffffcccccccc] + mov bx,[a32 rel qword fs:0xffffffffcccccccc] + mov eax,[a32 rel qword fs:0xffffffffcccccccc] + mov ebx,[a32 rel qword fs:0xffffffffcccccccc] + mov rax,[a32 rel qword fs:0xffffffffcccccccc] + mov rbx,[a32 rel qword fs:0xffffffffcccccccc] + + mov al,[es:foo] + mov bl,[es:foo] + mov ax,[es:foo] + mov bx,[es:foo] + mov eax,[es:foo] + mov ebx,[es:foo] + mov rax,[es:foo] + mov rbx,[es:foo] + mov al,[es:0xaaaaaaaaaaaaaaaa] + mov bl,[es:0xaaaaaaaaaaaaaaaa] + mov ax,[es:0xaaaaaaaaaaaaaaaa] + mov bx,[es:0xaaaaaaaaaaaaaaaa] + mov eax,[es:0xaaaaaaaaaaaaaaaa] + mov ebx,[es:0xaaaaaaaaaaaaaaaa] + mov rax,[es:0xaaaaaaaaaaaaaaaa] + mov rbx,[es:0xaaaaaaaaaaaaaaaa] + mov al,[es:0xbbbbbbbb] + mov bl,[es:0xbbbbbbbb] + mov ax,[es:0xbbbbbbbb] + mov bx,[es:0xbbbbbbbb] + mov eax,[es:0xbbbbbbbb] + mov ebx,[es:0xbbbbbbbb] + mov rax,[es:0xbbbbbbbb] + mov rbx,[es:0xbbbbbbbb] + mov al,[es:0xffffffffcccccccc] + mov bl,[es:0xffffffffcccccccc] + mov ax,[es:0xffffffffcccccccc] + mov bx,[es:0xffffffffcccccccc] + mov eax,[es:0xffffffffcccccccc] + mov ebx,[es:0xffffffffcccccccc] + mov rax,[es:0xffffffffcccccccc] + mov rbx,[es:0xffffffffcccccccc] + + mov al,[dword es:foo] + mov bl,[dword es:foo] + mov ax,[dword es:foo] + mov bx,[dword es:foo] + mov eax,[dword es:foo] + mov ebx,[dword es:foo] + mov rax,[dword es:foo] + mov rbx,[dword es:foo] + mov al,[dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[dword es:0xaaaaaaaaaaaaaaaa] + mov al,[dword es:0xbbbbbbbb] + mov bl,[dword es:0xbbbbbbbb] + mov ax,[dword es:0xbbbbbbbb] + mov bx,[dword es:0xbbbbbbbb] + mov eax,[dword es:0xbbbbbbbb] + mov ebx,[dword es:0xbbbbbbbb] + mov rax,[dword es:0xbbbbbbbb] + mov rbx,[dword es:0xbbbbbbbb] + mov al,[dword es:0xffffffffcccccccc] + mov bl,[dword es:0xffffffffcccccccc] + mov ax,[dword es:0xffffffffcccccccc] + mov bx,[dword es:0xffffffffcccccccc] + mov eax,[dword es:0xffffffffcccccccc] + mov ebx,[dword es:0xffffffffcccccccc] + mov rax,[dword es:0xffffffffcccccccc] + mov rbx,[dword es:0xffffffffcccccccc] + + mov al,[qword es:foo] + mov bl,[qword es:foo] + mov ax,[qword es:foo] + mov bx,[qword es:foo] + mov eax,[qword es:foo] + mov ebx,[qword es:foo] + mov rax,[qword es:foo] + mov rbx,[qword es:foo] + mov al,[qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[qword es:0xaaaaaaaaaaaaaaaa] + mov al,[qword es:0xbbbbbbbb] + mov bl,[qword es:0xbbbbbbbb] + mov ax,[qword es:0xbbbbbbbb] + mov bx,[qword es:0xbbbbbbbb] + mov eax,[qword es:0xbbbbbbbb] + mov ebx,[qword es:0xbbbbbbbb] + mov rax,[qword es:0xbbbbbbbb] + mov rbx,[qword es:0xbbbbbbbb] + mov al,[qword es:0xffffffffcccccccc] + mov bl,[qword es:0xffffffffcccccccc] + mov ax,[qword es:0xffffffffcccccccc] + mov bx,[qword es:0xffffffffcccccccc] + mov eax,[qword es:0xffffffffcccccccc] + mov ebx,[qword es:0xffffffffcccccccc] + mov rax,[qword es:0xffffffffcccccccc] + mov rbx,[qword es:0xffffffffcccccccc] + + mov al,[a64 es:foo] + mov bl,[a64 es:foo] + mov ax,[a64 es:foo] + mov bx,[a64 es:foo] + mov eax,[a64 es:foo] + mov ebx,[a64 es:foo] + mov rax,[a64 es:foo] + mov rbx,[a64 es:foo] + mov al,[a64 es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 es:0xbbbbbbbb] + mov bl,[a64 es:0xbbbbbbbb] + mov ax,[a64 es:0xbbbbbbbb] + mov bx,[a64 es:0xbbbbbbbb] + mov eax,[a64 es:0xbbbbbbbb] + mov ebx,[a64 es:0xbbbbbbbb] + mov rax,[a64 es:0xbbbbbbbb] + mov rbx,[a64 es:0xbbbbbbbb] + mov al,[a64 es:0xffffffffcccccccc] + mov bl,[a64 es:0xffffffffcccccccc] + mov ax,[a64 es:0xffffffffcccccccc] + mov bx,[a64 es:0xffffffffcccccccc] + mov eax,[a64 es:0xffffffffcccccccc] + mov ebx,[a64 es:0xffffffffcccccccc] + mov rax,[a64 es:0xffffffffcccccccc] + mov rbx,[a64 es:0xffffffffcccccccc] + + mov al,[a64 dword es:foo] + mov bl,[a64 dword es:foo] + mov ax,[a64 dword es:foo] + mov bx,[a64 dword es:foo] + mov eax,[a64 dword es:foo] + mov ebx,[a64 dword es:foo] + mov rax,[a64 dword es:foo] + mov rbx,[a64 dword es:foo] + mov al,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 dword es:0xbbbbbbbb] + mov bl,[a64 dword es:0xbbbbbbbb] + mov ax,[a64 dword es:0xbbbbbbbb] + mov bx,[a64 dword es:0xbbbbbbbb] + mov eax,[a64 dword es:0xbbbbbbbb] + mov ebx,[a64 dword es:0xbbbbbbbb] + mov rax,[a64 dword es:0xbbbbbbbb] + mov rbx,[a64 dword es:0xbbbbbbbb] + mov al,[a64 dword es:0xffffffffcccccccc] + mov bl,[a64 dword es:0xffffffffcccccccc] + mov ax,[a64 dword es:0xffffffffcccccccc] + mov bx,[a64 dword es:0xffffffffcccccccc] + mov eax,[a64 dword es:0xffffffffcccccccc] + mov ebx,[a64 dword es:0xffffffffcccccccc] + mov rax,[a64 dword es:0xffffffffcccccccc] + mov rbx,[a64 dword es:0xffffffffcccccccc] + + mov al,[a64 qword es:foo] + mov bl,[a64 qword es:foo] + mov ax,[a64 qword es:foo] + mov bx,[a64 qword es:foo] + mov eax,[a64 qword es:foo] + mov ebx,[a64 qword es:foo] + mov rax,[a64 qword es:foo] + mov rbx,[a64 qword es:foo] + mov al,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 qword es:0xbbbbbbbb] + mov bl,[a64 qword es:0xbbbbbbbb] + mov ax,[a64 qword es:0xbbbbbbbb] + mov bx,[a64 qword es:0xbbbbbbbb] + mov eax,[a64 qword es:0xbbbbbbbb] + mov ebx,[a64 qword es:0xbbbbbbbb] + mov rax,[a64 qword es:0xbbbbbbbb] + mov rbx,[a64 qword es:0xbbbbbbbb] + mov al,[a64 qword es:0xffffffffcccccccc] + mov bl,[a64 qword es:0xffffffffcccccccc] + mov ax,[a64 qword es:0xffffffffcccccccc] + mov bx,[a64 qword es:0xffffffffcccccccc] + mov eax,[a64 qword es:0xffffffffcccccccc] + mov ebx,[a64 qword es:0xffffffffcccccccc] + mov rax,[a64 qword es:0xffffffffcccccccc] + mov rbx,[a64 qword es:0xffffffffcccccccc] + + mov al,[a32 es:foo] + mov bl,[a32 es:foo] + mov ax,[a32 es:foo] + mov bx,[a32 es:foo] + mov eax,[a32 es:foo] + mov ebx,[a32 es:foo] + mov rax,[a32 es:foo] + mov rbx,[a32 es:foo] + mov al,[a32 es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 es:0xbbbbbbbb] + mov bl,[a32 es:0xbbbbbbbb] + mov ax,[a32 es:0xbbbbbbbb] + mov bx,[a32 es:0xbbbbbbbb] + mov eax,[a32 es:0xbbbbbbbb] + mov ebx,[a32 es:0xbbbbbbbb] + mov rax,[a32 es:0xbbbbbbbb] + mov rbx,[a32 es:0xbbbbbbbb] + mov al,[a32 es:0xffffffffcccccccc] + mov bl,[a32 es:0xffffffffcccccccc] + mov ax,[a32 es:0xffffffffcccccccc] + mov bx,[a32 es:0xffffffffcccccccc] + mov eax,[a32 es:0xffffffffcccccccc] + mov ebx,[a32 es:0xffffffffcccccccc] + mov rax,[a32 es:0xffffffffcccccccc] + mov rbx,[a32 es:0xffffffffcccccccc] + + mov al,[a32 dword es:foo] + mov bl,[a32 dword es:foo] + mov ax,[a32 dword es:foo] + mov bx,[a32 dword es:foo] + mov eax,[a32 dword es:foo] + mov ebx,[a32 dword es:foo] + mov rax,[a32 dword es:foo] + mov rbx,[a32 dword es:foo] + mov al,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 dword es:0xbbbbbbbb] + mov bl,[a32 dword es:0xbbbbbbbb] + mov ax,[a32 dword es:0xbbbbbbbb] + mov bx,[a32 dword es:0xbbbbbbbb] + mov eax,[a32 dword es:0xbbbbbbbb] + mov ebx,[a32 dword es:0xbbbbbbbb] + mov rax,[a32 dword es:0xbbbbbbbb] + mov rbx,[a32 dword es:0xbbbbbbbb] + mov al,[a32 dword es:0xffffffffcccccccc] + mov bl,[a32 dword es:0xffffffffcccccccc] + mov ax,[a32 dword es:0xffffffffcccccccc] + mov bx,[a32 dword es:0xffffffffcccccccc] + mov eax,[a32 dword es:0xffffffffcccccccc] + mov ebx,[a32 dword es:0xffffffffcccccccc] + mov rax,[a32 dword es:0xffffffffcccccccc] + mov rbx,[a32 dword es:0xffffffffcccccccc] + + mov al,[a32 qword es:foo] + mov bl,[a32 qword es:foo] + mov ax,[a32 qword es:foo] + mov bx,[a32 qword es:foo] + mov eax,[a32 qword es:foo] + mov ebx,[a32 qword es:foo] + mov rax,[a32 qword es:foo] + mov rbx,[a32 qword es:foo] + mov al,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 qword es:0xbbbbbbbb] + mov bl,[a32 qword es:0xbbbbbbbb] + mov ax,[a32 qword es:0xbbbbbbbb] + mov bx,[a32 qword es:0xbbbbbbbb] + mov eax,[a32 qword es:0xbbbbbbbb] + mov ebx,[a32 qword es:0xbbbbbbbb] + mov rax,[a32 qword es:0xbbbbbbbb] + mov rbx,[a32 qword es:0xbbbbbbbb] + mov al,[a32 qword es:0xffffffffcccccccc] + mov bl,[a32 qword es:0xffffffffcccccccc] + mov ax,[a32 qword es:0xffffffffcccccccc] + mov bx,[a32 qword es:0xffffffffcccccccc] + mov eax,[a32 qword es:0xffffffffcccccccc] + mov ebx,[a32 qword es:0xffffffffcccccccc] + mov rax,[a32 qword es:0xffffffffcccccccc] + mov rbx,[a32 qword es:0xffffffffcccccccc] + + mov al,[abs es:foo] + mov bl,[abs es:foo] + mov ax,[abs es:foo] + mov bx,[abs es:foo] + mov eax,[abs es:foo] + mov ebx,[abs es:foo] + mov rax,[abs es:foo] + mov rbx,[abs es:foo] + mov al,[abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs es:0xaaaaaaaaaaaaaaaa] + mov al,[abs es:0xbbbbbbbb] + mov bl,[abs es:0xbbbbbbbb] + mov ax,[abs es:0xbbbbbbbb] + mov bx,[abs es:0xbbbbbbbb] + mov eax,[abs es:0xbbbbbbbb] + mov ebx,[abs es:0xbbbbbbbb] + mov rax,[abs es:0xbbbbbbbb] + mov rbx,[abs es:0xbbbbbbbb] + mov al,[abs es:0xffffffffcccccccc] + mov bl,[abs es:0xffffffffcccccccc] + mov ax,[abs es:0xffffffffcccccccc] + mov bx,[abs es:0xffffffffcccccccc] + mov eax,[abs es:0xffffffffcccccccc] + mov ebx,[abs es:0xffffffffcccccccc] + mov rax,[abs es:0xffffffffcccccccc] + mov rbx,[abs es:0xffffffffcccccccc] + + mov al,[abs dword es:foo] + mov bl,[abs dword es:foo] + mov ax,[abs dword es:foo] + mov bx,[abs dword es:foo] + mov eax,[abs dword es:foo] + mov ebx,[abs dword es:foo] + mov rax,[abs dword es:foo] + mov rbx,[abs dword es:foo] + mov al,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[abs dword es:0xbbbbbbbb] + mov bl,[abs dword es:0xbbbbbbbb] + mov ax,[abs dword es:0xbbbbbbbb] + mov bx,[abs dword es:0xbbbbbbbb] + mov eax,[abs dword es:0xbbbbbbbb] + mov ebx,[abs dword es:0xbbbbbbbb] + mov rax,[abs dword es:0xbbbbbbbb] + mov rbx,[abs dword es:0xbbbbbbbb] + mov al,[abs dword es:0xffffffffcccccccc] + mov bl,[abs dword es:0xffffffffcccccccc] + mov ax,[abs dword es:0xffffffffcccccccc] + mov bx,[abs dword es:0xffffffffcccccccc] + mov eax,[abs dword es:0xffffffffcccccccc] + mov ebx,[abs dword es:0xffffffffcccccccc] + mov rax,[abs dword es:0xffffffffcccccccc] + mov rbx,[abs dword es:0xffffffffcccccccc] + + mov al,[abs qword es:foo] + mov bl,[abs qword es:foo] + mov ax,[abs qword es:foo] + mov bx,[abs qword es:foo] + mov eax,[abs qword es:foo] + mov ebx,[abs qword es:foo] + mov rax,[abs qword es:foo] + mov rbx,[abs qword es:foo] + mov al,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[abs qword es:0xbbbbbbbb] + mov bl,[abs qword es:0xbbbbbbbb] + mov ax,[abs qword es:0xbbbbbbbb] + mov bx,[abs qword es:0xbbbbbbbb] + mov eax,[abs qword es:0xbbbbbbbb] + mov ebx,[abs qword es:0xbbbbbbbb] + mov rax,[abs qword es:0xbbbbbbbb] + mov rbx,[abs qword es:0xbbbbbbbb] + mov al,[abs qword es:0xffffffffcccccccc] + mov bl,[abs qword es:0xffffffffcccccccc] + mov ax,[abs qword es:0xffffffffcccccccc] + mov bx,[abs qword es:0xffffffffcccccccc] + mov eax,[abs qword es:0xffffffffcccccccc] + mov ebx,[abs qword es:0xffffffffcccccccc] + mov rax,[abs qword es:0xffffffffcccccccc] + mov rbx,[abs qword es:0xffffffffcccccccc] + + mov al,[a64 abs es:foo] + mov bl,[a64 abs es:foo] + mov ax,[a64 abs es:foo] + mov bx,[a64 abs es:foo] + mov eax,[a64 abs es:foo] + mov ebx,[a64 abs es:foo] + mov rax,[a64 abs es:foo] + mov rbx,[a64 abs es:foo] + mov al,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs es:0xbbbbbbbb] + mov bl,[a64 abs es:0xbbbbbbbb] + mov ax,[a64 abs es:0xbbbbbbbb] + mov bx,[a64 abs es:0xbbbbbbbb] + mov eax,[a64 abs es:0xbbbbbbbb] + mov ebx,[a64 abs es:0xbbbbbbbb] + mov rax,[a64 abs es:0xbbbbbbbb] + mov rbx,[a64 abs es:0xbbbbbbbb] + mov al,[a64 abs es:0xffffffffcccccccc] + mov bl,[a64 abs es:0xffffffffcccccccc] + mov ax,[a64 abs es:0xffffffffcccccccc] + mov bx,[a64 abs es:0xffffffffcccccccc] + mov eax,[a64 abs es:0xffffffffcccccccc] + mov ebx,[a64 abs es:0xffffffffcccccccc] + mov rax,[a64 abs es:0xffffffffcccccccc] + mov rbx,[a64 abs es:0xffffffffcccccccc] + + mov al,[a64 abs dword es:foo] + mov bl,[a64 abs dword es:foo] + mov ax,[a64 abs dword es:foo] + mov bx,[a64 abs dword es:foo] + mov eax,[a64 abs dword es:foo] + mov ebx,[a64 abs dword es:foo] + mov rax,[a64 abs dword es:foo] + mov rbx,[a64 abs dword es:foo] + mov al,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs dword es:0xbbbbbbbb] + mov bl,[a64 abs dword es:0xbbbbbbbb] + mov ax,[a64 abs dword es:0xbbbbbbbb] + mov bx,[a64 abs dword es:0xbbbbbbbb] + mov eax,[a64 abs dword es:0xbbbbbbbb] + mov ebx,[a64 abs dword es:0xbbbbbbbb] + mov rax,[a64 abs dword es:0xbbbbbbbb] + mov rbx,[a64 abs dword es:0xbbbbbbbb] + mov al,[a64 abs dword es:0xffffffffcccccccc] + mov bl,[a64 abs dword es:0xffffffffcccccccc] + mov ax,[a64 abs dword es:0xffffffffcccccccc] + mov bx,[a64 abs dword es:0xffffffffcccccccc] + mov eax,[a64 abs dword es:0xffffffffcccccccc] + mov ebx,[a64 abs dword es:0xffffffffcccccccc] + mov rax,[a64 abs dword es:0xffffffffcccccccc] + mov rbx,[a64 abs dword es:0xffffffffcccccccc] + + mov al,[a64 abs qword es:foo] + mov bl,[a64 abs qword es:foo] + mov ax,[a64 abs qword es:foo] + mov bx,[a64 abs qword es:foo] + mov eax,[a64 abs qword es:foo] + mov ebx,[a64 abs qword es:foo] + mov rax,[a64 abs qword es:foo] + mov rbx,[a64 abs qword es:foo] + mov al,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 abs qword es:0xbbbbbbbb] + mov bl,[a64 abs qword es:0xbbbbbbbb] + mov ax,[a64 abs qword es:0xbbbbbbbb] + mov bx,[a64 abs qword es:0xbbbbbbbb] + mov eax,[a64 abs qword es:0xbbbbbbbb] + mov ebx,[a64 abs qword es:0xbbbbbbbb] + mov rax,[a64 abs qword es:0xbbbbbbbb] + mov rbx,[a64 abs qword es:0xbbbbbbbb] + mov al,[a64 abs qword es:0xffffffffcccccccc] + mov bl,[a64 abs qword es:0xffffffffcccccccc] + mov ax,[a64 abs qword es:0xffffffffcccccccc] + mov bx,[a64 abs qword es:0xffffffffcccccccc] + mov eax,[a64 abs qword es:0xffffffffcccccccc] + mov ebx,[a64 abs qword es:0xffffffffcccccccc] + mov rax,[a64 abs qword es:0xffffffffcccccccc] + mov rbx,[a64 abs qword es:0xffffffffcccccccc] + + mov al,[a32 abs es:foo] + mov bl,[a32 abs es:foo] + mov ax,[a32 abs es:foo] + mov bx,[a32 abs es:foo] + mov eax,[a32 abs es:foo] + mov ebx,[a32 abs es:foo] + mov rax,[a32 abs es:foo] + mov rbx,[a32 abs es:foo] + mov al,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs es:0xbbbbbbbb] + mov bl,[a32 abs es:0xbbbbbbbb] + mov ax,[a32 abs es:0xbbbbbbbb] + mov bx,[a32 abs es:0xbbbbbbbb] + mov eax,[a32 abs es:0xbbbbbbbb] + mov ebx,[a32 abs es:0xbbbbbbbb] + mov rax,[a32 abs es:0xbbbbbbbb] + mov rbx,[a32 abs es:0xbbbbbbbb] + mov al,[a32 abs es:0xffffffffcccccccc] + mov bl,[a32 abs es:0xffffffffcccccccc] + mov ax,[a32 abs es:0xffffffffcccccccc] + mov bx,[a32 abs es:0xffffffffcccccccc] + mov eax,[a32 abs es:0xffffffffcccccccc] + mov ebx,[a32 abs es:0xffffffffcccccccc] + mov rax,[a32 abs es:0xffffffffcccccccc] + mov rbx,[a32 abs es:0xffffffffcccccccc] + + mov al,[a32 abs dword es:foo] + mov bl,[a32 abs dword es:foo] + mov ax,[a32 abs dword es:foo] + mov bx,[a32 abs dword es:foo] + mov eax,[a32 abs dword es:foo] + mov ebx,[a32 abs dword es:foo] + mov rax,[a32 abs dword es:foo] + mov rbx,[a32 abs dword es:foo] + mov al,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs dword es:0xbbbbbbbb] + mov bl,[a32 abs dword es:0xbbbbbbbb] + mov ax,[a32 abs dword es:0xbbbbbbbb] + mov bx,[a32 abs dword es:0xbbbbbbbb] + mov eax,[a32 abs dword es:0xbbbbbbbb] + mov ebx,[a32 abs dword es:0xbbbbbbbb] + mov rax,[a32 abs dword es:0xbbbbbbbb] + mov rbx,[a32 abs dword es:0xbbbbbbbb] + mov al,[a32 abs dword es:0xffffffffcccccccc] + mov bl,[a32 abs dword es:0xffffffffcccccccc] + mov ax,[a32 abs dword es:0xffffffffcccccccc] + mov bx,[a32 abs dword es:0xffffffffcccccccc] + mov eax,[a32 abs dword es:0xffffffffcccccccc] + mov ebx,[a32 abs dword es:0xffffffffcccccccc] + mov rax,[a32 abs dword es:0xffffffffcccccccc] + mov rbx,[a32 abs dword es:0xffffffffcccccccc] + + mov al,[a32 abs qword es:foo] + mov bl,[a32 abs qword es:foo] + mov ax,[a32 abs qword es:foo] + mov bx,[a32 abs qword es:foo] + mov eax,[a32 abs qword es:foo] + mov ebx,[a32 abs qword es:foo] + mov rax,[a32 abs qword es:foo] + mov rbx,[a32 abs qword es:foo] + mov al,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 abs qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 abs qword es:0xbbbbbbbb] + mov bl,[a32 abs qword es:0xbbbbbbbb] + mov ax,[a32 abs qword es:0xbbbbbbbb] + mov bx,[a32 abs qword es:0xbbbbbbbb] + mov eax,[a32 abs qword es:0xbbbbbbbb] + mov ebx,[a32 abs qword es:0xbbbbbbbb] + mov rax,[a32 abs qword es:0xbbbbbbbb] + mov rbx,[a32 abs qword es:0xbbbbbbbb] + mov al,[a32 abs qword es:0xffffffffcccccccc] + mov bl,[a32 abs qword es:0xffffffffcccccccc] + mov ax,[a32 abs qword es:0xffffffffcccccccc] + mov bx,[a32 abs qword es:0xffffffffcccccccc] + mov eax,[a32 abs qword es:0xffffffffcccccccc] + mov ebx,[a32 abs qword es:0xffffffffcccccccc] + mov rax,[a32 abs qword es:0xffffffffcccccccc] + mov rbx,[a32 abs qword es:0xffffffffcccccccc] + + mov al,[rel es:foo] + mov bl,[rel es:foo] + mov ax,[rel es:foo] + mov bx,[rel es:foo] + mov eax,[rel es:foo] + mov ebx,[rel es:foo] + mov rax,[rel es:foo] + mov rbx,[rel es:foo] + mov al,[rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel es:0xaaaaaaaaaaaaaaaa] + mov al,[rel es:0xbbbbbbbb] + mov bl,[rel es:0xbbbbbbbb] + mov ax,[rel es:0xbbbbbbbb] + mov bx,[rel es:0xbbbbbbbb] + mov eax,[rel es:0xbbbbbbbb] + mov ebx,[rel es:0xbbbbbbbb] + mov rax,[rel es:0xbbbbbbbb] + mov rbx,[rel es:0xbbbbbbbb] + mov al,[rel es:0xffffffffcccccccc] + mov bl,[rel es:0xffffffffcccccccc] + mov ax,[rel es:0xffffffffcccccccc] + mov bx,[rel es:0xffffffffcccccccc] + mov eax,[rel es:0xffffffffcccccccc] + mov ebx,[rel es:0xffffffffcccccccc] + mov rax,[rel es:0xffffffffcccccccc] + mov rbx,[rel es:0xffffffffcccccccc] + + mov al,[rel dword es:foo] + mov bl,[rel dword es:foo] + mov ax,[rel dword es:foo] + mov bx,[rel dword es:foo] + mov eax,[rel dword es:foo] + mov ebx,[rel dword es:foo] + mov rax,[rel dword es:foo] + mov rbx,[rel dword es:foo] + mov al,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[rel dword es:0xbbbbbbbb] + mov bl,[rel dword es:0xbbbbbbbb] + mov ax,[rel dword es:0xbbbbbbbb] + mov bx,[rel dword es:0xbbbbbbbb] + mov eax,[rel dword es:0xbbbbbbbb] + mov ebx,[rel dword es:0xbbbbbbbb] + mov rax,[rel dword es:0xbbbbbbbb] + mov rbx,[rel dword es:0xbbbbbbbb] + mov al,[rel dword es:0xffffffffcccccccc] + mov bl,[rel dword es:0xffffffffcccccccc] + mov ax,[rel dword es:0xffffffffcccccccc] + mov bx,[rel dword es:0xffffffffcccccccc] + mov eax,[rel dword es:0xffffffffcccccccc] + mov ebx,[rel dword es:0xffffffffcccccccc] + mov rax,[rel dword es:0xffffffffcccccccc] + mov rbx,[rel dword es:0xffffffffcccccccc] + + mov al,[rel qword es:foo] + mov bl,[rel qword es:foo] + mov ax,[rel qword es:foo] + mov bx,[rel qword es:foo] + mov eax,[rel qword es:foo] + mov ebx,[rel qword es:foo] + mov rax,[rel qword es:foo] + mov rbx,[rel qword es:foo] + mov al,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[rel qword es:0xbbbbbbbb] + mov bl,[rel qword es:0xbbbbbbbb] + mov ax,[rel qword es:0xbbbbbbbb] + mov bx,[rel qword es:0xbbbbbbbb] + mov eax,[rel qword es:0xbbbbbbbb] + mov ebx,[rel qword es:0xbbbbbbbb] + mov rax,[rel qword es:0xbbbbbbbb] + mov rbx,[rel qword es:0xbbbbbbbb] + mov al,[rel qword es:0xffffffffcccccccc] + mov bl,[rel qword es:0xffffffffcccccccc] + mov ax,[rel qword es:0xffffffffcccccccc] + mov bx,[rel qword es:0xffffffffcccccccc] + mov eax,[rel qword es:0xffffffffcccccccc] + mov ebx,[rel qword es:0xffffffffcccccccc] + mov rax,[rel qword es:0xffffffffcccccccc] + mov rbx,[rel qword es:0xffffffffcccccccc] + + mov al,[a64 rel es:foo] + mov bl,[a64 rel es:foo] + mov ax,[a64 rel es:foo] + mov bx,[a64 rel es:foo] + mov eax,[a64 rel es:foo] + mov ebx,[a64 rel es:foo] + mov rax,[a64 rel es:foo] + mov rbx,[a64 rel es:foo] + mov al,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel es:0xbbbbbbbb] + mov bl,[a64 rel es:0xbbbbbbbb] + mov ax,[a64 rel es:0xbbbbbbbb] + mov bx,[a64 rel es:0xbbbbbbbb] + mov eax,[a64 rel es:0xbbbbbbbb] + mov ebx,[a64 rel es:0xbbbbbbbb] + mov rax,[a64 rel es:0xbbbbbbbb] + mov rbx,[a64 rel es:0xbbbbbbbb] + mov al,[a64 rel es:0xffffffffcccccccc] + mov bl,[a64 rel es:0xffffffffcccccccc] + mov ax,[a64 rel es:0xffffffffcccccccc] + mov bx,[a64 rel es:0xffffffffcccccccc] + mov eax,[a64 rel es:0xffffffffcccccccc] + mov ebx,[a64 rel es:0xffffffffcccccccc] + mov rax,[a64 rel es:0xffffffffcccccccc] + mov rbx,[a64 rel es:0xffffffffcccccccc] + + mov al,[a64 rel dword es:foo] + mov bl,[a64 rel dword es:foo] + mov ax,[a64 rel dword es:foo] + mov bx,[a64 rel dword es:foo] + mov eax,[a64 rel dword es:foo] + mov ebx,[a64 rel dword es:foo] + mov rax,[a64 rel dword es:foo] + mov rbx,[a64 rel dword es:foo] + mov al,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel dword es:0xbbbbbbbb] + mov bl,[a64 rel dword es:0xbbbbbbbb] + mov ax,[a64 rel dword es:0xbbbbbbbb] + mov bx,[a64 rel dword es:0xbbbbbbbb] + mov eax,[a64 rel dword es:0xbbbbbbbb] + mov ebx,[a64 rel dword es:0xbbbbbbbb] + mov rax,[a64 rel dword es:0xbbbbbbbb] + mov rbx,[a64 rel dword es:0xbbbbbbbb] + mov al,[a64 rel dword es:0xffffffffcccccccc] + mov bl,[a64 rel dword es:0xffffffffcccccccc] + mov ax,[a64 rel dword es:0xffffffffcccccccc] + mov bx,[a64 rel dword es:0xffffffffcccccccc] + mov eax,[a64 rel dword es:0xffffffffcccccccc] + mov ebx,[a64 rel dword es:0xffffffffcccccccc] + mov rax,[a64 rel dword es:0xffffffffcccccccc] + mov rbx,[a64 rel dword es:0xffffffffcccccccc] + + mov al,[a64 rel qword es:foo] + mov bl,[a64 rel qword es:foo] + mov ax,[a64 rel qword es:foo] + mov bx,[a64 rel qword es:foo] + mov eax,[a64 rel qword es:foo] + mov ebx,[a64 rel qword es:foo] + mov rax,[a64 rel qword es:foo] + mov rbx,[a64 rel qword es:foo] + mov al,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a64 rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a64 rel qword es:0xbbbbbbbb] + mov bl,[a64 rel qword es:0xbbbbbbbb] + mov ax,[a64 rel qword es:0xbbbbbbbb] + mov bx,[a64 rel qword es:0xbbbbbbbb] + mov eax,[a64 rel qword es:0xbbbbbbbb] + mov ebx,[a64 rel qword es:0xbbbbbbbb] + mov rax,[a64 rel qword es:0xbbbbbbbb] + mov rbx,[a64 rel qword es:0xbbbbbbbb] + mov al,[a64 rel qword es:0xffffffffcccccccc] + mov bl,[a64 rel qword es:0xffffffffcccccccc] + mov ax,[a64 rel qword es:0xffffffffcccccccc] + mov bx,[a64 rel qword es:0xffffffffcccccccc] + mov eax,[a64 rel qword es:0xffffffffcccccccc] + mov ebx,[a64 rel qword es:0xffffffffcccccccc] + mov rax,[a64 rel qword es:0xffffffffcccccccc] + mov rbx,[a64 rel qword es:0xffffffffcccccccc] + + mov al,[a32 rel es:foo] + mov bl,[a32 rel es:foo] + mov ax,[a32 rel es:foo] + mov bx,[a32 rel es:foo] + mov eax,[a32 rel es:foo] + mov ebx,[a32 rel es:foo] + mov rax,[a32 rel es:foo] + mov rbx,[a32 rel es:foo] + mov al,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel es:0xbbbbbbbb] + mov bl,[a32 rel es:0xbbbbbbbb] + mov ax,[a32 rel es:0xbbbbbbbb] + mov bx,[a32 rel es:0xbbbbbbbb] + mov eax,[a32 rel es:0xbbbbbbbb] + mov ebx,[a32 rel es:0xbbbbbbbb] + mov rax,[a32 rel es:0xbbbbbbbb] + mov rbx,[a32 rel es:0xbbbbbbbb] + mov al,[a32 rel es:0xffffffffcccccccc] + mov bl,[a32 rel es:0xffffffffcccccccc] + mov ax,[a32 rel es:0xffffffffcccccccc] + mov bx,[a32 rel es:0xffffffffcccccccc] + mov eax,[a32 rel es:0xffffffffcccccccc] + mov ebx,[a32 rel es:0xffffffffcccccccc] + mov rax,[a32 rel es:0xffffffffcccccccc] + mov rbx,[a32 rel es:0xffffffffcccccccc] + + mov al,[a32 rel dword es:foo] + mov bl,[a32 rel dword es:foo] + mov ax,[a32 rel dword es:foo] + mov bx,[a32 rel dword es:foo] + mov eax,[a32 rel dword es:foo] + mov ebx,[a32 rel dword es:foo] + mov rax,[a32 rel dword es:foo] + mov rbx,[a32 rel dword es:foo] + mov al,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel dword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel dword es:0xbbbbbbbb] + mov bl,[a32 rel dword es:0xbbbbbbbb] + mov ax,[a32 rel dword es:0xbbbbbbbb] + mov bx,[a32 rel dword es:0xbbbbbbbb] + mov eax,[a32 rel dword es:0xbbbbbbbb] + mov ebx,[a32 rel dword es:0xbbbbbbbb] + mov rax,[a32 rel dword es:0xbbbbbbbb] + mov rbx,[a32 rel dword es:0xbbbbbbbb] + mov al,[a32 rel dword es:0xffffffffcccccccc] + mov bl,[a32 rel dword es:0xffffffffcccccccc] + mov ax,[a32 rel dword es:0xffffffffcccccccc] + mov bx,[a32 rel dword es:0xffffffffcccccccc] + mov eax,[a32 rel dword es:0xffffffffcccccccc] + mov ebx,[a32 rel dword es:0xffffffffcccccccc] + mov rax,[a32 rel dword es:0xffffffffcccccccc] + mov rbx,[a32 rel dword es:0xffffffffcccccccc] + + mov al,[a32 rel qword es:foo] + mov bl,[a32 rel qword es:foo] + mov ax,[a32 rel qword es:foo] + mov bx,[a32 rel qword es:foo] + mov eax,[a32 rel qword es:foo] + mov ebx,[a32 rel qword es:foo] + mov rax,[a32 rel qword es:foo] + mov rbx,[a32 rel qword es:foo] + mov al,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bl,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov bx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov eax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov ebx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rax,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov rbx,[a32 rel qword es:0xaaaaaaaaaaaaaaaa] + mov al,[a32 rel qword es:0xbbbbbbbb] + mov bl,[a32 rel qword es:0xbbbbbbbb] + mov ax,[a32 rel qword es:0xbbbbbbbb] + mov bx,[a32 rel qword es:0xbbbbbbbb] + mov eax,[a32 rel qword es:0xbbbbbbbb] + mov ebx,[a32 rel qword es:0xbbbbbbbb] + mov rax,[a32 rel qword es:0xbbbbbbbb] + mov rbx,[a32 rel qword es:0xbbbbbbbb] + mov al,[a32 rel qword es:0xffffffffcccccccc] + mov bl,[a32 rel qword es:0xffffffffcccccccc] + mov ax,[a32 rel qword es:0xffffffffcccccccc] + mov bx,[a32 rel qword es:0xffffffffcccccccc] + mov eax,[a32 rel qword es:0xffffffffcccccccc] + mov ebx,[a32 rel qword es:0xffffffffcccccccc] + mov rax,[a32 rel qword es:0xffffffffcccccccc] + mov rbx,[a32 rel qword es:0xffffffffcccccccc] + + +foo: diff --git a/test/riprel.pl b/test/riprel.pl new file mode 100755 index 0000000..61af723 --- /dev/null +++ b/test/riprel.pl @@ -0,0 +1,29 @@ +#!/usr/bin/perl + +print ";Testname=unoptimized; Arguments=-fbin -oriprel.bin -O0; Files=stdout stderr riprel.bin\n"; +print ";Testname=optimized; Arguments=-fbin -oriprel.bin -Ox; Files=stdout stderr riprel.bin\n"; + + +print "\tbits 64\n"; + +foreach $mode ('abs', 'rel') { + print "\n\tdefault $mode\n\n"; + + foreach $so ('', 'fs:', 'es:') { + foreach $rq ('', 'abs ', 'rel ') { + foreach $ao ('', 'a64 ', 'a32 ') { + foreach $sq ('', 'dword ', 'qword ') { + foreach $v ('foo', '0xaaaaaaaaaaaaaaaa', '0xbbbbbbbb', + '0xffffffffcccccccc') { + foreach $r ( 'al', 'bl', 'ax', 'bx', 'eax', 'ebx', 'rax', 'rbx') { + print "\tmov $r,[$ao$rq$sq$so$v]\n"; + } + } + print "\n"; + } + } + } + } +} + +print "\nfoo:\n"; diff --git a/test/riprel2.asm b/test/riprel2.asm new file mode 100644 index 0000000..2d13d3e --- /dev/null +++ b/test/riprel2.asm @@ -0,0 +1,11 @@ +;Testname=unoptimized; Arguments=-fbin -oriprel2.bin -O0; Files=stdout stderr riprel.bin +;Testname=optimized; Arguments=-fbin -oriprel2.bin -Ox; Files=stdout stderr riprel.bin + + bits 64 + + default rel + mov dword [foo],12345678h + mov qword [foo],12345678h + mov [foo],rax + mov dword [foo],12345678h +foo: diff --git a/test/smartalign16.asm b/test/smartalign16.asm new file mode 100644 index 0000000..42915de --- /dev/null +++ b/test/smartalign16.asm @@ -0,0 +1,36 @@ +;Testname=test; Arguments=-fbin -osmartalign16.bin; Files=stdout stderr smartalign16.bin + +%use smartalign + + bits 16 + + alignmode nop, 32 + add ax,ax + align 32 + + alignmode generic, 32 + add ax,ax + align 32 + + alignmode k7, 32 + add ax,ax + align 32 + + alignmode k8, 32 + add ax,ax + align 32 + + alignmode p6, 32 + add ax,ax + align 32 + + add ecx,ecx + align 32 + add edx,edx + align 128 + add ebx,ebx + align 256 + add esi,esi + align 512 + + add edi,edi diff --git a/test/smartalign32.asm b/test/smartalign32.asm new file mode 100644 index 0000000..64d65b0 --- /dev/null +++ b/test/smartalign32.asm @@ -0,0 +1,36 @@ +;Testname=test; Arguments=-fbin -osmartalign32.bin; Files=stdout stderr smartalign32.bin + +%use smartalign + + bits 32 + + alignmode nop, 32 + add ax,ax + align 32 + + alignmode generic, 32 + add ax,ax + align 32 + + alignmode k7, 32 + add ax,ax + align 32 + + alignmode k8, 32 + add ax,ax + align 32 + + alignmode p6, 32 + add ax,ax + align 32 + + add ecx,ecx + align 32 + add edx,edx + align 128 + add ebx,ebx + align 256 + add esi,esi + align 512 + + add edi,edi diff --git a/test/smartalign64.asm b/test/smartalign64.asm new file mode 100644 index 0000000..74454ca --- /dev/null +++ b/test/smartalign64.asm @@ -0,0 +1,36 @@ +;Testname=test; Arguments=-fbin -osmartalign64.bin; Files=stdout stderr smartalign64.bin + +%use smartalign + + bits 64 + + alignmode nop, 32 + add ax,ax + align 32 + + alignmode generic, 32 + add ax,ax + align 32 + + alignmode k7, 32 + add ax,ax + align 32 + + alignmode k8, 32 + add ax,ax + align 32 + + alignmode p6, 32 + add ax,ax + align 32 + + add ecx,ecx + align 32 + add edx,edx + align 128 + add ebx,ebx + align 256 + add esi,esi + align 512 + + add edi,edi diff --git a/test/struc.asm b/test/struc.asm new file mode 100644 index 0000000..3c8c1b4 --- /dev/null +++ b/test/struc.asm @@ -0,0 +1,33 @@ +;Testname=test; Arguments=-fbin -ostruc.bin; Files=stdout stderr struc.bin + +bits 32 + +; Simple struc example +struc teststruc1 + .long: resd 1 + .word: resw 1 + .byte: resb 1 + .str: resb 32 +endstruc + +; Reference with offset +mov [ebp - 40 + teststruc1.word], ax + +istruc teststruc1 + at .word, db 5 +iend + +; Struc with base offset +; should be the same as the previous stuc +struc teststruc2, -40 + .long: resd 1 + .word: resw 1 + .byte: resb 1 + .str: resb 32 +endstruc + +mov [ebp + teststruc2.word], ax + +istruc teststruc2 + at .word, db 5 +iend diff --git a/test/test67.asm b/test/test67.asm new file mode 100644 index 0000000..7cf300d --- /dev/null +++ b/test/test67.asm @@ -0,0 +1,38 @@ +;Testname=unoptimized; Arguments=-fbin -otest67.bin -O0; Files=stdout stderr test67.bin +;Testname=optimized; Arguments=-fbin -otest67.bin -Ox; Files=stdout stderr test67.bin + + bits 16 + + mov ax,[bx] + mov ax,[foo] + mov ax,[word foo] + mov ax,[dword foo] + mov ax,[ebx] + rep movsb + a16 rep movsb + a32 rep movsb + a32 mov ax,bx + + bits 32 + + mov ax,[bx] + mov ax,[foo] + mov ax,[word foo] + mov ax,[dword foo] + mov ax,[ebx] + rep movsb + a16 rep movsb + a32 rep movsb + + bits 64 + + mov ax,[rbx] + mov ax,[foo] + mov ax,[qword foo] + mov ax,[dword foo] + mov ax,[ebx] + rep movsb + a32 rep movsb + a64 rep movsb + +foo: diff --git a/test/testdos.asm b/test/testdos.asm new file mode 100644 index 0000000..2f6bf91 --- /dev/null +++ b/test/testdos.asm @@ -0,0 +1,13 @@ +;Testname=test; Arguments=-fbin -otestdos.bin; Files=stdout stderr testdos.bin +; +; This file was known to miscompile with the 16-bit NASM built +; under Borland C++ 3.1, so keep it around for testing... +; +; The proper output looks like: +; +; 00000000 A10300 +; 00000003 EA0000FFFF +; + org 0100h + mov ax,[3] + jmp 0FFFFh:0000 diff --git a/test/testnos3.asm b/test/testnos3.asm new file mode 100644 index 0000000..b243e15 --- /dev/null +++ b/test/testnos3.asm @@ -0,0 +1,973 @@ +;Testname=test; Arguments=-fbin -otestnos3.bin; Files=stdout stderr testnos3.bin +; +; Double-precision floating point tests, derived from Fred Tydeman's posting +; of 26 February 1996 to comp.arch.arithmetic, via David M. Gay's gdtoa +; package. +; + bits 64 + + dq 9.e0306 + dq 0x7fa9a2028368022e + + dq 4.e-079 + dq 0x2fa7b6d71d20b96c + + dq 7.e-261 + dq 0x09eb8d7e32be6396 + + dq 6.e-025 + dq 0x3ae7361cb863de62 + + dq 7.e-161 + dq 0x1eaf7e0db3799aa3 + + dq 7.e0289 + dq 0x7c1cbb547777a285 + + dq 5.e0079 + dq 0x507afcef51f0fb5f + + dq 1.e0080 + dq 0x508afcef51f0fb5f + + dq 7.e-303 + dq 0x0133339131c46f8b + + dq 5.e0152 + dq 0x5fa317e5ef3ab327 + + dq 5.e0125 + dq 0x5a07a2ecc414a03f + + dq 2.e0126 + dq 0x5a27a2ecc414a03f + + dq 7.e-141 + dq 0x22d5570f59bd178c + + dq 4.e-192 + dq 0x18323ff06eea847a + + dq 9.e0043 + dq 0x49102498ea6df0c4 + + dq 1.e0303 + dq 0x7ed754e31cd072da + + dq 95.e-089 + dq 0x2dde3cbc9907fdc8 + + dq 85.e0194 + dq 0x689d1c26db7d0dae + + dq 69.e0267 + dq 0x77c0b7cb60c994da + + dq 97.e-019 + dq 0x3c665dde8e688ba6 + + dq 37.e0046 + dq 0x49d033d7eca0adef + + dq 74.e0046 + dq 0x49e033d7eca0adef + + dq 61.e-099 + dq 0x2bc0ad836f269a17 + + dq 53.e-208 + dq 0x151b39ae1909c31b + + dq 93.e-234 + dq 0x0fc27b2e4f210075 + + dq 79.e-095 + dq 0x2c9a5db812948281 + + dq 87.e-274 + dq 0x0772d36cf48e7abd + + dq 83.e0025 + dq 0x4585747ab143e353 + + dq 17.e-036 + dq 0x38b698ccdc60015a + + dq 53.e0033 + dq 0x47246a3418629ef6 + + dq 51.e-074 + dq 0x30ecd5bee57763e6 + + dq 63.e-022 + dq 0x3bbdc03b8fd7016a + + dq 839.e0143 + dq 0x5e3ae03f245703e2 + + dq 749.e-182 + dq 0x1abf14727744c63e + + dq 999.e-026 + dq 0x3b282782afe1869e + + dq 345.e0266 + dq 0x77b0b7cb60c994da + + dq 914.e-102 + dq 0x2b5ffc81bc29f02b + + dq 829.e0102 + dq 0x55b7221a79cdd1d9 + + dq 307.e0090 + dq 0x5322d6b183fe4b55 + + dq 859.e0182 + dq 0x6654374d8b87ac63 + + dq 283.e0085 + dq 0x5216c309024bab4b + + dq 589.e0187 + dq 0x675526be9c22eb17 + + dq 302.e0176 + dq 0x64fdcf7df8f573b7 + + dq 604.e0176 + dq 0x650dcf7df8f573b7 + + dq 761.e-244 + dq 0x0de03cea3586452e + + dq 647.e0230 + dq 0x7044d64d4079150c + + dq 755.e0174 + dq 0x64a7d93193f78fc6 + + dq 255.e-075 + dq 0x30dcd5bee57763e6 + + dq 3391.e0055 + dq 0x4c159bd3ad46e346 + + dq 4147.e-015 + dq 0x3d923d1b5eb1d778 + + dq 3996.e-026 + dq 0x3b482782afe1869e + + dq 1998.e-026 + dq 0x3b382782afe1869e + + dq 3338.e-296 + dq 0x0335519ac5142aab + + dq 1669.e-296 + dq 0x0325519ac5142aab + + dq 8699.e-276 + dq 0x0772d2df246ecd2d + + dq 5311.e0243 + dq 0x73284e91f4aa0fdb + + dq 7903.e-096 + dq 0x2cd07c2d27a5b989 + + dq 7611.e-226 + dq 0x11d19b8744033457 + + dq 3257.e0058 + dq 0x4cb444b34a6fb3eb + + dq 6514.e0058 + dq 0x4cc444b34a6fb3eb + + dq 3571.e0263 + dq 0x77462644c61d41aa + + dq 7142.e0263 + dq 0x77562644c61d41aa + + dq 5311.e0242 + dq 0x72f3720e5d54d97c + + dq 1617.e-063 + dq 0x3384c98fce16152e + + dq 51881.e0037 + dq 0x4897d2950dc76da4 + + dq 31441.e-118 + dq 0x285ef890f5de4c86 + + dq 30179.e0079 + dq 0x5143e272a77478e8 + + dq 60358.e0079 + dq 0x5153e272a77478e8 + + dq 63876.e-020 + dq 0x3cc703856844bdbf + + dq 31938.e-020 + dq 0x3cb703856844bdbf + + dq 46073.e-032 + dq 0x3a42405b773fbdf3 + + dq 32941.e0051 + dq 0x4b757eb8ad52a5c9 + + dq 82081.e0041 + dq 0x49770105df3d47cb + + dq 38701.e-215 + dq 0x1440492a4a8a37fd + + dq 62745.e0047 + dq 0x4ab0c52fe6dc6a1b + + dq 12549.e0048 + dq 0x4ac0c52fe6dc6a1b + + dq 64009.e-183 + dq 0x1af099b393b84832 + + dq 89275.e0261 + dq 0x77262644c61d41aa + + dq 75859.e0025 + dq 0x46232645e1ba93f0 + + dq 57533.e0287 + dq 0x7c8272ed2307f56a + + dq 584169.e0229 + dq 0x70ad657059dc79aa + + dq 940189.e-112 + dq 0x29eb99d6240c1a28 + + dq 416121.e0197 + dq 0x6a00fd07ed297f80 + + dq 832242.e0197 + dq 0x6a10fd07ed297f80 + + dq 584738.e0076 + dq 0x50e8a85eb277e645 + + dq 933587.e-140 + dq 0x241b248728b9c117 + + dq 252601.e0121 + dq 0x5a2dda592e398dd7 + + dq 358423.e0274 + dq 0x79f9463b59b8f2bd + + dq 892771.e-213 + dq 0x14f25818c7294f27 + + dq 410405.e0040 + dq 0x49670105df3d47cb + + dq 928609.e-261 + dq 0x0afbe2dd66200bef + + dq 302276.e-254 + dq 0x0c55a462d91c6ab3 + + dq 920657.e-023 + dq 0x3c653a9985dbde6c + + dq 609019.e-025 + dq 0x3bf1f99e11ea0a24 + + dq 252601.e0120 + dq 0x59f7e1e0f1c7a4ac + + dq 654839.e-060 + dq 0x34b00e7db3b3f242 + + dq 8823691.e0130 + dq 0x5c5e597c0b94b7ae + + dq 2920845.e0228 + dq 0x709d657059dc79aa + + dq 9210917.e0080 + dq 0x51fda232347e6032 + + dq 5800419.e-303 + dq 0x026e58ffa48f4fce + + dq 6119898.e-243 + dq 0x0ee3ecf22ea07863 + + dq 3059949.e-243 + dq 0x0ed3ecf22ea07863 + + dq 2572231.e0223 + dq 0x6f90f73be1dff9ad + + dq 5444097.e-021 + dq 0x3cf8849dd33c95af + + dq 5783893.e-127 + dq 0x26f7e5902ce0e151 + + dq 3865421.e-225 + dq 0x1295d4fe53afec65 + + dq 4590831.e0156 + dq 0x61b4689b4a5fa201 + + dq 9181662.e0156 + dq 0x61c4689b4a5fa201 + + dq 5906361.e-027 + dq 0x3bbbe45a312d08a0 + + dq 7315057.e0235 + dq 0x7225f0d408362a72 + + dq 9088115.e0106 + dq 0x5762e51a84a3c6a0 + + dq 1817623.e0107 + dq 0x5772e51a84a3c6a0 + + dq 44118455.e0129 + dq 0x5c4e597c0b94b7ae + + dq 35282041.e0293 + dq 0x7e5512d5273e62e8 + + dq 31279898.e-291 + dq 0x05129b01b6885d36 + + dq 15639949.e-291 + dq 0x05029b01b6885d36 + + dq 27966061.e0145 + dq 0x5f955bcf72fd10f9 + + dq 55932122.e0145 + dq 0x5fa55bcf72fd10f9 + + dq 70176353.e-053 + dq 0x36900683a21de855 + + dq 40277543.e-032 + dq 0x3adf29ca0ff893b1 + + dq 50609263.e0157 + dq 0x622193aff1f1c8e3 + + dq 66094077.e0077 + dq 0x518b37c4b7928317 + + dq 84863171.e0114 + dq 0x59406e98f5ec8f37 + + dq 89396333.e0264 + dq 0x786526f061ca9053 + + dq 87575437.e-309 + dq 0x016e07320602056c + + dq 78693511.e-044 + dq 0x3870bc7b7603a2ca + + dq 90285923.e-206 + dq 0x16d1470083f89d48 + + dq 30155207.e-030 + dq 0x3b423a4ad20748a2 + + dq 245540327.e0121 + dq 0x5acc569e968e0944 + + dq 263125459.e0287 + dq 0x7d44997a298b2f2e + + dq 566446538.e-257 + dq 0x0c64472ba9550e86 + + dq 283223269.e-257 + dq 0x0c54472ba9550e86 + + dq 245540327.e0122 + dq 0x5b01b6231e18c5cb + + dq 491080654.e0122 + dq 0x5b11b6231e18c5cb + + dq 971212611.e-126 + dq 0x27a397d3c9745d2f + + dq 229058583.e0052 + dq 0x4c76ce94febdc7a5 + + dq 325270231.e0039 + dq 0x49cc7ccf90c9f8ab + + dq 989648089.e-035 + dq 0x3a8880a3d515e849 + + dq 653777767.e0273 + dq 0x7a720223f2b3a881 + + dq 923091487.e0209 + dq 0x6d30bc60e6896717 + + dq 526250918.e0288 + dq 0x7d89bfd8b3edfafa + + dq 350301748.e-309 + dq 0x018e07320602056c + + dq 741111169.e-203 + dq 0x17a14fe7daf8f3ae + + dq 667284113.e-240 + dq 0x0ff09355f8050c02 + + dq 1227701635.e0120 + dq 0x5abc569e968e0944 + + dq 9981396317.e-182 + dq 0x1c38afe10a2a66aa + + dq 5232604057.e-298 + dq 0x041465b896c24520 + + dq 5572170023.e-088 + dq 0x2fb0847822f765b2 + + dq 1964322616.e0122 + dq 0x5b31b6231e18c5cb + + dq 3928645232.e0122 + dq 0x5b41b6231e18c5cb + + dq 8715380633.e-058 + dq 0x35f4614c3219891f + + dq 4856063055.e-127 + dq 0x279397d3c9745d2f + + dq 8336960483.e-153 + dq 0x223a06a1024b95e1 + + dq 1007046393.e-155 + dq 0x21a01891fc4717fd + + dq 5378822089.e-176 + dq 0x1d695fd4c88d4b1b + + dq 5981342308.e-190 + dq 0x1a83db11ac608107 + + dq 7214782613.e-086 + dq 0x3020b552d2edcdea + + dq 5458466829.e0142 + dq 0x5f70acde6a98eb4c + + dq 9078555839.e-109 + dq 0x2b5fc575867314ee + + dq 6418488827.e0079 + dq 0x526021f14ed7b3fa + + dq 65325840981.e0069 + dq 0x5081a151ddbd3c4a + + dq 49573485983.e0089 + dq 0x54a221bd871d2cf4 + + dq 46275205733.e0074 + dq 0x51830e6c7d4e3480 + + dq 92550411466.e0074 + dq 0x51930e6c7d4e3480 + + dq 41129842097.e-202 + dq 0x1832c3e72d179607 + + dq 93227267727.e-049 + dq 0x380960fe08d5847f + + dq 41297294357.e0185 + dq 0x688c49437fccfadb + + dq 41534892987.e-067 + dq 0x343a12666477886d + + dq 42333842451.e0201 + dq 0x6be0189a26df575f + + dq 78564021519.e-227 + dq 0x131155515fd37265 + + dq 53587107423.e-061 + dq 0x35800a19a3ffd981 + + dq 53827010643.e-200 + dq 0x18a32fa69a69bd6d + + dq 83356057653.e0193 + dq 0x6a4544e6daee2a18 + + dq 45256834646.e-118 + dq 0x29a541ecdfd48694 + + dq 45392779195.e-110 + dq 0x2b4fc575867314ee + + dq 23934638219.e0291 + dq 0x7e81deaf40ead9a0 + + dq 995779191233.e0113 + dq 0x59e2d44edcc51304 + + dq 997422852243.e-265 + dq 0x0b676688faee99bc + + dq 653532977297.e-123 + dq 0x28d925a0aabcdc68 + + dq 938885684947.e0147 + dq 0x60f11894b202e9f4 + + dq 619534293513.e0124 + dq 0x5c210c20303fe0f1 + + dq 539879452414.e-042 + dq 0x39a5e66dc3d6bdb5 + + dq 742522891517.e0259 + dq 0x782c1c352fc3c309 + + dq 254901016865.e-022 + dq 0x3dbc06d366394441 + + dq 685763015669.e0280 + dq 0x7c85fd7aa44d9477 + + dq 384865004907.e-285 + dq 0x072aa65b58639e69 + + dq 286556458711.e0081 + dq 0x5321958b36c5102b + + dq 573112917422.e0081 + dq 0x5331958b36c5102b + + dq 769525178383.e-150 + dq 0x234253ec0e161420 + + dq 416780288265.e0192 + dq 0x6a3544e6daee2a18 + + dq 226963895975.e-111 + dq 0x2b3fc575867314ee + + dq 665592809339.e0063 + dq 0x4f778b6516c2b478 + + dq 3891901811465.e0217 + dq 0x6f99ab8261990292 + + dq 4764593340755.e0069 + dq 0x50e4177a9915fbf8 + + dq 6336156586177.e0269 + dq 0x7a7173f76c63b792 + + dq 8233559360849.e0095 + dq 0x56566fee05649a7a + + dq 3662265515198.e-107 + dq 0x2c538e6edd48f2a3 + + dq 1831132757599.e-107 + dq 0x2c438e6edd48f2a3 + + dq 7812878489261.e-179 + dq 0x1d726dae7bbeda75 + + dq 6363857920591.e0145 + dq 0x60b28a61cf9483b7 + + dq 8811915538555.e0082 + dq 0x53a51f508b287ae7 + + dq 9997878507563.e-195 + dq 0x1a253db2fea1ea31 + + dq 9224786422069.e-291 + dq 0x0634ee5d56b32957 + + dq 6284426329974.e-294 + dq 0x058d3409dfbca26f + + dq 9199302046091.e-062 + dq 0x35c135972630774c + + dq 6070482281213.e-122 + dq 0x29423fa9e6fcf47e + + dq 2780161250963.e-301 + dq 0x0405acc2053064c2 + + dq 8233559360849.e0094 + dq 0x5621f324d11d4862 + + dq 72027097041701.e0206 + dq 0x6d94677812d3a606 + + dq 97297545286625.e0215 + dq 0x6f79ab8261990292 + + dq 99021992302453.e-025 + dq 0x3da5c6714def374c + + dq 54104687080198.e-022 + dq 0x3e373cdf8db7a7bc + + dq 33519685743233.e0089 + dq 0x5537f203339c9629 + + dq 67039371486466.e0089 + dq 0x5547f203339c9629 + + dq 39064392446305.e-180 + dq 0x1d626dae7bbeda75 + + dq 17796979903653.e0261 + dq 0x78e072f3819c1321 + + dq 28921916763211.e0038 + dq 0x4a9eebabe0957af3 + + dq 87605699161665.e0155 + dq 0x6302920f96e7f9ef + + dq 41921560615349.e-067 + dq 0x34d9b2a5c4041e4b + + dq 80527976643809.e0061 + dq 0x4f7c7c5aea080a49 + + dq 72335858886654.e-159 + dq 0x21cce77c2b3328fc + + dq 52656615219377.e0102 + dq 0x57f561def4a9ee32 + + dq 15400733123779.e-072 + dq 0x33b8bf7e7fa6f02a + + dq 77003665618895.e-073 + dq 0x33a8bf7e7fa6f02a + + dq 475603213226859.e-042 + dq 0x3a42d73088f4050a + + dq 972708181182949.e0116 + dq 0x5b218a7f36172332 + + dq 246411729980464.e-071 + dq 0x342eef5e1f90ac34 + + dq 123205864990232.e-071 + dq 0x341eef5e1f90ac34 + + dq 609610927149051.e-255 + dq 0x0e104273b18918b1 + + dq 475603213226859.e-041 + dq 0x3a778cfcab31064d + + dq 672574798934795.e0065 + dq 0x508226c684c87261 + + dq 134514959786959.e0066 + dq 0x509226c684c87261 + + dq 294897574603217.e-151 + dq 0x2395f2df5e675a0f + + dq 723047919080275.e0036 + dq 0x4a7eebabe0957af3 + + dq 660191429952702.e-088 + dq 0x30bddc7e975c5045 + + dq 330095714976351.e-088 + dq 0x30addc7e975c5045 + + dq 578686871093232.e-159 + dq 0x21fce77c2b3328fc + + dq 144671717773308.e-159 + dq 0x21dce77c2b3328fc + + dq 385018328094475.e-074 + dq 0x3398bf7e7fa6f02a + + dq 330095714976351.e-089 + dq 0x3077e3987916a69e + + dq 2215901545757777.e-212 + dq 0x171a80a6e566428c + + dq 1702061899637397.e-276 + dq 0x09cacc46749dccfe + + dq 1864950924021923.e0213 + dq 0x6f53ae60753af6ca + + dq 3729901848043846.e0213 + dq 0x6f63ae60753af6ca + + dq 7487252720986826.e-165 + dq 0x20f8823a57adbef9 + + dq 3743626360493413.e-165 + dq 0x20e8823a57adbef9 + + dq 4988915232824583.e0119 + dq 0x5be5f6de9d5d6b5b + + dq 3771476185376383.e0277 + dq 0x7cae3c14d6916ce9 + + dq 6182410494241627.e-119 + dq 0x2a81b96458445d07 + + dq 2572981889477453.e0142 + dq 0x609dfc11fbf46087 + + dq 7793560217139653.e0051 + dq 0x4dd280461b856ec5 + + dq 9163942927285259.e-202 + dq 0x194fe601457dce4d + + dq 6353227084707473.e0155 + dq 0x63650aff653ffe8a + + dq 4431803091515554.e-211 + dq 0x176090684f5fe998 + + dq 9324754620109615.e0211 + dq 0x6f0f7d6721f7f144 + + dq 8870461176410409.e0263 + dq 0x79d90529a37b7e22 + + dq 90372559027740405.e0143 + dq 0x612491daad0ba280 + + dq 18074511805548081.e0146 + dq 0x61a011f2d73116f4 + + dq 54897030182071313.e0029 + dq 0x496ec55666d8f9ec + + dq 76232626624829156.e-032 + dq 0x3ccb7738011e75fe + + dq 59898021767894608.e-165 + dq 0x2128823a57adbef9 + + dq 29949010883947304.e-165 + dq 0x2118823a57adbef9 + + dq 26153245263757307.e0049 + dq 0x4d83de005bd620df + + dq 27176258005319167.e-261 + dq 0x0d27c0747bd76fa1 + + dq 18074511805548081.e0147 + dq 0x61d4166f8cfd5cb1 + + dq 24691002732654881.e-115 + dq 0x2b759a2783ce70ab + + dq 58483921078398283.e0057 + dq 0x4f408ce499519ce3 + + dq 64409240769861689.e-159 + dq 0x22692238f7987779 + + dq 94080055902682397.e-242 + dq 0x11364981e39e66ca + + dq 31766135423537365.e0154 + dq 0x63550aff653ffe8a + + dq 68985865317742005.e0164 + dq 0x657a999ddec72aca + + dq 13797173063548401.e0165 + dq 0x658a999ddec72aca + + dq 902042358290366539.e-281 + dq 0x09522dc01ca1cb8c + + dq 238296178309629163.e0272 + dq 0x7c038fd93f1f5342 + + dq 783308178698887621.e0226 + dq 0x72925ae62cb346d8 + + dq 439176241456570504.e0029 + dq 0x499ec55666d8f9ec + + dq 899810892172646163.e0283 + dq 0x7e6adf51fa055e03 + + dq 926145344610700019.e-225 + dq 0x14f307a67f1f69ff + + dq 653831131593932675.e0047 + dq 0x4d63de005bd620df + + dq 130766226318786535.e0048 + dq 0x4d73de005bd620df + + dq 557035730189854663.e-294 + dq 0x0693bfac6bc4767b + + dq 902042358290366539.e-280 + dq 0x0986b93023ca3e6f + + dq 272104041512242479.e0200 + dq 0x6d13bbb4bf05f087 + + dq 544208083024484958.e0200 + dq 0x6d23bbb4bf05f087 + + dq 680429695511221511.e0192 + dq 0x6b808ebc116f8a20 + + dq 308975121073410857.e0236 + dq 0x7490db75cc001072 + + dq 792644927852378159.e0078 + dq 0x53d7bff336d8ff06 + + dq 783308178698887621.e0223 + dq 0x71f2cbac35f71140 + + dq 8396094300569779681.e-252 + dq 0x0f8ab223efcee35a + + dq 3507665085003296281.e-074 + dq 0x346b85c026a264e4 + + dq 7322325862592278999.e0074 + dq 0x5336775b6caa5ae0 + + dq 6014546754280072926.e0209 + dq 0x6f396397b06732a4 + + dq 7120190517612959703.e0120 + dq 0x5cc3220dcd5899fd + + dq 3507665085003296281.e-073 + dq 0x34a1339818257f0f + + dq 4345544743100783551.e-218 + dq 0x168a9c42e5b6d89f + + dq 9778613303868468131.e-090 + dq 0x313146fe1075e1ef + + dq 7539204280836061195.e-082 + dq 0x32d3d969e3dbe723 + + dq 7862637540082247119.e-202 + dq 0x19eaba3262ee707b + + dq 2176832332097939832.e0200 + dq 0x6d43bbb4bf05f087 + + dq 8643988913946659879.e0115 + dq 0x5bbe71ec1ed0a4f9 + + dq 5529436763613147623.e0138 + dq 0x6079c677be6f236e + + dq 6764958008109694533.e-173 + dq 0x1fed06692e6f5ef6 + + dq 6802601037806061975.e0197 + dq 0x6cbf92bacb3cb40c + + dq 1360520207561212395.e0198 + dq 0x6ccf92bacb3cb40c + + dq 62259110684423957791.e0047 + dq 0x4dcd8f2cfc20d6e8 + + dq 88800290202542652011.e-226 + dq 0x1526cec51a43f41a + + dq 41010852717673354694.e-221 + dq 0x162012954b6aabba + + dq 20505426358836677347.e-221 + dq 0x161012954b6aabba + + dq 66102447903809911604.e0055 + dq 0x4f7762068a24fd55 + + dq 35600952588064798515.e0119 + dq 0x5cb3220dcd5899fd + + dq 14371240869903838702.e0205 + dq 0x6e78d92d2bcc7a81 + + dq 57500690832492901689.e0043 + dq 0x4cf65d3e2acd616b + + dq 23432630639573022093.e-107 + dq 0x2dbdd54c40a2f25f + + dq 62259110684423957791.e0048 + dq 0x4e02797c1d948651 + + dq 35620497849450218807.e-306 + dq 0x0475b22082529425 + + dq 69658634627134074624.e0200 + dq 0x6d93bbb4bf05f087 + + dq 99440755792436956989.e-062 + dq 0x37362d10462a26f4 + + dq 55277197169490210673.e0081 + dq 0x54d945bfa911e32a + + dq 36992084760177624177.e-318 + dq 0x01f8c5f9551c2f9a + + dq 30888265282878466443.e-111 + dq 0x2cf01b8ef28251fc + + dq 2.4703282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772285886546332835517796989819938739800539093906315035659515570226392290858392449105184435931802849936536152500319370457678249219365623669863658480757001585769269903706311928279558551332927834338409351978015531246597263579574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324673600968951340535537458516661134223766678604162159680461914467291840300530057530849048765391711386591646239524912623653881879636239373280423891018672348497668235089863388587925628302755995657524455507255189313690836254779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125e-324 + dq 0x0000000000000000 + + dq 2.47032822920623272e-324 + dq 0x0000000000000000 diff --git a/test/time.asm b/test/time.asm new file mode 100644 index 0000000..ee4b9b7 --- /dev/null +++ b/test/time.asm @@ -0,0 +1,11 @@ +;Not automatically testable because it is not constant + db __DATE__, 13, 10 + db __TIME__, 13, 10 + db __UTC_DATE__, 13, 10 + db __UTC_TIME__, 13, 10 + align 4 + dd __DATE_NUM__ + dd __TIME_NUM__ + dd __UTC_DATE_NUM__ + dd __UTC_TIME_NUM__ + dd __POSIX_TIME__ diff --git a/test/tmap.nas b/test/tmap.nas new file mode 100644 index 0000000..51b477f --- /dev/null +++ b/test/tmap.nas @@ -0,0 +1,1447 @@ +;; NASM note: this file abuses the section flags in such a way that
+;; NASM 0.98.37 broke when this was compiled with:
+;; nasm -o tmap.o -f elf -DLINUX tmap.nas
+
+;;-----------------------------------------------------------------------------
+;;
+;; $Id$
+;;
+;; Copyright (C) 1998-2000 by DooM Legacy Team.
+;;
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License
+;; as published by the Free Software Foundation; either version 2
+;; of the License, or (at your option) any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;;
+;; $Log$ +;; Revision 1.2 2003/09/10 23:33:38 hpa +;; Use the version of tmap.nas that actually caused problems +;;
+;; Revision 1.10 2001/02/24 13:35:21 bpereira
+;; no message
+;;
+;; Revision 1.9 2001/02/10 15:24:19 hurdler
+;; Apply Rob's patch for Linux version
+;;
+;; Revision 1.8 2000/11/12 09:48:15 bpereira
+;; no message
+;;
+;; Revision 1.7 2000/11/06 20:52:16 bpereira
+;; no message
+;;
+;; Revision 1.6 2000/11/03 11:48:40 hurdler
+;; Fix compiling problem under win32 with 3D-Floors and FragglScript (to verify!)
+;;
+;; Revision 1.5 2000/11/03 03:27:17 stroggonmeth
+;; Again with the bug fixing...
+;;
+;; Revision 1.4 2000/11/02 17:50:10 stroggonmeth
+;; Big 3Dfloors & FraggleScript commit!!
+;;
+;; Revision 1.3 2000/04/24 20:24:38 bpereira
+;; no message
+;;
+;; Revision 1.2 2000/02/27 00:42:11 hurdler
+;; fix CR+LF problem
+;;
+;; Revision 1.1.1.1 2000/02/22 20:32:32 hurdler
+;; Initial import into CVS (v1.29 pr3)
+;;
+;;
+;; DESCRIPTION:
+;; assembler optimised rendering code for software mode
+;; draw floor spans, and wall columns.
+;;
+;;-----------------------------------------------------------------------------
+
+
+[BITS 32]
+
+%ifdef LINUX
+%macro cextern 1
+[extern %1]
+%endmacro
+
+%macro cglobal 1
+[global %1]
+%endmacro
+
+%define CODE_SEG .data
+%else
+%macro cextern 1
+%define %1 _%1
+[extern %1]
+%endmacro
+
+%macro cglobal 1
+%define %1 _%1
+[global %1]
+%endmacro
+
+%define CODE_SEG .text
+%endif
+
+
+;; externs
+;; columns
+cextern dc_x
+cextern dc_yl
+cextern dc_yh
+cextern ylookup
+cextern columnofs
+cextern dc_source
+cextern dc_texturemid
+cextern dc_iscale
+cextern centery
+cextern dc_colormap
+cextern dc_transmap
+cextern colormaps
+
+;; spans
+cextern ds_x1
+cextern ds_x2
+cextern ds_y
+cextern ds_xfrac
+cextern ds_yfrac
+cextern ds_xstep
+cextern ds_ystep
+cextern ds_source
+cextern ds_colormap
+;cextern ds_textureheight
+
+; polygon edge rasterizer
+cextern prastertab
+
+
+;;----------------------------------------------------------------------
+;;
+;; R_DrawColumn
+;;
+;; New optimised version 10-01-1998 by D.Fabrice and P.Boris
+;; TO DO: optimise it much farther... should take at most 3 cycles/pix
+;; once it's fixed, add code to patch the offsets so that it
+;; works in every screen width.
+;;
+;;----------------------------------------------------------------------
+
+[SECTION .data]
+
+;;.align 4
+loopcount dd 0
+pixelcount dd 0
+tystep dd 0
+
+[SECTION CODE_SEG write]
+
+;----------------------------------------------------------------------------
+;fixed_t FixedMul (fixed_t a, fixed_t b)
+;----------------------------------------------------------------------------
+cglobal FixedMul
+; align 16
+FixedMul:
+ mov eax,[esp+4]
+ imul dword [esp+8]
+ shrd eax,edx,16
+ ret
+
+;----------------------------------------------------------------------------
+;fixed_t FixedDiv2 (fixed_t a, fixed_t b);
+;----------------------------------------------------------------------------
+cglobal FixedDiv2
+; align 16
+FixedDiv2:
+ mov eax,[esp+4]
+ mov edx,eax ;; these two instructions allow the next
+ sar edx,31 ;; two to pair, on the Pentium processor.
+ shld edx,eax,16
+ sal eax,16
+ idiv dword [esp+8]
+ ret
+
+;----------------------------------------------------------------------------
+; void ASM_PatchRowBytes (int rowbytes);
+;----------------------------------------------------------------------------
+cglobal ASM_PatchRowBytes
+; align 16
+ASM_PatchRowBytes:
+ mov eax,[esp+4]
+ mov [p1+2],eax
+ mov [p2+2],eax
+ mov [p3+2],eax
+ mov [p4+2],eax
+ mov [p5+2],eax
+ mov [p6+2],eax
+ mov [p7+2],eax
+ mov [p8+2],eax
+ mov [p9+2],eax
+ mov [pa+2],eax
+ mov [pb+2],eax
+ mov [pc+2],eax
+ mov [pd+2],eax
+ mov [pe+2],eax
+ mov [pf+2],eax
+ mov [pg+2],eax
+ mov [ph+2],eax
+ mov [pi+2],eax
+ mov [pj+2],eax
+ mov [pk+2],eax
+ mov [pl+2],eax
+ mov [pm+2],eax
+ mov [pn+2],eax
+ mov [po+2],eax
+ mov [pp+2],eax
+ mov [pq+2],eax
+ add eax,eax
+ mov [q1+2],eax
+ mov [q2+2],eax
+ mov [q3+2],eax
+ mov [q4+2],eax
+ mov [q5+2],eax
+ mov [q6+2],eax
+ mov [q7+2],eax
+ mov [q8+2],eax
+ ret
+
+
+;----------------------------------------------------------------------------
+; 8bpp column drawer
+;----------------------------------------------------------------------------
+
+cglobal R_DrawColumn_8
+; align 16
+R_DrawColumn_8:
+ push ebp ;; preserve caller's stack frame pointer
+ push esi ;; preserve register variables
+ push edi
+ push ebx
+;;
+;; dest = ylookup[dc_yl] + columnofs[dc_x];
+;;
+ mov ebp,[dc_yl]
+ mov ebx,ebp
+ mov edi,[ylookup+ebx*4]
+ mov ebx,[dc_x]
+ add edi,[columnofs+ebx*4] ;; edi = dest
+;;
+;; pixelcount = yh - yl + 1
+;;
+ mov eax,[dc_yh]
+ inc eax
+ sub eax,ebp ;; pixel count
+ mov [pixelcount],eax ;; save for final pixel
+ jle near vdone ;; nothing to scale
+;;
+;; frac = dc_texturemid - (centery-dc_yl)*fracstep;
+;;
+ mov ecx,[dc_iscale] ;; fracstep
+ mov eax,[centery]
+ sub eax,ebp
+ imul eax,ecx
+ mov edx,[dc_texturemid]
+ sub edx,eax
+ mov ebx,edx
+ shr ebx,16 ;; frac int.
+ and ebx,0x7f
+ shl edx,16 ;; y frac up
+
+ mov ebp,ecx
+ shl ebp,16 ;; fracstep f. up
+ shr ecx,16 ;; fracstep i. ->cl
+ and cl,0x7f
+ mov esi,[dc_source]
+;;
+;; lets rock :) !
+;;
+ mov eax,[pixelcount]
+ mov dh,al
+ shr eax,2
+ mov ch,al ;; quad count
+ mov eax,[dc_colormap]
+ test dh,0x3
+ je near v4quadloop
+;;
+;; do un-even pixel
+;;
+ test dh,0x1
+ je two_uneven
+
+ mov al,[esi+ebx] ;; prep un-even loops
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+ and bl,0x7f ;; mask 0-127 texture index
+ mov [edi],dl ;; output pixel
+p1: add edi,0x12345678
+;;
+;; do two non-quad-aligned pixels
+;;
+two_uneven:
+ test dh,0x2
+ je f3
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+ and bl,0x7f ;; mask 0-127 texture index
+ mov [edi],dl ;; output pixel
+ mov al,[esi+ebx]
+ add edx,ebp ;; fetch source texel
+ adc bl,cl ;; ypos f += ystep f
+ mov dl,[eax] ;; ypos i += ystep i
+ and bl,0x7f ;; colormap texel
+p2: add edi,0x12345678 ;; mask 0-127 texture index
+ mov [edi],dl
+p3: add edi,0x12345678 ;; output pixel
+;;
+;; test if there was at least 4 pixels
+;;
+f3:
+ test ch,0xff ;; test quad count
+ je near vdone
+;;
+;; ebp : ystep frac. upper 16 bits
+;; edx : y frac. upper 16 bits
+;; ebx : y i. lower 7 bits, masked for index
+;; ecx : ch = counter, cl = y step i.
+;; eax : colormap aligned 256
+;; esi : source texture column
+;; edi : dest screen
+;;
+v4quadloop:
+ mov dh,0x7f ;; prep mask
+align 4
+vquadloop:
+ mov al,[esi+ebx] ;; prep loop
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+ mov [edi],dl ;; output pixel
+ and bl,0x7f ;; mask 0-127 texture index
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+p4: add edi,0x12345678
+ mov dl,[eax]
+ and bl,0x7f
+ mov [edi],dl
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+p5: add edi,0x12345678
+ mov dl,[eax]
+ and bl,0x7f
+ mov [edi],dl
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+p6: add edi,0x12345678
+ mov dl,[eax]
+ and bl,0x7f
+ mov [edi],dl
+
+p7: add edi,0x12345678
+
+ dec ch
+ jne vquadloop
+
+vdone:
+ pop ebx ;; restore register variables
+ pop edi
+ pop esi
+ pop ebp ;; restore caller's stack frame pointer
+ ret
+
+;;----------------------------------------------------------------------
+;;13-02-98:
+;; R_DrawSkyColumn : same as R_DrawColumn but:
+;;
+;; - wrap around 256 instead of 127.
+;; this is needed because we have a higher texture for mouselook,
+;; we need at least 200 lines for the sky.
+;;
+;; NOTE: the sky should never wrap, so it could use a faster method.
+;; for the moment, we'll still use a wrapping method...
+;;
+;; IT S JUST A QUICK CUT N PASTE, WAS NOT OPTIMISED AS IT SHOULD BE !!!
+;;
+;;----------------------------------------------------------------------
+
+cglobal R_DrawSkyColumn_8
+; align 16
+R_DrawSkyColumn_8:
+ push ebp
+ push esi
+ push edi
+ push ebx
+;;
+;; dest = ylookup[dc_yl] + columnofs[dc_x];
+;;
+ mov ebp,[dc_yl]
+ mov ebx,ebp
+ mov edi,[ylookup+ebx*4]
+ mov ebx,[dc_x]
+ add edi,[columnofs+ebx*4] ;; edi = dest
+;;
+;; pixelcount = yh - yl + 1
+;;
+ mov eax,[dc_yh]
+ inc eax
+ sub eax,ebp ;; pixel count
+ mov [pixelcount],eax ;; save for final pixel
+ jle near vskydone ;; nothing to scale
+;;
+;; frac = dc_texturemid - (centery-dc_yl)*fracstep;
+;;
+ mov ecx,[dc_iscale] ;; fracstep
+ mov eax,[centery]
+ sub eax,ebp
+ imul eax,ecx
+ mov edx,[dc_texturemid]
+ sub edx,eax
+ mov ebx,edx
+ shr ebx,16 ;; frac int.
+ and ebx,0xff
+ shl edx,16 ;; y frac up
+ mov ebp,ecx
+ shl ebp,16 ;; fracstep f. up
+ shr ecx,16 ;; fracstep i. ->cl
+ mov esi,[dc_source]
+;;
+;; lets rock :) !
+;;
+ mov eax,[pixelcount]
+ mov dh,al
+ shr eax,0x2
+ mov ch,al ;; quad count
+ mov eax,[dc_colormap]
+ test dh,0x3
+ je vskyquadloop
+;;
+;; do un-even pixel
+;;
+ test dh,0x1
+ je f2
+ mov al,[esi+ebx] ;; prep un-even loops
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+ mov [edi],dl ;; output pixel
+p8: add edi,0x12345678
+;;
+;; do two non-quad-aligned pixels
+;;
+f2: test dh,0x2
+ je skyf3
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+ mov [edi],dl ;; output pixel
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp ;; ypos f += ystep f
+ adc bl,cl ;; ypos i += ystep i
+ mov dl,[eax] ;; colormap texel
+p9: add edi,0x12345678
+ mov [edi],dl ;; output pixel
+
+pa: add edi,0x12345678
+;;
+;; test if there was at least 4 pixels
+;;
+skyf3: test ch,0xff ;; test quad count
+ je vskydone
+;;
+;; ebp : ystep frac. upper 24 bits
+;; edx : y frac. upper 24 bits
+;; ebx : y i. lower 7 bits, masked for index
+;; ecx : ch = counter, cl = y step i.
+;; eax : colormap aligned 256
+;; esi : source texture column
+;; edi : dest screen
+;;
+align 4
+vskyquadloop:
+ mov al,[esi+ebx] ;; prep loop
+ add edx,ebp ;; ypos f += ystep f
+ mov dl,[eax] ;; colormap texel
+ adc bl,cl ;; ypos i += ystep i
+ mov [edi],dl ;; output pixel
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+pb: add edi,0x12345678
+ mov dl,[eax]
+ mov [edi],dl
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+pc: add edi,0x12345678
+ mov dl,[eax]
+ mov [edi],dl
+
+ mov al,[esi+ebx] ;; fetch source texel
+ add edx,ebp
+ adc bl,cl
+pd: add edi,0x12345678
+ mov dl,[eax]
+ mov [edi],dl
+
+pe: add edi,0x12345678
+
+ dec ch
+ jne vskyquadloop
+vskydone:
+ pop ebx
+ pop edi
+ pop esi
+ pop ebp
+ ret
+
+
+;;----------------------------------------------------------------------
+;; R_DrawTranslucentColumn_8
+;;
+;; Vertical column texture drawer, with transparency. Replaces Doom2's
+;; 'fuzz' effect, which was not so beautiful.
+;; Transparency is always impressive in some way, don't know why...
+;;----------------------------------------------------------------------
+
+cglobal R_DrawTranslucentColumn_8
+R_DrawTranslucentColumn_8:
+ push ebp ;; preserve caller's stack frame pointer
+ push esi ;; preserve register variables
+ push edi
+ push ebx
+;;
+;; dest = ylookup[dc_yl] + columnofs[dc_x];
+;;
+ mov ebp,[dc_yl]
+ mov ebx,ebp
+ mov edi,[ylookup+ebx*4]
+ mov ebx,[dc_x]
+ add edi,[columnofs+ebx*4] ;; edi = dest
+;;
+;; pixelcount = yh - yl + 1
+;;
+ mov eax,[dc_yh]
+ inc eax
+ sub eax,ebp ;; pixel count
+ mov [pixelcount],eax ;; save for final pixel
+ jle near vtdone ;; nothing to scale
+;;
+;; frac = dc_texturemid - (centery-dc_yl)*fracstep;
+;;
+ mov ecx,[dc_iscale] ;; fracstep
+ mov eax,[centery]
+ sub eax,ebp
+ imul eax,ecx
+ mov edx,[dc_texturemid]
+ sub edx,eax
+ mov ebx,edx
+
+ shr ebx,16 ;; frac int.
+ and ebx,0x7f
+ shl edx,16 ;; y frac up
+
+ mov ebp,ecx
+ shl ebp,16 ;; fracstep f. up
+ shr ecx,16 ;; fracstep i. ->cl
+ and cl,0x7f
+ push cx
+ mov ecx,edx
+ pop cx
+ mov edx,[dc_colormap]
+ mov esi,[dc_source]
+;;
+;; lets rock :) !
+;;
+ mov eax,[pixelcount]
+ shr eax,0x2
+ test byte [pixelcount],0x3
+ mov ch,al ;; quad count
+ mov eax,[dc_transmap]
+ je vt4quadloop
+;;
+;; do un-even pixel
+;;
+ test byte [pixelcount],0x1
+ je trf2
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add ecx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov dl,[edx]
+ mov [edi],dl
+pf: add edi,0x12345678
+;;
+;; do two non-quad-aligned pixels
+;;
+trf2: test byte [pixelcount],0x2
+ je trf3
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add ecx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov dl,[edx]
+ mov [edi],dl
+pg: add edi,0x12345678
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add ecx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov dl,[edx]
+ mov [edi],dl
+ph: add edi,0x12345678
+;;
+;; test if there was at least 4 pixels
+;;
+trf3: test ch,0xff ;; test quad count
+ je near vtdone
+
+;;
+;; ebp : ystep frac. upper 24 bits
+;; edx : y frac. upper 24 bits
+;; ebx : y i. lower 7 bits, masked for index
+;; ecx : ch = counter, cl = y step i.
+;; eax : colormap aligned 256
+;; esi : source texture column
+;; edi : dest screen
+;;
+vt4quadloop:
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [tystep],ebp
+pi: add edi,0x12345678
+ mov al,[edi] ;; fetch dest : index into colormap
+pj: sub edi,0x12345678
+ mov ebp,edi
+pk: sub edi,0x12345678
+ jmp short inloop
+align 4
+vtquadloop:
+ add ecx,[tystep]
+ adc bl,cl
+q1: add ebp,0x23456789
+ and bl,0x7f
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov dl,[edx]
+ mov [edi],dl
+ mov al,[ebp] ;; fetch dest : index into colormap
+inloop:
+ add ecx,[tystep]
+ adc bl,cl
+q2: add edi,0x23456789
+ and bl,0x7f
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov dl,[edx]
+ mov [ebp+0x0],dl
+ mov al,[edi] ;; fetch dest : index into colormap
+
+ add ecx,[tystep]
+ adc bl,cl
+q3: add ebp,0x23456789
+ and bl,0x7f
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov dl,[edx]
+ mov [edi],dl
+ mov al,[ebp] ;; fetch dest : index into colormap
+
+ add ecx,[tystep]
+ adc bl,cl
+q4: add edi,0x23456789
+ and bl,0x7f
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov dl,[edx]
+ mov [ebp],dl
+ mov al,[edi] ;; fetch dest : index into colormap
+
+ dec ch
+ jne vtquadloop
+vtdone:
+ pop ebx
+ pop edi
+ pop esi
+ pop ebp
+ ret
+
+
+;;----------------------------------------------------------------------
+;; R_DrawShadeColumn
+;;
+;; for smoke..etc.. test.
+;;----------------------------------------------------------------------
+cglobal R_DrawShadeColumn_8
+R_DrawShadeColumn_8:
+ push ebp ;; preserve caller's stack frame pointer
+ push esi ;; preserve register variables
+ push edi
+ push ebx
+
+;;
+;; dest = ylookup[dc_yl] + columnofs[dc_x];
+;;
+ mov ebp,[dc_yl]
+ mov ebx,ebp
+ mov edi,[ylookup+ebx*4]
+ mov ebx,[dc_x]
+ add edi,[columnofs+ebx*4] ;; edi = dest
+;;
+;; pixelcount = yh - yl + 1
+;;
+ mov eax,[dc_yh]
+ inc eax
+ sub eax,ebp ;; pixel count
+ mov [pixelcount],eax ;; save for final pixel
+ jle near shdone ;; nothing to scale
+;;
+;; frac = dc_texturemid - (centery-dc_yl)*fracstep;
+;;
+ mov ecx,[dc_iscale] ;; fracstep
+ mov eax,[centery]
+ sub eax,ebp
+ imul eax,ecx
+ mov edx,[dc_texturemid]
+ sub edx,eax
+ mov ebx,edx
+ shr ebx,16 ;; frac int.
+ and ebx,byte +0x7f
+ shl edx,16 ;; y frac up
+
+ mov ebp,ecx
+ shl ebp,16 ;; fracstep f. up
+ shr ecx,16 ;; fracstep i. ->cl
+ and cl,0x7f
+
+ mov esi,[dc_source]
+;;
+;; lets rock :) !
+;;
+ mov eax,[pixelcount]
+ mov dh,al
+ shr eax,2
+ mov ch,al ;; quad count
+ mov eax,[colormaps]
+ test dh,3
+ je sh4quadloop
+;;
+;; do un-even pixel
+;;
+ test dh,0x1
+ je shf2
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add edx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov [edi],dl
+pl: add edi,0x12345678
+;;
+;; do two non-quad-aligned pixels
+;;
+shf2:
+ test dh,0x2
+ je shf3
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add edx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov [edi],dl
+pm: add edi,0x12345678
+
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ add edx,ebp
+ adc bl,cl
+ mov al,[edi] ;; fetch dest : index into colormap
+ and bl,0x7f
+ mov dl,[eax]
+ mov [edi],dl
+pn: add edi,0x12345678
+;;
+;; test if there was at least 4 pixels
+;;
+shf3:
+ test ch,0xff ;; test quad count
+ je near shdone
+
+;;
+;; ebp : ystep frac. upper 24 bits
+;; edx : y frac. upper 24 bits
+;; ebx : y i. lower 7 bits, masked for index
+;; ecx : ch = counter, cl = y step i.
+;; eax : colormap aligned 256
+;; esi : source texture column
+;; edi : dest screen
+;;
+sh4quadloop:
+ mov dh,0x7f ;; prep mask
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [tystep],ebp
+po: add edi,0x12345678
+ mov al,[edi] ;; fetch dest : index into colormap
+pp: sub edi,0x12345678
+ mov ebp,edi
+pq: sub edi,0x12345678
+ jmp short shinloop
+
+align 4
+shquadloop:
+ add edx,[tystep]
+ adc bl,cl
+ and bl,dh
+q5: add ebp,0x12345678
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [edi],dl
+ mov al,[ebp] ;; fetch dest : index into colormap
+shinloop:
+ add edx,[tystep]
+ adc bl,cl
+ and bl,dh
+q6: add edi,0x12345678
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [ebp],dl
+ mov al,[edi] ;; fetch dest : index into colormap
+
+ add edx,[tystep]
+ adc bl,cl
+ and bl,dh
+q7: add ebp,0x12345678
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [edi],dl
+ mov al,[ebp] ;; fetch dest : index into colormap
+
+ add edx,[tystep]
+ adc bl,cl
+ and bl,dh
+q8: add edi,0x12345678
+ mov dl,[eax]
+ mov ah,[esi+ebx] ;; fetch texel : colormap number
+ mov [ebp],dl
+ mov al,[edi] ;; fetch dest : index into colormap
+
+ dec ch
+ jne shquadloop
+
+shdone:
+ pop ebx ;; restore register variables
+ pop edi
+ pop esi
+ pop ebp ;; restore caller's stack frame pointer
+ ret
+
+
+
+;;----------------------------------------------------------------------
+;;
+;; R_DrawSpan
+;;
+;; Horizontal texture mapping
+;;
+;;----------------------------------------------------------------------
+
+
+[SECTION .data]
+
+oldcolormap dd 0
+
+[SECTION CODE_SEG write]
+
+cglobal R_DrawSpan_8
+R_DrawSpan_8:
+ push ebp ;; preserve caller's stack frame pointer
+ push esi ;; preserve register variables
+ push edi
+ push ebx
+;;
+;; initilise registers
+;;
+
+ mov edx, [ds_xfrac]
+ mov eax, [ds_ystep]
+ ror edx, 14
+ ror eax, 15
+ mov bl, dl
+ mov ecx, [ds_xstep]
+ mov dh, al
+ mov ax, 1
+ mov [tystep], eax
+
+
+ mov eax, [ds_yfrac]
+ ror ecx, 13
+ ror eax, 16
+ mov dl, cl
+ mov bh, al
+ xor cx, cx
+ and ebx, 0x3fff
+ mov [pixelcount],ecx
+
+ mov ecx, [ds_x2]
+ mov edi, [ds_y]
+ mov esi, [ds_x1]
+ mov edi, [ylookup+edi*4]
+ mov ebp, ebx
+ add edi, [columnofs+esi*4]
+ sub esi, ecx ;; pixel count
+ shr ebp, 2
+ mov ecx, [ds_colormap]
+ mov ax, si
+ mov esi, [ds_source]
+ sar ax,1
+ jnc near .midloop ;; check parity
+
+; summary
+; edx = high16bit xfrac[0..13], ah=ystep[16..24] al=xtep[14..21]
+; ebx = high16bit =0, bh=yfrac[16..24], bl=xfrac[14..21]
+; ecx = colormap table cl=0 (colormap is aligned 8 bits)
+; eax = high16bit yfrac[0..15], dx = count
+; esi = flat texture source
+; edi = screeen buffer destination
+; ebp = work register
+; pixelcount = high16bit xstep[0..13] rest to 0
+; tystep = high16bit ystep[0..15] low 16 bit = 2 (increment of count)
+
+align 4
+.loop
+ add eax, [tystep]
+ mov cl, [esi+ebp]
+ adc bh, dh
+ mov cl, [ecx]
+ and bh, 0x3f
+ mov [edi], cl
+ mov ebp, ebx
+ inc edi
+ shr ebp, 2
+
+.midloop:
+ add edx, [pixelcount]
+ mov cl, [esi+ebp]
+ adc bl, dl
+ mov cl, [ecx]
+ mov ebp, ebx
+ mov [edi], cl
+ inc edi
+ shr ebp, 2
+
+ test eax, 0xffff
+ jnz near .loop
+
+.hdone: pop ebx ;; restore register variables
+ pop edi
+ pop esi
+ pop ebp ;; restore caller's stack frame pointer
+ ret
+
+
+[SECTION .data]
+
+obelix dd 0
+etaussi dd 0
+
+[SECTION CODE_SEG]
+
+cglobal R_DrawSpan_8_old
+R_DrawSpan_8_old:
+ push ebp ;; preserve caller's stack frame pointer
+ push esi ;; preserve register variables
+ push edi
+ push ebx
+;;
+;; find loop count
+;;
+ mov eax,[ds_x2]
+ inc eax
+ sub eax,[ds_x1] ;; pixel count
+ mov [pixelcount],eax ;; save for final pixel
+ js near .hdone ;; nothing to scale
+ shr eax,0x1 ;; double pixel count
+ mov [loopcount],eax
+;;
+;; build composite position
+;;
+ mov ebp,[ds_xfrac]
+ shl ebp,10
+ and ebp,0xffff0000
+ mov eax,[ds_yfrac]
+ shr eax,6
+ and eax,0xffff
+ mov edi,[ds_y]
+ or ebp,eax
+
+ mov esi,[ds_source]
+;;
+;; calculate screen dest
+;;
+ mov edi,[ylookup+edi*4]
+ mov eax,[ds_x1]
+ add edi,[columnofs+eax*4]
+;;
+;; build composite step
+;;
+ mov ebx,[ds_xstep]
+ shl ebx,10
+ and ebx,0xffff0000
+ mov eax,[ds_ystep]
+ shr eax,6
+ and eax,0xffff
+ or ebx,eax
+
+ mov [obelix],ebx
+ mov [etaussi],esi
+
+;; %eax aligned colormap
+;; %ebx aligned colormap
+;; %ecx,%edx scratch
+;; %esi virtual source
+;; %edi moving destination pointer
+;; %ebp frac
+
+ mov eax,[ds_colormap]
+ mov ecx,ebp
+ add ebp,ebx ;; advance frac pointer
+ shr cx,10
+ rol ecx,6
+ and ecx,4095 ;; finish calculation for third pixel
+ mov edx,ebp
+ shr dx,10
+ rol edx,6
+ add ebp,ebx ;; advance frac pointer
+ and edx,4095 ;; finish calculation for fourth pixel
+ mov ebx,eax
+ mov al,[esi+ecx] ;; get first pixel
+ mov bl,[esi+edx] ;; get second pixel
+
+ test dword [pixelcount],0xfffffffe
+
+ mov dl,[eax] ;; color translate first pixel
+
+;; movw $0xf0f0,%dx ;;see visplanes start
+
+ je .hchecklast
+
+ mov dh,[ebx] ;; color translate second pixel
+ mov esi,[loopcount]
+align 4
+.hdoubleloop:
+ mov ecx,ebp
+ shr cx,10
+ rol ecx,6
+ add ebp,[obelix] ;; advance frac pointer
+ mov [edi],dx ;; write first pixel
+ and ecx,4095 ;; finish calculation for third pixel
+ mov edx,ebp
+ shr dx,10
+ rol edx,6
+ add ecx,[etaussi]
+ and edx,4095 ;; finish calculation for fourth pixel
+ mov al,[ecx] ;; get third pixel
+ add ebp,[obelix] ;; advance frac pointer
+ add edx,[etaussi]
+ mov bl,[edx] ;; get fourth pixel
+ mov dl,[eax] ;; color translate third pixel
+ add edi,byte +0x2 ;; advance to third pixel destination
+ dec esi ;; done with loop?
+ mov dh,[ebx] ;; color translate fourth pixel
+ jne .hdoubleloop
+;; check for final pixel
+.hchecklast:
+ test dword [pixelcount],0x1
+ je .hdone
+ mov [edi],dl ;; write final pixel
+.hdone: pop ebx ;; restore register variables
+ pop edi
+ pop esi
+ pop ebp ;; restore caller's stack frame pointer
+ ret
+
+
+;; ========================================================================
+;; Rasterization des segments d'un polyg“ne textur‚ de maniŠre LINEAIRE.
+;; Il s'agit donc d'interpoler les coordonn‚es aux bords de la texture en
+;; mˆme temps que les abscisses minx/maxx pour chaque ligne.
+;; L'argument 'dir' indique quels bords de la texture sont interpolés:
+;; 0 : segments associ‚s aux bord SUPERIEUR et INFERIEUR ( TY constant )
+;; 1 : segments associ‚s aux bord GAUCHE et DROITE ( TX constant )
+;; ========================================================================
+;;
+;; void rasterize_segment_tex( LONG x1, LONG y1, LONG x2, LONG y2, LONG tv1, LONG tv2, LONG tc, LONG dir );
+;; ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 ARG7 ARG8
+;;
+;; Pour dir = 0, (tv1,tv2) = (tX1,tX2), tc = tY, en effet TY est constant.
+;;
+;; Pour dir = 1, (tv1,tv2) = (tY1,tY2), tc = tX, en effet TX est constant.
+;;
+;;
+;; Uses: extern struct rastery *_rastertab;
+;;
+
+[SECTION CODE_SEG write]
+
+MINX EQU 0
+MAXX EQU 4
+TX1 EQU 8
+TY1 EQU 12
+TX2 EQU 16
+TY2 EQU 20
+RASTERY_SIZEOF EQU 24
+
+cglobal rasterize_segment_tex
+rasterize_segment_tex:
+ push ebp
+ mov ebp,esp
+
+ sub esp,byte +0x8 ;; alloue les variables locales
+
+ push ebx
+ push esi
+ push edi
+ o16 mov ax,es
+ push eax
+
+;; #define DX [ebp-4]
+;; #define TD [ebp-8]
+
+ mov eax,[ebp+0xc] ;; y1
+ mov ebx,[ebp+0x14] ;; y2
+ cmp ebx,eax
+ je near .L_finished ;; special (y1==y2) segment horizontal, exit!
+
+ jg near .L_rasterize_right
+
+;;rasterize_left: ;; on rasterize un segment … la GAUCHE du polyg“ne
+
+ mov ecx,eax
+ sub ecx,ebx
+ inc ecx ;; y1-y2+1
+
+ mov eax,RASTERY_SIZEOF
+ mul ebx ;; * y2
+ mov esi,[prastertab]
+ add esi,eax ;; point into rastertab[y2]
+
+ mov eax,[ebp+0x8] ;; ARG1
+ sub eax,[ebp+0x10] ;; ARG3
+ shl eax,0x10 ;; ((x1-x2)<<PRE) ...
+ cdq
+ idiv ecx ;; dx = ... / (y1-y2+1)
+ mov [ebp-0x4],eax ;; DX
+
+ mov eax,[ebp+0x18] ;; ARG5
+ sub eax,[ebp+0x1c] ;; ARG6
+ shl eax,0x10
+ cdq
+ idiv ecx ;; tdx =((tx1-tx2)<<PRE) / (y1-y2+1)
+ mov [ebp-0x8],eax ;; idem tdy =((ty1-ty2)<<PRE) / (y1-y2+1)
+
+ mov eax,[ebp+0x10] ;; ARG3
+ shl eax,0x10 ;; x = x2<<PRE
+
+ mov ebx,[ebp+0x1c] ;; ARG6
+ shl ebx,0x10 ;; tx = tx2<<PRE d0
+ ;; ty = ty2<<PRE d1
+ mov edx,[ebp+0x20] ;; ARG7
+ shl edx,0x10 ;; ty = ty<<PRE d0
+ ;; tx = tx<<PRE d1
+ push ebp
+ mov edi,[ebp-0x4] ;; DX
+ cmp dword [ebp+0x24],byte +0x0 ;; ARG8 direction ?
+
+ mov ebp,[ebp-0x8] ;; TD
+ je .L_rleft_h_loop
+;;
+;; TY varie, TX est constant
+;;
+.L_rleft_v_loop:
+ mov [esi+MINX],eax ;; rastertab[y].minx = x
+ add ebx,ebp
+ mov [esi+TX1],edx ;; .tx1 = tx
+ add eax,edi
+ mov [esi+TY1],ebx ;; .ty1 = ty
+
+ ;;addl DX, %eax // x += dx
+ ;;addl TD, %ebx // ty += tdy
+
+ add esi,RASTERY_SIZEOF ;; next raster line into rastertab[]
+ dec ecx
+ jne .L_rleft_v_loop
+ pop ebp
+ jmp .L_finished
+;;
+;; TX varie, TY est constant
+;;
+.L_rleft_h_loop:
+ mov [esi+MINX],eax ;; rastertab[y].minx = x
+ add eax,edi
+ mov [esi+TX1],ebx ;; .tx1 = tx
+ add ebx,ebp
+ mov [esi+TY1],edx ;; .ty1 = ty
+
+ ;;addl DX, %eax // x += dx
+ ;;addl TD, %ebx // tx += tdx
+
+ add esi,RASTERY_SIZEOF ;; next raster line into rastertab[]
+ dec ecx
+ jne .L_rleft_h_loop
+ pop ebp
+ jmp .L_finished
+;;
+;; on rasterize un segment … la DROITE du polyg“ne
+;;
+.L_rasterize_right:
+ mov ecx,ebx
+ sub ecx,eax
+ inc ecx ;; y2-y1+1
+
+ mov ebx,RASTERY_SIZEOF
+ mul ebx ;; * y1
+ mov esi,[prastertab]
+ add esi,eax ;; point into rastertab[y1]
+
+ mov eax,[ebp+0x10] ;; ARG3
+ sub eax,[ebp+0x8] ;; ARG1
+ shl eax,0x10 ;; ((x2-x1)<<PRE) ...
+ cdq
+ idiv ecx ;; dx = ... / (y2-y1+1)
+ mov [ebp-0x4],eax ;; DX
+
+ mov eax,[ebp+0x1c] ;; ARG6
+ sub eax,[ebp+0x18] ;; ARG5
+ shl eax,0x10
+ cdq
+ idiv ecx ;; tdx =((tx2-tx1)<<PRE) / (y2-y1+1)
+ mov [ebp-0x8],eax ;; idem tdy =((ty2-ty1)<<PRE) / (y2-y1+1)
+
+ mov eax,[ebp+0x8] ;; ARG1
+ shl eax,0x10 ;; x = x1<<PRE
+
+ mov ebx,[ebp+0x18] ;; ARG5
+ shl ebx,0x10 ;; tx = tx1<<PRE d0
+ ;; ty = ty1<<PRE d1
+ mov edx,[ebp+0x20] ;; ARG7
+ shl edx,0x10 ;; ty = ty<<PRE d0
+ ;; tx = tx<<PRE d1
+ push ebp
+ mov edi,[ebp-0x4] ;; DX
+
+ cmp dword [ebp+0x24], 0 ;; direction ?
+
+ mov ebp,[ebp-0x8] ;; TD
+ je .L_rright_h_loop
+;;
+;; TY varie, TX est constant
+;;
+.L_rright_v_loop:
+
+ mov [esi+MAXX],eax ;; rastertab[y].maxx = x
+ add ebx,ebp
+ mov [esi+TX2],edx ;; .tx2 = tx
+ add eax,edi
+ mov [esi+TY2],ebx ;; .ty2 = ty
+
+ ;;addl DX, %eax // x += dx
+ ;;addl TD, %ebx // ty += tdy
+
+ add esi,RASTERY_SIZEOF
+ dec ecx
+ jne .L_rright_v_loop
+
+ pop ebp
+
+ jmp short .L_finished
+;;
+;; TX varie, TY est constant
+;;
+.L_rright_h_loop:
+ mov [esi+MAXX],eax ;; rastertab[y].maxx = x
+ add eax,edi
+ mov [esi+TX2],ebx ;; .tx2 = tx
+ add ebx,ebp
+ mov [esi+TY2],edx ;; .ty2 = ty
+
+ ;;addl DX, %eax // x += dx
+ ;;addl TD, %ebx // tx += tdx
+
+ add esi,RASTERY_SIZEOF
+ dec ecx
+ jne .L_rright_h_loop
+
+ pop ebp
+
+.L_finished:
+ pop eax
+ o16 mov es,ax
+ pop edi
+ pop esi
+ pop ebx
+
+ mov esp,ebp
+ pop ebp
+ ret
+
+
+;;; this version can draw 64x64 tiles, but they would have to be arranged 4 per row,
+;; so that the stride from one line to the next is 256
+;;
+;; .data
+;;xstep dd 0
+;;ystep dd 0
+;;texwidth dd 64 ;; texture width
+;; .text
+;; this code is kept in case we add high-detail floor textures for example (256x256)
+; align 16
+;_R_DrawSpan_8:
+; push ebp ;; preserve caller's stack frame pointer
+; push esi ;; preserve register variables
+; push edi
+; push ebx
+;;
+;; find loop count
+;;
+; mov eax,[ds_x2]
+; inc eax
+; sub eax,[ds_x1] ;; pixel count
+; mov [pixelcount],eax ;; save for final pixel
+; js near .hdone ;; nothing to scale
+;;
+;; calculate screen dest
+;;
+; mov edi,[ds_y]
+; mov edi,[ylookup+edi*4]
+; mov eax,[ds_x1]
+; add edi,[columnofs+eax*4]
+;;
+;; prepare registers for inner loop
+;;
+; xor eax,eax
+; mov edx,[ds_xfrac]
+; ror edx,16
+; mov al,dl
+; mov ecx,[ds_yfrac]
+; ror ecx,16
+; mov ah,cl
+;
+; mov ebx,[ds_xstep]
+; ror ebx,16
+; mov ch,bl
+; and ebx,0xffff0000
+; mov [xstep],ebx
+; mov ebx,[ds_ystep]
+; ror ebx,16
+; mov dh,bl
+; and ebx,0xffff0000
+; mov [ystep],ebx
+;
+; mov esi,[ds_source]
+;
+;;; %eax Yi,Xi in %ah,%al
+;;; %ebx aligned colormap
+;;; %ecx Yfrac upper, dXi in %ch, %cl is counter (upto 1024pels, =4x256)
+;;; %edx Xfrac upper, dYi in %dh, %dl receives mapped pixels from (ebx)
+;;; ystep dYfrac, add to %ecx, low word is 0
+;;; xstep dXfrac, add to %edx, low word is 0
+;;; %ebp temporary register serves as offset like %eax
+;;; %esi virtual source
+;;; %edi moving destination pointer
+;
+; mov ebx,[pixelcount]
+; shr ebx,0x2 ;; 4 pixels per loop
+; test bl,0xff
+; je near .hchecklast
+; mov cl,bl
+;
+; mov ebx,[dc_colormap]
+;;;
+;;; prepare loop with first pixel
+;;;
+; add ecx,[ystep] ;;pr‚a1
+; adc ah,dh
+; add edx,[xstep]
+; adc al,ch
+; and eax,0x3f3f
+; mov bl,[esi+eax] ;;pr‚b1
+; mov dl,[ebx] ;;pr‚c1
+;
+; add ecx,[ystep] ;;a2
+; adc ah,dh
+;
+;.hdoubleloop:
+; mov [edi+1],dl
+; add edx,[xstep]
+; adc al,ch
+; add edi,byte +0x2
+; mov ebp,eax
+; add ecx,[ystep]
+; adc ah,dh
+; and ebp,0x3f3f
+; add edx,[xstep]
+; mov bl,[esi+ebp]
+; adc al,ch
+; mov dl,[ebx]
+; and eax,0x3f3f
+; mov [edi],dl
+; mov bl,[esi+eax]
+; add ecx,[ystep]
+; adc ah,dh
+; add edx,[xstep]
+; adc al,ch
+; mov dl,[ebx]
+; mov ebp,eax
+; mov [edi+1],dl
+; and ebp,0x3f3f
+; add ecx,[ystep]
+; adc ah,dh
+; mov bl,[esi+ebp]
+; add edi,byte +0x2
+; add edx,[xstep]
+; adc al,ch
+; mov dl,[ebx]
+; and eax,0x3f3f
+; mov [edi],dl
+; mov bl,[esi+eax]
+; add ecx,[ystep]
+; adc ah,dh
+; mov dl,[ebx]
+; dec cl
+; jne near .hdoubleloop
+;;; check for final pixel
+;.hchecklast:
+;;; to do
+;.hdone:
+; pop ebx
+; pop edi
+; pop esi
+; pop ebp
+; ret
diff --git a/test/uscore.asm b/test/uscore.asm new file mode 100644 index 0000000..ec61443 --- /dev/null +++ b/test/uscore.asm @@ -0,0 +1,15 @@ +;Testname=test; Arguments=-fbin -ouscore.bin; Files=stdout stderr uscore.bin + dd 0x1234_5678 + dd 305_419_896 ; Same number as above it + dd 0x1e16 ; NOT a floating-point number! + dd 1e16h ; NOT a floating-point number! + dd 1e16_h ; NOT a floating-point number! + dd $1e16 ; NOT a floating-point number! + dd $1e+16 ; NOT a floating-point number! + dd 1e16 ; THIS is a floating-point number! + dd 1e+16 + dd 1.e+16 + dd 1e+1_6 + dd 1e1_6 + dd 1.0e16 + dd 1_0e16 ; This is 1e17, not 1e16! diff --git a/test/utf.asm b/test/utf.asm new file mode 100644 index 0000000..4b894f8 --- /dev/null +++ b/test/utf.asm @@ -0,0 +1,30 @@ +;Testname=test; Arguments=-fbin -outf.bin; Files=stdout stderr utf.bin +;Testname=error; Arguments=-fbin -outf.bin -DERROR; Files=stdout stderr utf.bin +%define u(x) __utf16__(x) +%define w(x) __utf32__(x) + + db `Test \u306a\U0001abcd\n` + dw u(`Test \u306a\U0001abcd\n`) + dd w(`Test \u306a\U0001abcd\n`) + + db `\u306a` + db `\xe3\x81\xaa` + + dw __utf16__ "Hello, World!" + + nop + + mov ax,u(`a`) + mov bx,u(`\u306a`) + mov cx,u(`\xe3\x81\xaa`) + mov eax,u(`ab`) + mov ebx,u(`\U0001abcd`) + mov ecx,w(`\U0001abcd`) + +%ifdef ERROR + dw __utf16__ 33 + dw __utf16__, 46 + dw __utf16__("Hello, World!",16) + dw __utf16__("Hello, World!",16 + dw u(`\xff`) +%endif diff --git a/test/vmread.asm b/test/vmread.asm new file mode 100644 index 0000000..551c71a --- /dev/null +++ b/test/vmread.asm @@ -0,0 +1,26 @@ +;Testname=test; Arguments=-fbin -ovmread.bin; Files=stdout stderr vmread.bin + + bits 32 + vmread dword [0], eax + vmwrite eax, dword [0] + vmread [0], eax + vmwrite eax, [0] + + bits 64 + vmread qword [0], rax + vmwrite rax, qword [0] + vmread [0], rax + vmwrite rax, [0] + +%ifdef ERROR + bits 32 + vmread qword [0], eax + vmwrite eax, qword [0] + + bits 64 + vmread dword [0], eax + vmwrite eax, dword [0] + + vmread qword [0], eax + vmwrite eax, qword [0] +%endif
\ No newline at end of file diff --git a/test/weirdpaste.asm b/test/weirdpaste.asm new file mode 100644 index 0000000..46bfa90 --- /dev/null +++ b/test/weirdpaste.asm @@ -0,0 +1,29 @@ +;Testname=preproc; Arguments=-E; Files=stdout stderr +;Testname=bin; Arguments=-fbin -oweirdpaste.bin; Files=stdout stderr weirdpaste.bin + + %define foo xyzzy +%define bar 1e+10 + +%define xyzzy1e 15 + +%macro dx 2 +%assign xx %1%2 + dw xx +%endmacro + + dx foo, bar + +%macro df 2 +%assign xy __float32__(%1e+%2) + dd xy + dd %1e+%2 +%endmacro + + df 1, 36 + df 33, 20 + df 0, 2 + df 1.2, 5 + + +%define N 1e%++%+ 5 + dd N, 1e+5 diff --git a/test/xchg.asm b/test/xchg.asm new file mode 100644 index 0000000..9c826dd --- /dev/null +++ b/test/xchg.asm @@ -0,0 +1,96 @@ +;Testname=unoptimized; Arguments=-fbin -oxchg.bin -O0; Files=stdout stderr xchg.bin +;Testname=optimized; Arguments=-fbin -oxchg.bin -Ox; Files=stdout stderr xchg.bin + +%macro x 2 + xchg %1,%2 + xchg %2,%1 +%endmacro + + bits 16 + + x ax,ax + x ax,cx + x ax,dx + x ax,bx + x ax,sp + x ax,bp + x ax,si + x ax,di + x eax,eax + x eax,ecx + x eax,edx + x eax,ebx + x eax,esp + x eax,ebp + x eax,esi + x eax,edi + + bits 32 + + x ax,ax + x ax,cx + x ax,dx + x ax,bx + x ax,sp + x ax,bp + x ax,si + x ax,di + x eax,eax + x eax,ecx + x eax,edx + x eax,ebx + x eax,esp + x eax,ebp + x eax,esi + x eax,edi + + bits 64 + + x ax,ax + x ax,cx + x ax,dx + x ax,bx + x ax,sp + x ax,bp + x ax,si + x ax,di + x ax,r8w + x ax,r9w + x ax,r10w + x ax,r11w + x ax,r12w + x ax,r13w + x ax,r14w + x ax,r15w + x eax,eax + x eax,ecx + x eax,edx + x eax,ebx + x eax,esp + x eax,ebp + x eax,esi + x eax,edi + x eax,r8d + x eax,r9d + x eax,r10d + x eax,r11d + x eax,r12d + x eax,r13d + x eax,r14d + x eax,r15d + x rax,rax + x rax,rcx + x rax,rdx + x rax,rbx + x rax,rsp + x rax,rbp + x rax,rsi + x rax,rdi + x rax,r8 + x rax,r9 + x rax,r10 + x rax,r11 + x rax,r12 + x rax,r13 + x rax,r14 + x rax,r15 diff --git a/test/xcrypt.asm b/test/xcrypt.asm new file mode 100644 index 0000000..55a3f5d --- /dev/null +++ b/test/xcrypt.asm @@ -0,0 +1,24 @@ +;Testname=test; Arguments=-fbin -oxcrypt.bin; Files=stdout stderr xcrypt.bin +; BR 2029829 + + bits 32 + + rep xstore + rep xcryptecb + rep xcryptcbc + rep xcryptctr + rep xcryptcfb + rep xcryptofb + rep montmul + rep xsha1 + rep xsha256 + + xstore + xcryptecb + xcryptcbc + xcryptctr + xcryptcfb + xcryptofb + montmul + xsha1 + xsha256 diff --git a/test/zerobyte.asm b/test/zerobyte.asm new file mode 100644 index 0000000..c3a0441 --- /dev/null +++ b/test/zerobyte.asm @@ -0,0 +1,22 @@ +;Testname=test; Arguments=-fbin -ozerobyte.bin; Files=stdout stderr zerobyte.bin + bits 64 + + mov eax,bar-foo + +foo: + add al,r10b +bar: + + lldt ax + lldt r8w + ltr [rax] + sldt eax + sldt r8d + str eax + str rax + str r8d + str r8 + verr ax + verr r8w + verw ax + verw r8w |