From 993d65531741fccf26fc10fc5789a5c9fca8c5ae Mon Sep 17 00:00:00 2001 From: Jinkun Jang Date: Tue, 12 Mar 2013 15:14:36 +0900 Subject: Tizen 2.1 base --- test/Makefile | 91 + test/_file_.asm | 5 + test/_version.asm | 2 + test/a32offs.asm | 9 + test/absolute.asm | 40 + test/addr64x.asm | 18 + test/align13.asm | 16 + test/align13s.asm | 16 + test/alonesym-obj.asm | 163 ++ test/andbyte.asm | 15 + test/aoutso.asm | 99 + test/aouttest.asm | 86 + test/aouttest.c | 36 + test/avx.asm | 53 + test/avx005.asm | 529 +++++ test/bcd.asm | 21 + test/binexe.asm | 35 + test/bintest.asm | 59 + test/bisect.sh | 22 + test/br1879590.asm | 25 + test/br2003451.asm | 15 + test/br2030823.asm | 5 + test/br2148476.asm | 221 ++ test/br2222615.asm | 19 + test/br560575.asm | 17 + test/br560873.asm | 27 + test/br890790.asm | 7 + test/br890790_i.asm | 1 + test/changed.asm | 383 ++++ test/cofftest.asm | 85 + test/cofftest.c | 35 + test/crc32.asm | 37 + test/dtbcd.asm | 72 + test/elf64so.asm | 118 ++ test/elfso.asm | 100 + test/elftest.asm | 87 + test/elftest.c | 38 + test/elftest64.c | 43 + test/elif.asm | 39 + test/expimp.asm | 90 + test/far64.asm | 10 + test/float.asm | 186 ++ test/float8.asm | 135 ++ test/floatb.asm | 35 + test/floatexp.asm | 382 ++++ test/floatize.asm | 19 + test/floattest.asm | 28 + test/floatx.asm | 525 +++++ test/fpu.asm | 127 ++ test/fwdopt.asm | 133 ++ test/fwdoptpp.asm | 150 ++ test/gotoff64.asm | 25 + test/ifelse.asm | 46 + test/ifmacro.asm | 413 ++++ test/iftoken.asm | 317 +++ test/iftoken.pl | 32 + test/imacro.asm | 8 + test/imm64.asm | 7 + test/immwarn.asm | 91 + test/imul.asm | 117 ++ test/inc1.asm | 6 + test/inc2.asm | 8 + test/inctest.asm | 15 + test/insnlbl.asm | 12 + test/invlpga.asm | 11 + test/jmp64.asm | 15 + test/lar_lsl.asm | 124 ++ test/larlsl.asm | 23 + test/lnxhello.asm | 54 + test/local.asm | 19 + test/loopoffs.asm | 12 + test/macro-defaults.asm | 64 + test/mmxsize.asm | 38 + test/movimm.asm | 28 + test/movnti.asm | 10 + test/multisection.asm | 96 + test/nasmformat.asm | 17 + test/new | 9 + test/nop.asm | 17 + test/nullfile.asm | 4 + test/objexe.asm | 30 + test/objlink.c | 33 + test/objtest.asm | 85 + test/optimization.asm | 104 + test/org.asm | 18 + test/perf/label.pl | 18 + test/perf/macro.pl | 18 + test/perf/token.pl | 23 + test/performtest.pl | 192 ++ test/pinsr16.asm | 53 + test/pinsr32.asm | 53 + test/pinsr64.asm | 68 + test/popcnt.asm | 32 + test/ppindirect.asm | 42 + test/pushseg.asm | 17 + test/r13.asm | 15 + test/radix.asm | 54 + test/riprel.asm | 5357 +++++++++++++++++++++++++++++++++++++++++++++++ test/riprel.pl | 29 + test/riprel2.asm | 11 + test/smartalign16.asm | 36 + test/smartalign32.asm | 36 + test/smartalign64.asm | 36 + test/struc.asm | 33 + test/test67.asm | 38 + test/testdos.asm | 13 + test/testnos3.asm | 973 +++++++++ test/time.asm | 11 + test/tmap.nas | 1447 +++++++++++++ test/uscore.asm | 15 + test/utf.asm | 30 + test/vmread.asm | 26 + test/weirdpaste.asm | 29 + test/xchg.asm | 96 + test/xcrypt.asm | 24 + test/zerobyte.asm | 22 + 116 files changed, 15264 insertions(+) create mode 100644 test/Makefile create mode 100644 test/_file_.asm create mode 100644 test/_version.asm create mode 100644 test/a32offs.asm create mode 100644 test/absolute.asm create mode 100644 test/addr64x.asm create mode 100644 test/align13.asm create mode 100644 test/align13s.asm create mode 100644 test/alonesym-obj.asm create mode 100644 test/andbyte.asm create mode 100644 test/aoutso.asm create mode 100644 test/aouttest.asm create mode 100644 test/aouttest.c create mode 100644 test/avx.asm create mode 100644 test/avx005.asm create mode 100644 test/bcd.asm create mode 100644 test/binexe.asm create mode 100644 test/bintest.asm create mode 100755 test/bisect.sh create mode 100644 test/br1879590.asm create mode 100644 test/br2003451.asm create mode 100644 test/br2030823.asm create mode 100644 test/br2148476.asm create mode 100644 test/br2222615.asm create mode 100644 test/br560575.asm create mode 100644 test/br560873.asm create mode 100644 test/br890790.asm create mode 100644 test/br890790_i.asm create mode 100644 test/changed.asm create mode 100644 test/cofftest.asm create mode 100644 test/cofftest.c create mode 100644 test/crc32.asm create mode 100644 test/dtbcd.asm create mode 100644 test/elf64so.asm create mode 100644 test/elfso.asm create mode 100644 test/elftest.asm create mode 100644 test/elftest.c create mode 100644 test/elftest64.c create mode 100644 test/elif.asm create mode 100644 test/expimp.asm create mode 100644 test/far64.asm create mode 100644 test/float.asm create mode 100644 test/float8.asm create mode 100644 test/floatb.asm create mode 100644 test/floatexp.asm create mode 100644 test/floatize.asm create mode 100644 test/floattest.asm create mode 100644 test/floatx.asm create mode 100644 test/fpu.asm create mode 100644 test/fwdopt.asm create mode 100644 test/fwdoptpp.asm create mode 100644 test/gotoff64.asm create mode 100644 test/ifelse.asm create mode 100644 test/ifmacro.asm create mode 100644 test/iftoken.asm create mode 100755 test/iftoken.pl create mode 100644 test/imacro.asm create mode 100644 test/imm64.asm create mode 100644 test/immwarn.asm create mode 100644 test/imul.asm create mode 100644 test/inc1.asm create mode 100644 test/inc2.asm create mode 100644 test/inctest.asm create mode 100644 test/insnlbl.asm create mode 100644 test/invlpga.asm create mode 100644 test/jmp64.asm create mode 100644 test/lar_lsl.asm create mode 100644 test/larlsl.asm create mode 100644 test/lnxhello.asm create mode 100644 test/local.asm create mode 100644 test/loopoffs.asm create mode 100644 test/macro-defaults.asm create mode 100644 test/mmxsize.asm create mode 100644 test/movimm.asm create mode 100644 test/movnti.asm create mode 100644 test/multisection.asm create mode 100644 test/nasmformat.asm create mode 100755 test/new create mode 100644 test/nop.asm create mode 100644 test/nullfile.asm create mode 100644 test/objexe.asm create mode 100644 test/objlink.c create mode 100644 test/objtest.asm create mode 100644 test/optimization.asm create mode 100644 test/org.asm create mode 100755 test/perf/label.pl create mode 100755 test/perf/macro.pl create mode 100755 test/perf/token.pl create mode 100755 test/performtest.pl create mode 100644 test/pinsr16.asm create mode 100644 test/pinsr32.asm create mode 100644 test/pinsr64.asm create mode 100644 test/popcnt.asm create mode 100644 test/ppindirect.asm create mode 100644 test/pushseg.asm create mode 100644 test/r13.asm create mode 100644 test/radix.asm create mode 100644 test/riprel.asm create mode 100755 test/riprel.pl create mode 100644 test/riprel2.asm create mode 100644 test/smartalign16.asm create mode 100644 test/smartalign32.asm create mode 100644 test/smartalign64.asm create mode 100644 test/struc.asm create mode 100644 test/test67.asm create mode 100644 test/testdos.asm create mode 100644 test/testnos3.asm create mode 100644 test/time.asm create mode 100644 test/tmap.nas create mode 100644 test/uscore.asm create mode 100644 test/utf.asm create mode 100644 test/vmread.asm create mode 100644 test/weirdpaste.asm create mode 100644 test/xchg.asm create mode 100644 test/xcrypt.asm create mode 100644 test/zerobyte.asm (limited to 'test') 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 +#include + +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 +#include + +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 +#include + +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 +#include + +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 +%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 +#include + +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() { + #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=; Arguments=; 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)<