laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/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.
+;

data/vendor/repo.or.cz/nasm/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:

data/vendor/repo.or.cz/nasm/test/objlink.c

@@ -0,0 +1,33 @@
+/*
+ * test source file for assembling to Microsoft 16-bit .OBJ
+ * build with (16-bit Microsoft C):
+ *    nasm -f obj objtest.asm
+ *    cl /AL objtest.obj objlink.c
+ * other compilers should work too, provided they handle large
+ * model in the same way as MS C
+ */
+
+#include <stdio.h>
+#include <inttypes.h>
+
+int8_t text[] = "hello, world\n";
+
+extern void function(int8_t *);
+extern int bsssym, commvar;
+extern void *selfptr;
+extern void *selfptr2;
+
+int main(void)
+{
+    printf("these should be identical: %p, %p\n",
+           (int32_t)selfptr, (int32_t)&selfptr);
+    printf("these should be equivalent but different: %p, %p\n",
+           (int32_t)selfptr2, (int32_t)&selfptr2);
+    printf("you should see \"hello, world\" twice:\n");
+    bsssym = 0xF00D;
+    commvar = 0xD00F;
+    function(text);
+    printf("this should be 0xF00E: 0x%X\n", bsssym);
+    printf("this should be 0xD00E: 0x%X\n", commvar);
+    return 0;
+}

data/vendor/repo.or.cz/nasm/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]

data/vendor/repo.or.cz/nasm/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

data/vendor/repo.or.cz/nasm/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

data/vendor/repo.or.cz/nasm/test/paste.asm

@@ -0,0 +1,12 @@
+%macro bug 1-*
+	%push foo
+		%define %$v %1
+		%define vv %$v_ %+ %1
+		%%top_{%$v}%1:
+		mov eax, eax
+		mov eax, %%top_{%$v}%1
+		mov eax, vv
+	%pop
+%endmacro
+
+bug a

data/vendor/repo.or.cz/nasm/test/pcrel.asm

@@ -0,0 +1,52 @@
+	bits 32
+foo:				; Backwards reference
+	mov eax,[foo - $]
+	mov ebx,[ebx + foo - $]
+	mov ecx,foo - $
+	mov edx,foo - bar
+
+	mov eax,[bar - $]
+	mov ebx,[ebx + bar - $]
+	mov ecx,bar - $
+	mov edx,bar - foo
+
+	mov eax,[baz - $]
+	mov ebx,[ebx + baz - $]
+	mov esi,[baz - bar]
+	mov ecx,baz - $
+	mov edx,baz - bar
+
+	bits 64
+	default rel
+
+	times 16 nop
+
+	mov eax,[foo]
+	mov eax,[foo - $]
+	mov eax,[abs foo - $]
+	mov ebx,[rbx + foo - $]
+	mov ecx,foo - $
+	mov edx,foo - bar
+
+	mov eax,[bar]
+	mov eax,[bar - $]
+	mov eax,[abs bar - $]
+	mov ebx,[rbx + bar - $]
+	mov ecx,bar - $
+	mov edx,bar - foo
+
+	mov eax,[baz]
+	mov eax,[baz - $]
+	mov eax,[abs baz - $]
+	mov ebx,[rbx + baz - $]
+	mov esi,[baz - bar]
+	mov esi,[abs baz - bar]
+	mov ecx,baz - $
+	mov edx,baz - bar
+
+bar:				; Forwards reference
+	hlt
+
+	section ".data"
+baz:				; Other-segment reference
+	dd 0

data/vendor/repo.or.cz/nasm/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";
+    }
+}

data/vendor/repo.or.cz/nasm/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";
+    }
+}

data/vendor/repo.or.cz/nasm/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";
+}

data/vendor/repo.or.cz/nasm/test/performtest.pl

@@ -0,0 +1,192 @@
+#!/usr/bin/perl
+#Perform tests on nasm
+
+use strict;
+use warnings;
+
+use Getopt::Long qw(GetOptions);
+use Pod::Usage qw(pod2usage);
+
+use File::Basename qw(fileparse);
+use File::Compare qw(compare compare_text);
+use File::Copy qw(move);
+use File::Path qw(mkpath rmtree);
+
+#sub debugprint { print (pop() . "\n"); }
+ sub debugprint { }
+
+my $globalresult = 0;
+
+#Process one testfile
+sub perform {
+    my ($clean, $diff, $golden, $nasm, $quiet, $testpath) = @_;
+    my ($stdoutfile, $stderrfile) = ("stdout", "stderr");
+
+    my ($testname, $ignoredpath, $ignoredsuffix) = fileparse($testpath, ".asm");
+    debugprint $testname;
+
+    my $outputdir = $golden ? "golden" : "testresults";
+
+    mkdir "$outputdir" unless -d "$outputdir";
+
+    if ($clean) {
+        rmtree "$outputdir/$testname";
+        return;
+    }
+
+    if(-d "$outputdir/$testname") {
+        rmtree "$outputdir/$testname";
+    }
+
+    open(TESTFILE, '<', $testpath) or (warn "Can't open $testpath\n", return);
+    TEST:
+    while(<TESTFILE>) {
+        #See if there is a test case
+        last unless /Testname=(.*);\s*Arguments=(.*);\s*Files=(.*)/;
+        my ($subname, $arguments, $files) = ($1, $2, $3);
+        debugprint("$subname | $arguments | $files");
+
+        #Call nasm with this test case
+        system("$nasm $arguments $testpath > $stdoutfile 2> $stderrfile");
+        debugprint("$nasm $arguments $testpath > $stdoutfile 2> $stderrfile ----> $?");
+
+        #Move the output to the test dir
+        mkpath("$outputdir/$testname/$subname");
+        foreach(split / /,$files) {
+            if (-f $_) {
+                move($_, "$outputdir/$testname/$subname/$_") or die $!
+            }
+        }
+        unlink ("$stdoutfile", "$stderrfile"); #Just to be sure
+
+        if($golden) {
+            print "Test $testname/$subname created.\n" unless $quiet;
+        } else {
+            #Compare them with the golden files
+            my $result = 0;
+            my @failedfiles = ();
+            foreach(split / /, $files) {
+                if(-f "$outputdir/$testname/$subname/$_") {
+                    my $temp;
+                    if($_ eq $stdoutfile or $_ eq $stderrfile) {
+                        #Compare stdout and stderr in text mode so line ending changes won't matter
+                        $temp = compare_text("$outputdir/$testname/$subname/$_", "golden/$testname/$subname/$_",
+                                             sub { my ($a, $b) = @_;
+                                                   $a =~ s/\r//g;
+                                                   $b =~ s/\r//g;
+                                                   $a ne $b; } );
+                    } else {
+                        $temp = compare("$outputdir/$testname/$subname/$_", "golden/$testname/$subname/$_");
+                    }
+
+                    if($temp == 1) {
+                        #different
+                        $result = 1;
+                        $globalresult = 1;
+                        push @failedfiles, $_;
+                    } elsif($temp == -1) {
+                        #error
+                        print "Can't compare at $testname/$subname file $_\n";
+                        next TEST;
+                    }
+                } elsif (-f "golden/$testname/$subname/$_") {
+                    #File exists in golden but not in output
+                    $result = 1;
+                    $globalresult = 1;
+                    push @failedfiles, $_;
+                }
+            }
+
+            if($result == 0) {
+                print "Test $testname/$subname succeeded.\n" unless $quiet;
+            } elsif ($result == 1) {
+                print "Test $testname/$subname failed on @failedfiles.\n";
+                if($diff) {
+                    for(@failedfiles) {
+                        if($_ eq $stdoutfile or $_ eq $stderrfile) {
+                            system "diff -u golden/$testname/$subname/$_ $outputdir/$testname/$subname/$_";
+                            print "\n";
+                        }
+                    }
+                }
+            } else {
+                die "Impossible result";
+            }
+        }
+    }
+    close(TESTFILE);
+}
+
+my $nasm;
+my $clean = 0;
+my $diff = 0;
+my $golden = 0;
+my $help = 0;
+my $verbose = 0;
+
+GetOptions('clean' => \$clean,
+           'diff'=> \$diff,
+           'golden' => \$golden,
+           'help' => \$help,
+           'verbose' => \$verbose,
+           'nasm=s' => \$nasm
+          ) or pod2usage();
+
+pod2usage() if $help;
+die "Please specify either --nasm or --clean. Use --help for help.\n"
+unless $nasm or $clean;
+die "Please specify the test files, e.g. *.asm\n" unless @ARGV;
+
+unless (!defined $nasm or -x $nasm) {
+  warn "Warning: $nasm may not be executable. Expect problems.\n\n";
+  sleep 5;
+}
+
+perform($clean, $diff, $golden, $nasm, ! $verbose, $_) foreach @ARGV;
+exit $globalresult;
+
+__END__
+
+=head1 NAME
+
+performtest.pl - NASM regression tester based on golden files
+
+=head1 SYNOPSIS
+
+performtest.pl [options] [testfile.asm ...]
+
+Runs NASM on the specified test files and compare the results
+with "golden" output files.
+
+ Options:
+     --clean     Clean up test results (or golden files with --golden)
+     --diff      Execute diff when stdout or stderr don't match
+     --golden    Create golden files
+     --help      Get this help
+     --nasm=file Specify the file name for the NASM executable, e.g. ../nasm
+     --verbose   Get more output
+
+     If --clean is not specified, --nasm is required.
+
+ testfile.asm ...:
+    One or more files that NASM should be tested with,
+    often *.asm in the test directory.
+    It should contain one or more option lines at the start,
+    in the following format:
+
+;Testname=<testname>; Arguments=<arguments to nasm>; Files=<output files>
+
+    If no such lines are found at the start, the file is skipped.
+    testname should ideally describe the arguments, eg. unoptimized for -O0.
+    arguments can be an optimization level (-O), an output format (-f),
+    an output file specifier (-o) etc.
+    The output files should be a space seperated list of files that will
+    be checked for regressions. This should often be the output file
+    and the special files stdout and stderr.
+
+Any mismatch could be a regression,
+but it doesn't have to be. COFF files have a timestamp which
+makes this method useless. ELF files have a comment section
+with the current version of NASM, so they will change each version number.
+
+=cut