basic.exp

binary ultilities binary ultilities binary ultilities

    # Check the assembled instruction against a table built by the HP assembler
    # Any differences should be checked by hand -- with the number of problems
    # I've seen in the HP assembler I don't completely trust it.
    #
    # Instead of having a variable for each match string just increment the
    # total number of matches seen.  That's simpler when testing large numbers
    # of instructions (as these tests to).
    while 1 {
	expect {
	    -re "^ +\[0-9\]+ 0000 08A40246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0004 08A42246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0008 08A44246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 000c 08A46246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0010 08A4E246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0014 08A41246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0018 08A43246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 001c 08A45246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0020 08A47246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0024 08A4F246\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0028 08A40286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 002c 08A42286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0030 08A44286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0034 08A46286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0038 08A4E286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 003c 08A41286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0040 08A43286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0044 08A45286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0048 08A47286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 004c 08A4F286\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0050 08A40206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0054 08A42206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0058 08A44206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 005c 08A46206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0060 08A4E206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0064 08A41206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0068 08A43206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 006c 08A45206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0070 08A47206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0074 08A4F206\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0078 08A40006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 007c 08A42006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0080 08A44006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0084 08A46006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0088 08A4E006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 008c 08A41006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0090 08A43006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0094 08A45006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0098 08A47006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 009c 08A4F006\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "\[^\n\]*\n"				{ }
	    timeout				{ perror "timeout\n"; break }
	    eof					{ break }
	}
    }

    # This was intended to do any cleanup necessary.  It kinda looks like it
    # isn't needed, but just in case, please keep it in for now.
    gas_finish

    # Did we find what we were looking for?  If not, flunk it.
    if [expr $x==40] then { pass $testname } else { fail $testname }
}

proc do_unit {} {
    set testname "unit.s: unit tests"
    set x 0

    gas_start "unit.s" "-al"

    # Check the assembled instruction against a table built by the HP assembler
    # Any differences should be checked by hand -- with the number of problems
    # I've seen in the HP assembler I don't completely trust it.
    #
    # Instead of having a variable for each match string just increment the
    # total number of matches seen.  That's simpler when testing large numbers
    # of instructions (as these tests to).
    while 1 {
	expect {
	    -re "^ +\[0-9\]+ 0000 08A40386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0004 08A44386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0008 08A46386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 000c 08A48386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0010 08A4C386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0014 08A4E386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0018 08A41386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 001c 08A45386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0020 08A47386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0024 08A49386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0028 08A4D386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 002c 08A4F386\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0030 08A40986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0034 08A44986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0038 08A46986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 003c 08A48986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0040 08A4C986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0044 08A4E986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0048 08A41986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 004c 08A45986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0050 08A47986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0054 08A49986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0058 08A4D986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 005c 08A4F986\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0060 08A409C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0064 08A449C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0068 08A469C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 006c 08A489C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0070 08A4C9C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0074 08A4E9C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0078 08A419C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 007c 08A459C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0080 08A479C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0084 08A499C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0088 08A4D9C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 008c 08A4F9C6\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "\[^\n\]*\n"				{ }
	    timeout				{ perror "timeout\n"; break }
	    eof					{ break }
	}
    }

    # This was intended to do any cleanup necessary.  It kinda looks like it
    # isn't needed, but just in case, please keep it in for now.
    gas_finish

    # Did we find what we were looking for?  If not, flunk it.
    if [expr $x==36] then { pass $testname } else { fail $testname }
}

proc do_dcor {} {
    set testname "dcor.s: dcor tests"
    set x 0

    gas_start "dcor.s" "-al"

    # Check the assembled instruction against a table built by the HP assembler
    # Any differences should be checked by hand -- with the number of problems
    # I've seen in the HP assembler I don't completely trust it.
    #
    # Instead of having a variable for each match string just increment the
    # total number of matches seen.  That's simpler when testing large numbers
    # of instructions (as these tests to).
    while 1 {
	expect {
	    -re "^ +\[0-9\]+ 0000 08800B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0004 08804B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0008 08806B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 000c 08808B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0010 0880CB85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0014 0880EB85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0018 08801B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 001c 08805B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0020 08807B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0024 08809B85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0028 0880DB85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 002c 0880FB85\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0030 08800BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0034 08804BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0038 08806BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 003c 08808BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0040 0880CBC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0044 0880EBC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0048 08801BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 004c 08805BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0050 08807BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0054 08809BC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0058 0880DBC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 005c 0880FBC5\[^\n]*\n"	{ set x [expr $x+1] }
	    -re "\[^\n\]*\n"				{ }
	    timeout				{ perror "timeout\n"; break }
	    eof					{ break }
	}
    }

    # This was intended to do any cleanup necessary.  It kinda looks like it
    # isn't needed, but just in case, please keep it in for now.
    gas_finish

    # Did we find what we were looking for?  If not, flunk it.
    if [expr $x==24] then { pass $testname } else { fail $testname }
}

proc do_addi {} {
    set testname "addi.s: addi tests"
    set x 0

    gas_start "addi.s" "-al"

    # Check the assembled instruction against a table built by the HP assembler
    # Any differences should be checked by hand -- with the number of problems
    # I've seen in the HP assembler I don't completely trust it.
    #
    # Instead of having a variable for each match string just increment the
    # total number of matches seen.  That's simpler when testing large numbers
    # of instructions (as these tests to).
    while 1 {
	expect {
	    -re "^ +\[0-9\]+ 0000 B4A600F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0004 B4A620F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0008 B4A640F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 000c B4A660F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0010 B4A680F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0014 B4A6A0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0018 B4A6C0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 001c B4A6E0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0020 B4A610F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0024 B4A630F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0028 B4A650F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 002c B4A670F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0030 B4A690F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0034 B4A6B0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0038 B4A6D0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 003c B4A6F0F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0040 B4A608F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0044 B4A628F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0048 B4A648F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 004c B4A668F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0050 B4A688F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0054 B4A6A8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0058 B4A6C8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 005c B4A6E8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0060 B4A618F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0064 B4A638F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0068 B4A658F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 006c B4A678F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0070 B4A698F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0074 B4A6B8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0078 B4A6D8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 007c B4A6F8F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0080 B0A600F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0084 B0A620F6\[^\n\]*\n"	{ set x [expr $x+1] }
	    -re "^ +\[0-9\]+ 0088 B0A6