/* cmpc1 * * Just compare two equal 8 character (9 bit) strings. * = => zero and carry indicators will be on. */ inst cmpc -nt "Equal 9 bit char strings" -io 1 -ir zr cr; desc 1 -ns 8; desc 2 -ns 8; data 1 "abcd1234"; data 2 "abcd1234"; page -all; /* cmpc2 * * Same as cmpc1 except move data across page boundary and add modification. */ inst cmpc -nt"Same as prev but X pg bound" -io 2 -ir zr cr -mf1 ar reg idb -mf2 ar reg idb; desc 1 -ns 8; desc 2 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "ab" "cd1234"; page -all; /* cmpc3 * * Same as cmpc2 except first string is > than second string. */ inst cmpc -nt "S1 > S2 - X pg bound" -io 3 -ir cr -mf1 ar reg idb -mf2 ar reg idb; desc 1 -ns 8; desc 2 -ns 8; data 1 -do -5 "abcd1" "235"; data 2 -do -2 "ab" "cd1234"; page -all; /* cmpc4 * * Same as cmpc2 except first string is < than second string. */ inst cmpc -nt "S1 < S2 - X pg bound" -io 1 -mf1 ar reg idb -mf2 ar reg idb; desc 1 -ns 8; desc 2 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "ab" "cd1235"; page -all; /* cmpc5 * * Same as cmpc2 except we will use cn fields. */ inst cmpc -nt "Test use of CN fields" -io 2 -ir zr cr -mf1 ar reg idb -mf2 ar reg idb; desc 1 -ns 8 -cn 1; desc 2 -cn 2 -ns 8; data 1 -do -4 " abc" "d1234"; data 2 -do -2 "**" "abcd1234"; page -all; /* cmpc6 * * We will test the use of the fill character. In this test we will fill * string 1. */ inst cmpc -nt "Fill in S1" -io 1 -ir cr zr -fc* -mf1 idr ar -mf2 ida ar; desc 1 -ns 6; desc 2 -ns 10; data 1 -do -3 "123" "456"; data 2 -do -6 "123456" "****"; page -all; /* cmpc7 * * Same as cmpc6 except the fill characters will be split across * a page boundary. */ inst cmpc -nt "Fill X pg bound" -io 1 -ir cr zr -fc* -mf1 idr ar -mf2 ida ar; desc 1 -ns 6; desc 2 -ns 10; data 1 -do -5 "12345" "6"; data 2 -do -9 "123456***" "*"; page -all; /* cmpc8 * * In this test we will test using the fill character of string 2. */ inst cmpc -nt "Fill in S2" -io 2 -ir zr cr -fc /* Fill character is a blank. */ -mf1 idb rl 8 ar reg -mf2 idb rl 4 ar reg; /* No desc statements needed. */ data 1 -do -4 "1234" " "; data 2 -do -3 "123" "4"; page -all; /* cmpc9 * * The same as cmpc8 except we will split the fill characters across a page boundary. */ inst cmpc -nt "Same as prev - fill X pg bound" -io 2 -ir zr cr -fc /* Fill character is a blank. */ -mf1 idb rl 8 ar reg -mf2 idb rl 4 ar reg; /* No desc statements needed. */ data 1 -do -5 "1234 " " "; data 2 -do -3 "123" "4"; page -all; /* cmpc10 * * This test will compare two strings that cross two page boundaries. */ inst cmpc -nt "Both strings X pg bounds" -io 3 -ir cr zr -mf1 idb reg ar rl 4352 -mf2 idb reg ar rl 4352; data 1 -do -128 (4352) "S"; data 2 -do -128 (4352) "S"; page -all; /* cmpc11 * * This test will compare 3 (6 bit) characters. We will have them * cross a page boundary and we will use the cn field of the * descriptors to start the string at a character other than character * zero of the effectively addressed word. */ inst cmpc -nt "6 bit characters" -io 2 -ir cr zr -mf1 ar reg idb rl 3 -mf2 ar reg idb; desc 1 -cn 2 -ta 6; desc 2 -ns 3 -cn 1; /* NOTE, ta field taken from desc 1 statement. */ data 1 -do -2 000020 /*Page Boundary*/ 2122; data 2 -do -2 002021 /*Page Boundary*/ 22; page -all; /* cmpc12 * * This test is like cmpc11 except that the character size will be 4. */ inst cmpc -nt "4 bit characters" -ir cr zr -mf1 idb reg ar -mf2 idb reg ar; desc 1 -ns 3 -cn 2 -ta 4; /* This desc statement must be first. */ desc 2 -ns 3 -cn 1; /* This desc statement can NOT have a -ta option. */ data 1 -do -2 000232 260; /* characters "1001"b "1010"b "1011"b */ data 2 -do -1 011 253; /* The same 3 characters. */ page -all; /* cmpc13 * compare two strings of maximum length. * the data is six bit data and maximum * desc. mod. is taken * */ inst cmpc -nt "d1,2 covers 3pp. 6bit zr cr" -ir zr cr -mf1 idb ar reg rl 6528 -mf2 idb ar reg rl 6528; desc 1 -ta 6 ; data 1 -do -128 (1088) 212121212121; data 2 -do -128 (1088) 212121212121; page -all; /* cmpc14 * this is a test using 4 bit data with the * first string covering the maximum number of words. * the second string also is of maximum length * and the descriptors are all direct mod. * */ inst cmpc -nt "d1,2 covers 3pp 4bit zr cr" -ir cr zr -mf1 rl 8704 -mf2 rl 8704; desc 1 -ta 4; data 1 -do -128 (1088) 232232232232; data 2 -do -128 (1088) 232232232232; page -all; /* cmpc15 * the next four tests will again use the maximum * amount of data but will vary the desc. mod. taken. * */ inst cmpc -io 2 -nt "d1,2 covers 3pp 6 bit zr cr" -mf1 ida reg rl 6528 -mf2 idr ar rl 6528 -ir cr zr; desc 1 -ta 6; data 1 -do -128 (1088) 212223242526; data 2 -do -128 (1088) 212223242526; page -all; /* cmpc16 * this is the same as test 15 but there will be not3 * match of the data (str1 < str2 : zr=0 cr=0) * */ inst cmpc -io 1 -nt "d1,2 covers 3 pp 6 bit" -mf1 ida reg rl 6528 -mf2 idr ar rl 6528; desc 1 -ta 6; data 1 -do -128 (1088) 212221222122; data 2 -do -128 (1088) 2122232422226; page -all; /* cmpc17 * this test is similar to test14 only the * maximum number of desc. mods. are taken. * the data is still four bit. * */ inst cmpc -io 3 -nt "d1,2 covers 3pp 4bit zr cr" -ir zr cr -mf1 idb ar reg rl 8704 -mf2 idb ar reg rl 8704; desc 1 -ta 4; data 1 -do -128 (1088) 232232232232; data 2 -do -128 (1088) 232232232232; page -all; /* cmpc18 * this test will take a variety of desc. mod. * and will force st1 > st2 (zr =0 cr = 1). * the data is four bit. * */ inst cmpc -io 1 -nt "d1,2 covers 3pp 4 bit cr" -ir cr -mf1 ida reg rl 8704 -mf2 idr ar rl 8704; desc 1 -ta 4; data 1 -do -128 (1088) 232232232222; data 2 -do -128 (1088) 227237237237; page -all; /* cmpc19 * the test exercises the fill char option along with * the cn option. the test also uses 6 bit data. * */ inst cmpc -io 1 -nt "d1 split cn 6bit zr cr" -ir zr cr -fc /* fc = 000 */ -mf1 reg ar rl 8 -mf2 reg rl 5; desc 1 -ta 6 -cn 2; desc 2 -cn 1; data 1 -do -2 000020 /* page bound */ 21222324000000; data 2 002021222324; page -all; /* cmpc20 * this test uses 6 bit data and test a different * variety of desc. mods. that test 19. the * data is the same as test 19 except str1 < str2). * */ inst cmpc -io 2 -nt "d1 split fc 6bit" -mf1 idb ar -mf2 ar reg -fc /* fc = 000 */ /* fc = 000 */; desc 1 -ta 6 -ns 8 -cn 2; desc 2 -ns 5 -cn 2; data 1 -do -2 000020 /* paGE BOUND */ 212223220000; data 2 002021222324; page -all; /* cmpc21 * the next wo tests use 4 bit data and test the use of the * fill character. a variety of desc. mods. are taken. * **/ inst cmpc -io 2 -nt "fc 4bit zr cr" -fc /* fc = 000 */ /* fc = 000 */ -mf1 ida ar reg rl 2 -mf2 idr ar rl 4 -ir zr cr; desc 1 -ta 4; data 1 232; data 2 232000; page -all; /* cmcp22 * this test results in str1 > str 2. * */ inst cmpc -io 2 -nt " fc 4bit cr" -ir cr -mf1 idb ar reg -mf2 rl 6 -fc /* fc = 000 */; /* fc = 000 */ desc 1 -ta 4 -ns 4; data 1 -do -2 237237 /* page bound */ ; data 2 232232000; page -all; /* scd1 * * We will split both string 1 and string 2 across page * boundaries. We will use all mods and use a cn * field in descriptors 1 & 2. */ inst scd -nt "Strings X pg bound - all mods" -io 2 -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -cn 1; desc 2 -cn 3; data 1 -do -5 " " /* Character skipped by cn field. */ "123*" "$678"; data 2 -do -4 " " "*" "$"; data 3 000 000 000 003; page -all; /* scd2 * * simple test which takes no more than the minimum * number of page faults. assures the instruction is * working correctly. * */ inst scd -nt "simple test 9bit"; desc 1 -ns 8; /* 9 bit char */ data 1 "abcd1234"; data 2 "cd"; data 3 000 000 000 002; page -all; /* scd3 * this test uses the same data as test 2 * but splits the first string across a page boundary. the maximum number of descriptor page faultd * for the first two descriptors are also taken. * */ inst scd -nt "d1 split 9bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 8 -mf2 idb ar reg; data 1 -do 2 "ab" "cd1234"; data 2 "cd"; data 3 000 000 000 002; page -all; /* scd4 * this test mixes the page faults among descriptors * and splits data across a page boundary with a * match on the first try. * */ inst scd -nt "d1 split match 1st try; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar -mf2 ar reg -mf3 ar; /* note the data word indirection */ desc 1 -ns 8; data 1 -do -1 "a" "bcd1234"; data 2 "ab"; data 3 000 000 000 000; page -all; /* scd5 * same as previous test but both strings * are split across page boundaries. data * word is also accessed directly. * */ inst scd -io 2 -nt "d1,2 split 9bit" -mf1 idb ar reg -mf2 idb ar reg; desc 1 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -1 "d" "1"; data 3 000 000 000 003; page -all; /* scd6 * this test takes all the page faults * possible with the descriptors, and * tests the -cn and -rl option. * */ inst scd -io 2 -nt "max page fault 9bit" -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; /* that's all pssible indirections */ desc 2 -cn 2; data 1 -do -4 "abcd" "1234"; data 2 -do -2 " " "12"; data 3 000 000 000 004; page -all; /* scd7 * salient feature of this test is * that there is no match on the search. * both data strings cross page boundaries. * */ inst scd -io 2 -nt "no match 9bit" -ir tr /* mf1 is direct */ -mf2 idb ar reg; desc 1 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -1 "5" "6"; data 3 000 000 000 007; page -all; /* scd8 * all possible indirection for descriptors * taken with the cn option for both tested. * strings both split across page. * */ inst scd -io 3 -nt "d1,2 split 9bit" -mf1 idb ar reg rl 5 -mf2 idb ar reg; desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 001; page -all; /* scd9 *the next three tests all use the same basic * data but vary the type of indirection and thus * the type of page faults that will be taken. * */ inst scd -io 1 -nt "desc mod d1,2 split 9bit" -mf1 ar -mf2 idb ar reg -mf3 ar reg; desc 1 -ns 5 -cn 3; desc 2 -cn 1; data 1 -do -3"***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 001; page -all; /* scd10 * swap desc1 and desc2 mod * */ inst scd -io 1 -nt "d1,2 split 9bit" -mf1 idb ar reg rl 8 -mf2 ar -mf3 ar reg; desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 001; page -all; /* scd11 * mf3 is direct : other two indirect * */ inst scd -io 1 -nt "mf1 direct others ind. 9b" -mf1 idb ar reg rl 8 -mf2 idb ar reg; /* mf3 is direct */ desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 001; page -all; /* scd12 * the data for the next two tests spans three pages. * this test uses all direct mod for descriptors. * */ inst scd -io 1 -nt "d1 spans 3pp 9bit" -mf1 rl 4352; data 1 -do -128 (2175) "ab" "bc"; data 2 "bc"; data 3 000 000 010376; page -all; /* scd13 * same data as previous test but using * maximum indirection on the desc. * */ inst scd -io 2 -nt "d1 spans 3pp max desc mod 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 reg ar; /* no desc statements are needed */ data 1 -do -128 (2175) "ab" "bc"; data 2 "bc"; data 3 000 000 010 376; page -all; /* scd14 * the next two tests move the two char data 2 string * across a page boundary using the large data field of * the previous two tests as data 1. * */ inst scd -io 3 -nt "3 page d1, d2 split 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; /* desc statements not needed */ data 1 -do -128 (2175) "ab" "bc"; data 2 -do -1 "b" "c"; data 3 000 000 010 376; page -all; /* scd15 * data 2 fully contained on page 0 * */ inst scd -io 2 -nt "3page d1, d2 split 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; data 1 -do -128(2175) "ab" "bc"; data 2 -do -2"bc"; data 3 000 000 010 376; page -all; /* scd16 * this starts the 6 bit char tests. * nothing fancy--indirect mod on desc 1 & 2 * */ inst scd -nt "mf1,2 mod 6b; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 6 -mf2 idb ar reg /* desc3 is direct */; desc 1 -ta 6 /* six bit char */; data 1 202122232425; data 2 2425; data 3 000 000 000 004; page -all; /* scd17 * same data but first string offseet by * 3 char. full indirect mod on desc. * */ inst scd -io 2 -nt "desc mod d1 split 6b; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ns 6 -ta 6; data 1 -do -2 212223 242526; data 2 2425; data 3 000 000 000 003; page -all; /* scd18 *this test offsets the second data string. * */ inst scd -io 1 -nt "desc mod d2 offset 6b; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 6 -mf2 ar reg -mf3 reg /* note the variety of indirection */; desc 1 -ta 6; data 1 212223242526; data 2 -do -2 242500; data 3 000 000 000 003; page -all; /* scd19 * this test specifically exercises the -cn option * along with multiple indirection. * */ inst scd -io 3 -nt "cn on d2 6bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 6 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6 -cn 3; desc 2 -cn 3; data 1 -do -4 000000202122 232425000000; data 2 -do -2 000000 212200; data 3 000 000 000 001; page -all; /* scd20 * data 1 covers three pages. match * is on the last pair of characters. * */ inst scd -nt "d1 spans 3pp 6bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 7680 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128(1087) 202124252627 202122242223; data 2 2223; data 3 000000014576 000; page -all; /* scd21 *the final series of tests are with 4 bit data * this is just a simple test of two char per string * crossing no page pound. * */ inst scd -nt "d1,2 2 char 4bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg -mf2 idb ar reg /* mf3 is direct */; desc 1 -ta 4 -ns 2; data 1 232 000 000 000 /* "1001" "1010" */; data 2 232 000 000 000; data 3 000 000 000 000; page -all; /* scd22 * split the second string across page bound. * test -cn option for data 2. * */ inst scd -io 2 -nt "cn,offset for d2 4bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 2 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; desc 2 -cn 1; data 1 232 000 000 000; data 2 -do -1 011 240 /* "1001" "1010" */; data 3 000 000 000 000; page -all; /* scd23 * this test splits both strings and tests * the cn option for both strings * */ inst scd -io 2 -nt "d1,2 offset 4bit" -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 2 -cn 2; desc 2 -cn 1; data 1 -do -2 000 232 000; data 2 -do -1 011 24; data 3 000 000 000 000; page -all; /* scd24 * this test will force data to cover all * three pages with the first data string. * */ inst scd -io 3 -nt "d1 covers 3pp 4bit" -mf1 ar rl 10240 -mf2 reg -mf3 ar; desc 1 -ta 4 ; data 1 -do -128 (4350) 232 236; data 2 236; data 3 000 000 020 774; page -all; /* scdr1 * * Same as test for scd. * We will split both string 1 and string 2 across page * boundaries. We will use all mods and use a cn * field in descriptors 1 & 2. */ inst scdr -nt "Same as scd test" -io 3 -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -cn 1; desc 2 -cn 3; data 1 -do -5 " " /* Character skipped by cn field. */ "123*" "$678"; data 2 -do -4 " " "*" "$"; data 3 000 000 000 003; page -all; /* scdr2 * * simple test which takes no more than the minimum * number of page faults. assures the instruction is * working correctly. * */ inst scdr -nt "simple test 9bit"; desc 1 -ns 8; /* 9 bit char */ data 1 "abcd1234"; data 2 "cd"; data 3 000 000 000 004; page -all; /* scdr3 * this test mixes the page faults among descriptors * and splits data across a page boundary with a * match on the first try. * */ inst scdr -nt "d1 split match first time 9b" -mf1 idb ar -mf2 ar reg -mf3 ar; /* note the data word indirection */ desc 1 -ns 8; data 1 -do -1 "a" "bcd1234"; data 2 "ab"; data 3 000 000 000 006; page -all; /* scdr4 * same as previous test but both strings * are split across page boundaries. data * word is also accessed directly. * */ inst scdr -io 2 -nt "d1,2 split 9bit" -mf1 idb ar reg -mf2 idb ar reg; desc 1 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -1 "d" "1"; data 3 000 000 000 003; page -all; /* scdr5 * this test takes all the page faults * possible with the descriptors, and * tests the -cn and -rl option. * */ inst scdr -io 2 -nt "max page fault 9bit" -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; /* that's all pssible indirections */ desc 2 -cn 2; data 1 -do -4 "abcd" "1234"; data 2 -do -2 " " "12"; data 3 000 000 000 002; page -all; /* scdr6 * salient feature of this test is * that there is no match on the search. * both data strings cross page boundaries. * */ inst scdr -io 2 -nt "no match 9bit" -ir tr /* mf1 is direct */ -mf2 idb ar reg; desc 1 -ns 8; data 1 -do -4 "abcd" "1234"; data 2 -do -1 "5" "6"; data 3 000 000 000 007; page -all; /* scdr7 * all possible indirection for descriptors * taken with the cn option for both tested. * strings both split across page. * */ inst scdr -io 3 -nt "d1,2 split 9bit" -mf1 idb ar reg rl 5 -mf2 idb ar reg; desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 002; page -all; /* scdr8 *the next three tests all use the same basic * data but vary the type of indirection and thus * the type of page faults that will be taken. * */ inst scdr -io 1 -nt "desc mod d1,2 split 9b" -mf1 ar -mf2 idb ar reg -mf3 ar reg; desc 1 -ns 5 -cn 3; desc 2 -cn 1; data 1 -do -3"***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 002; page -all; /* scdr9 * swap desc1 and desc2 mod * */ inst scdr -io 1 -nt "desc mod d1,2 split 9b" -mf1 idb ar reg rl 8 -mf2 ar -mf3 ar reg; desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 005; page -all; /* scdr10 * mf3 is direct : other two indirect * */ inst scdr -io 1 -nt "mf1 direct others ind 9bit" -mf1 idb ar reg rl 8 -mf2 idb ar reg; /* mf3 is direct */ desc 1 -cn 3; desc 2 -cn 1; data 1 -do -3 "***" "abcde"; data 2 -do -3 "*bc" "*"; data 3 000 000 000 005; page -all; /* scdr11 * the data for the next two tests spans three pages. * this test uses all direct mod for descriptors. * */ inst scdr -io 1 -nt "d1 spans 3 pp 9bit" -mf1 rl 4352; data 1 -do -128 "bc" (2175) "ab" ; data 2 "bc"; data 3 000 000 010376; page -all; /* scdr12 * same data as previous test but using * maximum indirection on the desc. * */ inst scdr -io 2 -nt "d1 spans 3pp max desc mod 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 reg ar; /* no desc statements are needed */ data 1 -do -128 "bc" (2175) "ab" ; data 2 "bc"; data 3 000 000 010 376; page -all; /* scdr13 * the next two tests move the two char data 2 string * across a page boundary using the large data field of * the previous two tests as data 1. * */ inst scdr -io 3 -nt "3 page d1, d2 split 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; /* desc statements not needed */ data 1 -do -128 (2175) "ab" "bc"; data 2 -do -1 "b" "c"; data 3 000 000 000 000; page -all; /* scdr14 * data 2 fully contained on page 0 * */ inst scdr -io 2 -nt "3 page d1, d2 split 9b" -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; data 1 -do -128 "bc" (2175) "ab" ; data 2 -do -2"bc"; data 3 000 000 010376; page -all; /* scdr15 * this starts the 6 bit char tests. * nothing fancy--indirect mod on desc 1 & 2 * */ inst scdr -nt "desc 1,2 mod 6bit" -mf1 idb ar reg rl 6 -mf2 idb ar reg /* desc3 is direct */; desc 1 -ta 6 /* six bit char */; data 1 202122232425; data 2 2425; data 3 000 000 000 000; page -all; /* scdr16 * same data but first string offseet by * 3 char. full indirect mod on desc. * */ inst scdr -io 2 -nt "mod d1 split 6b; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ns 6 -ta 6; data 1 -do -2 212223 242526; data 2 2425; data 3 000 000 000 001; page -all; /* scdr17 *this test offsets the second data string. * */ inst scdr -io 1 -nt "full desc mod d2 offset 6b" -mf1 idb ar reg rl 6 -mf2 ar reg -mf3 reg /* note the variety of indirection */; desc 1 -ta 6; data 1 212223242526; data 2 -do -2 242500; data 3 000 000 000 001; page -all; /* scdr18 * this test specifically exercises the -cn option * along with multiple indirection. * */ inst scdr -io 3 -nt "cn on d2 6bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg rl 6 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6 -cn 3; desc 2 -cn 3; data 1 -do -4 000000202122 232425000000; data 2 -do -2 000000 212200; data 3 000 000 000 003; page -all; /* scdr19 * data 1 covers three pages. match * is on the last pair of characters. * */ inst scdr -nt "no off d1 spans 3pp 6b" -mf1 idb ar reg rl 7680 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128(1087) 202124252627 202122242223; data 2 2223; data 3 000000002200 000; page -all; /* scdr20 *the final series of tests are with 4 bit data * this is just a simple test of two char per string * crossing no page pound. * */ inst scdr -nt "d1.2 2 char 4bit" -mf1 idb ar reg -mf2 idb ar reg /* mf3 is direct */; desc 1 -ta 4 -ns 2; data 1 232 000 000 000 /* "1001" "1010" */; data 2 232 000 000 000; data 3 000 000 000 000; page -all; /* scdr21 * split the second string across page bound. * test -cn option for data 2. * */ inst scdr -io 2 -nt "cn,offset for d2 4bit" -mf1 idb ar reg rl 2 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; desc 2 -cn 1; data 1 232 000 000 000; data 2 -do -1 011 240 /* "1001" "1010" */; data 3 000 000 000 000; page -all; /* scdr22 * this test splits both strings and tests * the cn option for both strings * */ inst scdr -io 2 -nt "d1,2 offset 4bit; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 2 -cn 2; desc 2 -cn 1; data 1 -do -2 000 232 000; data 2 -do -1 011 24; data 3 000 000 000 000; page -all; /* scdr23 * this test will force data to cover all * three pages with the first data string. * */ inst scdr -io 3 -nt "d1 covers 3 pp 4bit" -mf1 ar rl 10240 -mf2 reg -mf3 ar; desc 1 -ta 4 ; data 1 -do -128 (4350) 232 236; data 2 236; data 3 000 000 003 002; page -all; /* mlr1 * * Just a simple test. Move one 9 bit character to another. */ inst mlr -nt "Move 1 (9) bit char"; desc 1 -ns 1; data 1 "a"; desc 2 -ns 1; data 2 "a"; page -all; /* mlr2 * * Move two characters that cross a page boundary. Note, we need AR * modification in order to set a data offset that is not a multiple * of the word size. By doing this we will move the data fields to * segments etd1 and etd2. */ inst mlr -nt "2 chars X page bound" -mf1 ar -mf2 ar; desc 1 -ns 2; desc 2 -ns 2; data 1 "ab" -do -1; data 2 "ab" -do -1; page -all; /* mlr3 * * This test will move 20 characters. The characters will start in the middle * of a word. The last two characters moved will cross a page boundary. * The instruction word will be moved so that its descriptors cross a * page boundary. */ inst mlr -nt "20 char X page bound (-io 1)" -io 1; desc 1 -cn 2 /* Effective address will point to a word boundary. * We will start the string at character 2. Note, when * we set up the data we have to enter the two characters * that we are not using. */ -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000000 (5) "abcd" ; /* Skipped data in a result field * must be zeros since this is what * et initializes the test area * to be. */ page -all; /* mlr4 * * This test is the same as mlr3 except that the descriptors will be * referenced via indirect words. These indirect words will use no * modification so the descriptors and the data will still be in * segment etx. Also we will move the instruction word back * so that the second descriptor is on the 2nd page. */ inst mlr -nt "Same as prev - ind desc" -io 2 -mf1 id -mf2 id; desc 1 -ns 20 -cn 2; /* Note the order of the terms. */ desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr5 * /* This test is the same as mlr4 except that the indirect words will * use index register modification. */ inst mlr -nt "Same as prev - use indexes" -io 2 -mf2 idr -mf1 idr; /* Note order of mf terms. */ desc 1 -cn 2 -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr6 * /* This test is the same as mlr4 except that the indirect words will * use AR modification. This will force ET to place the descriptors and * the data fields in segments eti1 and eti2. */ inst mlr -nt "Ind with AR mod" -io 2 -mf2 ida -mf1 ida; desc 1 -cn 2 -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr7 * * This test is the same as the test mlr3 except that the descriptors * will use REG and RL modification. */ inst mlr -nt "Ind with REG 7. RL mod" -io 1 -mf2 reg rl 20 -mf1 rl 20 reg; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr8 * * This test is the same as the test mlr3 except that the descriptors * will use AR, REG and RL modification. */ inst mlr -nt "Desc use AR,REG,& RL mod" -io 1 -mf1 reg ar rl 20 -mf2 rl 20 ar reg; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr9 * * This test is the same as the test mlr3 except that the descriptors * will use AR, REG and RL modification AND we will use indirect descriptors. * We will not have any modification in the indirect words so the descriptors * will still be in segment etx. */ inst mlr -nt "Same as prev - use ind" -io 1 -mf1 rl 20 ar /* This puts the data in etd1. */ reg /* Use index register 1.. */ id /* This adds indirect descriptors. */ -mf2 id rl 20 reg ar; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr10 * * This test is the same as the test mlr3 except that the descriptors * will use AR, REG and RL modification AND we will use indirect descriptors. * The indirect words will use both reg and ar modification. */ inst mlr -nt "Desc: AR,RL,REG Ind: AR,REG" -io 1 -mf1 rl 20 ar /* This puts the data in etd1. */ reg /* Use index register 1.. */ idb /* This adds indirect descriptors. Descriptors will go in * segments eti1 and eti2. */ -mf2 idb rl 20 reg ar; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mlr11 * * This test will move 6 6 bit characters. Both strings will have 3 characters * on each side of the page boundary. The descriptor 2 data will be offset 4 * 9 bit characters but will specify a "cn" field of 3 so the effective starting * address will be the same as descriptor 1. All possible modification will be * used. Descriptor 1 will also use RL modification. */ inst mlr -nt "6 bit chars X pg bound" -mf1 rl 6 idb ar reg -mf2 reg ar idb; desc 1 -ta 6; desc 2 -cn 3 -ta 6 -ns 6; data 1 -do -2 212223242526; data 2 -do -4 (2) 000 /* We must fill in the unused 3 six bit characters. */ 212223242526; /* The actual data result field. */ page -all; /* mlr12 * * This test will move 3 4 bit characters. Below is a description of what is * going on. EA is the effective address of the descriptor. * * string 1 EA 1 | 2 3 * --------------------------------------------------- * char addr 0 1 2 3 4 5 6 7 | 0 1 2 3 4 5 6 7 * --------------------------------------------------- * string 2 EA 1 2 | 3 * * All possible modification will be used. Descriptor 2 will use RL mod. */ inst mlr -nt "4 bit chars" -mf1 idb ar reg -mf2 reg ar idb rl 3; desc 1 -ta 4 -cn 1 -ns 3; desc 2 -cn 6 -ta 4; data 1 011 253 -do -1; data 2 -do -4 000000000 232 26; page -all; /* mlr13 * * This test will move 6 9 bit characters into 6 6 bit characters. * Both strings will be split in the middle across a page boundary. */ inst mlr -nt "9 bit chars into 6 bit chars" -mf1 ar reg idr -mf2 reg ar idb; data 1 -do -3 " te" "st "; data 2 -do -2 406445 636440; desc 1 -ns 6; desc 2 -ns 6 -ta 6; page -all; /* mlr14 * * This test will test the fill character function. * Also the truncation bit will be turned ON but we will specify that * we do not expect a truncation fault. */ inst mlr -nt "Use fill char" -io 3 -fc* -tbn -mf1 idr ar rl 4 -mf2 ida reg rl 8; /* No desc statements are needed because all the defaults are correct. */ data 1 "abcd" -do -2; /* Split the 4 characters across a page boundary. */ data 2 "abcd" "****" -do -4; /* The fill characters go on a different page. */ page -all; /* mlr15 * * This is the same test as mlr14 except the fill characters will start on * one page and end on the next page. * we do not expect a truncation fault. */ inst mlr -nt "Fill X pg bound" -io 1 -fc* -tbn -mf1 idr ar rl 4 -mf2 ida reg ar rl 8; /* No desc statements are needed because all the defaults are correct. */ data 1 "abcd" -do -2; /* Split the 4 characters across a page boundary. */ data 2 "abcd**" "**" -do -6; /* The fill characters are split across a page boundary. */ page -all; /* mlr16 * * This test is designed to test truncation. We will expect the truncation * indicator to be ON. The truncation bit will be left OFF and so we will not * expect a truncation fault. */ inst mlr -nt "Trunc Ind ON" -mf2 ar -io 2 -ir tn; desc 1 -ns 8; desc 2 -ns 4; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "abcd"; page -all; /* mlr17 * * This test is designed to test truncation. We will expect the truncation * indicator to be ON. This test is the same as mlr16 except that the * truncation bit in the instruction word will be set ON. This should * cause a truncation fault. We should be ready for it. */ inst mlr -nt "Take trunc fault" -tby -mf2 ar -io 2 -ir tn; desc 1 -ns 8; desc 2 -ns 4; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "abcd"; page -all; /* mlr18 * * This test will try to move over a page of data. We will move 1088 words * containing the characters "cisl". */ inst mlr -nt "Move over 1 page" -io 1 -mf1 rl 4352 idb ar reg -mf2 rl 4352 idbar reg; data 1 -do -128 (1088) "cisl"; data 2 -do -128 (1088) "cisl"; page -all; /* mrl1 * * Just a simple test. Move one 9 bit character to another. */ inst mrl -nt "Move 1 (9) bit char"; desc 1 -ns 1; data 1 "a"; desc 2 -ns 1; data 2 "a"; page -all; /* mrl2 * * Move two characters that cross a page boundary. Note, we need AR * modification in order to set a data offset that is not a multiple * of the word size. By doing this we will move the data fields to * segments etd1 and etd2. */ inst mrl -nt "2 chars X page bound" -mf1 ar -mf2 ar; desc 1 -ns 2; desc 2 -ns 2; data 1 "ab" -do -1; data 2 "ab" -do -1; page -all; /* mrl3 * * This test will move 20 characters. The characters will start in the middle * of a word. The last two characters moved will cross a page boundary. * The instruction word will be moved so that its descriptors cross a * page boundary. */ inst mrl -nt "20 char X page bound (-io 1)" -io 1; desc 1 -cn 2 /* Effective address will point to a word boundary. * We will start the string at character 2. Note, when * we set up the data we have to enter the two characters * that we are not using. */ -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000000 (5) "abcd" ; /* Skipped data in a result field * must be zeros since this is what * et initializes the test area * to be. */ page -all; /* mrl4 * * This test is the same as mrl3 except that the descriptors will be * referenced via indirect words. These indirect words will use no * modification so the descriptors and the data will still be in * segment etx. Also we will move the instruction word back * so that the second descriptor is on the 2nd page. */ inst mrl -nt "Same as prev - ind desc" -io 2 -mf1 id -mf2 id; desc 1 -ns 20 -cn 2; /* Note the order of the terms. */ desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl5 * /* This test is the same as mrl4 except that the indirect words will * use index register modification. */ inst mrl -nt "Same as prev - use indexes" -io 2 -mf2 idr -mf1 idr; /* Note order of mf terms. */ desc 1 -cn 2 -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl6 * /* This test is the same as mrl4 except that the indirect words will * use AR modification. This will force ET to place the descriptors and * the data fields in segments eti1 and eti2. */ inst mrl -nt "Ind with AR mod" -io 2 -mf2 ida -mf1 ida; desc 1 -cn 2 -ns 20; desc 2 -cn 2 -ns 20; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl7 * * This test is the same as the test mrl3 except that the descriptors * will use REG and RL modification. */ inst mrl -nt "Ind with REG 7. RL mod" -io 1 -mf2 reg rl 20 -mf1 rl 20 reg; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl8 * * This test is the same as the test mrl3 except that the descriptors * will use AR, REG and RL modification. */ inst mrl -nt "Desc use AR,REG,& RL mod" -io 1 -mf1 reg ar rl 20 -mf2 rl 20 ar reg; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl9 * * This test is the same as the test mrl3 except that the descriptors * will use AR, REG and RL modification AND we will use indirect descriptors. * We will not have any modification in the indirect words so the descriptors * will still be in segment etx. */ inst mrl -nt "Same as prev - use ind" -io 1 -mf1 rl 20 ar /* This puts the data in etd1. */ reg /* Use index register 1.. */ id /* This adds indirect descriptors. */ -mf2 id rl 20 reg ar; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl10 * * This test is the same as the test mrl3 except that the descriptors * will use AR, REG and RL modification AND we will use indirect descriptors. * The indirect words will use both reg and ar modification. */ inst mrl -nt "Desc: AR,RL,REG Ind: AR,REG" -io 1 -mf1 rl 20 ar /* This puts the data in etd1. */ reg /* Use index register 1.. */ idb /* This adds indirect descriptors. Descriptors will go in * segments eti1 and eti2. */ -mf2 idb rl 20 reg ar; desc 1 -cn 2; desc 2 -cn 2; data 1 -do -20 " " (5) "abcd" ; data 2 -do -20 000 000 (5) "abcd" ; page -all; /* mrl11 * * This test will move 6 6 bit characters. Both strings will have 3 characters * on each side of the page boundary. The descriptor 2 data will be offset 4 * 9 bit characters but will specify a "cn" field of 3 so the effective starting * address will be the same as descriptor 1. All possible modification will be * used. Descriptor 1 will also use RL modification. */ inst mrl -nt "6 bit chars X pg bound" -mf1 rl 6 idb ar reg -mf2 reg ar idb; desc 1 -ta 6; desc 2 -cn 3 -ta 6 -ns 6; data 1 -do -2 212223242526; data 2 -do -4 (2) 000 /* We must fill in the unused 3 six bit characters. */ 212223242526; /* The actual data result field. */ page -all; /* mrl12 * * This test will move 3 4 bit characters. Below is a description of what is * going on. EA is the effective address of the descriptor. * * string 1 EA 1 | 2 3 * --------------------------------------------------- * char addr 0 1 2 3 4 5 6 7 | 0 1 2 3 4 5 6 7 * --------------------------------------------------- * string 2 EA 1 2 | 3 * * All possible modification will be used. Descriptor 2 will use RL mod. */ inst mrl -nt "4 bit chars" -mf1 idb ar reg -mf2 reg ar idb rl 3; desc 1 -ta 4 -cn 1 -ns 3; desc 2 -cn 6 -ta 4; data 1 011 253 -do -1; data 2 -do -4 000000000 232 26; page -all; /* mrl13 * * This test will move 6 9 bit characters into 6 6 bit characters. * Both strings will be split in the middle across a page boundary. */ inst mrl -nt "9 bit chars into 6 bit chars" -mf1 ar reg idr -mf2 reg ar idb; data 1 -do -3 " te" "st "; data 2 -do -2 406445 636440; desc 1 -ns 6; desc 2 -ns 6 -ta 6; page -all; /* mrl14 * * This test will test the fill character function. * Also the truncation bit will be turned ON but we will specify that * we do not expect a truncation fault. */ inst mrl -nt "Use fill char" -io 3 -fc* -tbn -mf1 idr ar rl 4 -mf2 ida reg rl 8; /* No desc statements are needed because all the defaults are correct. */ data 1 "abcd" -do -2; /* Split the 4 characters across a page boundary. */ data 2 "****" "abcd" -do -4; /* The fill characters go on a different page. */ page -all; /* mrl15 * * This is the same test as mrl14 except the fill characters will start on * one page and end on the next page. * we do not expect a truncation fault. */ inst mrl -nt "Fill X pg bound" -io 1 -fc* -tbn -mf1 idr ar rl 4 -mf2 ida reg ar rl 8; /* No desc statements are needed because all the defaults are correct. */ data 1 "abcd" -do -2; /* Split the 4 characters across a page boundary. */ data 2 "**" "**abcd" -do -2; /* The fill characters are split across a page boundary. */ page -all; /* mrl16 * * This test is designed to test truncation. We will expect the truncation * indicator to be ON. The truncation bit will be left OFF and so we will not * expect a truncation fault. */ inst mrl -nt "Trunc Ind ON" -mf2 ar -io 2 -ir tn; desc 1 -ns 8; desc 2 -ns 4; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "1234"; page -all; /* mrl17 * * This test is designed to test truncation. We will expect the truncation * indicator to be ON. This test is the same as mrl16 except that the * truncation bit in the instruction word will be set ON. This should * cause a truncation fault. We should be ready for it. */ inst mrl -nt "Take trunc fault" -tby -mf2 ar -io 2 -ir tn; desc 1 -ns 8; desc 2 -ns 4; data 1 -do -4 "abcd" "1234"; data 2 -do -2 "1234"; page -all; /* mrl18 * * This test will try to move over a page of data. We will move 1088 words * containing the characters "cisl". */ inst mrl -nt "Move over 1 page" -io 1 -mf1 rl 4352 idb ar reg -mf2 rl 4352 idbar reg; data 1 -do -128 (1088) "cisl"; data 2 -do -128 (1088) "cisl"; page -all; /* mvt 1 * * Just a simple test. Table is "0123". result = "01233210". */ inst mvt -nt "Simple test with 9 bit chars"; desc 1 -ns 8; desc 2 -ns 8; data 1 000 001 002 003 003 002 001 000; /* 9 bit characters used as indexes. */ data 2 "01233210"; data 3 "0123"; page -all; /* mvt 2 * * Same test as mvt 1 except that the data fields have been move across * a page boundary. */ inst mvt -nt "Same as prev - fields X pg bound" -io 1; desc 1 -ns 8; desc 2 -ns 8; data 1 -do -4 000 001 002 003 003 002 001 000; data 2 -do -4 "0123" "3210"; data 3 "0123"; page -all; /* mvt 3 * * Same test as mvt 2 except we will add a lot of modification and adjust * that data fields so that they do not begin on WORD boundaries. */ inst mvt -nt "Same as prev - with mod" -io 3 -mf1 rl 8 ar reg idb -mf2 rl 8 ar reg idb -mf3 ar reg; /* No desc statements needed since rl mod specified and other defaults OK. */ data 1 -do -2 000 001 002 003 003 002 001 000; data 2 -do -2 "01" "233210"; data 3 "0123"; page -all; /* mvt 4 * * This test will use a fill character. The table will have 110 characters * but we should only reference 5 of them. */ inst mvt -nt "Use fill characters" -io 1 -fce /* Fill character is "e" = 145 octal. */ -mf1 ar -mf2 ar -mf3 ar; desc 1 -ns 3; desc 2 -ns 8; /* L2 > L1 => use of fill character. */ /* There are no legal fields we can specify with a desc 3 statement * for this instruction. */ data 1 -do -1 "c" "ba"; data 2 -do -5 "32155" "555"; data 3 -do -100 (97) "*" /* These characters in table never used. */ "123" "45" (9) "*"; page -all; /* mvt 5 * * Test page faults when first character of desc 1 and 2 are * at the end of a page. */ inst mvt -nt"check special page fault 1" -io 1; desc 1 -ns 9 -cn 3 ; desc 2 -ns 9 -cn 3 ; data 1 -do -4 " " 000 001 002 003 002 000 004 005 003 ; data 2 -do -4 000 000 000 "character" ; data 3 "charted" ; page -all ; /* mvt 6 * * Test page faults when last character of desc 1 and 2 are on a new page. * */ inst mvt -nt "check special page fault 2" -io 1 ; desc 1 -ns 9 ; desc 2 -ns 9 ; data 1 -do -8 000 001 002 003 002 000 004 005 003 ; data 2 -do -8 "character" ; data 3 "charte" ; page -all ; /* mvt 7 * * Test direct data movement for data 1 and 2 . * Also test moving data across 3 pages. To move more than * 4096 characters of data register length modification must be used. */ inst mvt -nt "dir desc. 3 page move; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 rl 4112 -mf2 rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 8 * * Test address register usage for data 1 and 2. Also test moving data across * 3 pages. All descriptors are direct. * Also use register length modification. */ inst mvt -nt "tst ar1&ar2. 3 pg move;FCOs PHAFPG179 & 181 required on L68 CPU" -io 2 -mf1 ar rl 4112 -mf2 ar rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 9 * Test ar, reg, and register length modification for data 1 and 2. * Also test data movement of three pages. */ inst mvt -nt "tst ar,rg,rl. 3 pg mv; FCOs PHAFPG179 & 181 required on L68 CPU" -io 2 -mf1 ar reg rl 4112 -mf2 ar reg rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 10 * * Test indirect referencing of descriptors 1 and 2. * Test register length modification and move data from 3 pages. */ inst mvt -nt "tst ind descs; FCOs PHAFPG179 & 181 required on L68 CPU" -io 1 -mf1 id rl 4112 -mf2 id rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 11 * * Test indirect referencing of descriptors 1 and 2 with ar modification * of the indirect word. Also data is moved from 3 pages. */ inst mvt -nt "tst ida. 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU" -io 2 -mf1 ida rl 4112 -mf2 ida rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 12 * * Test indirect referencing of descriptors 1 and 2 with reg modification * of the indirect word. Also data is moved from 3 pages. */ inst mvt -nt "tst idr, 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU" -io 1 -mf1 idr rl 4112 -mf2 idr rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 13 * * Test indirect referencing of descriptors 1 and 2 with both * ar and reg modification of the indirect word. Also data is * moved from three pages. */ inst mvt -nt "tst idb. 3 pgs moved; FCOs PHAFPG179 & 181 required on L68 CPU" -io 2 -mf1 idb rl 4112 -mf2 idb rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 14 * * Test indirect referencing of of descriptors 1 and 2 with * ar, reg, and reg length modification of the descriptors. * Data is moved from 3 pages. */ inst mvt -nt "tst ar,reg,rl,id.; FCOs PHAFPG179 & 181 required on L68 CPU" -mf1 id ar reg rl 4112 -mf2 id ar reg rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 15 * * Test indirect referencing of descriptors 1 and 2 with ar * and reg modification of the indirect word. Also ar, reg, * and register length modification is applied to the * descriptors. Three pages of data is moved. */ inst mvt -nt "tst ar,reg,rl,idb; FCOs PHAFPG179 & 181 required on L68 CPU" -io 2 -mf1 idb ar reg rl 4112 -mf2 idb ar reg rl 4112 ; desc 1 -cn 1 ; data 1 -do -4 " " (257) 000001002003004005006007010011012013014015016017 ; data 2 -do -4 (257) "abcdefghijklmnop" ; data 3 "abcdefghijklmnop" ; page -all ; /* mvt 16 * * Test translation of 9 bit to 6 bit characters. Only direct descriptors * with no modification are used. All forms of modification and * indirection have been tested in previous tests. * This test has no truncation. * */ inst mvt -nt "9 to 6 bit chars" -fc ; desc 1 -ns 50 -cn 2 ; desc 2 -ns 50 -cn 5 -ta 6 ; data 1 -do 4068 " " (6) 000001002003004005006007010 ; data 2 -do 20 000000000060 (5) 616263414243440060 61626341 ; data 3 "0123abcd" (23) 000 020 ; page -all; /* mvt 17 * * Test translation of 9 to 6 `bit characters. * L1 is less than L2. String 2 is `blank filled. * */ inst mvt -nt "9 to 6 bit chars" -fc ; desc 1 -ns 28 -cn 2 ; desc 2 -ns 50 -cn 5 -ta 6 ; data 1 -do 4068 " " (6) 000001002003004005006007010 ; data 2 -do 20 000000000060 (3) 616263414243440060 (7) 202020 20 ; data 3 "0123abcd" (24) 000 020 ; page -all; /* mvt 18 * * Test translation of 9 to 6 bit characters. * L1 is greater than L2. Truncation fault is not taken. * */ inst mvt -nt "truncation but no fault" -ir tn ; desc 1 -ns 50 -cn 2 ; desc 2 -ns 28 -cn 5 -ta 6 ; data 1 -do 4068 " " (6) 000001002003004005006007010 ; data 2 -do 20 000000000060 (3) 616263414243440060 ; data 3 "0123abcd" (24) 000 020 ; page -all; /* mvt 19 * * Test translation of 6 bit to 9 bit characters. Only direct * descriptors with no modification are used. * This test has no truncation. * */ inst mvt -nt "6-9 bit. no truncation" -fc ; desc 1 -ns 63 -cn 3 -ta 6 ; desc 2 -ns 63 ; data 1 -do -20 000000 (7) 000102030405060710 ; data 2 -do -28 (7) 141142143144060061062063000 ; data 3 "abcd0123" (24) 000 040 ; page -all; /* mvt 20 * * Test translation of 6 bit to 9 bit characters. * L1 is less than L2. String 2 is blank filled. * */ inst mvt -nt "6-9 bit. blank fill" -fc ; desc 1 -ns 29 -cn 3 -ta 6 ; desc 2 -ns 63 ; data 1 -do -20 000000 (7) 000102030405060710 ; data 2 -do -28 (3) 141142143144060061062063000 141142 (34) 040 ; data 3 "abcd0123" (24) 000 040 ; page -all; /* mvt 21 * * Test translation of 6 bit to 9 bit characters. * L1 is greater than L2. Truncation fault is not taken. * */ inst mvt -nt "6-9 bit. truncation" -ir tn -fc ; desc 1 -ns 63 -cn 3 -ta 6 ; desc 2 -ns 29 ; data 1 -do -20 000000 (7) 000102030405060710 ; data 2 -do -28 (3) 141142143144060061062063000 141142 ; data 3 "abcd0123" (24) 000 040 ; page -all; /* mvt 22 * * Test translation of 4 bit characters. The test is made * with full descriptor modification. Data is placed across a * page boundary. * */ inst mvt -nt "4 bit char translation" -io 1 -mf1 idb ar reg rl 16 -mf2 idb ar reg rl 16 -mf3 ar reg ; desc 1 -ta 4 ; desc 2 -ta 4 ; data 1 -do -4 (2) 002215053176 ; data 2 -do -4 (2) 002215053176 ; data 3 000 001 002 003 004 005 006 007 010 011 012 013 014 015 016 017 ; page -all; /* mve1 * * Move 6 (9 bit) characters with zero -> "*" replacement. * All the fields including the micro op string will take faults * and cross a page boundary. */ inst mve -nt "zero rep, mod, faults" -io 3 -mf1 idb ar reg rl 6 -mf2 idb ar reg rl 2 -mf3 idb ar reg rl 6; /* No desc statements needed. */ data 1 -do -4 "0010" "23"; data 2 -do -1 124 /* mvza 4 */ 322; /* mvc 2 */ data 3 -do -3 "**1" "023"; page -all; /* mve2 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9 simple test with no mod" -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve3 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9offset inst. and desc mod" -io 2 -mf1 ida ar -mf2 reg -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve4 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9 off inst desc mod d1 off" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve5 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9 d2 offset d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve6 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9d3 offset d2 offset d1 offset" -io 3 -mf1 ida ar reg -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -28 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve7 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9data 1 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar -mf3 ar reg rl 31; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve8 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9data 2 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; /* no desc needed */ data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve9 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9all data totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; /* no desc needed */ data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -31 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve10 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-9 all data on p0 all mod" -io 3 -mf1 idb ar reg rl 27 -mf2 idb ar reg rl 26 -mf3 ar reg rl 31; /* no desc needed */ data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -31 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "-123" ";;;"; page -all; /* mve11 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 simple test with no mod" -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 9; data 1 /* arranged according mop use */ 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve12 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 offset inst. and desc mod" -io 2 -mf1 ida ar -mf2 reg -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve13 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 desc mod d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -6 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve14 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 d2 offset d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -6 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve15 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 d3 offset and d2 and d1" -io 3 -mf1 ida ar reg -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -6 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -28 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve16 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 data 1 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar -mf3 ar reg rl 31; desc 1 -ta 6; desc 2 -ns 26; data 1 /* arranged according mop use */ -do -28 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -13 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve17 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 data 2 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; data 1 /* arranged according mop use */ 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve18 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 all data totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; data 1 /* arranged according mop use */ -do -28 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -31 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve19 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-9 all data on p0 all mod" -io 3 -mf1 idb ar reg rl 27 -mf2 idb ar reg rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; data 1 /* arranged according mop use */ -do -28 606061626060616260606162616263646465666752616263616263; data 2 /* mops arranged in order */ -do -26 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 420 "* +- " /* change table with string shown */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -31 " 12" "**12" "$" " $12" "=" "*" "4567" "****" "*123" ";;;"; page -all; /* mve20 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 simple test with no mod" -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; data 3 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve21 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 offset inst. and desc mod" -io 2 -mf1 ida ar -mf2 reg -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve22 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 desc mod d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve23 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 d2 offset d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve24 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 d3 offset d2 and d1" -io 3 -mf1 ida ar reg -mf2 idb ar -mf3 rl 31; desc 1 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -7 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -28 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve25 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 data 1 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar -mf3 ar reg rl 31; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve26 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 data 2 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -12 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve27 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 all data totally on p0" -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -32 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve28 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "9-6 all data on p0 all mod" -io 3 -mf1 idb ar reg rl 27 -mf2 idb ar reg rl 26 -mf3 ar reg rl 31; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -27 "0012" "0012" "0012" "1234" "4567" "-123" "123"; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -32 20206162545461625320205361627554646566672020202055616263616263; page -all; /* mve29 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 simple test with no mod" -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; data 3 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve30 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 offset inst. and desc mod" -io 2 -mf1 ida ar -mf2 reg -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve31 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 desc mod d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -6 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve32 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 d2 offset d1 offset" -io 2 -mf1 ida ar -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -6 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve33 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 d3 offset and d1 and d2" -io 3 -mf1 ida ar reg -mf2 idb ar -mf3 rl 31; desc 1 -ta 6 -ns 27; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -6 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -28 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve34 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 data 1 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar -mf3 ar reg rl 31; desc 1 -ta 6; desc 2 -ns 26; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -28 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -13 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do 30 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve35 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 data 2 totally on p0" -io 3 -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -28 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -12 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve36 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 all data totally on p0" -mf1 ida ar reg rl 27 -mf2 idb ar rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -28 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -32 20200102545401025320205301027554040506072020202052010203616263; page -all; /* mve37 * this test uses a sequence of micro op strings * that are appropriate for alpha numeric data. * each string is input to et such that it is * explained via a comment after each mop. * this particular mop sequence and the sending string is * used for all 6 and 9 bit tests with mod done * on descriptor access and data placement. * */ inst mve -nt "6-6 all data on p0 all mod" -io 3 -mf1 idb ar reg rl 27 -mf2 idb ar reg rl 26 -mf3 ar reg rl 31; desc 1 -ta 6; desc 3 -ta 6; data 1 /* arranged according mop use */ -do -28 000001020000010200000102010203040405060752010203010203; data 2 /* mops arranged in order */ -do -26 /* change table and mvzb */ 420020054060052053073033000 104 060 /* ses es reset */ 124 /* mvza */ 060 /* ses es reset */ 050 /* enf for $ insert */ 064 /* ses es reset and bz set */ 164 /* mflc */ 200075 /* insb with = */ 060 /* ses es reset */ 220076 /* insa with " not used since es=0 */ 304 /* ign */ 324 /* mvc */ 024 /* insm */ 344 /* mses sn is set */ 364; /* mors */ data 3 -do -32 20200102545401025320205301027554040506072020202052010203616263; page -all; /* tct1 * * Out table will be indexed by the characters "abcde". "b" & "e" are the two * non zero entries. Start off with a simple test */ inst tct -nt "Simple test"; desc 1 -ns 4; data 1 "aceb"; data 2 (97) "*" /* These characters should never be referenced. */ 000 /* "a" */ "b" 000 /* "c" */ "d" 000 ; /* "e" */ data 3 "b" 000 000 003; page -all; /* tct2 * * Same as tct1 only we will move the data fields across page boundaries and * add modification. */ inst tct -nt "Same as prev - fields X pg bound" -io 3 -mf1 rl 4 ar reg idb -mf2 ar reg /* RL and ID mod NOT allowed for descriptors 2 & 3. */ -mf3 reg ar; data 1 -do -3 "aceb"; data 2 -do -100 (97) "*" /* These characters should never be referenced. */ 000 /* "a" */ "b" 000 /* "c" */ "d" 000 ; /* "e" */ data 3 "b" 000 000 003; page -all; /* tct3 * * Same as tct2 except string 1 will be changed so we will have a * tally runout. */ inst tct -nt "Test tally runout" -io 2 -ir tr -mf1 ar idb reg rl 18 -mf2 ar reg -mf3 ar reg; data 1 -do -9 (6) "ace"; data 2 -do -100 (97) "*" 000 "b" 000 "d" 000; data 3 000 000 000 022; page -all; /* tct4 * * Test using 6 bit characters. The -cn field will specify that the string * starts at the 5th character of the word (last character). */ inst tct -nt "Use 6 bit characters" -io 1 -mf1 idb reg ar -mf2 reg ar -mf3 ar reg; desc 1 -ns 10 -cn 5 -ta 6; data 1 -do -6 /* Test string is 0 1 2 3 4 5 6 7 10 11 */ 0606060606 /* Filler, not part of string, 1st 5 characters of word. */ 010203 /* Page boundary. */ 040506 071011; data 2 -do -4 000 000 000 000 000 000 006 000 000 000; data 3 -do 4 006 000000 006; page -all; /* tct5 * * The indexes in string 1 will be 4 bit characters. */ inst tct -nt "Use 4 bit characters" -io 2 -mf1 idb ar reg -mf2 ar reg -mf3 ar reg; desc 1 -ns 8 -ta 4 /* 4 bit characters. */ -cn 2; /* First 2 characters of word not used. * This is the first 9 bit character. */ data 1 -do -2 000 /* The first two characters of the word - skipped. */ 001 /* Characters "0" and "1". In page 1. */ 043 105 147; /* "234567" (4 bit) in page 2. */ data 2 -do -4 000 000 000 000 /* All in page 1. Represent index values 0,1,2,3 */ 000 "*" 000 000; /* In page 2. Correspond to index values 4,5,6,7 */ data 3 "*" 000 000 005; page -all; /* tct 6 * * Test loading across three pages. One character loaded from * page 1 and 3. Test 6146 characters. Tally runout indicator * is set. */ inst tct -nt "(6 bit)no modif. tally is set" -io 1 -ir tr -mf1 rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 7 * * Test loading data across three pages. One character is loaded * from page 1 and 3 with 6146 characters tested. A nonzero * character is found in the test table. */ inst tct -nt "(6 bit)no mod. a nonzero entry" -mf1 rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 8 * * Test similiar to tct 6. Test ar, reg, and rl for descriptor 1. * */ inst tct -nt "(6 bit)ar,reg,rl. tally runout" -io 2 -ir tr -mf1 ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 9 * * Test similiar to tct 7. Test ar, reg, and rl modification * for descriptor 1. Test ar and reg modification for descriptor 1 and 2. * */ inst tct -nt "(6 bit)ar,reg,rl.no tally runout" -io 1 -mf1 ar reg rl 6146 -mf2 ar reg -mf3 ar reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 10 * * Test similiar to tct 6. Test indirect referencing * of descriptor 1. Test ar and reg modification for descriptors 2 and 3. */ inst tct -nt "(6 bit)test id. tally runout" -ir tr -mf1 id rl 6146 -mf2 ar reg -mf3 ar reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 11 * * Test similiar to tct 7. Test indirect referencing of * descriptor 1. * */ inst tct -nt "(6 bit)test id. no tally runout" -io 2 -mf1 id rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 12 * * Test similiar to tct 6. Test indirect referencing of descriptor 1 * with ar modification of the indirect word. Also test reg * modification of descriptors 2 and 3. * */ inst tct -nt "(6 bit)test ida. tally runout" -io 1 -ir tr -mf1 ida rl 6146 -mf2 reg -mf3 reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 13 * * Test similiar to tct 7. Test indirect referencing of descriptor 1 * with ar modification of the indirect word. Also test ar * modification of descriptors 2 and 3. * */ inst tct -nt "(6 bit)test ida. no tally runout" -mf1 ida rl 6146 -mf2 ar -mf3 ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 14 * * Test similiar to tct 6. Test indirect referencing of decriptor 1 * with ar and reg modification of the indirect word. * */ inst tct -nt "(6 bit)test idb. tally runout" -io 2 -ir tr -mf1 idb rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 15 * * Test similiar to tct 7. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. * */ inst tct -nt "(6 bit)test idb. no tally runout" -mf1 idb rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 16 * * Test similiar to tct 6. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. Further the * descriptor has ar, reg, and rl modification. * */ inst tct -nt "(6 bit)idb,ar,reg. tally runout" -io 1 -ir tr -mf1 idb ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tct 17 * * Test similiar to tct 7. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. Further the * descriptor has ar, reg, and rl modification. * */ inst tct -nt "(6bit)idb,ar,reg.no tally runout" -io 2 -mf1 idb ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 001 ; page -all ; /* tct 18 * * Test for character match on the first character of page 3. * Also, test idb, ar, reg, and rl of descriptor 1. Also, test * ar and reg modification of descriptors 2 and 3. * */ inst tct -nt "(6 bit)match 1st char of page 3" -io 1 -mf1 idb ar reg rl 6146 -mf2 reg ar -mf3 reg ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 (128) 000102030405060710111213141516172021222324252627 31 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 014 001 ; page -all ; /* tct 19 * * Test for character match on the last character of page 1. * Also, test idb, ar, reg, and rl of descriptor 1. Also, test * ar and reg modification of descriptors 2 and 3. * */ inst tct -nt "(6 bit)match last char of page 1" -io 1 -mf1 idb ar reg rl 6146 -mf2 reg ar -mf3 reg ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 031 (128) 010203040506071011121314151617202122232425262700 (128) 000102030405060710111213141516172021222324252627 00 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 000 000 ; page -all ; /* tctr1 * * Out table will be indexed by the characters "abcde". "b" & "e" are the two * non zero entries. Start off with a simple test */ inst tctr -nt "Simple test"; desc 1 -ns 4; data 1 "bace"; data 2 (97) "*" /* These characters should never be referenced. */ 000 /* "a" */ "b" 000 /* "c" */ "d" 000 ; /* "e" */ data 3 "b" 000 000 003; page -all; /* tctr2 * * Same as tctr1 only we will move the data fields across page boundaries and * add modification. */ inst tctr -nt "Same as prev - fields X pg bound" -io 3 -mf1 rl 4 ar reg idb -mf2 ar reg /* RL and ID mod NOT allowed for descriptors 2 & 3. */ -mf3 reg ar; data 1 -do -3 "bace"; data 2 -do -100 (97) "*" /* These characters should never be referenced. */ 000 /* "a" */ "b" 000 /* "c" */ "d" 000 ; /* "e" */ data 3 "b" 000 000 003; page -all; /* tctr3 * * Same as tctr2 except string 1 will be changed so we will have a * tally runout. */ inst tctr -nt "Test tally runout" -io 2 -ir tr -mf1 ar idb reg rl 18 -mf2 ar reg -mf3 ar reg; data 1 -do -9 (6) "ace"; data 2 -do -100 (97) "*" 000 "b" 000 "d" 000; data 3 000 000 000 022; page -all; /* tctr4 * * Test using 6 bit characters. The -cn field will specify that the string * starts at the 5th character of the word (last character). */ inst tctr -nt "Use 6 bit characters" -io 1 -mf1 idb reg ar -mf2 reg ar -mf3 ar reg; desc 1 -ns 10 -cn 5 -ta 6; data 1 -do -6 /* Test string is 0 1 2 3 4 5 6 7 10 11 */ 0606060606 /* Filler, not part of string, 1st 5 characters of word. */ 010203 /* Page boundary. */ 040506 071011; data 2 -do -4 000 000 000 000 000 000 006 000 000 000; data 3 -do 4 006 000000 003; page -all; /* tctr5 * * The indexes in string 1 will be 4 bit characters. */ inst tctr -nt "Use 4 bit characters" -io 2 -mf1 idb ar reg -mf2 ar reg -mf3 ar reg; desc 1 -ns 8 -ta 4 /* 4 bit characters. */ -cn 2; /* First 2 characters of word not used. * This is the first 9 bit character. */ data 1 -do -2 000 /* The first two characters of the word - skipped. */ 001 /* Characters "0" and "1". In page 1. */ 043 105 147; /* "234567" (4 bit) in page 2. */ data 2 -do -4 000 000 000 000 /* All in page 1. Represent index values 0,1,2,3 */ 000 "*" 000 000; /* In page 2. Correspond to index values 4,5,6,7 */ data 3 "*" 000 000 002; page -all; /* tctr 6 * * Test loading across three pages. One character loaded from * page 1 and 3. Test 6146 characters. Tally runout indicator * is set. */ inst tctr -nt "(6bit)no modif. tally is set" -io 1 -ir tr -mf1 rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 7 * * Test loading data across three pages. One character is loaded * from page 1 and 3 with 6146 characters tested. A nonzero * character is found in the test table. */ inst tctr -nt "(6bit)no modif. a nonzero entry" -mf1 rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 8 * * Test similiar to tctr 6. Test ar, reg, and rl for descriptor 1. * */ inst tctr -nt "(6bit)ar,reg,rl. tally runout" -io 2 -ir tr -mf1 ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 9 * * Test similiar to tctr 7. Test ar, reg, and rl modification * for descriptor 1. Test ar and reg modification for descriptor 1 and 2. * */ inst tctr -nt "(6bit)ar,reg,rl. no tally runout" -io 1 -mf1 ar reg rl 6146 -mf2 ar reg -mf3 ar reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 10 * * Test similiar to tctr 6. Test indirect referencing * of descriptor 1. Test ar and reg modification for descriptors 2 and 3. */ inst tctr -nt "(6bit)test id. tally runout" -ir tr -mf1 id rl 6146 -mf2 ar reg -mf3 ar reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 11 * * Test similiar to tctr 7. Test indirect referencing of * descriptor 1. * */ inst tctr -nt "(6bit)test id. no tally runout" -io 2 -mf1 id rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 12 * * Test similiar to tctr 6. Test indirect referencing of descriptor 1 * with ar modification of the indirect word. Also test reg * modification of descriptors 2 and 3. * */ inst tctr -nt "(6bit)test ida. tally runout" -io 1 -ir tr -mf1 ida rl 6146 -mf2 reg -mf3 reg ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 13 * * Test similiar to tctr 7. Test indirect referencing of descriptor 1 * with ar modification of the indirect word. Also test ar * modification of descriptors 2 and 3. * */ inst tctr -nt "(6bit)test ida. no tally runout" -mf1 ida rl 6146 -mf2 ar -mf3 ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 14 * * Test similiar to tctr 6. Test indirect referencing of decriptor 1 * with ar and reg modification of the indirect word. * */ inst tctr -nt "(6bit)test idb. tally runout" -io 2 -ir tr -mf1 idb rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 15 * * Test similiar to tctr 7. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. * */ inst tctr -nt "(6bit)test idb. no tally runout" -mf1 idb rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 16 * * Test similiar to tctr 6. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. Further the * descriptor has ar, reg, and rl modification. * */ inst tctr -nt "(6bit)idb,ar,reg. tally runout" -io 1 -ir tr -mf1 idb ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 000102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 000 000 014 002 ; page -all ; /* tctr 17 * * Test similiar to tctr 7. Test indirect referencing of descriptor 1 * with ar and reg modification of the indirect word. Further the * descriptor has ar, reg, and rl modification. * */ inst tctr -nt "(6bit)idb,ar,reg.no tally runout" -io 2 -mf1 idb ar reg rl 6146 ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 310102030405 (128) 000102030405060710111213141516172021222324252627 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 006 000 ; page -all ; /* tctr 18 * * Test for character match on the first character of page 3. * Also, test idb, ar, reg, and rl of descriptor 1. Also, test * ar and reg modification of descriptors 2 and 3. * */ inst tctr -nt "(6bit)match 1st char of page 3" -io 1 -mf1 idb ar reg rl 6146 -mf2 reg ar -mf3 reg ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 000 (128) 010203040506071011121314151617202122232425262700 (128) 000102030405060710111213141516172021222324252627 31 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 000 000 ; page -all ; /* tctr 19 * * Test for character match on the last character of page 1. * Also, test idb, ar, reg, and rl of descriptor 1. Also, test * ar and reg modification of descriptors 2 and 3. * */ inst tctr -nt "(6bit)match last char of page 1" -io 1 -mf1 idb ar reg rl 6146 -mf2 reg ar -mf3 reg ar ; desc 1 -cn 5 -ta 6 ; data 1 -do -4 " " 031 (128) 010203040506071011121314151617202122232425262700 (128) 000102030405060710111213141516172021222324252627 00 ; data 2 -do -4 (24) 000 000 141 ; data 3 141 000 014 001 ; page -all ; /* scm1 * * No match found in data 1 field so tally runout indicator will be ON. * CN field used in descriptor 1 and its data will cross a page boundary. */ inst scm -nt "Tally runout" -io 3 -mc /* Mask = (007) octal. */ -ir tr -mf1 ida -mf2 ar -mf3 ar reg; desc 1 -ns 3 -cn 3 -ta 9; desc 2 -ns 4 -cn 1; data 1 -do -4 000 000 000 /* Fill due to cn 3. */ 011 /* Part of string on page 1. */ 021 031; /* Part of string on page 2. */ data 2 -do -1 000 001; data 3 000 000 000 003; page -all; /* scm2 * simple test to determine if instruction * is working correctly. data is 9 bit * written in octal format to allow easy * comparison with the mask. this test * accesses all descriptors directly. * */ inst scm -nt "mc 8 9bit" -mc8; desc 1 -ns 8 -ta 9; data 1 060061062063064065066067; data 2 047; data 3 000 000 000 007; page -all; /* scm3 * same data as test 2 but with data 1 * split across page boundary. indirect * mod on desc 1 and 2. * */ inst scm -io 1 -nt "d1 split mc 8 9bit" -mc8 -mf1 idb -mf2 idb; desc 1 -ns 8 -ta 9; data 1 -do -4 060061062063 064065066067; data 2 047; data 3 000 000 000 007; page -all; /* scm4 * same data config as test 2 but with * full desc mod. * */ inst scm -io 3 -nt "d1 split mc8 9bit" -mc8 -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; data 1 060061062063064065066067; data 2 047; data 3 000 000 000 007; page -all; /* scm5 * test of the -cn option for desc 1 and 2 * along with a varied of """mode of desc mod. * both data strings are split across page bound. * */ inst scm -io 2 -nt "mc8 no match 9bit" -ir tr -mc8 -mf1 idb ar reg rl 6 -mf2 ar -mf3 ar; desc 1 -ta 9; desc 2 -cn 3; data 1 -do -2 000000 060061062063064066; data 2 -do -1 000 000 000 047; data 3 000 000 000 006 /* no match */; page -all; /* scm6 * data 1 wholey contained on page 0 and * data starting on word 0 of page 1; char 0. * all desc mod. * */ inst scm -io 1 -nt "mc8 d1 on p0 9bit" -mc8 -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9 -ns 2 -cn 2; data 1 -do -4 000000060067; data 2 047; data 3 000 000 000 001; page -all; /* scm7 * a variety of desc mod are used~ and the mask * is set so that there is no match. using the * using the same data as test 6. * */ inst scm -io 3 -nt "mc777 no match 9 bit" -mcÿ /* mc = 777 */ -mf1 idr ar rl 2 -mf2 ar reg -mf3 ar; desc 1 -ta 9 -cn 2; data 1 -do -4 000000060067; data 2 047; data 3 000 000 000 000; page -all; /* scm 8 * the next four tests use the maximum amount of * data for string 1 to test the paging of the data * strings. this test will make sure the inst is operating * correctly using no desc mod. * */ inst scm -nt "d1 covers 3pp 9bit" -mc /* mc = 001 */ /* mc = 001 */ -mf1 rl 4352 /* no desc mod.--all direct */; desc 1 -ta 9 ; data 1 -do -128 (4351) 062 066; data 2 067; data 3 000 000 010 377; page -all; /* scm9 * uses same data setup as test 8 but applies * maximum mod to descriptors. * */ inst scm -io 3 -nt "d1 covers 3 pp max desc mod 9b" -mc /* mc = 001 */ -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; data 1 -do -128 (4351) 062 066; data 2 067; data 3 000 000 010 377; page -all; /* scm10 * this test specifically tests the -cn option ** for data 2 along with forcing it to cross * a page boundary. all desc mods are taken. * */ inst scm -io 1 -nt "d1 covers 3pp d2 split 9b" -mc /* mc = 001 */ -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; desc 2 -cn 1; data 1 -do -128 (4351) 062 066; data 2 -do -2 000067 000000; data 3 000 000 010 377; page -all; /* scm11 * there will be no match on this test. also, * a variety of desc mods are taken. note * tr indicator will be on. * */ inst scm -io 1 -nt "no match d1 covers 3pp 9bit" -mc /* mc = 001 */ -ir tr -mf1 idb rl 4352 -mf2 ar reg /* mf3 is direct */; desc 1 -ta 9; desc 2 -cn 1; data 1 -do -128 (4352) 062; data 2 -do -2 000067 000000; data 3 000 000 010 400; page -all; /* scm12 * this starts the sequence of seven * four bit data tests. this first * test makes sure that the inst is working * correctly without any desc. mod. * */ inst scm -nt "simple test 4 bit" -mc /* mc = 001 */ /* mc = 001 */ /* all the desc. are direct */; desc 1 -ta 4 -ns 8; data 1 237 323 070 361 /* 1001 1111 1101 0011 0011 1000 1111 00001 */; data 2 360 /* 1111 */; data 3 000 000 000 001; page -all; /* scm13 * same as previous test but taking all of the * possible desc. mod. * */ inst scm -io 1 -nt " full desc mod 4bit" -mc /* mc = 001 */ /* mc = 001 */ -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; data 1 237 323 070 361; data 2 360; data 3 000 000 000 001; page -all; /* scm14 * changing the mask characters and offsetting * the first data string across a page boundary * with a variety of desc. mod. * */ inst scm -io 3 -nt "d1 split 4 bit" -mc? -mf1 ar -mf2 idb /* mf3 is direct */; desc 1 -ta 4 -ns 8; data 1 -do -2 237 323 /* page bound */ 070 361; data 2 360; data 3 000 000 000 000; page -all; /* scm15 * again using the same data but this time splitting * both strings across page bound. and exercising * the -cn option. all desc. mod. are taken. * */ inst scm -io 1 -nt "d1 and d2 split 4 bit" -mc? -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 6 -cn 1; desc 2 -cn 3; data 1 -do -2 237 323 /* page boun. */ 070 361; data 2 -do -3 000 000 360 /* page bound. */ 000; data 3 000 000 000 000; page -all; /* scm16 * this time there will be no match with * the same parameters as test 15 with a mask of * 777. * */ inst scm -io 2 -nt "match on first char 4bit" -mcÿ -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 8 -cn 1; desc 2 -cn 3; data 1 -do -2 237 323 070 361; data 2 -do -3 000 000 360 000; data 3 000 000 000 000; page -all; /* scm17 * the next three tests use the maximum amount * of data for string 1. this test uses a mask * of 000 but searches for a char which will not * match ( tr ind). no desc. mod. * */ inst scm -nt "mc=000 no mat d1 covers 3pp 4b" -mc /* mc = 000 */ -ir tr -mf1 rl 8704 /* all desc. are direct */; desc 1 -ta 4; data 1 -do -128 (1088) 237323070361; data 2 000; data 3 000 000 021 000; page -all; /* scm18 * this test will force a match on a middle * char. all desc mods. are taken. * */ inst scm -io 2 -nt "d1 covers 3pp 4bit" -mc /* mc = 001 */ -mf1 idb ar reg rl 8704 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; data 1 -do -128 (1087) 237323070361 237 323 070 000; data 2 000; data 3 000 000 000 007; page -all; /* scm19 * this test puts the second string on page 0 * and tests the -cn option. * */ inst scm -io 2 -nt "d1 covers 3pp 4bit" -mc /* mc = 001 */ -mf1 ida ar reg rl 8704 -mf2 idr ar /* mf3 is direct */; desc 1 -ta 4 ; desc 2 -cn 3; data 1 -do -128 (1087) 237323070361 237323070000; data 2 -do -3 000 000 000 000; data 3 000 000 000 007; page -all; /* scm20 * the following tests use 6 bit data. * this test merely makes sure the instruction * is working correctly. direct mod on descriptors. * */ inst scm -nt "6bit" -mc /* all desc. are direct */; desc 1 -ta 6 -ns 12; data 1 414243444546 575051525353; data 2 57; data 3 000 000 000 006; page -all; /* scm21 * same as previous test but with first string * split across page bound. and a variety * of desc. mods taken. * */ inst scm -io 1 -nt "di split 6bit" -mc /* mc = 020 */ -mf1 ar reg -mf2 idb /* mf3 is direct */; desc 1 -ta 6 -ns 12; data 1 -do -4 414243444546 /*page bound */ 475051525354; data 2 67; data 3 000 000 000 006; page -all; /* scm22 * this is the same as test 22 except the mask * has been set to preclude a match (tr on) and different desc. mods. are taken. * */ inst scm -io 2 -nt "no match 6bit" -mc -ir tr -mf1 idb ar -mf2 ar reg -mf3 ar reg; desc 1 -ta 6 -ns 12; data 1 -do -4 414243444546 475051525354; data 2 67; data 3 000 000 000 014; page -all; /* scm23 *this test exercises all the desc. mods. * and tests the rl and -cn options. it also * changes the mask char . * * */ inst scm -io 3 -nt "full desc mod 6bit" -mc /* mc = 025 */ -mf1 idb ar reg rl 12 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; desc 2 -cn 3; data 1 -do -6 414243444546475051 525354; data 2 -do -4 000000720000 /* page bound. */; data 3 000 000 000 011; page -all; /* scm24 * using the -cn option on both descriptors * direct mod on mf3 desc. * */ inst scm -io 2 -nt "d1 split 6bit" -mc /* mc = 025 */ -mf1 ar rl 5 -mf2 ar /* mf3 is direct */; desc 1 -ta 6 -cn 4; desc 2 -cn 2; data 1 -do -4 000000005100 /*page bound. */ 525354; data 2 -do -2 00007200 /* page bound. */; data 3 000 000 000 002; page -all; /* scm25 * this test and the next one uses the maximum amount * of char for string 1. this test forces a "no match" * condition (ir tr on) and takes the maximum mod. * on the desc. * */ inst scm -io 3 -nt "d1 covers 3pp no match 6b" -mc000 -ir tr -mf1 idb ar reg rl 6528 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128 (1087) 515151515151 515151515153; data 2 52; data 3 000 000 014 600; page -all; /* scm26 * same as previous test but a match occurs * on the last char. * */ inst scm -io 2 -nt "d1 covers 3pp 6bit" -mc /* mc = 000 */ -mf1 idb ar reg rl 6528 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128 (1087) 515151515151 515151515152; data 2 52; data 3 000 000 014 577; page -all; /* scmr1 * * Same as scm only we will change the data of string 2 so that there is * a match. */ inst scmr -nt "Same as scm but strings match" -io 2 -mc /* Mask = (007) octal. */ -mf1 ida -mf2 ar -mf3 ar reg; desc 1 -ns 3 -cn 3 -ta 9; desc 2 -cn 1; data 1 -do -4 000 000 000 /* Fill due to cn 3. */ 011 /* Part of string on page 1. */ 021 033; /* Part of string on page 2. */ data 2 -do -1 000 013; data 3 000 000 000 002; page -all; /* scmr2 * simple test to determine if instruction * is working correctly. data is 9 bit * written in octal format to allow easy * comparison with the mask. this test * accesses all descriptors directly. * */ inst scmr -nt "mc8 simple test 9 bit" -mc8; desc 1 -ns 8 -ta 9; data 1 060061062063064065066067; data 2 047; data 3 000 000 000 000; page -all; /* scmr3 * same data as test 2 but with data 1 * split across page boundary. indirect * mod on desc 1 and 2. * */ inst scmr -io 1 -nt "d1 split 9bit" -mc8 -mf1 idb -mf2 idb; desc 1 -ns 8 -ta 9; data 1 -do -4 060061062063 064065066067; data 2 047; data 3 000 000 000 000; page -all; /* scmr4 * same data config as test 2 but with * full desc mod. * */ inst scmr -io 3 -nt "d1 split 9bit" -mc8 -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; data 1 060061062063064065066067; data 2 047; data 3 000 000 000 000; page -all; /* scmr5 * test of the -cn option for desc 1 and 2 * along with a varied of """mode of desc mod. * both data strings are split across page bound. * */ inst scmr -io 2 -nt "no match 9bit" -ir tr -mc8 -mf1 idb ar reg rl 6 -mf2 ar -mf3 ar; desc 1 -ta 9; desc 2 -cn 3; data 1 -do -2 000000 060061062063064066; data 2 -do -1 000 000 000 047; data 3 000 000 000 006 /* no match */; page -all; /* scmr6 * data 1 wholey contained on page 0 and * data starting on word 0 of page 1; char 0. * all desc mod. * */ inst scmr -io 1 -nt "d1 on p0 9bit" -mc8 -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9 -ns 2 -cn 2; data 1 -do -4 000000060067; data 2 047; data 3 000 000 000 000; page -all; /* scmr7 * a variety of desc mod are used~ and the mask * is set so that there is no match. using the * using the same data as test 6. * */ inst scmr -io 3 -nt "no match 9bit" -mcÿ /* mc = 777 */ -mf1 idr ar rl 2 -mf2 ar reg -mf3 ar; desc 1 -ta 9 -cn 2; data 1 -do -4 000000060067; data 2 047; data 3 000 000 000 000; page -all; /* scmr 8 * the next four tests use the maximum amount of * data for string 1 to test the paging of the data * strings. this test will make sure the inst is operating * correctly using no desc mod. * */ inst scmr -nt "d1 covers 3pp 9bit" -mc /* mc = 001 */ /* mc = 001 */ -mf1 rl 4352 /* no desc mod.--all direct */; desc 1 -ta 9 ; data 1 -do -128 066 (4351) 062; data 2 067; data 3 000 000 010 377; page -all; /* scmr9 * uses same data setup as test 8 but applies * maximum mod to descriptors. * */ inst scmr -io 3 -nt "d1 covers 3pp max desc mod 9b" -mc /* mc = 001 */ -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; data 1 -do -128 (4351) 062 066; data 2 067; data 3 000 000 000 000; page -all; /* scmr10 * this test specifically tests the -cn option ** for data 2 along with forcing it to cross * a page boundary. all desc mods are taken. * */ inst scmr -io 1 -nt "d1 covers 3pp d2 split 9b" -mc /* mc = 001 */ -mf1 idb ar reg rl 4352 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 9; desc 2 -cn 1; data 1 -do -128 066 (4351) 062; data 2 -do -2 000067 000000; data 3 000 000 010 377; page -all; /* scmr11 * there will be no match on this test. also, * a variety of desc mods are taken. note * tr indicator will be on. * */ inst scmr -io 1 -nt "no match d1 covers 3pp 9bit" -mc /* mc = 001 */ -ir tr -mf1 idb rl 4352 -mf2 ar reg /* mf3 is direct */; desc 1 -ta 9; desc 2 -cn 1; data 1 -do -128 (4352) 062; data 2 -do -2 000067 000000; data 3 000 000 010 400; page -all; /* scmr12 * this starts the sequence of seven * four bit data tests. this first * test makes sure that the inst is working * correctly without any desc. mod. * */ inst scmr -nt "4bit simple test" -mc /* mc = 001 */ /* all the desc. are direct */; desc 1 -ta 4 -ns 8; data 1 237 323 070 361 /* 1001 1111 1101 0011 0011 1000 1111 00001 */; data 2 360 /* 1111 */; data 3 000 000 000 001; page -all; /* scmr13 * same as previous test but taking all of the * possible desc. mod. * */ inst scmr -io 1 -nt "full desc mod 4bit" -mc /* mc = 001 */ -mf1 idb ar reg rl 8 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; data 1 237 323 070 361; data 2 360; data 3 000 000 000 001; page -all; /* scmr14 * changing the mask characters and offsetting * the first data string across a page boundary * with a variety of desc. mod. * */ inst scmr -io 3 -nt "d1 split 4bit" -mc? -mf1 ar -mf2 idb /* mf3 is direct */; desc 1 -ta 4 -ns 8; data 1 -do -2 237 323 /* page bound */ 070 361; data 2 360; data 3 000 000 000 000; page -all; /* scmr15 * again using the same data but this time splitting * both strings across page bound. and exercising * the -cn option. all desc. mod. are taken. * */ inst scmr -io 1 -nt " d1,d" split 4 bit" -mc? -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 6 -cn 1; desc 2 -cn 3; data 1 -do -2 237 323 /* page boun. */ 070 361; data 2 -do -3 000 000 360 /* page bound. */ 000; data 3 000 000 000 000; page -all; /* scmr16 * this time there will be no match with * the same parameters as test 15 with a mask of * 777. the tr indicator will be on. * */ inst scmr -io 2 -nt "match on first try 4 bit" -mcÿ -mf1 idb ar reg -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4 -ns 8 -cn 1; desc 2 -cn 3; data 1 -do -2 237 323 070 361; data 2 -do -3 000 000 360 000; data 3 000 000 000 000; page -all; /* scmr17 * the next three tests use the maximum amount * of data for string 1. this test uses a mask * of 000 but searches for a char which will not * match ( tr ind). no desc. mod. * */ inst scmr -nt "no mat d1 covers 3pp 4b" -mc /* mc = 000 */ -ir tr -mf1 rl 8704 /* all desc. are direct */; desc 1 -ta 4; data 1 -do -128 (1088) 237323070361; data 2 000; data 3 000 000 021 000; page -all; /* scmr18 * this test will force a match on a middle * char. all desc mods. are taken. * */ inst scmr -io 2 -nt "d1 covers 3 pp 4bit" -mc /* mc = 001 */ -mf1 idb ar reg rl 8704 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 4; data 1 -do -128 (1087) 237323070361 237 323 070 000; data 2 000; data 3 000 000 000 000; page -all; /* scmr19 * this test puts the second string on page 0 * and tests the -cn option. * */ inst scmr -io 2 -nt "d1 covers 3pp 4 bit" -mc /* mc = 001 */ -mf1 ida ar reg rl 8704 -mf2 idr ar /* mf3 is direct */; desc 1 -ta 4 ; desc 2 -cn 3; data 1 -do -128 237323070000 (1087) 237323070361 ; data 2 -do -3 000 000 000 000; data 3 000 000 000 000; page -all; /* scmr20 * the following tests use 6 bit data. * this test merely makes sure the instruction * is working correctly. direct mod on descriptors. * */ inst scmr -nt "simple test 6 bit" -mc /* all desc. are direct */; desc 1 -ta 6 -ns 12; data 1 414243444546 575051525353; data 2 57; data 3 000 000 000 005; page -all; /* scmr21 * same as previous test but with first string * split across page bound. and a variety * of desc. mods taken. * */ inst scmr -io 1 -nt "d1 split 6bit" -mc /* mc - 020 */ -mf1 ar reg -mf2 idb /* mf3 is direct */; desc 1 -ta 6 -ns 12; data 1 -do -4 414243444546 /*page bound */ 475051525354; data 2 67; data 3 000 000 000 005; page -all; /* scmr22 * this is the same as test 22 except the mask * has been set to preclude a match (tr on) and different desc. mods. are taken. * */ inst scmr -io 2 -nt "no match 6bit" -mc -ir tr -mf1 idb ar -mf2 ar reg -mf3 ar reg; desc 1 -ta 6 -ns 12; data 1 -do -4 414243444546 475051525354; data 2 67; data 3 000 000 000 014; page -all; /* scmr23 *this test exercises all the desc. mods. * and tests the rl and -cn options. it also * changes the mask char . * * */ inst scmr -io 3 -nt "full desc mod 6bit" -mc /* mc = 025 */ -mf1 idb ar reg rl 12 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; desc 2 -cn 3; data 1 -do -6 414243444546475051 525354; data 2 -do -4 000000720000 /* page bound. */; data 3 000 000 000 001; page -all; /* scmr24 * using the -cn option on both descriptors * direct mod on mf3 desc. * */ inst scmr -io 2 -nt "d1 split 6bit" -mc /* mc = 025 */ -mf1 ar rl 5 -mf2 ar /* mf3 is direct */; desc 1 -ta 6 -cn 4; desc 2 -cn 2; data 1 -do -4 000000005100 /*page bound. */ 525354; data 2 -do -2 00007200 /* page bound. */; data 3 000 000 000 001; page -all; /* scmr25 * this test and the next one uses the maximum amount * of char for string 1. this test forces a "no match" * condition (ir tr on) and takes the maximum mod. * on the desc. * */ inst scmr -io 3 -nt "d1 covers 3pp no mat 6bit" -mc000 -ir tr -mf1 idb ar reg rl 6528 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128 (1087) 515151515151 515151515153; data 2 52; data 3 000 000 014 600; page -all; /* scmr26 * same as previous test but a match occurs * on the last char. * */ inst scmr -io 2 -nt "d1 covers 3pp 6bit" -mc /* mc = 000 */ -mf1 idb ar reg rl 6528 -mf2 idb ar reg -mf3 ar reg; desc 1 -ta 6; data 1 -do -128 515151515152 (1087) 515151515151 ; data 2 52; data 3 000 000 014 572; page -all; /* mvn1 * * a simple test to see if it works * 9 bit scaled leading sign to 9 bit scaled trailing sign * */ inst mvn -nt "simple" -io 2; desc1 -nn 13 -sd l; desc2 -nn 14 -sd t; data 1 -do 12 "+" (12) "9"; data 2 "0" (12) "9" "+"; page -all; /* mvn2 * truncation fault taken * all page faults taken * integer to floating */ inst mvn -nt "truncation fault" -io 1 -tby -ir tn -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -cn 1 -sd l; desc2 -cn 1 -sd f; data 1 -do -63 " " "+98" (15) "7435"; data 2 000 "+" "98" (14) "7435" "743" 001; page -all; /* mvn3 * this is a good test * all page faults taken * legal floating word developed * 9 bit scaled to 9 bit float * */ inst mvn -nt "int -> float" -io 1 -mf1 ar rl 23 idb reg -mf2 ar rl 28 idb reg; desc1 -sf 13 -sd l -cn 3; desc2 -sd f -cn 2; data 1 -do 25 " " "+" (5) "00" (12) "1"; data 2 000000 "+" (4) "000" "00" (12) "1" 015; page -all; /* mvn4 * all page faults taken * float to integer scale factor 12 * 9 bit to 9 bit * */ inst mvn -nt "float to int" -io 1 -ir ng -mf1 ar rl 28 idb reg -mf2 ar rl 23 idb reg; desc1 -sd f -cn 2; desc2 -sf 12 -sd l -cn 3; data 1 -do 27 " -" (14) "0" (12) "1" 015; data 2 000000000 "-" (9) "0" (12) "1" "0"; page -all; /* mvn5 * 9 bit scaled to floating 9 bit * */ inst mvn -nt "scaled to floating" -io 1 -rb -mf1 ar rl 63 idb reg -mf2 ar rl 3 idb reg; desc1 -sd n -sf 31; desc2 -sd f; data 1 -do 62 "1" (62) "0"; data 2 "+" "1" 135; page -all; /* mvn6 * convert float 4 bit to * floating 9 bit * */ inst mvn -nt "float 9 -> float 4" -io 2 -mf1 ar rl 3 idb reg -mf2 ar rl 4 idb; desc1 -sd f; desc2 -sd f -tn 4; data 1 -do -3 "+1" 135; data 2 301135; page -all; /* mvn7 * 9 bit scaled to 4 bit floating * all page faults taken * */ inst mvn -nt "9 scaled to 4 float" -io 3 -ir ng -mf1 ar rl 25 ida reg -mf2 ar rl 23 idb; desc1 -sd t ; desc2 -sd f -cn 3 -tn 4; data 1 -do -1 (20) "0" (4) "3" "-"; data 2 (3) 000 320 (7) 000 003 063 0600; page -all; /* mvn8 * convert 9bit floating point to 4 bit scaled * */ inst mvn -nt "9bit float to 4bit scaled" -io 2 -mf1 ar rl 22 idb reg -mf2 ar rl 33 ida; desc1 -sd f; desc2 -sd t -sf 5 -tn 4; data 1 -do -8 "+" (11) "0" (3) "123" 006; data 2 (11) 000 022 061043022060 300; page -all; /* mvn9 * convert 9 bit floating to 4 bit scaled * */ inst mvn -nt "9bitfloat to 4 bit scaled" -io 1 -mf1 ar rl 20 idb reg -mf2 ar rl 63 ida; desc1 -sd f -cn 2; desc2 -sd l -tn 4 -cn 1; data 1 " +" (9) "0" (4) "45" 060000; data 2 000300 (26) 000 105105105105 (8) 000; page -all; /* mvn10 * 9 bit scaled trailing sign to * 9 bit scaled leading sign */ inst mvn -nt "simple" -io 1; desc1 -nn 14 -sd t; desc2 -nn 13 -sd l; data 1 -do 12 "0" (12) "9" "+"; data 2 "+" (12) "9"; page -all; /* mvn11 * 9 bit float to 9 bit scaled leading sign */ inst mvn -nt "float to int" -io 1 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -cn 1 -sd f; desc2 -cn 1 -sd l; data 1 -do -63 " " "+98" (14) "7435" "743" 001; data 2 000 "+98" (14) "7435" "7430"; page -all; /* mvn12 * 9 bit float to 9 bit scaled negative indicator */ inst mvn -nt "float -> int" -io 2 -mf1 ar rl 28 idb reg -mf2 ar rl 23 idb reg; desc1 -sd f -cn 2; desc2 -sf 13 -sd l -cn 3; data 1 -do 29 " +" (4) "000" "00" (12) "1" 015; data 2 000000000 "+" (5) "00" (12) "1"; page -all; /* mvn13 * 9 bit scaled to 9 bit float * negative indicator on */ inst mvn -nt "int to float" -io 2 -ir ng -mf1 ar rl 23 idb reg -mf2 ar rl 28 idb reg; desc1 -sf 12 -sd l -cn 3; desc2 -sd f -cn 2; data 1 -do 25 " -" (9) "0" (12) "1" "0"; data 2 000000 "-" (13) "0" (12) "1" "0" 014; page -all; /* mvn14 * 9 bit float to 9 bit scaled * */ inst mvn -nt "float to scaled" -io 2 -rb -mf1 ar rl 3 idb reg -mf2 ar rl 63 idb reg; desc1 -sd f; desc2 -sd n -sf 31; data 1 "+1" 135; data 2 "1" (62) "0"; page -all; /* mvn15 * 4 bit float to 9 bit float * */ inst mvn -nt "float 4 -> float 9" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 3 idb reg; desc1 -sd f -tn 4; desc2 -sd f; data 1 -do 3 301135; data 2 "+1" 135; page -all; /* mvn16 * 4 bit floating to 9 bit scaled * truncation and negative indicators on * */ inst mvn -nt "4 float to 9 scaled" -io 1 -ir ng tn -mf1 ar rl 23 idb -mf2 ar rl 25 ida reg; desc1 -sd f -cn 3 -tn 4; desc2 -sd t -sf 2; data 1 -do 1 " " 320 (7) 000 003 063060000; data 2 (22) "0" (2) "3" "-"; page -all; /* mvn17 * 4 bit scaled to 9 bit floating * */ inst mvn -nt "4bit scaled to 9 bit float" -io 3 -mf1 ar rl 33 ida -mf2 ar rl 22 idb reg; desc1 -sd t -sf 5 -tn 4; desc2 -sd f; data 1 (11) 000 022 061043022060 300; data 2 "+" (10) "0" (3) "123" "0" 005; page -all; /* mvn18 * 4 bit scaled to 9 bit floating : */ inst mvn -nt "4bit scaled to 9 bit float" -io 2 -mf1 ar rl 63 ida -mf2 ar rl 20 idb reg; desc1 -sd l -tn 4 -cn 1; desc2 -sd f -cn 2; data 1 " " 300 (26) 000 (4) 105 (8) 000; data 2 000000 "+" (9) "0" (4) "45" "0" 000; page -all; /* mvn19 * 9 bit scaled to 4 bit floating * */ inst mvn -nt "9 bit to 4 bit float" -io 3 -mf1 ar rl 10 ida reg -mf2 ar rl 10 ; desc1 -sd l -cn 1; desc2 -sd f -tn 4; data 1 " +" (5) "0" (4) "1"; data 2 300 000 021 021 000; page -all; /* mvn20 * 9 bit scaled to 4 bit floating * */ inst mvn -nt "9bit to 4 bit float" -mf1 ar rl 10 idb reg -mf2 ar rl 10; desc1 -sd t -cn 2; desc2 -sd f-tn 4; data 1 " " (5) "0" (4) "2" "+"; data 2 300 000 042 042 000; page -all; /* mvn21 * * Move +12.34 into 12.3400+. Length of string 2 will be too short to handle * increased scaling factor so there will be significant digit overflow. */ inst mvn -nt "Sig digit overflow" -io 1 -ir ov -mf1 ar rl 5 -mf2 idr; desc 1 -cn 2 -sd l -sf -2; desc 2 -sd t -sf -3 -nn 5; data 1 -do -5 000 000 /* Fill for cn. */ 053 "12" /* Page 1. */ "34"; /* Page 2. */ data 2 -do -4 "2340" 053; page -all; /* CMPN * * The CMPN instruction algebtaically compares two numbers and sets the * zero, negative, and carry indicators to indicate the results of the * comparison. The five possible settings of the indicators and the inputs * which cause the settings are shown below: * * ZR NG CR INPUTS INPUT * COMBINATION * NUMBER * * 0 0 1 neg,pos,[N1]<[N2] 1 * 0 0 1 pos,pos,[N1]<[N2] 2 * 1 0 1 neg,neg,[N1]=[N2] 3 * 1 0 1 pos,pos,[N1]=[N2] 4 * 0 1 1 neg,neg,[N1]<[N2] 5 * 0 1 1 pos,neg,[N1]<[N2] 6 * 0 1 0 pos,neg,[N1]>[N2] 7 * 0 1 0 pos,pos,[N1]>[N2] 8 * 0 0 0 neg,neg,[N1]>[N2] 9 * 0 0 0 neg,pos,[N1]>[N2] 10 * * * where neg,neg,[N1]<[N2] means that the 1st operand is negative, * the second operand is negative, and the absolute value of the ist * operand is less than the absolute value of the 2nd. * * * Each of the even numbered input combinations is tested with: * * 1). both of the numbers 9-bit decimal and floating point, * 2). both of the numbers 9-bit decimal with leading sign, * 3) both of the numbers 9-bit decimal with trailing sign, * 4). where possible, both of the numbers 9-bit decimal and unsigned. * * * Each of the odd numbered input combinations is tested with: * * 1). both of the numbers 4-bit decimal and floating point, * 2). both of the numbers 4-bit decimal with leading sign, * 3). both of the numbers 4-bit decimal with trailing sign, * 4). where possible, both of the numbers 4-bit decimal and unsigned. * * */ /* cmpn1 * The carry indicator is set. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit pos" -ir cr -mf1 idb ar -mf2 idb ar rl 5 -io 2; desc 1 -tn 4 -sd t -nn 5; desc 2 -tn 4 -sd t; data 1 -do -2 "76" 32; data 2 -do -2 "98" 26; page -all; /* cmpn2 * The carry indicator is set. * Two 4-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit pos" -ir cr -mf1 idb ar rl 13 -mf2 idb ar -io 1; desc 1 -tn 4 -sd l -sf -1; desc 2 -tn 4 -sd l -sf -2 -nn 16; data 1 -do -2 325 "98642" 00; data 2 -do -3 262 "3278411"; page -all; /* cmpn3 * The carry indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit pos" -ir cr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd f -nn 12; desc 2 -tn 4 -sd f -nn 12; data 1 -do -2 323 "98762"; data 2 -do -1 264 "32943"; page -all; /* cmpn4 * The carry indicator is set. * Two 9-bit unsigned operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir cr -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd n -sf 4 -nn 63; desc 2 -sd n -sf 5 -nn 63; data 1 -do -1 (15)"9834" "395"; data 2 -do -62 (15)"8765" "147"; page -all; /* cmpn5 * The carry indicator is set. * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir cr -mf1 idb ar reg -mf2 idb ar reg -io 3; desc 1 -sd t -sf -2 -nn 14; desc 2 -sd t -sf 12 -nn 14; data 1 -do -13 (4)"298" "3" 053; data 2 -do -13 (4)"687" "2" 053; page -all; /* cmpn6 * The carry indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir cr -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf 2 -nn 12; desc 2 -sd l -sf 3 -nn 12; data 1 -do -4 053 (11)"3"; data 2 -do -4 053 (11)"2"; page -all; /* cmpn7 * The carry indicator is set. * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir cr -mf1 idb ar reg rl 9 -mf2 idb ar reg -io 1; desc 1 -sd f; desc 2 -sd f -nn 8; data 1 -do -8 053 "7654321" 377; data 2 -do -1 053 "987654" 002; page -all; /* cmpn8 * The zero indicator is set. * The carry indicator is set. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir zr cr -mf1 idb ar -mf2 idb ar rl 4 -io 2; desc 1 -tn 4 -sd t -nn 4; desc 2 -tn 4 -sd t; data 1 -do -1 "7" 035; data 2 -do -1 "7" 035; page -all; /* cmpn9 * The zero indicator is set. * The carry indicator is set. * Two 4-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir zr cr -mf1 idb ar rl 63 -mf2 idb ar rl 63 -io 1; desc 1 -tn 4 -sd l -sf 3; desc 2 -tn 4 -sd l -sf 3; data 1 -do -31 32 (31)"5"; data 2 -do -1 32 (31)"5"; page -all; /* cmpn10 * The zero indicator is set. * The carry indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir zr cr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd f -nn 8; desc 2 -tn 4 -sd f -nn 8; data 1 -do -1 325 "495"; data 2 -do -2 325 "495"; page -all; /* cmpn11 * The zero indicator is set. * The carry indicator is set. * Two 9-bit unsigned operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir zr cr -mf1 idb ar reg rl 3 -mf2 idb ar reg -io 1; desc 1 -sd n -sf 1; desc 2 -sd n -sf 1 -nn 3; data 1 -do -2 "432"; data 2 -do -1 "432"; page -all; /* cmpn12 * The zero indicator is set. * The carry indicator is set. * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir zr cr -mf1 idb ar reg rl 63 -mf2 idb ar reg rl 63 -io 2; desc 1 -sd t; desc 2 -sd t; data 1 -do -62 (12)"98765" "28" 053; data 2 -do -61 (12)"98765" "28" 053; page -all; /* cmpn13 * The zero indicator is set. * The carry indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir zr cr -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf -8 -nn 18; desc 2 -sd l -sf -8 -nn 18; data 1 -do -16 053 (5)"369" "00"; data 2 -do -15 053 (5)"369" "00"; page -all; /* cmpn14 * The zero indicator is set. * The carry indicator is set. * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir zr cr -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd f -nn 39; desc 2 -sd f -nn 39; data 1 -do -30 053 (6)"125897" "4" 017; data 2 -do -24 053 (6)"125897" "4" 017; page -all; /* cmpn15 * The negative indicator is set. * The carry indicator is set. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir ng cr -mf1 idb ar -mf2 idb ar -io 3; desc 1 -tn 4 -sd t -sf -1 -nn 13; desc 2 -tn 4 -sd t -sf 1 -nn 63; data 1 -do -1 "123456" 32; data 2 -do -30 (15)"12" "9" 32; page -all; /* cmpn16 * The negative indicator is set. * The carry indicator is set. * Two 4-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir ng cr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd l -sf 1 -nn 6; desc 2 -tn 4 -sd l -sf 2 -nn 6; data 1 -do -2 321 "44"; data 2 -do -2 321 "44"; page -all; /* cmpn17 * The negative indicator is set. * The carry indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -ir ng cr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd f -nn 5; desc 2 -tn 4 -sd f -nn 5; data 1 -do -1 324 "5" 00; data 2 -do -1 327 "6" 00; page -all; /* cmpn18 * The negative indicator is set. * The carry indicator is set. * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit neg" -ir ng cr -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd t -nn 8; desc 2 -sd t -nn 9; data 1 -do -4 "4567821" 053; data 2 -do -8 "92814372" 055; page -all; /* cmpn19 * The negative indicator is set. * The carry indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit neg" -ir ng cr -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf -5 -nn 63; desc 2 -sd l -sf -4 -nn 63; data 1 -do -60 053 "92" (15)"6391"; data 2 -do -4 055 "82" (15)"7482"; page -all; /* cmpn20 * The negative indicator is set. * The carry indicator is set. * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit neg" -ir ng cr -mf1 idb ar reg -mf2 idb ar reg -io3; desc 1 -sd f -nn 11; desc 2 -sd f -nn 11; data 1 -do -10 053 "345678901" 001; data 2 -do -1 055 "456789012" 002; page -all; /* cmpn21 * The negative indicator is set. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit pos with 4-bit neg" -ir ng -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd t -nn 3; desc 2 -tn 4 -sd t -nn 3; data 1 -do -1 "4" 26; data 2 -do -1 "3" 32; page -all; /* cmpn22 * The negative indicator is set. * Two 4-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit neg" -ir ng -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd l -nn 5; desc 2 -tn 4 -sd l -nn 4; data 1 -do -2 267 000 00; data 2 -do -1 324 000; page -all; /* cmpn23 * The negative indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit neg" -ir ng -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd f -nn 63; desc 2 -tn 4 -sd f -nn 63; data 1 -do -4 270 (14)"10" 00000000; data 2 -do -4 321 (14)"10" 00000000; page -all; /* cmpn24 * The negative indicator is set. * Two 9-bit unsigned operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 3; desc 1 -sd n -sf 4 -nn 5; desc 2 -sd n -sf 1 -nn 4; data 1 -do -1 "12345"; data 2 -do -3 "2345"; page -all; /* cmpn25 * The negative indicator is set. * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd t -sf 4 -nn 37; desc 2 -sd t -sf 3 -nn 37; data 1 -do -36 (12)"965" 053; data 2 -do -1 (12)"965" 053; page -all; /* cmpn26 * The negative indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd l -sf 2 -nn 63; desc 2 -sd l -sf 2 -nn 63; data 1 -do -3 053 "95" (15)"2398"; data 2 -do -4 053 "68" (15)"4782"; page -all; /* cmpn27 * The negative indicator is set. * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit pos with 9-bit pos" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd f -nn 63; desc 2 -sd f -nn 63; data 1 -do -4 053 "4" (15)"8901" 002; data 2 -do -3 053 "4" (15)"8901" 001; page -all; /* cmpn28 * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd t -nn 39; desc 2 -tn 4 -sd t -nn 39; data 1 -do -19 (19)"5" 32; data 2 -do -19 (19)"4" 32; page -all; /* cmpn29 * Two 4-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -mf1 idb ar rl 7 -mf2 idb ar -io 2; desc 1 -tn 4 -sd l -sf 5 ; desc 2 -tn 4 -sd l -sf 1 -nn 7; data 1 -do -3 324 "98" 00; data 2 -do -1 323 "64" 00; page -all; /* cmpn30 * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 4-bit neg with 4-bit neg" -mf1 idb ar -mf2 idb ar rl 60 -io 2; desc 1 -tn 4 -sd f -nn 63; desc 2 -tn 4 -sd f; data 1 -do -1 321 (15)"892" 00; data 2 -do -29 322 (14)"98" 000; page -all; /* cmpn31 * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit neg with 9-bit pos" -mf1 idb ar reg rl 63 -mf2 idb ar reg -io 2; desc 1 -sd t -sf 12; desc 2 -sd t -sf -1 -nn 5; data 1 -do -62 (31)"98" 055; data 2 -do -4 "5432" 053; page -all; /* cmpn32 * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit neg with 9-bit pos" -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf -4 -nn 6; desc 2 -sd l -sf -6 -nn 6; data 1 -do -4 055 "42816"; data 2 -do -5 053 "98321"; page -all; /* cmpn33 * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst cmpn -nt "Compare 9-bit neg with 9-bit pos" -mf1 idb ar reg rl 63 -mf2 idb ar reg rl 63 -io 1; desc 1 -sd f ; desc 2 -sd f ; data 1 -do -8 055 (15)"9999" "8" 004; data 2 -do -9 053 (15)"8777" "4" 002; page -all; /* mvne1 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "simple test no mod 9-9" -mf2 rl 29; desc 1 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ /* the strings are 0012 0012 3456 3456 0012 3456 */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne2 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset inst and desc mod 9-9" -io 3 -mf1 idr reg -mf2 reg rl 29 -mf3 idb; desc 1 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ /* the strings are 0012 0012 3456 3456 0012 3456 */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne3 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset inst and d1 offset 9-9" -io 3 -mf1 idr reg -mf2 reg rl 29 -mf3 idb; desc 1 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne4 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 offset 9-9" -io 3 -mf1 idr reg -mf2 reg rl 29 -mf3 idb; desc 1 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne5 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 and d3 9-9" -io 3 -mf1 idr reg -mf2 reg rl 29 -mf3 idb; desc 1 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne6 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 and d3 9-9" -io 3 -mf1 idr reg -mf2 reg rl 29 -mf3 idb; desc 1 -cn 3 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ "***" /* for cn */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne7 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d1 totally on p0 9-9" -io 2 -mf1 idr ar -mf2 reg rl 29 -mf3 ida ar reg; desc 1 -cn 3 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -24 /* the strings are 0012 0012 3456 3456 0012 3456 */ "***" /* for cn */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne8 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d2 totally on p0 9-9" -io 2 -mf1 idr ar -mf2 ar reg rl 29 -mf3 ida ar reg; desc 1 -cn 3 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -20 /* the strings are 0012 0012 3456 3456 0012 3456 */ "***" /* for cn */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -30 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne9 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d3 totally on p0 9-9" -io 2 -mf1 idr ar -mf2 reg ar rl 29 -mf3 ida ar reg; desc 1 -cn 3 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -20 /* the strings are 0012 0012 3456 3456 0012 3456 */ "***" /* for cn */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -10 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -34 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne10 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "all data totally on p0 9-9" -io 2 -mf1 idr ar -mf2 reg ar rl 29 -mf3 ida ar reg; desc 1 -cn 3 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -30 /* the strings are 0012 0012 3456 3456 0012 3456 */ "***" /* for cn */ "001200123456345600123456"; data 2 /* ***mop sequence arranged in order *** */ -do -30 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -34 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne11 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "simple test no mod 4-9" -mf2 rl 29; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne12 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset inst and desc mod 4-9" -io 2 -mf2 reg rl 29 -mf3 ida; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne13 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset inst and d1 offset 4-9" -io 3 -mf2 reg rl 29 -mf3 ida; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne14 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 offset 4-9" -io 3 -mf2 reg rl 29 -mf3 ida; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne15 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 and d3 4-9" -io 3 -mf2 reg rl 29 -mf3 ida; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne16 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "offset d2 and d1 and d3 4-9" -io 3 -mf2 reg rl 29 -mf3 ida; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -16 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne17 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d1 totally on p0 4-9" -io 2 -mf1 idr ar -mf2 reg rl 29 -mf3 ida ar reg; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -24 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -20 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne18 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d2 totally on p0 4-9" -io 2 -mf1 idr ar -mf2 ar reg rl 29 -mf3 ida ar reg; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -20 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -30 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -8 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne19 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "d3 totally on p0 4-9" -io 2 -mf1 idr ar -mf2 reg ar rl 29 -mf3 ida ar reg; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -20 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -10 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -34 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* mvne20 * these tests exercise the mvne instruction * using the 4 to 9 bit option and the 9 to 9 * bit options on the data. the same template * for the mop sequence will be used for all * tests with various desc and data mod. * */ inst mvne -nt "all data totally on p0 4-9" -io 2 -mf1 idr ar -mf2 reg ar rl 29 -mf3 ida ar reg; desc 1 -tn 4 -nn 24 -sd n; desc 3 -nn 33 ; data 1 /* the 9 bit data arranged in sequence of use */ -do -30 /* the strings are 0012 0012 3456 3456 0012 3456 */ 000022000022064126064126000022064126; data 2 /* ***mop sequence arranged in order *** */ -do -30 104 /* mvzb */ 060 /* ses es reset */ 124 /* mvza */ 064 /* ses es reset bz set */ 144 /* mfls */ 064 /* ses */ 040 /* enf for "+" insert. */ 200 "=" /* insb */ 220 "q" /* insa insert "q" */ 260 "q" /* insp */ 304 /* ign */ 344 /* mvc */ 420 "12345678" /* change table with string shown */ 024 /* insm */ 401 "2" /* load table entry 1 with "2" */ 024 /* insm */ 364 /* mors */ /* end of mop string */; data 3 /* arranged in order */ -do -34 " 12" "**12" "+3456" "+" "=" "q" "q" "0012" "1111" "2222" "3777"; page -all; /* ad3d1 * The zero indicator is set. * Three 9-bit floating point operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -ir zr -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd f -nn 63; desc 2 -sd f -nn 60; desc 3 -sd f -nn 63; data 1 -do -1 "+" (14)"2583" "00000" 005; data 2 -do -60 "-" (14)"2583" "00" 010; data 3 -do -8 "+" (61)"0" 177; page -all; /* ad3d2 * The zero indicator is set. * Three 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -ir zr tn -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd l -nn 13 -sf 4; desc 2 -sd l -nn 13 -sf 4; desc 3 -sd l -nn 5 -sf 6; data 1 -do -12 "-" (2)"392457"; data 2 -do -4 "+" (2)"392457"; data 3 -do -4 "+" (4)"0"; page -all; /* ad3d3 * The negative indicator is set. * Three 4-bit floating point operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "4 bit + 4 bit -> 4 bit" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 3; desc 1 -tn 4 -sd f -nn 22; desc 2 -tn 4 -sd f -nn 22; desc 3 -tn 4 -sd f -nn 22; data 1 -do -11 320 (5)000 "8888" 005; data 2 -do -1 260 (5) 000 "7777" 005; data 3 -do -4 320 (5)000 (4)001 005; page -all; /* ad3d4 * The negative indicator is set. * Three 4-bit trailing sign operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "4 bit + 4 bit -> 4 bit" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd t -sf -1 -nn 8; desc 2 -tn 4 -sd t -sf -1 -nn 8; desc 3 -tn 4 -sd t -sf -1 -nn 8; data 1 -do -4 "555+"; data 2 -do -4 "777-"; data 3 -do -4 (3)002 015; page -all; /* ad3d5 * The truncation indicator is set. * Three 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -ir tn -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd f -nn 63; desc 2 -sd f -nn 63; desc 3 -sd f -nn 50; data 1 -do -1 "+" (61)"4" 003; data 2 -do -62 "+" (61)"5" 003; data 3 -do -48 "+" (48)"9" 020; page -all; /* ad3d6 * The truncation indicator is set. * Three 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -ir tn -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 3; desc 1 -sd l -sf 5 -nn 37; desc 2 -sd l -sf 5 -nn 37; desc 3 -sd l -sf 10 -nn 37; data 1 -do -20 "+" (6)"121212"; data 2 -do -20 "+" (6)"212121"; data 3 -do -32 "+" (5)"0" (31)"3"; page -all; /* ad3d7 * Rounding is tested. * Three 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -rb -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd t -sf 5 -nn 37; desc 2 -sd t -sf 5 -nn 37; desc 3 -sd t -sf 10 -nn 37; data 1 -do -36 (6)"121212" "+"; data 2 -do -1 (6)"212121" "+"; data 3 -do -35 (5)"0" (31)"3" "+"; page -all; /* ad3d8 * The overflow indicator is set. * Three 4-bit unsigned operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "4 bit + 4 bit -> 4 bit" -ir ov -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -tn 4 -sd n -sf 8 -nn 16; desc 2 -tn 4 -sd n -sf 8 -nn 16; desc 3 -tn 4 -sd n -sf 5 -nn 16; data 1 -do -15 (8) 042; data 2 -do -1 (8) 063; data 3 -do -8 (6) 125 120 000; page -all; /* ad3d9 * The exponent overflow indicator is set. * Three 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -ir eo tn -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 3; desc 1 -sd f -nn 6; desc 2 -sd f -nn 6; desc 3 -sd f -nn 6; data 1 -do -1 "+" (4)"9" 177; data 2 -do -5 "+" (4)"2" 177; data 3 -do -4 "+" "1222" 200; page -all; /* ad3d10 * A 9-bit operand is added to a 9-bit operand and stored in a 4-bit operand. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 4 bit" -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar -io 1; desc 1 -sd l -nn 10; desc 2 -sd l -nn 10; desc 3 -sd l -tn 4 -nn 11 -cn 1; data 1 -do -1 "+" "987654321"; data 2 -do -8 "+" "123456789"; data 3 -do -1 00 301 (4)021 00; page -all; /* ad3d11 * A 4-bit operand is added to a 4-bit operand and stored in a 9-bit operand. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "4 bit + 4 bit -> 9 bit" -mf1 idb ar -mf2 idb ar -mf3 idb ar reg -io 2; desc 1 -sd t -tn 4 -sf -1 -nn 10 -cn 1; desc 2 -sd t -tn 4 -sf -1 -nn 10 -cn 1; desc 3 -sd t -sf -1 -nn 11; data 1 -do -1 00 230 166 124 062 033; data 2 -do -5 00 022 064 126 170 233; data 3 -do -10 (9)"1" "0" "+"; page -all; /* ad3d12 * A 9-bit operand is added to a 4-bit operand and stored in a 4-bit operand. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 4 bit -> 4 bit" -mf1 idb ar reg -mf2 idb ar -mf3 idb ar -io 3; desc 1 -sd f -nn 11; desc 2 -sd f -tn 4 -nn 12; desc 3 -sd f -tn 4 -nn 13; data 1 -do -9 "+" "987654321" 036; data 2 -do -5 261 043 105 147 211 036; data 3 -do -6 301 (4)021 001 34; page -all; /* ad3d13 * A 9-bit operand is added to a 4-bit operand and stored in a 9-bit operand. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 4 bit -> 9 bit" -mf1 idb ar reg -mf2 idb ar -mf3 idb ar reg -io 1; desc 1 -sd n -sf -5 -nn 9; desc 2 -sd n -tn 4 -sf -5 -nn 9; desc 3 -sd n -sf -5 -nn 10; data 1 -do -8 "987654321"; data 2 -do -1 022 064 126 170 22; data 3 -do -5 (9)"1" "0"; page -all; /* ad3d14 * Leading, trailing, and floating point operands are mixed. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "9 bit + 9 bit -> 9 bit" -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd l -sf 7 -nn 10; desc 2 -sd t -sf 7 -nn 10; desc 3 -sd f -nn 12; data 1 -do -9 "+" "987654321"; data 2 -do -4 "123456789" "+"; data 3 -do -8 "+" (9)"1" "0" 007; page -all; /* ad3d15 * Floating point, unsigned, and leading sign operands are mixed. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst ad3d -nt "4 bit + 4 bit -> 4 bit" -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 3; desc 1 -tn 4 -sd f -nn 12; desc 2 -tn 4 -sd n -nn 9; desc 3 -tn 4 -sd l -nn 13 -sf -2; data 1 -do -6 271 207 145 103 041 000; data 2 -do -4 022 064 126 170 22; data 3 -do -5 301 (4)021 00000; page -all; /* ad2d1 * Use RL mod and cn field with indirect descriptors * add 9 bit scaled to 9 bit scaled * two character offset * */ inst ad2d -nt "9scaled+9scal->9scaled" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "2" "-"; data 2 -do -9 "*" (9) "1" "+"; data 3 "*" (9) "1" "-"; page -all; /* ad2d2 * Use RL mod and cn field with indirect descriptors * 9 bit scaled to 9 bit scaled * one character offset * */ inst ad2d -nt "9scaled+9scaled->9scaled" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -10 " " (9) "2" "-"; data 2 -do -10 "*" (9) "1" "+"; data 3 "*" (9) "1" "-"; page -all; /* ad2d3 * Use RL mod and cn field * 9 bit scaled to 9 bit scaled * no indirect descriptors * */ inst ad2d -nt "9scaled+9scaled->9scaled" -io 2 -ir ng -mf1 ar rl 10 reg -mf2 ar rl 10 reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "2" "-"; data 2 -do -9 "*" (9) "1" "+"; data 3 "*" (9) "1" "-"; page -all; /* ad2d4 * Use no modification * 9bit scaled added to 9 bit scaled * */ inst ad2d -nt "9scaled+9scaled->9scaled" -io 2 -ir ng; desc1 -cn 1 -sd t -nn 12; desc2 -cn 1 -sd t -nn 12; data 1 -do -12 " " (11) "2" "-"; data 2 -do -12 "*" (11) "1" "+"; data 3 "*" (11) "1" "-"; page -all; /* ad2d5 * Use ar and rl * 9 bit scaled to 9 bit scaled * */ inst ad2d -nt "ar and rl modification" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 ; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "2" "-"; data 2 -do -9 "*" (9) "1" "+"; data 3 "*" (9) "1" "-"; page -all; /* ad2d6 * Use ar and rl modification, desc1 * Use ar rl idb reg on desc2 * 9 bit scaled to 9 bit scaled * */ inst ad2d -nt "9scaled+9scaled->9scaled" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "2" "-"; data 2 -do -9 "*" (9) "1" "+"; data 3 "*" (9) "1" "-"; page -all; /* ad2d7 * maximum length add, leading sign * one character over next page * all modification taken */ inst ad2d -nt "9scaled+9scaled->9scaled" -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -cn 1 -sd l ; desc2 -cn 1 -sd l ; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+11" (15) "2357"; data 3 "*" "+45" (14) "1000" "0999"; page -all; /* ad2d8 * This is a simple test * 9 bit add to 9 bit all scaled trailing sign * */ inst ad2d -nt "simple test"; desc1 -sd t -sf 10 -nn 63; desc2 -sd t -sf 10 -nn 63; data 1 "11" (15) "1111" "-"; data 2 "22" (15) "2222" "+"; data 3 "11" (15) "1111" "+"; page -all; /* ad2d9 * maximum length add resulting * in an overflow * all modification taken * 9 bit scaled to 9 bit scaled */ inst ad2d -nt "truncation fault" -io 1 -ir ov -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -sd l -cn 1; desc2 -sd l -cn 1; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+71" (15) "2357"; data 3 "*" "+" "05" (14) "1000" "0999"; page -all; /* ad2d10 * maximum length over two pages * no faults, 9 bit to 4 bit * */ inst ad2d -nt "9 bit -> 4 bit" -io 1 -mf1 ar rl 63 -mf2 ar rl 63 ; desc1 -sd t ; desc2 -sd t -tn 4; data 1 -do 4033 "33" (15) "3333" "+"; data 2 -do 4064 021021 (7) 021021021021 02126; data 3 104104 (7) 104104104104 1043; page -all; /* ad2d11 * 9 bit to 4 bit all page faults possible * no reg modification on desc2 * */ inst ad2d -nt "9bit ->4bit" -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb ; desc1 -cn 1 -sd l; desc2 -cn 1 -sd t -tn 4; data 1 -do 4033 " " "+33" (15) "3333"; data 2 -do 4068 "*" 021021 (7) 021021021021 0213; data 3 "*" 104104 (7) 104104104104 1043; page -all; /* ad2d12 * 4 bit added to 4 bit * maximum length * all page faults taken * no reg modification */ inst ad2d -nt "4 bit + 4bit" -io 1 -mf1 ar rl 63 idb -mf2 ar rl 63 idb; desc1 -cn 1 -sd t -tn 4; desc2 -cn 1 -sd t -tn 4; data 1 -do 4065 " " 021021 (7) 021021021021 0213; data 2 -do 4065 "*" 021021 (7) 021021021021 0213; data 3 "*" 042042 (7) 042042042042 0423; page -all; /* ad2d13 * floating point add * 9 bit to 9bit * all page faults taken * */ inst ad2d -nt "9bit float add" -io 1 -mf1 ar rl 63 reg idb -mf2 ar rl 63 reg idb; desc1 -sd f; desc2 -sd f; data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005; data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006; data 3 "+" (19) "0" "1" (9) "2" "1" (29) "0" "11" 005; page -all; /* ad2d14 * 4 bit floating added to * 4 bit floating * */ inst ad2d -nt "4 float to 4 float" -io 1 -mf1 ar rl 10 ida -mf2 ar rl 10 ida; desc1 -sd f -tn 4; desc2 -sd f -tn 4; data 1 -do -1 300 000 021 021 000; data 2 -do -1 300 000 021 021 000; data 3 300 000 042 042 000; page -all; /* ad2d15 * test 4bit scaled to 9 bit * */ inst ad2d -nt "4bit->9bit" -io 1 -mf1 ar rl 5 idb -mf2 ar rl 5 idb reg; desc 1 -tn 4 -sd l; desc 2 -sd n; data 1 30102100; data 2 -do 4 "02222"; data 3 "03332"; page -all; /* ad2d16 * test 9 floating to 4 floating * */ inst ad2d -nt "9float->4 float" -io 1 -mf1 ar rl 5 idb reg -mf2 ar rl 7 idb; desc 1 -sd f; desc 2 -sd f -tn 4; data 1 "+" (3) "1" 000; data 2 300 042 040 00; data 3 30006306000; page -all; /* ad2d17 * 4 float to 9 float * */ inst ad2d -nt "4float -> 9float" -io 1 -mf1 ar rl 7 idb -mf2 ar rl 7 idb reg; desc 1 -sd f -tn 4 ; desc 2 -sd f; data 1 300 042 040 00; data 2 "+0" (3) "1" "0" 000; data 3 "+01332" 000; page -all; /* ad2d18 * 9 scaled to 9 float * */ inst ad2d -nt "9sacled to 9 float" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb reg; desc1 -sd l; desc2 -sd f; data 1 "+" (4) "3"; data 2 "+" "0" (3) "2" 000; data 3 "+" "3555" 000; page -all; /* ad2d19 * 9 float to 9 scaled * */ inst ad2d -nt "9 float to 9 scaled" -io 2 -mf1 ar rl 6 idb reg -mf2 ar rl 5 idb reg; desc1 -sd f; desc2 -sd l; data 1 "+" "0" (3) "2" 000; data 2 "+" (4) "3"; data 3 "+" "3555"; page -all; /* ad2d20 * 9 scaled to 4 float * */ inst ad2d -nt "9scaled->4float" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb; desc 1 -sd l; desc 2 -sd f -tn 4; data 1 "+0" (3) "2"; data 2 303063 000; data 3 305125000; page -all; /* ad2d21 * 9 float to 4 scaled * */ inst ad2d -nt "9float->4scaled" -io 1 -mf1 ar rl 6 idb reg -mf2 ar rl 4 idb; desc 1 -sd f; desc 2 -sd l -tn 4; data 1 -do -1 "+0" (3) "2" 000; data 2 -do -2 303 063; data 3 305125; page -all; /* ad2d22 * 4scaled to 9 float * */ inst ad2d -nt "4scaled-.9float" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb reg; desc 1 -sd l -tn 4; desc 2 -sd f; data 1 -do -1 303063; data 2 -do -1 "+0" (3) "2" 000; data 3 "+0" (3) "5" 000; page -all; /* ad2d23 * 4 floating to 9 scaled * */ inst ad2d -nt "4float->9scaled" -io 1 -mf1 ar rl 6 idb -mf2 ar rl 5 idb reg; desc 1 -sd f -tn 4; desc 2 -sd n; data 1 -do -1 303 063 000; data 2 -do -2 "00" "555"; data 3 "00" "888"; page -all; /* ad2d24 * 4 scaled to 4 float * */ inst ad2d -nt "4scaled to 4 float" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb; desc 1 -tn 4 -sd l; desc 2 -tn 4 -sd f; data 1 -do -1 303 063; data 2 -do -1 302042000; data 3 305125 000; page -all; /* ad2d25 * 4 floating to 4 scaled * */ inst ad2d -nt "4 floating to 4 scaled" -io 2 -mf1 ar rl 6 idb -mf2 ar rl 4 idb; desc 1 -tn 4 -sd f; desc 2 -tn 4 -sd l; data 1 -do -1 302042000; data 2 -do -1 303 063; data 3 305125; page -all; /* ad2d26 * * Use RL mod and strings of length 63 and cn fields. */ inst ad2d -nt "63 char string" -io 2 -mf1 rl 63 idb reg ar -mf2 rl 63 idb reg ar; desc 1 -sd n -cn 1; desc 2 -sd n -cn 2; data 1 -do -21 " " "234" (15) "1234"; data 2 -do -22 "**" "345" (15) "2345"; data 3 "**" "579" (15) "3579"; /* This is just test data. This is how descriptor 2 * data is going to look after the ad2d. */ page -all; /* sb3d1 * a simple test * no modification used - 9 bit - 9 bit to 9 bit * */ inst sb3d -nt"9bit-9bit->9bit" -io 2; desc1 -sd l -cn 1 -nn 10; desc2 -sd l -cn 1 -nn 10; desc3 -sd l -cn 1 -nn 10; data 1 " -" (9) "1"; data 2 " +" (9) "1"; data 3 000 "+" (9) "2"; page -all; /* sb3d2 * 9 bit - 9 bit to 9 bit * negative indicator on * all page faults taken * */ inst sb3d -nt "9 bit - 9bit to 9 bit" -io 1 -ir ng -mf1 ar rl 23 idb reg -mf2 ar rl 24 idb reg -mf3 ar rl 24 idb reg; desc1 -sd t -cn 2; desc2 -sd t -cn 1; desc3 -sd l -cn 3; data 1 -do -9 " " (5) "0" (8) "12" "1+"; data 2 -do -11 " " (6) "0" (8) "23" "2-"; data 3 000000000 "-" (6) "0" (8) "35" "3"; page -all; /* sb3d3 * 9 bit scaled to 4 bit float to * 4 bit float * */ inst sb3d -nt "4bit float-9bit to 4bit" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb -mf3 ar rl 10 idb; desc1 -sd t -cn 1; desc2 -sd f -tn 4; desc3 -sd f -tn 4; data 1 -do -10 " " (5) "0" (4) "2" "+"; data 2 -do -4 300 000 021 021 000; data 3 -do -4 320 000 021 021 000; page -all; /* sb3d4 * 9 bit scaled - 9 bit scaled to * 9 bit scaled * all page faults taken * truncation indicator set * */ inst sb3d -nt "9bit-9bit to 9bit" -io 2 -ir tn -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l -sf 5; desc2 -cn 2 -sd l -sf 10; desc3 -cn 3 -sd l -sf 10; data 1 -do 4033 " -" (5) "0" (19) "543"; data 2 -do 4034 " +" (5) "0" (19) "765"; data 3 -do 4035 (3) 000 "+" (5) "0" "76577" (17) "120" "0"; page -all; /* sb3d5 * 9 bit scaled - 9 bit scaled tp * 9 bit scaled * all page faults taken * rounding desired, therefore no truncation * */ inst sb3d -nt "no truncation" -io 3 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg -rb; desc1 -cn 1 -sd l -sf 5; desc2 -cn 2 -sd l -sf 10; desc3 -cn 1 -sd l -sf 10; data 1 -do 4033 " -" (5) "0" (19) "543"; data 2 -do 4034 " +" (5) "0" (19) "765"; data 3 -do 4033 000 "+" (5) "0" "76577" (17) "120" "0"; page -all; /* sb3d6 * all operands 4 bit scaled * all page faults taken * negative indicator set * */ inst sb3d -nt "4 bit-4bit to 4bit scaled" -io 1 -ir ng -mf1 ar rl 63 idb -mf2 ar rl 63 idb -mf3 ar rl 63 idb; desc1 -sd l -tn 4 -cn 1; desc2 -sd l -tn 4 -cn 1; desc3 -sd l -tn 4 -cn 1; data 1 " " 300 (26) 000 (4) 105 (8) 000; data 2 " " 300 (26) 000 (3) 105 104 (7) 000; data 3 000320 (29) 000 001 (8) 000; page -all; /* sb3d7 * 9 bit scaled - 9 bit scaled to * 9 bit scaled * all page faults taken * rounding desired and it occurs * */ inst sb3d -nt "rounded result" -io 2 -rb -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l -sf 5; desc2 -cn 1 -sd l -sf 10; desc3 -sd l -cn 1 -sf 10; data 1 -do 4033 " -" (5) "0" (17) "543" "043543"; data 2 -do 4033 " +" (5) "0" (19) "765"; data 3 -do 4033 000 "+" (5) "0" "76577" (16) "120" "1195"; page -all; /* sb3d8 * all operands 9 bit float * all page faults taken * no rounding needed : */ inst sb3d -nt "9 bit floating" -io 1 -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg -mf3 ar rl 10 idb reg; desc1 -sd f -cn 1; desc2 -sd f -cn 1; desc3 -sd f -cn 1; data 1 -do -10 " -" (8) "1" 001; data 2 -do -10 " +" (8) "2" 001; data 3 -do -10 000 "+" (8) "3" 001; page -all; /* sb3d9 * all operands 9 bit floating * rounding not desired, but required * set round bit * */ inst sb3d -nt "round floating" -io 2 -rb -mf1 ar rl 10 ida -mf2 ar rl 10 ida -mf3 ar rl 10 ida; desc1 -cn 1 -sd f; desc2 -cn 1 -sd f; desc3 -sd f; data 1 " +" (8) "3" 000; data 2 " +" (8) "9" 001; data 3 "+" "9" (7) "6" 001; page -all; /* sb3d10 * all operands 9 bit floating * truncation will occur * */ inst sb3d -nt "truncation" -io 3 -ir tn -mf1 ar rl 10 -mf2 ar rl 10 -mf3 ar rl 10; desc1 -sd f; desc2 -sd f; desc3 -sd f; data 1 "+" (8) "3" 000; data 2 "+" (8) "9" 001; data 3 "+" "9" (6) "6" "5" 001; page -all; /* sb3d11 * all operands 9 bit floating * truncation will occur : */ inst sb3d -nt "truncation" -ir ng tn -mf1 ar rl 10 -mf2 ar rl 10 -mf3 ar rl 10; desc1 -sd f; desc2 -sd f; desc3 -sd f; data 1 -do -4 "+" (8) "3" 000; data 2 -do -4 "-" (8) "9" 001; data 3 -do -4 "-" "10" (6) "3" 002; page -all; /* sb3d12 * 4 scaled - 4 scaled to 4 float * */ inst sb3d -nt "4sc-4sc->4float" -io 3 -mf1 ar rl 4 idb -mf2 ar rl 4 idb -mf3 ar rl 6 idb; desc 1 -tn 4 -sd l; desc 2 -tn 4 -sd l; desc 3 -tn 4 -sd f; data 1 -do -1 323 063; data 2 -do -1 302 042; data 3 -do -1 305 125 000; page -all; /* sb3d13 * 4 scaled -4 float to 4 scaled * */ inst sb3d -nt "4scaled-4float to 4 scaled" -io 2 -mf1 ar rl 6 idb -mf2 ar rl 4 idb -mf3 ar rl 4 idb; desc 1 -tn 4 -sd f; desc 2 -tn 4 -sd l; desc 3 -tn 4 -sd l; data 1 -do -1 323 063 000; data 2 -do -1 302 042; data 3 -do -1 305 125; page -all; /* sb3d14 * 4 floating - 9 scaled to 9 floating * */ inst sb3d -nt "4float-9scaled->9float" -io 1 -mf1 ar rl 4 idb reg -mf2 ar rl 6 idb -mf3 ar rl 5 idb reg; desc 1 -sd t; desc 2 -sd f -tn 4; desc 3 -sd f; data 1 -do -3 "333-"; data 2 -do -2 302 042 000; data 3 -do -4 "+555" 000; page -all; /* sb3d15 * 9 scaled - 4 bit to 9 scaled * */ inst sb3d -nt "9bit-4bit->9bit" -io 1 -mf1 ar rl 5 idb -mf2 ar rl 5 idb reg -mf3 ar rl 5 idb reg; desc 1 -tn 4 -sd l; desc 2 -sd n; desc 3 -sd n; data 1 -do -1 321 02100; data 2 -do 4 "02222"; data 3 -do -1 "03332"; page -all; /* sb3d16 * 4float-9float to 4 float * */ inst sb3d -nt "4flo-9flo->4flo" -io 1 -mf1 ar rl 5 idb reg -mf2 ar rl 7 idb -mf3 ar rl 7 idb; desc 1 -sd f; desc 2 -sd f -tn 4; desc 3 -sd f -tn 4; data 1 -do -1 "-" (3) "1" 000; data 2 -do -1 300 042 040 00; data 3 -do -1 30006306000; page -all; /* sb3d17 * 9 float - 4 float to 9 float * */ inst sb3d -nt "9flo-4flo->9flo" -io 1 -mf1 ar rl 7 idb -mf2 ar rl 7 idb reg -mf3 ar rl 7 idb reg; desc 1 -sd f -tn 4 ; desc 2 -sd f; desc 3 -sd f; data 1 -do -1 320 042 040 00; data 2 -do -1 "+0" (3) "1" "0" 000; data 3 -do -1 "+01332" 000; page -all; /* sb3d18 * 9 float-9 scaled to 9 float * */ inst sb3d -nt "9flo-9sca->9flo" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb reg -mf3 ar rl 6 idb reg; desc1 -sd l; desc2 -sd f; data 1 -do -1 "-" (4) "3"; data 2 -do -1 "+" "0" (3) "2" 000; data 3 -do -1 "+" "3555" 000; page -all; /* sb3d19 * 9scaled - 9 floating to 9 scaled * */ inst sb3d -nt "9sca-9flo->9sca" -io 2 -mf1 ar rl 6 idb reg -mf2 ar rl 5 idb reg -mf3 ar rl 5 idb reg; desc1 -sd f; desc2 -sd l; desc 3 -sd l; data 1 -do -1 "-" "0" (3) "2" 000; data 2 -do -1 "+" (4) "3"; data 3 -do -1 "+" "3555"; page -all; /* sb3d20 * 4 float - 9 scaled to 4 float * */ inst sb3d -nt "4flo-9sca->9sca" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb -mf3 ar rl 6 idb; desc 1 -sd l; desc 2 -sd f -tn 4; desc 3 -sd f -tn 4; data 1 -do -1 "-0" (3) "2"; data 2 -do -1 303063 000; data 3 -do -1 305125000; page -all; /* sb3d21 * 4scaled - 9 float to 4 scaled * */ inst sb3d -nt "4sca-9flo->4sca" -io 1 -mf1 ar rl 6 idb reg -mf2 ar rl 4 idb -mf3 ar rl 4 idb; desc 1 -sd f; desc 2 -sd l -tn 4; desc 3 -sd l -tn 4; data 1 -do -1 "-0" (3) "2" 000; data 2 -do -2 303 063; data 3 305125; page -all; /* sb3d22 * 9 float - 4 scaled to 9 float * */ inst sb3d -nt "9flo-4sca->9flo" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb reg -mf3 ar rl 6 idb reg; desc 1 -sd l -tn 4; desc 2 -sd f; desc 3 -sd f; data 1 -do -1 323063; data 2 -do -1 "+0" (3) "2" 000; data 3 "+0" (3) "5" 000; page -all; /* sb3d23 * 9 scaled - 4 floating to 9 scaled * */ inst sb3d -nt "9sca-4flo->9sca" -io 1 -mf1 ar rl 6 idb -mf2 ar rl 5 idb reg -mf3 ar rl 5 idb reg; desc 1 -sd f -tn 4; desc 2 -sd n; desc 3 -sd n; data 1 -do -1 323 063 000; data 2 -do -2 "00" "555"; data 3 "00" "888"; page -all; /* sb3d24 * 4 float - 4 scaled to 4 float * */ inst sb3d -nt "4flo-4sca->4flo" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb -mf3 ar rl 6 idb; desc 1 -tn 4 -sd l; desc 2 -tn 4 -sd f; desc 3 -tn 4 -sd f; data 1 -do -1 323 063; data 2 -do -1 302042000; data 3 305125 000; page -all; /* sb3d25 * 4 scaled - 4 floatint to 4 scaled * */ inst sb3d -nt "4sca-4flo->4flo" -io 2 -mf1 ar rl 6 idb -mf2 ar rl 4 idb -mf3 ar rl 4 idb; desc 1 -tn 4 -sd f; desc 2 -tn 4 -sd l; desc 3 -tn 4 -sd l; data 1 -do -1 322042000; data 2 -do -1 303 063; data 3 305125; page -all; /* sb3d26 * * Subtraction yields a zero number. */ inst sb3d -nt "Result = zero" -io 1 -ir zr -mf1 ar -mf2 ida -mf3 ar reg idb rl 12; desc 1 -sd l -nn 7 -sf 2; desc 2 -sd t -nn 6 -sf 3; desc 3 -sd n -sf -4; data 1 -do -3 053 "55" "5550"; data 2 -do -4 "5555" "5" 053; data 3 -do -2 "00" "0000000000"; page -all; /* sb2d1 * The zero indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -ir zr -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd f -nn 63; desc 2 -tn 4 -sd f -nn 63; data 1 -do -1 261 (30)021 00; data 2 -do -31 261 (30)021 00; data 3 300 (29)000 007 36; page -all; /* sb2d2 * The zero indicator is set. * Two 4-bit operands with leading sign are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -ir zr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd l -sf 5 -nn 4; desc 2 -tn 4 -sd l -sf 4 -nn 5; data 1 -do -1 263 222; data 2 -do -2 263 222; data 3 300 000 00; page -all; /* sb2d3 * The negative indicator is set. * Two 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd f -nn 18; desc 2 -sd f -nn 18; data 1 -do -14 "+" (3)"98765" "8" 007; data 2 -do -4 "+" (3)"32411" "7" 007; data 3 "-" (3)"66354" "1" 007; page -all; /* sb2d4 * The negative indicator is set. * Two 9-bit operands with trailing sign are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd t -sf 5 -nn 25; desc 2 -sd t -sf 5 -nn 25; data 1 -do -23 (24) "5" "+"; data 2 -do -4 (24) "4" "-"; data 3 (24) "9" "-"; page -all; /* sb2d5 * The truncation indicator is set. * Two 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -ir tn -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd f -nn 8; desc 2 -tn 4 -sd f -nn 8; data 1 -do -2 331 231 231 004; data 2 -do -2 270 166 124 003; data 3 301 010 166 005; page -all; /* sb2d6 * The truncation indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -ir tn -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf 4 -nn 63; desc 2 -sd l -sf 5 -nn 62; data 1 -do -60 "+" (62)"3"; data 2 -do -3 "+" (61)"9"; data 3 "+" (60)"6" "5"; page -all; /* sb2d7 * Rounding is tested. * Two 9-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -rb -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd t -sf 4 -nn 63; desc 2 -sd t -sf 5 -nn 62; data 1 -do -38 (62)"3" "+"; data 2 -do -36 (61)"9" "+"; data 3 (61)"6" "+"; page -all; /* sb2d8 * The overflow indicator is set. * Two 4-bit trailing sign operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -ir ov -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd t -sf 3 -nn 7; desc 2 -tn 4 -sd t -sf 3 -nn 7; data 1 (3)163 32; data 2 (3)231 26; data 3 163 163 162 300; page -all; /* sb2d9 * The exponent overflow indicator is set. * Two 4-bit floating point operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -ir eo tn -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd f -nn 8 -cn 1; desc 2 -tn 4 -sd f -nn 8 -cn 1; data 1 -do -1 00 330 210 210 177; data 2 -do -4 00 267 167 167 177; data 3 00 301 146 146 200; page -all; /* sb2d10 * Leading and trailing signs are mixed. * Two 9-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd l -sf -8 -nn 42; desc 2 -sd t -sf -8 -nn 42; data 1 -do -40 "+" (4)"1234000000" "9"; data 2 -do -2 (4)"9876543210" "9" "+"; data 3 (4) "8642543210" "0+"; page -all; /* sb2d11 * Leading sign and floating point operands are mixed. * Two 4-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd l -nn 8; desc 2 -tn 4 -sd f -nn 10; data 1 -do -1 271 043 064 000; data 2 -do -1 271 207 145 000 000; data 3 300 144 061 000 000; page -all; /* sb2d12 * A leading sign 9-bit and an unsigned 4-bit operand are mixed. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 4 bit -> 4 bit" -mf1 idb ar reg -mf2 idb ar -io 2; desc 1 -sd l -nn 8; desc 2 -sd n -tn 4 -nn 7; data 1 -do -1 "+" "1234500"; data 2 -do -1 230 166 120 00; data 3 206 102 000 00; page -all; /* sb2d13 * Unsigned 4-bit and 9-bit operands are mixed. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 9 bit -> 9 bit" -mf1 idb ar -mf2 idb ar reg -io 1; desc 1 -sd n -sf 31 -tn 4 -nn 7; desc 2 -sd n -sf 31 -nn 7; data 1 -do -1 022 064 120 00 ; data 2 -do -3 "9876500"; data 3 "8642000"; page -all; /* sb2d14 * Floating point and trailing sign operands are mixed. * Two 9-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "9 bit - 9 bit -> 9 bit" -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd f -nn 9; desc 2 -sd t -sf 12 -nn 8; data 1 -do -7 "+" "1234500" 014; data 2 -do -3 "9876500" "+"; data 3 "8642000" "+"; page -all; /* sb2d15 * The special plus sign capability for 4-bit operands is tested. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst sb2d -nt "4 bit - 4 bit -> 4 bit" -pb -mf1 idb ar -mf2 idb ar -io 1; desc 1 -sd l -nn 7; desc 2 -sd l -tn 4 -nn 8; data 1 -do -7 "+" "1234500"; data 2 -do -2 261 043 105 000; data 3 261 021 020 120; page -all; /* mp3d1 * 9 bit scaled * 9 bit scaled to * 9 bit scaled * all page faults taken * rounding desired and it occurs * */ inst mp3d -nt "rounded result" -io 2 -rb -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l -sf 5; desc2 -cn 1 -sd l -sf 10; desc3 -sd l -cn 1 -sf 20; data 1 -do 4033 " +" (20) "0" (12) "543" "043543"; data 2 -do 4033 " +" (47) "0" (5) "765"; data 3 -do 4033 000 "+000000000041622703784865905405405405405405405" "36711707549441337"; page -all; /* mp3d2 * a simple test * no modification used * 9 bit*9 bit to 9 bit * */ inst mp3d -nt"9bit*9bit->9bit" -io 2 -ir ov ng; desc1 -sd l -cn 1 -nn 10; desc2 -sd l -cn 1 -nn 10; desc3 -sd l -cn 1 -nn 10; data 1 " -" (9) "1"; data 2 " +" (9) "1"; data 3 000 "-" "987654321"; page -all; /* mp3d3 * 9 bit*9 bit to 9 bit * negative indicator on * all page faults taken * */ inst mp3d -nt "9 bit*9bit to 9 bit" -io 1 -ir ng -mf1 ar rl 23 idb reg -mf2 ar rl 24 idb reg -mf3 ar rl 24 idb reg; desc1 -sd t -cn 2; desc2 -sd t -cn 1; desc3 -sd l -cn 3; data 1 -do -9 " " (15) "0" (3) "12" "1+"; data 2 -do -11 " " (16) "0" (3) "23" "2-"; data 3 (3) 000 "-" (10) "0" "2816038295072"; page -all; /* mp3d4 * 9 bit scaled to 4 bit float to * 4 bit float * */ inst mp3d -nt "4bit float*9bit to 4bit" -io 2 -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb -mf3 ar rl 10 idb; desc1 -sd t -cn 1; desc2 -sd f -tn 4; desc3 -sd f -tn 4; data 1 -do -10 " " (5) "0" (4) "2" "+"; data 2 -do -4 300 000 000 021 000; data 3 -do -4 300 002 104 102 000; page -all; /* mp3d5 * 9 bit scaled*9 bit scaled to * 9 bit scaled * all page faults taken * truncation indicator set * */ inst mp3d -nt "9bit*9bit to 9bit" -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l ; desc2 -cn 2 -sd l -sf 1; desc3 -cn 3 -sd l -sf 1; data 1 -do 4033 " +" (5) "0" (19) "543"; data 2 -do 4034 " +" (60) "0" "11"; data 3 -do 4035 (3) 000 "+" (4) "0" "5" (18) "978" "973"; page -all; /* mp3d6 * 9 bit scaled*9 bit scaled tp * 9 bit scaled * all page faults taken * rounding desired, therefore no truncation * */ inst mp3d -nt "no truncation" -io 3 -ir ng -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg -rb; desc1 -cn 1 -sd l -sf 5; desc2 -cn 2 -sd l -sf 10; desc3 -cn 1 -sd l -sf 10; data 1 -do 4033 " -" (53) "0" (3) "543"; data 2 -do 4034 " +" (53) "0" (3) "765"; data 3 -do 4033 000 "-" (39) "0" "416227037016205395" (5) "0"; page -all; /* mp3d7 * all operands 4 bit scaled * all page faults taken * negative indicator set * */ inst mp3d -nt "4 bit*4bit to 4bit scaled" -io 1 -mf1 ar rl 63 idb -mf2 ar rl 63 idb -mf3 ar rl 63 idb; desc1 -sd l -tn 4 -cn 1; desc2 -sd l -tn 4 -cn 1; desc3 -sd l -tn 4 -cn 1; data 1 " " 300 (26) 000 (4) 105 (8) 000; data 2 " " 300 (26) 000 (3) 105 104 (7) 000; data 3 000300 (21) 000 002 006 141 025 141 127 002 110 (9) 000; page -all; /* mp3d8 * all operands 9 bit float * all page faults taken * no rounding needed * */ inst mp3d -nt "9 bit floating" -io 1 -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg -mf3 ar rl 10 idb reg; desc1 -sd f -cn 1; desc2 -sd f -cn 1; desc3 -sd f -cn 1; data 1 -do -10 " +" (4) "0" (4) "1" 001; data 2 -do -10 " +" (4) "0" (4) "2" 001; data 3 -do -10 000 "+" "02468642" 002; page -all; /* mp3d9 * all operands 9 bit floating * rounding not desired, but required * set round bit * */ inst mp3d -nt "round floating" -io 2 -rb -mf1 ar rl 10 ida -mf2 ar rl 10 ida -mf3 ar rl 10 ida; desc1 -cn 1 -sd f; desc2 -cn 1 -sd f; desc3 -sd f; data 1 " +" (4) "0" (4) "3" 002; data 2 " +" (4) "0" (4) "9" 001; data 3 "+" (3) "3" "26667" 003; page -all; /* mp3d10 * all operands 9 bit floating * truncation will occur * */ inst mp3d -nt "truncation" -io 3 -ir tn -mf1 ar rl 10 -mf2 ar rl 10 -mf3 ar rl 10; desc1 -sd f; desc2 -sd f; desc3 -sd f; data 1 "+" (3) "0" (5) "3" 000; data 2 "+" (4) "0" (4) "9" 001; data 3 "+" (3) "3" "29666" 002; page -all; /* mp3d11 * set zero indicator, use three 9-bit operands * */ inst mp3d -nt"9sca*9sca->9sca" -ir zr -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd f -nn 63; desc 2 -sd f -nn 63; desc 3 -sd f -nn 63; data 1 "+" (61)"0" 000 -do -62; data 2 "-" (61)"9" 034 -do -34; data 3 "+" (61)"0" 177; page -all; /* mp3d12 * set zero indicator, use three 9-bit leading sign operands * */ inst mp3d -nt"9sca*9sca->9sca" -ir zr -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -sd l -sf 10 -nn 7; desc 2 -sd l -sf 10 -nn 28; desc3 -sd l -sf 10 -nn 28; data 1 -do -4 "-" (6)"4"; data 2 -do -24 "+" (27)"0"; data 3 "+" (27)"0"; page -all; /* mp3d13 * * set negative indicator, use three 4-bit floating operands * */ inst mp3d -nt "4float*4float->4float" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd f -nn 6; desc 2 -tn 4 -sd f -nn 6; desc 3 -tn 4 -sd f -nn 6; data 1 260 061 004; data 2 320 050 004; data 3 330 150 010; page -all; /* mp3d14 * * set negative indicator, use three 4-bit leading sign operands * */ inst mp3d -nt "4sca*4sca->4sca" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -tn 4 -sd l -sf 2 -nn 4; desc 2 -tn 4 -sd l -sf 2 -nn 6; desc 3 -tn 4 -sd l -sf 2 -nn 6; data 1 260 061; data 2 320 000 050; data 3 330 150 000; page -all; /* mp3d15 * * set truncation indicator, use three 4-bit floating operands * */ inst mp3d -nt "4float*4float->4float" -ir tn -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd f -nn 6; desc 2 -tn 4 -sd f -nn 6; desc 3 -tn 4 -sd f -nn 6; data 1 266 130 012; data 2 260 022 013; data 3 307 211 026; page -all; /* mp3d16 * * set truncation indicator, use three 4-bit leading sign operands * */ inst mp3d -nt "4sca*4sca->4sca" -ir tn -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -tn 4 -sd l -sf -1 -nn 2 -cn 1; desc 2 -tn 4 -sd l -sf 4 -nn 5 -cn 1; desc 3 -tn 4 -sd l -sf 4 -nn 5; data 1 00 271; data 2 00 261 043 10; data 3 301 021 00; page -all; /* mp3d17 * * test rounding, use three 4-bit trailing sign operands * */ inst mp3d -nt "4sca*4sca->4sca" -rb -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd t -sf -1 -cn 1 -nn 2; desc 2 -tn 4 -sd t -sf 4 -nn 5; desc 3 -tn 4 -sd t -sf 4 -nn 5; data 1 -do -1 00 233; data 2 -do -2 022 064 30; data 3 021 021 30; page -all; /* mp3d18 * * set overflow indicator, use three 9-bit unsigned operands * */ inst mp3d -nt "9sca*9sca->9sca" -ir ov -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd n -nn 3; desc 2 -sd n -nn 5; desc 3 -sd n -nn 5; data 1 -do -1 "999"; data 2 -do -4 "00999"; data 3 "98001"; page -all; /* mp3d19 * * set exponent overflow indicator, use three 9-bit floating operands * */ inst mp3d -nt "9flo*9flo->9flo" -ir eo tn -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd f -nn 6; desc 2 -sd f -nn 6; desc 3 -sd f -nn 6; data 1 -do -4 "+" "0900" 100; data 2 -do -1 "+" "0756" 076; data 3 "+" "6804" 200; page -all; /* mp3d20 * * set exponent underflow indicator, use three 4-bit trailing * sign operands * */ inst mp3d -nt "4sca*4sca->4sca" -ir eu -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -tn 4 -sd f -nn 6 -cn 1; desc 2 -tn 4 -sd f -nn 6 -cn 1; desc 3 -tn 4 -sd f -nn 6 -cn 1; data 1 -do -1 00 260 042 200; data 2 -do -2 00 260 063 300; data 3 00 307 046 100; page -all; /* mp3d21 * * mix leading and traling signs with 4-bit operands * */ inst mp3d -nt "4sca*4sca->4sca" -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd l -nn 63; desc 2 -tn 4 -sd t -sf 3 -nn 63; desc 3 -tn 4 -sd t -sf 3 -nn 63; data 1 -do -62 260 (30)000 22; data 2 -do -1 010 (30)210 26; data 3 171 (29)231 222 30; page -all; /* mp3d22 * * mix floating point and leading sign with 9-bit operands * */ inst mp3d -nt "9flo*9sca->9sca" -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd f -nn 5; desc 2 -sd l -sf -3 -nn 63; desc 3 -sd l -sf -3 -nn 63; data 1 -do -4 "+" "009" 001; data 2 -do -17 "+" "00" (60)"8"; data 3 "+" "7" (59)"9" "20"; page -all; /* mp3d23 * * mix 9-bit and 4-bit operands, use leading sign and unsigned scaled * decimals * */ inst mp3d -nt "9sca*4sca->4sca" -mf1 idb ar reg -mf2 idb ar -mf3 idb ar -io 1; desc 1 -sd l -sf 2 -nn 11; desc 2 -sd n -sf 2 -nn 15 -tn 4; desc 3 -sd n -sf 2 -nn 15 -tn 4; data 1 -do -7 "+" "2271658432"; data 2 -do -1 (6)000 124 04; data 3 022 061 043 210 160 024 100 000; page -all; /* mp3d24 * * mix 4-bit and 9-bit unsigned operands * */ inst mp3d -nt "4sca*9sca->9sca" -mf1 idb ar -mf2 idb ar reg -mf3 idb ar reg -io 2; desc 1 -sd n -tn 4 -sf 2 -nn 10; desc 2 -sd n -sf 2 -nn 15; desc 3 -sd n -sf 2 -nn 15; data 1 -do -1 042 161 145 204 142; data 2 -do -13 (12)"0" "542"; data 3 "123123888640400"; page -all; /* mp3d25 * * mix floating point and trailing sign 9-bit operands * */ inst mp3d -nt "9-bit f -> 4 bit trailing sign" -ir ng -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd f -nn 16; desc 2 -sd t -sf 4 -nn 16; desc 3 -sd t -sf 4 -nn 16; data 1 -do -5 "+" "0000" "2271658432" 002; data 2 -do -6 (12)"0" "542" "-"; data 3 "123123887014400" "-"; page -all; /* mp3d26 * * Multiply 505.05+ by floating +2.2 and get the 4 bit number * +1111.11000 */ inst mp3d -nt "Result is 4 bit num" -io 3 -mf1 ida -mf2 reg ar idb -mf3 ar idb; desc 1 -nn 6 -sd t -sf -2 -cn 1; data 1 -do -4 " " "505" "05" 053; desc 2 -nn 4 -sd f -cn 2; data 2 -do -3 " " 053 "22" 377; /* Exponent = -1 */ desc 3 -nn 10 -sd l -tn 4 -sf -5; data 3 301 021 021 020 000; page -all; /* mp3d27 * 9 bit scaled * 9 bit scaled to * 9 bit scaled * all page faults taken * */ inst mp3d -nt "rounded result" -io 2 -rb -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l ; desc2 -cn 1 -sd l ; desc3 -sd l -cn 1 ; data 1 -do 4033 " +" (20) "0" (12) "111" "111111"; data 2 -do 4033 " +" (53) "0" (9) "1"; data 3 -do 4033 000 "+" (12) "0" "12345678" (34) "9" "87654321"; page -all; /* mp2d1 * The zero indicator is set. * Two 9-bit operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 9-bit -> 9-bit" -ir zr -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd f -nn 63; desc 2 -sd f -nn 63; data 1 "+" (61)"0" 000 -do -62; data 2 "-" (61)"9" 034 -do -34; data 3 "+" (61)"0" 177; page -all; /* mp2d2 * The zero indicator is set. * Two 9-bit leading sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 9-bit -> 9-bit" -ir zr -mf1 idb ar -mf2 idb ar -io 2; desc 1 -sd l -sf 10 -nn 7; desc 2 -sd l -sf 10 -nn 28; data 1 -do -4 "-" (6)"4"; data 2 -do -24 "+" (27)"0"; data 3 "+" (27)"0"; page -all; /* mp2d3 * The negative indicator is set. * Two 4-bit floating point operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -ir ng -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd f -nn 6; desc 2 -tn 4 -sd f -nn 6; data 1 260 061 004; data 2 320 050 004; data 3 330 150 010; page -all; /* mp2d4 * The negative indicator is set. * Two 4-bit leading sign operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -ir ng -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd l -sf 2 -nn 4; desc 2 -tn 4 -sd l -sf 2 -nn 6; data 1 260 061; data 2 320 000 050; data 3 330 150 000; page -all; /* mp2d5 * The truncation indicator is set. * Two 4-bit floating point operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -ir tn -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd f -nn 6; desc 2 -tn 4 -sd f -nn 6; data 1 266 130 012; data 2 260 022 013; data 3 307 211 026; page -all; /* mp2d6 * The truncation indicator is set. * Two 4-bit leading sign operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -ir tn -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd l -sf -1 -nn 2 -cn 1; desc 2 -tn 4 -sd l -sf 4 -nn 5 -cn 1; data 1 00 271; data 2 00 261 043 10; data 3 00 301 021 00; page -all; /* mp2d7 * Rounding is tested. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -rb -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd t -sf -1 -cn 1 -nn 2; desc 2 -tn 4 -sd t -sf 4 -nn 5; data 1 -do -1 00 233; data 2 -do -2 022 064 30; data 3 021 021 30; page -all; /* mp2d8 * The overflow indicator is set. * Two 9-bit unsigned operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 9-bit -> 9-bit" -ir ov -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd n -nn 3; desc 2 -sd n -nn 5; data 1 -do -1 "999"; data 2 -do -4 "00999"; data 3 "98001"; page -all; /* mp2d9 * The exponent overflow indicator is set. * Two 9-bit floating point operands * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 9-bit -> 9-bit" -ir eo tn -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd f -nn 6; desc 2 -sd f -nn 6; data 1 -do -4 "+" "0900" 100; data 2 -do -1 "+" "0756" 076; data 3 "+" "6804" 200; page -all; /* mp2d10 * The exponent underflow indicator is set. * Two 4-bit trailing sign operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -ir eu -mf1 idb ar -mf2 idb ar -io 2; desc 1 -tn 4 -sd f -nn 6 -cn 1; desc 2 -tn 4 -sd f -nn 6 -cn 1; data 1 -do -1 00 260 042 200; data 2 -do -2 00 260 063 300; data 3 00 307 046 100; page -all; /* mp2d11 * Leading and trailing signs are mixed. * Two 4-bit operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -mf1 idb ar -mf2 idb ar -io 1; desc 1 -tn 4 -sd l -nn 63; desc 2 -tn 4 -sd t -sf 3 -nn 63; data 1 -do -62 260 (30)000 22; data 2 -do -1 010 (30)210 26; data 3 171 (29)231 222 30; page -all; /* mp2d12 * A floating point operand and a leading sign operand are used. * Two 9-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 4-bit -> 4-bit" -mf1 idb ar reg -mf2 idb ar reg -io 2; desc 1 -sd f -nn 5; desc 2 -sd l -sf -3 -nn 63; data 1 -do -4 "+" "009" 001; data 2 -do -17 "+" "00" (60)"8"; data 3 "+" "7" (59)"9" "20"; page -all; /* mp2d13 * A leading sign 9-bit operand and an unsigned 4-bit operand are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 4-bit -> 4-bit" -mf1 idb ar reg -mf2 idb ar -io 1; desc 1 -sd l -sf 2 -nn 11; desc 2 -sd n -sf 2 -nn 15 -tn 4; data 1 -do -7 "+" "2271658432"; data 2 -do -1 (6)000 124 04; data 3 022 061 043 210 160 024 100 000; page -all; /* mp2d14 * Unsigned 4-bit and 9-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "4-bit x 9-bit -> 9-bit" -mf1 idb ar -mf2 idb ar reg -io 2; desc 1 -sd n -tn 4 -sf 2 -nn 10; desc 2 -sd n -sf 2 -nn 15; data 1 -do -1 042 161 145 204 142; data 2 -do -13 (12)"0" "542"; data 3 "123123888640400"; page -all; /* mp2d15 * A floating point operand and a trailing sign operand are used. * Two 9-bit operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst mp2d -nt "9-bit x 9-bit -> 9-bit" -ir ng -mf1 idb ar reg -mf2 idb ar reg -io 1; desc 1 -sd f -nn 16; desc 2 -sd t -sf 4 -nn 16; data 1 -do -5 "+" "0000" "2271658432" 002; data 2 -do -6 (12)"0" "542" "-"; data 3 "123123887014400" "-"; page -all; /* dv3d1 * The zero indicator is set. * Three 9-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 9 bit" -ir zr -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 1; desc 1 -sd f -nn 6; desc 2 -sd f -nn 55; desc 3 -sd f -nn 31; data 1 -do -2 "+" "4275" 377; data 2 -do -50 "+" (53)"0" 374; data 3 -do -25 "+" (29)"0" 177; page -all; /* dv3d2 * The negative indicator is set. * Three 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 2; desc 1 -tn 4 -sd f -nn 8 -cn 1; desc 2 -tn 4 -sd f -nn 8 -cn 1; desc 3 -tn 4 -sd f -nn 8 -cn 1; data 1 -do -1 00 260 000 002 004; data 2 -do -4 00 320 225 120 004; data 3 -do -2 00 324 167 120 377; page -all; /* dv3d3 * The negative indicator is set. * Three 4-bit trailing sign operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ng -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 3; desc 1 -tn 4 -sd t -sf 4 -nn 4; desc 2 -tn 4 -sd t -sf 8 -nn 3; desc 3 -tn 4 -sd t -sf 3 -nn3; data 1 000 055; data 2 010 26; data 3 100 32; page -all; /* dv3d4 * The overflow indicator is set. * Three 4-bit floating point operands are used. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ov -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd n -sf 1 -nn 63; desc 2 -tn 4 -sd n -sf 1 -nn63; desc 3 -tn 4 -sd n -sf 10 -nn 50; data 1 -do -12 (31)000 10; data 2 -do -15 (31)167 16; data 3 -do -18 (25)104; page -all; /* dv3d5 * A 9-bit operand is divided by a 9-bit operand & stored in a 4-bit operand. * All operands are unsigned. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 4 bit" -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar -io 1; desc 1 -sd n -nn 8; desc 2 -sd n -nn 10; desc 3 -sd n -tn 4 -nn 8; data 1 -do -7 "30144196"; data 2 -do -3 "1567498217"; data 3 -do -2 (3)000 122; page -all; /* dv3d6 * A 4-bit operand is divided by a 4-bit operand & stored in a 9-bit operand. * All operands are floating point. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 9 bit" -mf1 idb ar -mf2 idb ar -mf3 idb ar reg -io 2; desc 1 -tn 4 -sd f -nn 11; desc 2 -tn 4 -sd f -nn 13; desc 3 -sd f -nn 10; data 1 -do -4 323 001 104 031 140 00; data 2 -do -3 321 126 164 230 041 160 00; data 3 -do -1 "+" "052" (5)"0" 373; page -all; /* dv3d7 * A 9-bit operand is divided by a 4-bit operand & stored in a 4-bit operand. * All operands are trailing sign. * The maximum number of page faults is taken. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 4 bit) -> 4 bit" -mf1 idb ar reg -mf2 idb ar -mf3 idb ar -io 3; desc 1 -sd t -nn 10; desc 2 -tn 4 -sd t -nn 11; desc 3 -tn 4 -sd t -nn 10; data 1 -do -8 "030144196" "-"; data 2 -do -5 025 147 111 202 027 320; data 3 -do -3 (3)000 005 054; page -all; /* dv3d8 * A 9-bit operand is divided by a 4-bit operand & stored in a 9-bit operand. * All operands are leading sign. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 4 bit) -> 9 bit" -mf1 idb ar reg -mf2 idb ar -mf3 idb ar reg -io 2; desc 1 -sd l -sf 6 -nn 20; desc 2 -sd l -sf 6 -tn 4 -nn 20; desc 3 -sd l -nn 20; data 1 "+" (11)"0" "30144196"; data 2 260 (4) 000 025 147 111 202 027; data 3 "+" (17)"0" "52"; page -all; /* dv3d9 * Leading sign, trailing sign, and floating point operands are used. * Three 9-bit operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 9 bit" -mf1 idb ar reg -mf2 idb ar reg -mf3 idb ar reg -io 3; desc 1 -sd l -sf 1 -nn 8; desc 2 -sd t -sf 2 -nn 8; desc 3 -sd f -nn 8; data 1 "+" (5)"0" "58"; data 2 "000" "1234" "+"; data 3 "+" "021275" 376; page -all; /* dv3d10 * Floating point, unsigned, and leading sign operands are used. * Three 4-bit operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit -> 4 bit" -mf1 idb ar -mf2 idb ar -mf3 idb ar -io 1; desc 1 -tn 4 -sd f -nn 8; desc 2 -tn 4 -sd n -sf 1 -nn 8; desc 3 -tn 4 -sd l -nn 8; data 1 260 002 022 000; data 2 000 000 022 064; data 3 300 000 000 130; page -all; /* dv3d11 * Use RL mod and cn field with indirect descriptors * Use three 9-bit trailing sign operands. * */ inst dv3d -nt "two character offset" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg -mf3 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; desc 3 -cn 1 -sd t; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 000 (8)"0" "2" "-"; page -all; /* dv3d12 * Use RL mod and cn field with indirect descriptors * Use three 9-bit trailing sign operands. * */ inst dv3d -nt "one character offset" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg -mf3 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; desc3 -cn 1 -sd t; data 1 -do -10 " " (9) "1" "-"; data 2 -do -20 "*" (9) "2" "+"; data 3 000 (8) "0" "2" "-"; page -all; /* dv3d13 * Use RL mod and cn field * Use three 9-bit trailing sign operands. * no indirect descriptors * */ inst dv3d -nt "no indirect descriptors" -io 2 -ir ng -mf1 ar rl 10 reg -mf2 ar rl 10 reg -mf3 ar rl 10 reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; desc3 -cn 1 -sd t; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 000 (8) "0" "2" "-"; page -all; /* dv3d14 * Use no modification * Use three 9 bit trailing sign operands. * */ inst dv3d -nt "no mf modification" -io 2 -ir ng; desc1 -cn 1 -sd t -nn 12; desc2 -cn 1 -sd t -nn 12; desc3 -cn 1 -sd t -nn 12; data 1 -do -12 " " (11) "1" "-"; data 2 -do -12 "*" (11) "2" "+"; data 3 000 (10) "0" "2" "-"; page -all; /* dv3d15 * Use ar and rl * Use three 9-bit trailing sign operands. * */ inst dv3d -nt "ar and rl modification" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 -mf3 ar rl 10 ; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; desc3 -cn 1 -sd t; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 000 (8)"0" "2" "-"; page -all; /* dv3d16 * Use ar and rl modification on desc1 * Use ar rl idb reg on desc2 * Use three 9-bit trailing sign operands. * */ inst dv3d -nt "two character offset" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 idb reg -mf3 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; desc3 -cn 1 -sd t; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 000 (8) "0" "2" "-"; page -all; /* dv3d17 * maximum length divide leading sign * one character over next page * all modification taken */ inst dv3d -nt "maximum length " -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -cn 1 -sd l ; desc2 -cn 1 -sd l ; desc3 -cn 1 -sd l; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+33" (15) "8642"; data 3 000 "+" (61) "0" "1"; page -all; /* dv3d18 * This is a simple test * Use three 9-bit trailing sign operands. * */ inst dv3d -nt "simple test"; desc1 -sd t -nn 63; desc2 -sd t -sf 10 -nn 63; desc3 -sd t -sf 10 -nn 63; data 1 "11" (12) "1111" "11" (10) "0" "+"; data 2 "22" (12) "2222" "22" (10) "0" "+"; data 3 (61) "0" "2" "+"; page -all; /* dv3d19 * maximum length divide resulting * in an overflow * all modification taken * Use three 9-bit leading sign operands. */ inst dv3d -nt "truncation fault" -io 1 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg -mf3 ar rl 63 idb reg; desc1 -sd l -cn 1; desc2 -sd l -cn 1; desc3 -sd l -cn 1; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+71" (15) "2357"; data 3 000 "+" (61) "0" "2"; page -all; /* dv3d20 * maximum length over two pages * no faults, (9 bit / 4 bit) -> 4 bit * */ inst dv3d -nt "(9 bit / 4 bit) -> 4 bit" -io 1 -mf1 ar rl 63 -mf2 ar rl 63 -mf3 ar rl 63 ; desc1 -sd t ; desc2 -sd t -tn 4; desc3 -sd t -tn 4; data 1 -do 4033 "33" (15) "3333" "+"; data 2 -do 4064 104104 (7) 104104104104 10426; data 3 (28) 000 000000001300; page -all; /* dv3d21 * (9 bit / 4 bit) -> 4 bit ; all page faults possible * no reg modification on desc2 * */ inst dv3d -nt "(9 bit / 4 bit) -> 4 bit" -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb -mf3 ar rl 63 idb ; desc1 -cn 1 -sd l; desc2 -cn 1 -sd t -tn 4; desc3 -cn 1 -sd t -tn 4; data 1 -do 4033 " " "+" (15) "0000" "22"; data 2 -do 4068 "*" (28) 000 104104 1043; data 3 000 (28) 000 002 002 002 300; page -all; /* dv3d22 * Use three 4-bit trailing sign operands. * maximum length * all page faults taken * no reg modification */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -io 1 -mf1 ar rl 63 idb -mf2 ar rl 63 idb -mf3 ar rl 63 idb; desc1 -cn 1 -sd t -tn 4; desc2 -cn 1 -sd t -tn 4; desc3 -cn 1 -sd t -tn 4; data 1 -do 4065 " " (28) 000 000 000 0013; data 2 -do 4065 "*" 021021 (7) 021021021021 0213; data 3 000 021021 (7) 021021021021 0213; page -all; /* dv3d23 * floating point divide * Use three 9-bit floatinf point operands. * all page faults taken * */ inst dv3d -nt "9bit float divide" -io 1 -mf1 ar rl 63 reg idb -mf2 ar rl 63 reg idb -mf3 ar rl 63 reg idb; desc1 -sd f; desc2 -sd f; desc3 -sd f; data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005; data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006; data 3 "+" "1" (60) "0" 305; page -all; /* dv3d24 * Use three 4-bit floating point operands. * */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -io 1 -mf1 ar rl 10 ida -mf2 ar rl 10 ida -mf3 ar rl 10 ida; desc1 -sd f -tn 4; desc2 -sd f -tn 4; desc3 -sd f -tn 4; data 1 -do -1 300 000 000 001 000; data 2 -do -1 300 000 021 021 000; data 3 301 021 020 000 375; page -all; /* dv3d25 * (4 bit / 9 bit) -> 9 bit * */ inst dv3d -nt "(4 bit / 9 bit) -> 9 bit" -io 1 -mf1 ar rl 5 idb -mf2 ar rl 5 idb reg -mf3 ar rl 5 idb reg; desc 1 -tn 4 -sd l; desc 2 -sd n; desc 3 -sd n; data 1 30102100; data 2 -do 4 "02222"; data 3 "00002"; page -all; /* dv3d26 * The zero indicator is set. * Three 9-bit floating point operands are used. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 9 bit" -ir zr -mf1 ar reg -mf2 ar reg -mf3 ar reg -io 1; desc 1 -sd f -nn 6; desc 2 -sd f -nn 55; desc 3 -sd f -nn 31; data 1 -do -2 "+" "4275" 377; data 2 -do -50 "+" (53)"0" 374; data 3 -do -25 "+" (29)"0" 177; page -all; /* dv3d27 * The negative indicator is set. * Three 4-bit floating point operands are used. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ng -mf1 ar -mf2 ar -mf3 ar -io 2; desc 1 -tn 4 -sd f -nn 8 -cn 1; desc 2 -tn 4 -sd f -nn 8 -cn 1; desc 3 -tn 4 -sd f -nn 8 -cn 1; data 1 -do -1 00 260 000 002 004; data 2 -do -4 00 320 225 120 004; data 3 -do -2 00 324 167 120 377; page -all; /* dv3d28 * The negative indicator is set. * Three 4-bit trailing sign operands are used. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ng -mf1 ar -mf2 ar -mf3 ar -io 3; desc 1 -tn 4 -sd t -sf 4 -nn 4; desc 2 -tn 4 -sd t -sf 8 -nn 3; desc 3 -tn 4 -sd t -sf 3 -nn3; data 1 000 055; data 2 010 26; data 3 100 32; page -all; /* dv3d29 * The overflow indicator is set. * Three 4-bit floating point operands are used. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 4 bit" -ir ov -mf1 ar -mf2 ar -mf3 ar -io 1; desc 1 -tn 4 -sd n -sf 1 -nn 63; desc 2 -tn 4 -sd n -sf 1 -nn63; desc 3 -tn 4 -sd n -sf 10 -nn 50; data 1 -do -12 (31)000 10; data 2 -do -15 (31)167 16; data 3 -do -18 (25)104; page -all; /* dv3d30 * A 9-bit operand is divided by a 9-bit operand & stored in a 4-bit operand. * All operands are unsigned. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 4 bit" -mf1 ar reg -mf2 ar reg -mf3 ar -io 1; desc 1 -sd n -nn 8; desc 2 -sd n -nn 10; desc 3 -sd n -tn 4 -nn 8; data 1 -do -7 "30144196"; data 2 -do -3 "1567498217"; data 3 -do -2 (3)000 122; page -all; /* dv3d31 * A 4-bit operand is divided by a 4-bit operand & stored in a 9-bit operand. * All operands are floating point. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit) -> 9 bit" -mf1 ar -mf2 ar -mf3 ar reg -io 2; desc 1 -tn 4 -sd f -nn 11; desc 2 -tn 4 -sd f -nn 13; desc 3 -sd f -nn 10; data 1 -do -4 323 001 104 031 140 00; data 2 -do -3 321 126 164 230 041 160 00; data 3 -do -1 "+" "052" (5)"0" 373; page -all; /* dv3d32 * A 9-bit operand is divided by a 4-bit operand & stored in a 4-bit operand. * All operands are trailing sign. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 4 bit) -> 4 bit" -mf1 ar reg -mf2 ar -mf3 ar -io 3; desc 1 -sd t -nn 10; desc 2 -tn 4 -sd t -nn 11; desc 3 -tn 4 -sd t -nn 10; data 1 -do -8 "030144196" "-"; data 2 -do -5 025 147 111 202 027 320; data 3 -do -3 (3)000 005 054; page -all; /* dv3d33 * A 9-bit operand is divided by a 4-bit operand & stored in a 9-bit operand. * All operands are leading sign. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 4 bit) -> 9 bit" -mf1 ar reg -mf2 ar -mf3 ar reg -io 2; desc 1 -sd l -sf 6 -nn 20; desc 2 -sd l -sf 6 -tn 4 -nn 20; desc 3 -sd l -nn 20; data 1 "+" (11)"0" "30144196"; data 2 260 (4) 000 025 147 111 202 027; data 3 "+" (17)"0" "52"; page -all; /* dv3d34 * Leading sign, trailing sign, and floating point operands are used. * Three 9-bit operands are used. * No indirect descriptors are used. * Address register modification is used for all operands. */ inst dv3d -nt "(9 bit / 9 bit) -> 9 bit" -mf1 ar reg -mf2 ar reg -mf3 ar reg -io 3; desc 1 -sd l -sf 1 -nn 8; desc 2 -sd t -sf 2 -nn 8; desc 3 -sd f -nn 8; data 1 "+" (5)"0" "58"; data 2 "000" "1234" "+"; data 3 "+" "021275" 376; page -all; /* dv3d35 * Floating point, unsigned, and leading sign operands are used. * Three 4-bit operands are used. * Indirect descriptors are used for all operands. * Address register modification is used for all operands. */ inst dv3d -nt "(4 bit / 4 bit -> 4 bit" -mf1 ar -mf2 ar -mf3 ar -io 1; desc 1 -tn 4 -sd f -nn 8; desc 2 -tn 4 -sd n -sf 1 -nn 8; desc 3 -tn 4 -sd l -nn 8; data 1 260 002 022 000; data 2 000 000 022 064; data 3 300 000 000 130; page -all; /* dv2d1 * Use RL mod and cn field with indirect descriptors * divide 9 bit scaled to 9 bit scaled * */ inst dv2d -nt "two character offset" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 "*" (8) "0" "2" "-"; page -all; /* dv2d2 * Use RL mod and cn field with indirect descriptors * 9 bit scaled to 9 bit scaled * */ inst dv2d -nt "one character offset" -io 2 -ir ng -mf1 ar rl 10 idb reg -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -10 " " (9) "1" "-"; data 2 -do -20 "*" (9) "2" "+"; data 3 "*" (8) "0" "2" "-"; page -all; /* dv2d3 * Use RL mod and cn field * 9 bit scaled to 9 bit scaled * no indirect descriptors * */ inst dv2d -nt "no indirect descriptors" -io 2 -ir ng -mf1 ar rl 10 reg -mf2 ar rl 10 reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 "*" (8) "0" "2" "-"; page -all; /* dv2d4 * Use no modification * 9bit scaled divideed to 9 bit scaled * */ inst dv2d -nt "no mf modification" -io 2 -ir ng; desc1 -cn 1 -sd t -nn 12; desc2 -cn 1 -sd t -nn 12; data 1 -do -12 " " (11) "1" "-"; data 2 -do -12 "*" (11) "2" "+"; data 3 "*" (10) "0" "2" "-"; page -all; /* dv2d5 * Use ar and rl * 9 bit scaled to 9 bit scaled * */ inst dv2d -nt "ar and rl modification" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 ; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 "*" (8)"0" "2" "-"; page -all; /* dv2d6 * Use aar and rl modification, desc1 * Use ar rl idb reg on desc2 * 9 bit scaled to 9 bit scaled * */ inst dv2d -nt "two character offset" -io 2 -ir ng -mf1 ar rl 10 -mf2 ar rl 10 idb reg; desc1 -cn 1 -sd t ; desc2 -cn 1 -sd t ; data 1 -do -9 " " (9) "1" "-"; data 2 -do -9 "*" (9) "2" "+"; data 3 "*" (8) "0" "2" "-"; page -all; /* dv2d7 * maximum length divide leading sign * one character over next page * all modification taken */ inst dv2d -nt "maximum length " -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -cn 1 -sd l ; desc2 -cn 1 -sd l ; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+33" (15) "8642"; data 3 "*" "+" (61) "0" "1"; page -all; /* dv2d8 * This is a simple test * 9 bit divide to 9 bit all scaled trailing sign * */ inst dv2d -nt "simple test"; desc1 -sd t -nn 63; desc2 -sd t -sf 10 -nn 63; data 1 "11" (12) "1111" "11" (10) "0" "+"; data 2 "22" (12) "2222" "22" (10) "0" "+"; data 3 (61) "0" "2" "+"; page -all; /* dv2d9 * maximum length divide resulting * in an overflow * all modification taken * 9 bit scaled to 9 bit scaled */ inst dv2d -nt "truncation fault" -io 1 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb reg; desc1 -sd l -cn 1; desc2 -sd l -cn 1; data 1 -do 4033 " " "+33" (15) "8642"; data 2 -do 4033 "*" "+71" (15) "2357"; data 3 "*" "+" (61) "0" "2"; page -all; /* dv2d10 * maximum length over two pages * no faults, 9 bit to 4 bit * */ inst dv2d -nt "9 bit -> 4 bit" -io 1 -mf1 ar rl 63 -mf2 ar rl 63 ; desc1 -sd t ; desc2 -sd t -tn 4; data 1 -do 4033 "33" (15) "3333" "+"; data 2 -do 4064 104104 (7) 104104104104 10426; data 3 (28) 000 000000001300; page -all; /* dv2d11 * 9 bit to 4 bit all page faults possible * no reg modification on desc2 * */ inst dv2d -nt "9bit ->4bit" -io 2 -mf1 ar rl 63 idb reg -mf2 ar rl 63 idb ; desc1 -cn 1 -sd l; desc2 -cn 1 -sd t -tn 4; data 1 -do 4033 " " "+" (15) "0000" "22"; data 2 -do 4068 "*" (28) 000 104104 1043; data 3 "*" (28) 000 002 002 002 300; page -all; /* dv2d12 * 4 bit divideed to 4 bit * maximum length * all page faults taken * no reg modification */ inst dv2d -nt "4 bit + 4bit" -io 1 -mf1 ar rl 63 idb -mf2 ar rl 63 idb; desc1 -cn 1 -sd t -tn 4; desc2 -cn 1 -sd t -tn 4; data 1 -do 4065 " " (28) 000 000 000 0013; data 2 -do 4065 "*" 021021 (7) 021021021021 0213; data 3 "*" 021021 (7) 021021021021 0213; page -all; /* dv2d13 * floating point divide * 9 bit to 9bit * all page faults taken * */ inst dv2d -nt "9bit float divide" -io 1 -mf1 ar rl 63 reg idb -mf2 ar rl 63 reg idb; desc1 -sd f; desc2 -sd f; data 1 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 005; data 2 -do -1 "+" (20) "0" (10) "1" (30) "0" "1" 006; data 3 "+" "1" (60) "0" 305; page -all; /* dv2d14 * 4 bit floating divided to * 4 bit floating * */ inst dv2d -nt "4 float to 4 float" -io 1 -mf1 ar rl 10 ida -mf2 ar rl 10 ida; desc1 -sd f -tn 4; desc2 -sd f -tn 4; data 1 -do -1 300 000 000 001 000; data 2 -do -1 300 000 021 021 000; data 3 301 021 020 000 375; page -all; /* dv2d15 * test 4bit scaled to 9 bit * */ inst dv2d -nt "4bit->9bit" -io 1 -mf1 ar rl 5 idb -mf2 ar rl 5 idb reg; desc 1 -tn 4 -sd l; desc 2 -sd n; data 1 30102100; data 2 -do 4 "02222"; data 3 "00002"; page -all; /* dv2d16 * test 9 floating to 4 floating * */ inst dv2d -nt "9float->4 float" -io 1 -mf1 ar rl 5 idb reg -mf2 ar rl 7 idb; desc 1 -sd f; desc 2 -sd f -tn 4; data 1 "+" (3) "1" 000; data 2 300 042 040 00; data 3 302 000 017 320; page -all; /* dv2d17 * 4 float to 9 float * */ inst dv2d -nt "4float -> 9float" -io 1 -mf1 ar rl 7 idb -mf2 ar rl 7 idb reg; desc 1 -sd f -tn 4 ; desc 2 -sd f; data 1 300 042 040 00; data 2 "+0" (3) "1" "0" 000; data 3 "+05000" 375; page -all; /* dv2d18 * 9 scaled to 9 float * */ inst dv2d -nt "9sacled to 9 float" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb reg; desc1 -sd l; desc2 -sd f; data 1 "+" (4) "3"; data 2 "+" "0" (3) "2" 000; data 3 "+" "0666" 374; page -all; /* dv2d19 * 9 float to 9 scaled * */ inst dv2d -nt "9 float to 9 scaled" -io 2 -mf1 ar rl 6 idb reg -mf2 ar rl 5 idb reg; desc1 -sd f; desc2 -sd l; data 1 "+" "0" (3) "2" 000; data 2 "+" (4) "3"; data 3 "+0015"; page -all; /* dv2d20 * 9 scaled to 4 float * */ inst dv2d -nt "9scaled->4float" -io 2 -mf1 ar rl 5 idb reg -mf2 ar rl 6 idb; desc 1 -sd l; desc 2 -sd f -tn 4; data 1 "+0" (3) "2"; data 2 303063 000; data 3 301 120 376; page -all; /* dv2d21 * 9 float to 4 scaled * */ inst dv2d -nt "9float->4scaled" -io 1 -mf1 ar rl 6 idb reg -mf2 ar rl 4 idb; desc 1 -sd f; desc 2 -sd l -tn 4; data 1 -do -1 "+0" (3) "2" 000; data 2 -do -2 303 063; data 3 300 001; page -all; /* dv2d22 * 4scaled to 9 float * */ inst dv2d -nt "4scaled-.9float" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb reg; desc 1 -sd l -tn 4; desc 2 -sd f; data 1 -do -1 303063; data 2 -do -1 "+0" (3) "2" 000; data 3 "+0" (3) "6" 375; page -all; /* dv2d23 * 4 floating to 9 scaled * */ inst dv2d -nt "4float->9scaled" -io 1 -mf1 ar rl 6 idb -mf2 ar rl 5 idb reg; desc 1 -sd f -tn 4; desc 2 -sd n; data 1 -do -1 303 063 000; data 2 -do -2 "00" "555"; data 3 (4) "0" "1"; page -all; /* dv2d24 * 4 scaled to 4 float * */ inst dv2d -nt "4scaled to 4 float" -io 1 -mf1 ar rl 4 idb -mf2 ar rl 6 idb; desc 1 -tn 4 -sd l; desc 2 -tn 4 -sd f; data 1 -do -1 303 063; data 2 -do -1 302042000; data 3 300 146 376; page -all; /* dv2d25 * 4 floating to 4 scaled * */ inst dv2d -nt "4 floating to 4 scaled" -io 2 -mf1 ar rl 6 idb -mf2 ar rl 4 idb; desc 1 -tn 4 -sd f; desc 2 -tn 4 -sd l; data 1 -do -1 302042000; data 2 -do -1 303 063; data 3 300 001; page -all; /* dv2d26 * */ inst dv2d -nt "Simple divide" -io 3 -mf1 ar reg idb -mf2 ar reg idb; desc 1 -sd n -nn 3; desc 2 -sd n -nn 4; data 1 -do -1 "060"; data 2 -do -3 "0120"; data 3 "0002"; page -all; /* csl 1 * * Simple test of instruction to see if its functions. * Move 72 bits, cross no boundaries, and use no modification. * */ inst csl -nt "simple test" -bo mov ; desc 1 -ns 72 ; desc 2 -ns 72 ; data 1 -do -8 "abcdefgh" ; data 2 -do -8 "wwwwwwww" ; data 3 "abcdefgh" ; page -all ; /* csl 2 * * Move two bits one on each side of a page boundary. * No modification is used. * */ inst csl -nt "invert 2 bits across boundary" -bo inv ; desc 1 -ns 2 -cp 3 -bp 8 ; desc 2 -ns 2 -cp 3 -bp 8 ; data 1 -do 4 000 000 000 001 000 ; data 2 -do 4 000 000 000 001 000 ; data 3 000 000 000 000 400 ; page -all ; /* csl 3 * * Test moving data across 3 pages. This requires register * length modification. * */ inst csl -nt "move data across 3 pages" -bo mov -io 1 -mf1 rl 36946 -mf2 rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 006 (513) 146531265234623214653126 760 ; page -all ; /* csl 4 * * AND bit strings using ar and reg modification in addition to * reg length modification. Use data across 3 pages. * */ inst csl -nt "ar,reg mod. AND across 3 pages" -bo and -io 2 -mf1 ar reg rl 36946 -mf2 ar reg rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 006 (513) 044111044210421004411104 600 ; page -all ; /* csl 5 * * OR bit strings using indirect modification in addition to register * length modification. Use data across 3 pages. * */ inst csl -nt "id mod. OR across 3 pages" -bo or -io 1 -mf1 id rl 36946 -mf2 id rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 037 (513) 356735677336667356757336 760 ; page -all ; /* csl 6 * * NAND bit strings using indirect ar and reg modification and * reg length modification. Use data across 3 pages. * */ inst csl -nt "idb mod. NAND across 3 pages" -bo nan -mf1 idb rl 36946 -mf2 idb rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 031 (513) 733666733567356773366673 160 ; page -all ; /* csl 7 * * XOR bit strings using indirect ar and reg modification and direct * ar, reg, and register length modification. User data across 3 pages. * */ inst csl -nt "idb,ar,reg mod. XOR across 3 pgs" -bo xor -io 2 -mf1 idb ar reg rl 36946 -mf2 idb ar reg rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 031 (513) 312624633126246352346232 160 ; page -all ; /* csl 8 * * Test bit string CLEAR operator. Data is moved across 3 pages with * full address modification. The zero indicator will be set. * */ inst csl -nt "CLEAR string. 3 pages moved" -bo zer -ir zr -io 3 -mf1 idb ar reg rl 36946 -mf2 rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 000 (513) 000000000000000000000000 000 ; page -all ; /* csl 9 * * Test truncation with INVERT operator. Use full modification * and move data across 3 pages. * */ inst csl -nt "INVERT truncation is set" -bo inv -ir tn -io 1 -mf1 idb ar reg rl 36946 -mf2 idb ar reg rl 36943 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 700 ; data 3 000 000 000 031 (513) 631246512543154563124651 100 ; page -all ; /* csl 10 * * Test the use of bit file with the COINcidence operator. Use full * modification across 3 pages. The fill bit is zero. * */ inst csl -nt "COIN. bit fill(0)" -bo nox -mf1 idb ar reg rl 36943 -mf2 idb ar reg rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 006 (513) 465153144651531425431545 760 ; page -all ; /* csr 1 * * Simple test of instruction to see if its functions. * Move 72 bits, cross no boundaries, and use no modification. * */ inst csr -nt "simple test" -bo mov ; desc 1 -ns 72 ; desc 2 -ns 72 ; data 1 -do -8 "abcdefgh" ; data 2 -do -8 "wwwwwwww" ; data 3 "abcdefgh" ; page -all ; /* csr 2 * * Move two bits one on each side of a page boundary. * No modification is used. * */ inst csr -nt "invert 2 bits across boundary" -bo inv ; desc 1 -ns 2 -cp 3 -bp 8 ; desc 2 -ns 2 -cp 3 -bp 8 ; data 1 -do 4 000 000 000 001 000 ; data 2 -do 4 000 000 000 001 000 ; data 3 000 000 000 000 400 ; page -all ; /* csr 3 * * Test moving data across 3 pages. This requires register * length modification. * */ inst csr -nt "move data across 3 pages" -bo mov -io 1 -mf1 rl 36946 -mf2 rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 006 (513) 146531265234623214653126 760 ; page -all ; /* csr 4 * * AND bit strings using ar and reg modification in addition to * reg length modification. Use data across 3 pages. * */ inst csr -nt "ar,reg mod. AND across 3 pages" -bo and -io 2 -mf1 ar reg rl 36946 -mf2 ar reg rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 006 (513) 044111044210421004411104 600 ; page -all ; /* csr 5 * * OR bit strings using indirect modification in addition to register * length modification. Use data across 3 pages. * */ inst csr -nt "id mod. OR across 3 pages" -bo or -io 1 -mf1 id rl 36946 -mf2 id rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 037 (513) 356735677336667356757336 760 ; page -all ; /* csr 6 * NAND bit strings using indirect ar and reg modification and * reg length modification. Use data across 3 pages. * */ inst csr -nt "idb mod. NAND across 3 pages" -bo nan -mf1 idb rl 36946 -mf2 idb rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 031 (513) 733666733567356773366673 160 ; page -all ; /* csr 7 * * XOR bit strings using indirect ar and reg modification and direct * ar, reg, and register length modification. User data across 3 pages. * */ inst csr -nt "idb,ar,reg mod. XOR across 3 pgs" -bo xor -io 2 -mf1 idb ar reg rl 36946 -mf2 idb ar reg rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 031 (513) 312624633126246352346232 160 ; page -all ; /* csr 8 * * Test bit string CLEAR operator. Data is moved across 3 pages with * full address modification. The zero indicator will be set. * */ inst csr -nt "CLEAR string. 3 pages moved" -bo zer -ir zr -io 3 -mf1 idb ar reg rl 36946 -mf2 rl 36946 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 000 (513) 000000000000000000000000 000 ; page -all ; /* csr 9 * * Test truncation with INVERT operator. Use full modification * and move data across 3 pages. * */ inst csr -nt "INVERT truncation is set" -bo inv -ir tn -io 1 -mf1 idb ar reg rl 36946 -mf2 idb ar reg rl 36943 ; desc 1 -cp 3 -bp 4 ; desc 2 -cp 3 -bp 7 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 700 ; data 3 000 000 000 035 (513) 631246512543154563124651 000 ; page -all ; /* csr 10 * * Test the use of bit file with the COINcidence operator. Use full * modification across 3 pages. The fill bit is zero. * */ inst csr -nt "COIN. bit fill(0)" -bo nox -mf1 idb ar reg rl 36943 -mf2 idb ar reg rl 36946 ; desc 1 -cp 3 -bp 7 ; desc 2 -cp 3 -bp 4 ; data 1 -do -8 000 000 000 006 (513) 146531265234623214653126 760 ; data 2 -do -8 000 000 000 037 (513) 254315456312465146515314 600 ; data 3 000 000 000 002 (513) 465153144651531425431545 600 ; page -all ; /* sztl1 * Use two maximum length strings (4352 chrs or 39168 bits). * The zero indicator will be on since a bool code of "zer" * is used. Take maximum number of page faults. */ inst sztl -nt "Both strings are the same length" -bo zer -ir zr -mf1 idb ar reg rl 39168 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -10 (4352)"5"; data 2 -do -30 (4352)"7"; page -all; /* sztl2 * Both the truncation and the zero indicators will be turned * on. The 1st string will begin on the last bit of a page and * the 2nd string will end on the 1st bit of a page. */ inst sztl -nt "Both strings cross page bounds" -bo zer -ir tn zr -mf1 ar -mf2 ar; desc 1 -bp 8 -ns 23; desc 2 -bp 1 -ns 18; data 1 -do -1 074 321 64; data 2 -do -4 023 776 4; page -all; /* sztl3 * No indicators are turned on. The zero fill bit is used. Bit strings * begin in the middle of a byte */ inst sztl -nt "Both strings cross page bounds" -bo and -mf1 ida ar -mf2 idb ar; desc 1 -bp 4 -ns 70; desc 2 -bp 5 -ns 80; data 1 -do -2 "3274" "1958" 0; data 2 -do -4 "4875" "7329" 326 0; page -all; /* sztl4 * The zero indicator will be turned on. Both strings are of the same length and begin and end on word boundaries. */ inst sztl -nt "only rl modification is used" -bo and -ir zr -mf1 rl 144 -mf2 rl 144 -io 2; data 1 (4)123 (12)075; data 2 (4)654 (12)402; page -all; /* sztl5 * Test the axr bool code. Set the zero and truncation * indicators. Bit strings begin in the middle of a byte * straddling a page boundary. */ inst sztl -nt "1st string is longer than 2nd" -bo axr -ir zr tn -mf1 ar reg rl 40 -mf2 ar idr rl 31; desc 1 -bp 5; desc 2 -bp 5; data 1 -do -1 074 321 652 403 777; data 2 -do -3 777 777 676 603; page -all; /* sztl6 * Test the axr bool code. No indicators will be set */ inst sztl -nt "Both strings are the same length" -bo axr -mf1 rl 7866 -mf2 rl 7866; data 1 (874)"321"; data 2 (874) "604"; page -all; /* sztl7 * Test the mov bool code. Use a maximum length string and the * zero fill bit. Take the maximum number of page faults. */ inst sztl -nt "2nd string is longer than 1st" -bo mov -mf1 ida ar rl 36000 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -40 (1000)"9874"; data 2 -do -20 (1088) "0000"; page -all; /* sztl8 * Test the move bool code. Set the zero indicator. * The first string is all zeroes. */ inst sztl -nt "2nd string is longer than 1st" -bo mov -ir zr -mf1 ar id -mf2 ar -io 2; desc 1 -bp 7 -ns 99; desc 2 -bp 1 -ns 100; data 1 -do 20 (12)000; data 2 -do 3 "abcde123456" 4; page -all; /* sztl9 * Test xra bool code. Set zero and truncation indicators. * Use two short bit strings which cross page boundaries. */ inst sztl -nt "1st string is longer than 2nd" -bo xra -ir tn zr -mf1 ar idr -mf2 ar idb; desc 1 -ns 3 -bp 7; desc 2 -ns 2 -bp 8; data 1 -do -1 777 4; data 2 -do -1 235 0; page -all; /* sztl10 * Test xra bool code. Use the zero fill bit. No indicators are set */ inst sztl -nt "2nd string is longer than 1st" -bo xra -mf1 idr reg -mf2 idr -io 2; desc 1 -ns 400; desc 2 -ns 500; data 1 (44)"9" 72; data 2 (55)"8" 36; page -all; /* sztl11 * Test ra2 bool code. Set the zero indicator. This means * that the 2nd bit string must be all zeroes. */ inst sztl -nt "2nd string is longer than 1st" -bo ra2 -mf1 ar rl 36 -mf2 reg -ir zr -io 1; desc 1 -bp 4; desc 2 -ns 36; data 1 -do -1 "abcd" 70; data 2 (4)000; page -all; /* sztl12 * Test ra2 bool code. No indicators are set. */ inst sztl -nt "Both strings are the same length" -bo ra2 -mf1 reg -mf2 ar rl 36 -io 2; desc 1 -ns 36; desc 2 -bp 4; data 1 (4)000; data 2 -do -1 "abcd" 70; page -all; /* sztl13 * Test xor bool code. Set the zero indicator. Use zero fill. */ inst sztl -nt "2nd string is longer than 1st" -bo xor -mf1 id reg -mf2 ar; desc 1 -ns 3600; desc 2 -ns 3672 -bp 7; data 1 -do -8 (100)3526; data 2 -do -63 000 (100)7254 (7)000; page -all; /* sztl14 * Test xor bool code. use strings of identical length. * No indicators are set. */ inst sztl -nt "Both strings are the same length" -bo xor; desc 1 -ns 900; desc 2 -ns 900; data 1 -do -12 (10) "abcdefghij"; data 2 -do -4 (10) "1234567890"; page -all; /* sztl15 * Test the or bool code. Set zero and truncation indicators. * This means that both bit strings must be all zeroes. The * first bit string must be longer than the second */ inst sztl -nt "1st string is longer than 2nd" -bo or -ir zr tn -mf1 rl 30 idb ar -mf2 rl 20 ar ida; data 1 000 000 000 0; data 2 000 000 0; page -all; /* sztl16 * Test the or bool code. No indicators are set. * The one fill bit is used. */ inst sztl -nt "2nd string is longer than 1st" -bo or -fb -mf1 rl 3000 ar id -mf2 rl 3900 ar idr -io 1; data 1 (1000)7; data 2 (325)"x" (325)3 ; page -all; /* sztl17 * Test the nor bool code. No indicators are set. */ inst sztl -nt "2nd string is longer than 1st" -bo nor -mf1 ida ar rl 14 -mf2 id ar rl 28 -io 2; data 1 342 22; data 2 234 760 621 0; page -all; /* sztl18 * Test the nor bool code. Set the zero indicator. * Use the one fill bit */ inst sztl -nt "2nd string is longer than 1st" -ir zr -bo nor -fb -mf1 ar -mf2 rl 19; desc 1 -ns 8 -bp 1; data 1 777; data 2 326 417 0; page -all; /* sztl19 * Test the nox bool code. Set the zero indicator. * For the indicator to be set, no two bits may matc. */ inst sztl -nt "Both strings are the same length" -ir zr -bo nox -mf1 id -mf2 ida; desc 1 -ns 54; desc 2 -ns 54; data 1 124 235 647 211 000 777; data 2 -do -4 653 542 130 566 777 000; page -all; /* sztl20 * Test the Nox bool code. Only the truncation indicator is set. */ inst sztl -nt "1st string is longer than 2nd" -bo nox -ir tn -mf1 ar rl 36000 -mf2 ar id -io 1; desc 1 -bp 7; desc 2 -bp 3 -ns 3600; data 1 003 (1000)"axyr"; data 2 024 (100)"rjqf"; page -all; /* sztl21 * Test the iv2 bool code. Both the zero and the truncation * indicators will be set. For the zero indicator to be set, * the 2nd bit string must be all ones. */ inst sztl -nt "1st string is longer than 2nd" -bo iv2 -ir zr tn -mf1 rl 64 ar reg -mf2 ar id -io 1; desc 1 -bp 6; desc 2 -ns 32 -bp 3; data 1 -do -1 "abpstuv" 4; data 2 077 777 777 776; page -all; /* sztl22 * Test the iv2 bool code. Use the zero fill bit. No indicators are set. */ inst sztl -nt "2nd string is longer than 1st" -bo iv2 -mf1 ar id -mf2 rl 64 ar reg -io 1; desc 1 -ns 32 -bp 3; desc 2 -bp 6; data 1 077 777 777 776; data 2 -do -1 "abpstuv" 4; page -all; /* sztl23 * Test the xrx bool code. The zero indicator will be set. * This can occur only when every bit in the first string is zero * and every bit in the 2nd string is one. */ inst sztl -nt "Both strings are the same length" -bo xrx -ir zr -mf1 reg -mf2 id; desc 1 -ns 108; desc 2 -ns 108; data 1 -do -4 (12)000; data 2 -do 4 (12)777; page -all; /* sztl24 * Test the xrx bool code. No indicators are set. The zero fill bit is used */ inst sztl -nt "2nd string is longer than 1st" -bo xrx -mf1 rl 720 idr ar -mf2 id -io 2; desc 2 -ns 1080 -bp 4; data 1 -do -3 (20)"ijkl"; data 2 -do 8 054 (30)"9832"; page -all; /* sztl25 * Test the inv bool code. Set the zero indicator. * To set the indicator, the first bit string must be * all ones. */ inst sztl -nt "Both string are the same length" -ir zr -bo inv -mf1 idb ar reg -mf2 idb ar; desc 1 -bp 5 -ns 13; desc 2 -bp 2 -ns 13; data 1 777 777; data 2 265 43; page -all; /* sztl26 * Test the inv bool code. No indicators are set */ inst sztl -nt "Both strings are the same length" -bo inv -mf1 idb ar -mf2 idb ar reg; desc 1 -bp 2 -ns 13; desc 2 -bp 5 -ns 13; data 1 265 43; data 2 777 777; page -all; /* sztl27 * Test the xxr bool code. This test sets the zero indicator. * The zero indicator is set only when the 1st string is all ones and * the second string is all zeroes. The one fill bit is used. */ inst sztl -nt "2nd string is longer than 1st" -ir zr -fb -bo xxr -io2; desc 1 -ns 1; desc 2 -ns 2; data 1 4; data 2 0; page -all; /* sztl28 * Test the xxr bool code. No indicators are set */ inst sztl -nt "2nd string is longer than 1st" -bo xxr -mf1 ar -mf2 reg rl 59; desc 1 -ns 43 -bp 5; data 1 -do -2 "tsrkv" 3; data 2 -do -4 "mnopqrs"; page -all; /* sztl29 * Test the nan bool code. The zero and truncation indicators * are set. For the zero indicator to be set, both bit strings * must be all ones. */ inst sztl -nt "1st string is longer than 2nd" -bo nan -ir zr tn -mf1 rl 39168 ar -mf2 rl 33000; data 1 (4352)777; data 2 (3667)777; page -all; /* sztl30 * Test the nan bool code. No indicators are set. * The one fill bit is set. */ inst sztl -nt "2nd string is longer than 1st" -fb -bo nan -mf1 ar -mf2 ar rl 436; desc 1 -bp 3 -ns 274; data 1 (7)"tack" "rgm"; data 2 (12)"mike" 023; page -all; /* sztl31 * Test the "set" bool code. The zero indicator cannot be set * when the "set" code is used. This test sets the truncation indicator. */ inst sztl -nt "1st string is longer than 2nd" -ir tn -bo set; desc 1 -ns 50; desc 2 -ns 49; data 1 023 571 725 152 111 243; data 2 023 571 777 043 121 000; page -all; /* sztl32 * Test the "set" bool code. No indicators are set. * The maximum number of page faults is taken */ inst sztl -nt "2nd string is longer than 1st" -bo set -mf1 idb ar reg rl 39159 -mf2 idb ar reg rl 39168 -io 1 -fb; data 1 (4351)000; data 2 (4352)071; page -all; /* sztr1 * Use two maximum length strings (4352 chrs or 39168 bits). * The zero indicator will be on since a bool code of "zer" * is used. Take maximum number of page faults. */ inst sztr -nt "Both strings are the same length" -bo zer -ir zr -mf1 idb ar reg rl 39168 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -10 (4352)"5"; data 2 -do -30 (4352)"7"; page -all; /* sztr2 * Both the truncation and the zero indicators will be turned * on. The 1st string will begin on the last bit of a page and * the 2nd string will end on the 1st bit of a page. */ inst sztr -nt "Both strings cross page bounds" -bo zer -ir tn zr -mf1 ar -mf2 ar; desc 1 -bp 8 -ns 23; desc 2 -bp 1 -ns 18; data 1 -do -1 074 321 64; data 2 -do -4 023 776 4; page -all; /* sztr3 * No indicators are turned on. The zero fill bit is used. Bit strings * begin in the middle of a byte */ inst sztr -nt "Both strings cross page bounds" -bo and -mf1 ida ar -mf2 idb ar; desc 1 -bp 4 -ns 70; desc 2 -bp 5 -ns 80; data 1 -do -2 "3274" "1958" 0; data 2 -do -4 "4875" "7329" 326 0; page -all; /* sztr4 * The zero indicator will be turned on. Both strings are of the same length and begin and end on word boundaries. */ inst sztr -nt "only rl modification is used" -bo and -ir zr -mf1 rl 144 -mf2 rl 144 -io 2; data 1 (4)123 (12)075; data 2 (4)654 (12)402; page -all; /* sztr5 * Test the axr bool code. Set the zero and truncation * indicators. Bit strings begin in the middle of a byte * straddling a page boundary. */ inst sztr -nt "1st string is longer than 2nd" -bo axr -ir tn -mf1 ar reg rl 40 -mf2 ar idr rl 31; desc 1 -bp 5; desc 2 -bp 5; data 1 -do -1 074 321 652 403 777; data 2 -do -3 777 777 676 603; page -all; /* sztr6 * Test the axr bool code. No indicators will be set */ inst sztr -nt "Both strings are the same length" -bo axr -mf1 rl 7866 -mf2 rl 7866; data 1 (874)"321"; data 2 (874) "604"; page -all; /* sztr7 * Test the mov bool code. Use a maximum length string and the * zero fill bit. Take the maximum number of page faults. */ inst sztr -nt "2nd string is longer than 1st" -bo mov -mf1 ida ar rl 36000 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -40 (1000)"9874"; data 2 -do -20 (1088) "0000"; page -all; /* sztr8 * Test the move bool code. Set the zero indicator. * The first string is all zeroes. */ inst sztr -nt "2nd string is longer than 1st" -bo mov -ir zr -mf1 ar id -mf2 ar -io 2; desc 1 -bp 7 -ns 99; desc 2 -bp 1 -ns 100; data 1 -do 20 (12)000; data 2 -do 3 "abcde123456" 4; page -all; /* sztr9 * Test xra bool code. Set zero and truncation indicators. * Use two short bit strings which cross page boundaries. */ inst sztr -nt "1st string is longer than 2nd" -bo xra -ir tn zr -mf1 ar idr -mf2 ar idb; desc 1 -ns 3 -bp 7; desc 2 -ns 2 -bp 8; data 1 -do -1 777 4; data 2 -do -1 235 0; page -all; /* sztr10 * Test xra bool code. Use the zero fill bit. No indicators are set */ inst sztr -nt "2nd string is longer than 1st" -bo xra -mf1 idr reg -mf2 idr -io 2; desc 1 -ns 400; desc 2 -ns 500; data 1 (44)"9" 72; data 2 (55)"8" 36; page -all; /* sztr11 * Test ra2 bool code. Set the zero indicator. This means * that the 2nd bit string must be all zeroes. */ inst sztr -nt "2nd string is longer than 1st" -bo ra2 -mf1 ar rl 36 -mf2 reg -ir zr -io 1; desc 1 -bp 4; desc 2 -ns 36; data 1 -do -1 "abcd" 70; data 2 (4)000; page -all; /* sztr12 * Test ra2 bool code. No indicators are set. */ inst sztr -nt "Both strings are the same length" -bo ra2 -mf1 reg -mf2 ar rl 36 -io 2; desc 1 -ns 36; desc 2 -bp 4; data 1 (4)000; data 2 -do -1 "abcd" 70; page -all; /* sztr13 * Test xor bool code. Set the zero indicator. Use zero fill. */ inst sztr -nt "2nd string is longer than 1st" -bo xor -mf1 id reg -mf2 ar; desc 1 -ns 3600; desc 2 -ns 3672 -bp 7; data 1 -do -8 (100)3526; data 2 -do -63 000 (100)7254 (7)000; page -all; /* sztr14 * Test xor bool code. use strings of identical length. * No indicators are set. */ inst sztr -nt "Both strings are the same length" -bo xor; desc 1 -ns 900; desc 2 -ns 900; data 1 -do -12 (10) "abcdefghij"; data 2 -do -4 (10) "1234567890"; page -all; /* sztr15 * Test the or bool code. Set zero and truncation indicators. * This means that both bit strings must be all zeroes. The * first bit string must be longer than the second */ inst sztr -nt "1st string is longer than 2nd" -bo or -ir zr tn -mf1 rl 30 idb ar -mf2 rl 20 ar ida; data 1 000 000 000 0; data 2 000 000 0; page -all; /* sztr16 * Test the or bool code. No indicators are set. * The one fill bit is used. */ inst sztr -nt "2nd string is longer than 1st" -bo or -fb -mf1 rl 3000 ar id -mf2 rl 3900 ar idr -io 1; data 1 (1000)7; data 2 (325)"x" (325)3 ; page -all; /* sztr17 * Test the nor bool code. No indicators are set. */ inst sztr -nt "2nd string is longer than 1st" -bo nor -mf1 ida ar rl 14 -mf2 id ar rl 28 -io 2; data 1 342 22; data 2 234 760 621 0; page -all; /* sztr18 * Test the nor bool code. Set the zero indicator. * Use the one fill bit */ inst sztr -nt "2nd string is longer than 1st" -ir zr -bo nor -fb -mf1 ar -mf2 rl 19; desc 1 -ns 8 -bp 1; data 1 777; data 2 326 417 0; page -all; /* sztr19 * Test the nox bool code. Set the zero indicator. * For the indicator to be set, no two bits may matc. */ inst sztr -nt "Both strings are the same length" -ir zr -bo nox -mf1 id -mf2 ida; desc 1 -ns 54; desc 2 -ns 54; data 1 124 235 647 211 000 777; data 2 -do -4 653 542 130 566 777 000; page -all; /* sztr20 * Test the Nox bool code. Only the truncation indicator is set. */ inst sztr -nt "1st string is longer than 2nd" -bo nox -ir tn -mf1 ar rl 36000 -mf2 ar id -io 1; desc 1 -bp 7; desc 2 -bp 3 -ns 3600; data 1 003 (1000)"axyr"; data 2 024 (100)"rjqf"; page -all; /* sztr21 * Test the iv2 bool code. Both the zero and the truncation * indicators will be set. For the zero indicator to be set, * the 2nd bit string must be all ones. */ inst sztr -nt "1st string is longer than 2nd" -bo iv2 -ir zr tn -mf1 rl 64 ar reg -mf2 ar id -io 1; desc 1 -bp 6; desc 2 -ns 32 -bp 3; data 1 -do -1 "abpstuv" 4; data 2 077 777 777 776; page -all; /* sztr22 * Test the iv2 bool code. Use the zero fill bit. No indicators are set. */ inst sztr -nt "2nd string is longer than 1st" -bo iv2 -mf1 ar id -mf2 rl 64 ar reg -io 1; desc 1 -ns 32 -bp 3; desc 2 -bp 6; data 1 077 777 777 776; data 2 -do -1 "abpstuv" 4; page -all; /* sztr23 * Test the xrx bool code. The zero indicator will be set. * This can occur only when every bit in the first string is zero * and every bit in the 2nd string is one. */ inst sztr -nt "Both strings are the same length" -bo xrx -ir zr -mf1 reg -mf2 id; desc 1 -ns 108; desc 2 -ns 108; data 1 -do -4 (12)000; data 2 -do 4 (12)777; page -all; /* sztr24 * Test the xrx bool code. No indicators are set. The zero fill bit is used */ inst sztr -nt "2nd string is longer than 1st" -bo xrx -mf1 rl 720 idr ar -mf2 id -io 2; desc 2 -ns 1080 -bp 4; data 1 -do -3 (20)"ijkl"; data 2 -do 8 054 (30)"9832"; page -all; /* sztr25 * Test the inv bool code. Set the zero indicator. * To set the indicator, the first bit string must be * all ones. */ inst sztr -nt "Both string are the same length" -ir zr -bo inv -mf1 idb ar reg -mf2 idb ar; desc 1 -bp 5 -ns 13; desc 2 -bp 2 -ns 13; data 1 777 777; data 2 265 43; page -all; /* sztr26 * Test the inv bool code. No indicators are set */ inst sztr -nt "Both strings are the same length" -bo inv -mf1 idb ar -mf2 idb ar reg; desc 1 -bp 2 -ns 13; desc 2 -bp 5 -ns 13; data 1 265 43; data 2 777 777; page -all; /* sztr27 * Test the xxr bool code. This test sets the zero indicator. * The zero indicator is set only when the 1st string is all ones and * the second string is all zeroes. The one fill bit is used. */ inst sztr -nt "2nd string is longer than 1st" -ir zr -fb -bo xxr -io2; desc 1 -ns 1; desc 2 -ns 2; data 1 4; data 2 0; page -all; /* sztr28 * Test the xxr bool code. No indicators are set */ inst sztr -nt "2nd string is longer than 1st" -bo xxr -mf1 ar -mf2 reg rl 59; desc 1 -ns 43 -bp 5; data 1 -do -2 "tsrkv" 3; data 2 -do -4 "mnopqrs"; page -all; /* sztr29 * Test the nan bool code. The zero and truncation indicators * are set. For the zero indicator to be set, both bit strings * must be all ones. */ inst sztr -nt "1st string is longer than 2nd" -bo nan -ir zr tn -mf1 rl 39168 ar -mf2 rl 33000; data 1 (4352)777; data 2 (3667)777; page -all; /* sztr30 * Test the nan bool code. No indicators are set. * The one fill bit is set. */ inst sztr -nt "2nd string is longer than 1st" -fb -bo nan -mf1 ar -mf2 ar rl 436; desc 1 -bp 3 -ns 274; data 1 (7)"tack" "rgm"; data 2 (12)"mike" 023; page -all; /* sztr31 * Test the "set" bool code. The zero indicator cannot be set * when the "set" code is used. This test sets the truncation indicator. */ inst sztr -nt "1st string is longer than 2nd" -ir tn -bo set; desc 1 -ns 50; desc 2 -ns 49; data 1 023 571 725 152 111 243; data 2 023 571 777 043 121 000; page -all; /* sztr32 * Test the "set" bool code. No indicators are set. * The maximum number of page faults is taken */ inst sztr -nt "2nd string is longer than 1st" -bo set -mf1 idb ar reg rl 39159 -mf2 idb ar reg rl 39168 -io 1 -fb; data 1 (4351)000; data 2 (4352)071; page -all; /* cmpb1 * Use two maximum length strings (4352 chrs or 39168 bits) * with the first string less than the 2nd. Take the maximum * number of page faults. */ inst cmpb -nt "both strings cross page bounds" -mf1 idb ar reg rl 39168 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -10 (4352)"5"; data 2 -do -30 (4352)"7"; page -all; /* cmpb2 * The first string begins on the last bit of a page and the * 2nd string ends on the first bit of a page. The first string is * greater than the 2nd. */ inst cmpb -nt "both strings cross page bounds" -ir cr -mf1 ar -mf2 ar; desc 1 -bp 8 -ns 23; desc 2 -bp 1 -ns 18; data 1 -do -1 074 321 64; data 2 -do -4 023 776 4; page -all; /* cmpb3 * Both strings begin in the middle of a byte and span page boundaries. * The first string is greater than the 2nd. */ inst cmpb -nt "both strings cross page bounds" -ir cr -mf1 ida ar -mf2 idb ar; desc 1 -bp 4 -ns 70; desc 2 -bp 5 -ns 80; data 1 -do -2 "3274" "1958" 0; data 2 -do -4 "4875" "7329" 326 0; page -all; /* cmpb4 * Both strings are 4 words in length and neither string spans a page boundary. The first string is * less than the 2nd. */ inst cmpb -nt "both strings are the same length" -mf1 rl 144 -mf2 rl 144 -io 2; data 1 (4)123 (12)075; data 2 (4)654 (12)402; page -all; /* cmpb5 * Both strings begin in the middle of a byte and span a * page boundary. The first string is less than the 2nd. */ inst cmpb -nt "2nd string has indirect desc" -mf1 ar reg rl 40 -mf2 ar idr rl 31; desc 1 -bp 5; desc 2 -bp 5; data 1 -do -1 074 321 652 403 777; data 2 -do -3 777 777 676 603; page -all; /* cmpb6 * Both strings are 874 bytes in length and the first string * is less than the 2nd. Only 3 page faults occur. */ inst cmpb -nt "both strings are the same length" -mf1 rl 7866 -mf2 rl 7866; data 1 (874)"321"; data 2 (874) "604"; page -all; /* cmpb7 * The first string is l000 words in length and the * 2nd string is 1088 words of all zeroes. The first * string is greater than the 2nd. */ inst cmpb -nt "both strings cross page bounds" -ir cr -mf1 ida ar rl 36000 -mf2 idb ar reg rl 39168 -io 1; data 1 -do -40 (1000)"9874"; data 2 -do -20 (1088) "0000"; page -all; /* cmpb8 * Both strings begin in the middle of a byte and * neither string spans a page boundary. The first string is less * than the 2nd. */ inst cmpb -nt "2nd string is longer than 1st" -mf1 ar id -mf2 ar -io 2; desc 1 -bp 7 -ns 99; desc 2 -bp 1 -ns 100; data 1 -do 20 (12)000; data 2 -do 3 "abcde123456" 4; page -all; /* cmpb9 * Both strings begin in the middle of a byte and span pages. * The first string is all ones and is greater than the 2nd. */ inst cmpb -nt "1st string is longer than 2nd" -ir cr -mf1 ar idr -mf2 ar idb; desc 1 -ns 3 -bp 7; desc 2 -ns 2 -bp 8; data 1 -do -1 777 4; data 2 -do -1 235 0; page -all; /* cmpb10 * The first string is greater than the 2nd, although it is shorter in length. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -mf1 idr reg -mf2 idr -io 2; desc 1 -ns 400; desc 2 -ns 500; data 1 (44)"9" 72; data 2 (55)"8" 36; page -all; /* cmpb11 * Both strings are 1 word in length and only the 1st * string spans a page boundary. The first string is greater * than the 2nd. */ inst cmpb -nt "2nd string is longer than 1st" -mf1 ar rl 36 -mf2 reg -ir cr -io 1; desc 1 -bp 4; desc 2 -ns 36; data 1 -do -1 "abcd" 70; data 2 (4)000; page -all; /* cmpb12 * Both strings are 1 word in length and only * the 2nd string spans a page boundary. The 2nd string * is greater than the first. */ inst cmpb -nt "both strings are the same length" -mf1 reg -mf2 ar rl 36 -io 2; desc 1 -ns 36; desc 2 -bp 4; data 1 (4)000; data 2 -do -1 "abcd" 70; page -all; /* cmpb13 * The first string is 100 words in length and the 2nd string is 102 words long. Both strings span a page and the first string is greater than the 2nd. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -mf1 id reg -mf2 ar; desc 1 -ns 3600; desc 2 -ns 3672 -bp 7; data 1 -do -8 (100)3526; data 2 -do -63 000 (100)7254 (7)000; page -all; /* cmpb14 * Both strings are 100 bytes long and span a page. The first string is larger than the 2nd. */ inst cmpb -nt "both strings are the same length" -ir cr; desc 1 -ns 900; desc 2 -ns 900; data 1 -do -12 (10) "abcdefghij"; data 2 -do -4 (10) "1234567890"; page -all; /* cmpb15 * Both strings are all zeroes and thus they are equal. */ inst cmpb -nt "1st string is longer than 2nd" -ir cr zr -mf1 rl 30 idb ar -mf2 rl 20 ar ida; data 1 000 000 000 0; data 2 000 000 0; page -all; /* cmpb16 * The first string is shorter than the 2nd and the one fill bit is used. The first string is all ones and is greater than the 2nd. */ inst cmpb -nt "2nds string is longer than 1st" -ir cr -fb -mf1 rl 3000 ar id -mf2 rl 3900 ar idr -io 1; data 1 (1000)7; data 2 (325)"x" (325)3 ; page -all; /* cmpb17 * The first string is greater than the 2nd although it is shorter in length. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -mf1 ida ar rl 14 -mf2 id ar rl 28 -io 2; data 1 342 22; data 2 234 760 621 0; page -all; /* cmpb18 * The fill bit is used to make the first string all ones. * The first string is greater than the second. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -fb -mf1 ar -mf2 rl 19; desc 1 -ns 8 -bp 1; data 1 777; data 2 326 417 0; page -all; /* cmpb19 * Both strings are 6 bytes in length and the 2nd string * spans a page boundary. The first string is less than the 2nd. */ inst cmpb -nt "both strings are the same length" -mf1 id -mf2 ida; desc 1 -ns 54; desc 2 -ns 54; data 1 124 235 647 211 000 777; data 2 -do -4 653 542 130 566 777 000; page -all; /* cmpb20 * Both strings begin in the middle of a byte. The first * string is 1000 words long while the 2nd string is 100 * words long. The first string is greater than the 2nd. */ inst cmpb -nt "1st string is longer than 2nd" -ir cr -mf1 ar rl 36000 -mf2 ar id -io 1; desc 1 -bp 7; desc 2 -bp 3 -ns 3600; data 1 003 (1000)"axyr"; data 2 024 (100)"rjqf"; page -all; /* cmpb21 * Both strings begin in the middle of a byte and only the first string crosses a page boundary. The 2nd string is all ones and is greater than the first. */ inst cmpb -nt "1st string is longer than 2nd" -mf1 rl 64 ar reg -mf2 ar id -io 1; desc 1 -bp 6; desc 2 -ns 32 -bp 3; data 1 -do -1 "abpstuv" 4; data 2 077 777 777 776; page -all; /* cmpb22 * Both strings begin in the middle of a byte and only the 2nd string crosses a page boundary. The first string is all ones and is greater than the 2nd string. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -mf1 ar id -mf2 rl 64 ar reg -io 1; desc 1 -ns 32 -bp 3; desc 2 -bp 6; data 1 077 777 777 776; data 2 -do -1 "abpstuv" 4; page -all; /* cmpb23 * Both strings are three words in length and the 1st string crosses a page boundary. The 2nd string is greater than the first. */ inst cmpb -nt "both strings are the same length" -mf1 reg -mf2 id; desc 1 -ns 108; desc 2 -ns 108; data 1 -do -4 (12)000; data 2 -do 4 (12)777; page -all; /* cmpb24 * The 1st string is 20 words in length and crosses a page boundary. The 2nd string is 30 words in length and is greater than the 1st. */ inst cmpb -nt "2nd string is longer than 1st" -mf1 rl 720 idr ar -mf2 id -io 2; desc 2 -ns 1080 -bp 4; data 1 -do -3 (20)"ijkl"; data 2 -do 8 054 (30)"9832"; page -all; /* cmpb25 * Both strings begin in the middle of a byte. The first string is all ones and is greater than the 2nd. */ inst cmpb -nt "both strings are the same length" -ir cr -mf1 idb ar reg -mf2 idb ar; desc 1 -bp 5 -ns 13; desc 2 -bp 2 -ns 13; data 1 777 777; data 2 265 43; page -all; /* cmpb26 * Both strings begin in the middle of a byte. The 2nd string is all ones and is greater than the first. */ inst cmpb -nt "both strings are the same length" -mf1 idb ar -mf2 idb ar reg; desc 1 -bp 2 -ns 13; desc 2 -bp 5 -ns 13; data 1 265 43; data 2 777 777; page -all; /* cmpb27 * The first string is one bit in length and the 2nd string is two bits long. The one fill bit is used and the first string is greater. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -fb -io2; desc 1 -ns 1; desc 2 -ns 2; data 1 4; data 2 0; page -all; /* cmpb28 * The 1st string begins in the middle of a byte and both strings cross page boundaries. The first string is greater than the 2nd. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -mf1 ar -mf2 reg rl 59; desc 1 -ns 43 -bp 5; data 1 -do -2 "tsrkv" 3; data 2 -do -4 "mnopqrs"; page -all; /* cmpb29 * Both strings consist of all ones but the first string is longer and the zero fill bit is used. Therefore, the first string is greater than the 2nd. */ inst cmpb -nt "1st string is longer than 2nd" -ir cr -mf1 rl 39168 ar -mf2 rl 33000; data 1 (4352)777; data 2 (3667)777; page -all; /* cmpb30 * The first string starts in the middle of a byte and neither string crosses a page boundary. The first string is greater than the second. */ inst cmpb -nt "2nd string is longer than 1st" -ir cr -fb -mf1 ar -mf2 ar rl 436; desc 1 -bp 3 -ns 274; data 1 (7)"tack" "rgm"; data 2 (12)"mike" 023; page -all; /* cmpb31 * Neither string crosses a page boundary and the first string is less than the 2nd. */ inst cmpb -nt "1st string is longer than 2nd"; desc 1 -ns 50; desc 2 -ns 49; data 1 023 571 725 152 111 243; data 2 023 571 777 043 121 000; page -all; /* cmpb32 * The first string consists of all zeroes and neither string crosses a page boundary. The second string is both longer and greater. */ inst cmpb -nt "2nd string is longer than 1st" -mf1 idb ar reg rl 39159 -mf2 idb ar reg rl 39168 -io 1 -fb; data 1 (4351)000; data 2 (4352)071; page -all; /* dtb1 * Indirect descriptors are used for both operands. * Address register modification is used for both operands. * The decimal operand is split across a page boundary. */ inst dtb -nt "9-bit unsigned decimal -> binary" -mf2 idb ar reg rl 1 -mf1 idb ar reg rl 2 -io 1; desc 1 -sd n; data 2 034; data 1 -do -1 "28"; page -all; /* dtb2 * No indirect descriptors are used. * Address register modification is used for both operands. * Both operands cross a page boundary. */ inst dtb -nt "9-bit leading sign -> binary" -mf2 ar -mf1 ar; desc 2 -nn 2; desc 1 -nn 6 -sd l; data 2 -do -1 127 531; data 1 -do -3 "+44889"; page -all; /* dtb3 * Indirect descriptors are used by both operands. * Address register modification is used for both operands. * Both operands cross a page boundary. */ inst dtb -nt "9-bit trailing sign -> binary" -mf2 ida ar -mf1 idb ar; desc 2 -nn 3; desc 1 -nn 9 -sd t; data 2 -do -2 211 664 372; data 1 -do -4 "36137210+"; page -all; /* dtb4 * No indirect descriptors are used. * No address register modification is used. * The decimal operand is split across a page boundary. * Register length modification is used by both operands. */ inst dtb -nt "9-bit unsigned decimal -> binary" -mf2 rl 4 -mf1 rl 10; desc 1 -sd n; data 2 111 222 333 444; data 1 -do -8 "9836279588"; page -all; /* dtb5 * Address register modification is used by both operands. * An indirect descriptor is used by the decimal operand. * Simple register modification is used by the binary operand. * Register length modification is used by both operands. */ inst dtb -nt "9-bit leading sign -> bim"nary" -mf2 ar reg rl 5 -mf1 ar idr rl 15; desc 1 -sd l; data 2 -do -4 333 444 333 222 111; data 1 -do -12 "+15088814466121"; page -all; /* dtb6 * Address register modification is used by both operands. * An indirect descriptor is used by the binary operand. * Neither operand crosses a page boundary. */ inst dtb -nt "9-bit trailing sign -> binary" -mf2 ar id -mf1 ar; desc 2 -nn 6; desc 1 -nn 17 -sd t; data 2 123 456 765 432 123 456; data 1 "2941123482396462+"; page -all; /* dtb7 * Simple register modification is used by both operands. * An indirect descriptor is used by the decimal operand. * Both operands begin in the middle of a page. * Neither operand spans a page boundary. */ inst dtb -nt "9-bit unsigned decimal -> binary" -mf2 reg -mf1 reg id; desc 2 -nn 7; desc 1 -nn 19 -sd n; data 2 -do 80 321 456 372 415 210 000 000; data 1 -do 60 "3775652184861966336"; page -all; /* dtb8 * Both operands use only simple register modification. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. */ inst dtb -nt "9-bit leading sign -> binary" -mf2 reg -mf1 reg; desc 2 -nn 8; desc 1 -nn 22 -sd l; data 2 124 570 642 000 000 375 125 743; data 1 "+781551372002965892067"; page -all; /* dtb9 * An indirect descriptor is used by the binary operand. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. * The eis instruction itself spans a page boundary. * No modifications are made to the decimal operand. */ inst dtb -nt "4-bit unsigned decimal -> binary" -mf2 id -io 1; desc 2 -nn 1; desc 1 -tn 4 -nn 2 -sd n; data 2 034; data 1 050 000; page -all; /* dtb10 * Address register modification is used for the binary operand. * No modifications are made to the decimal operand. * Both operands span a page boundary. */ inst dtb -nt "4-bit leading sign -> binary" -mf2 ar -io 1; desc 2 -nn 2; desc 1 -tn 4 -nn 6 -sd l; data 2 -do -1 127 531; data 1 -do -4 304110211000 000000; page -all; /* dtb11 * Address register modification is used for the decimal operand. * No modifications are made to the binary operand. * Only the decimal operand spans a page boundary. * The eis instruction itself spans a page boundary. */ inst dtb -nt "4-bit trailing sign -> binary" -mf1 ar -io2; desc 2 -nn 3; desc 1 -tn 4 -nn 9 -sd t; data 2 211 664 372; data 1 -do -8 066023162020 300000000000000; page -all; /* dtb12 * Indirect descriptors are used for both operands. * No address register modification is used. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. * The eis instruction itself spans a page boundary. */ inst dtb -nt "4-bit unsigned decimal -> binary" -mf2 id -mf1 id -io 2; desc 2 -nn 4; desc 1 -tn 4 -nn 10 -sd n; data 2 111 222 333 444; data 1 230066047225 210000000000; page -all; /* dtb13 * No modifications are made to the binary operand. * Address register modification is used for the decimal operand. * An indirect descriptor is used by the decimal operand. * Both operands span a page boundary. */ inst dtb -nt "4-bit leading sign -> binary" -mf1 ar id -io 1; desc 2 -nn 5; desc 1 -tn 4 -nn 15 -sd l; data 2 -do -4 333 444 333 222 111; data 1 -do -8 301120210201 104146022020; page -all; /* dtb14 * Indirect descriptors are used by both operands. * Both operands span a page boundary. */ inst dtb -nt "4-bit trailing sign -> binary" -mf2 idr -mf1 ida; desc 2 -nn 6; desc 1 -tn 4 -nn 17 -sd t; data 2 -do -4 123 456 765 432 123 456; data 1 -do -16 051101022064 202071144142 300; page -all; /* dtb15 * Indirect descriptors are used for both operands. * Address register modification is used for both operands. * Both operands span a page boundary. * The eis instruction itself spans a page boundary. */ inst dtb -nt "4-bit unsigned decimal -> binary" -mf2 id ar -mf1 id ar -io1; desc 2 -nn 7; desc 1 -tn 4 -nn 19 -sd n; data 2 -do -6 321 456 372 415 210 000 000; data 1 -do -1 067165145041 204206031146 063140; page -all; /* dtb16 * Indirect descriptors are used by both operands. * Address register modification is used by both operands. * Neither operand spans a page boundary. * Both operands begin in the middle of a page. */ inst dtb -nt "4-bit leading sign -> binary" -mf2 idb ar -mf1 idb ar; desc 2 -nn 8; desc 1 -tn 4 -nn 22 -sd l; data 2 -do 14 124 570 642 000 000 375 125 743; data 1 -do 100 307201125023162000051145 211040147000; page -all; /* btd1 * Indirect descriptors are used for both operands. * Address register modification is used for both operands. * The decimal operand is split across a page boundary. */ inst btd -nt "binary -> 9-bit unsigned decimal" -mf1 idb ar reg rl 1 -mf2 idb ar reg rl 2 -io 1; desc 2 -sd n; data 1 034; data 2 -do -1 "28"; page -all; /* btd2 * No indirect descriptors are used. * Address register modification is used for both operands. * Both operands cross a page boundary. */ inst btd -nt "binary -> 9-bit leading sign" -mf1 ar -mf2 ar; desc 1 -nn 2; desc 2 -nn 6 -sd l; data 1 -do -1 127 531; data 2 -do -3 "+44889"; page -all; /* btd3 * Indirect descriptors are used by both operands. * Address register modification is used for both operands. * Both operands cross a page boundary. */ inst btd -nt "binary -> 9-bit trailing sign" -mf1 ida ar -mf2 idb ar; desc 1 -nn 3; desc 2 -nn 9 -sd t; data 1 -do -2 211 664 372; data 2 -do -4 "36137210+"; page -all; /* btd4 * No indirect descriptors are used. * No address register modification is used. * The decimal operand is split across a page boundary. * Register length modification is used by both operands. */ inst btd -nt "binary -> 9-bit unsigned decimal" -mf1 rl 4 -mf2 rl 10; desc 2 -sd n; data 1 111 222 333 444; data 2 -do -8 "9836279588"; page -all; /* btd5 * Address register modification is used by both operands. * An indirect descriptor is used by the decimal operand. * Simple register modification is used by the binary operand. * Register length modification is used by both operands. */ inst btd -nt "binary -> 9-bit leading sign" -mf1 ar reg rl 5 -mf2 ar idr rl 15; desc 2 -sd l; data 1 -do -4 333 444 333 222 111; data 2 -do -12 "+15088814466121"; page -all; /* btd6 * Address register modification is used by both operands. * An indirect descriptor is used by the binary operand. * Neither operand crosses a page boundary. */ inst btd -nt "binary -> 9-bit trailing sign" -mf1 ar id -mf2 ar; desc 1 -nn 6; desc 2 -nn 17 -sd t; data 1 123 456 765 432 123 456; data 2 "2941123482396462+"; page -all; /* btd7 * Simple register modification is used by both operands. * An indirect descriptor is used by the decimal operand. * Both operands begin in the middle of a page. * Neither operand spans a page boundary. */ inst btd -nt "binary -> 9-bit unsigned decimal" -mf1 reg -mf2 reg id; desc 1 -nn 7; desc 2 -nn 19 -sd n; data 1 -do 80 321 456 372 415 210 000 000; data 2 -do 60 "3775652184861966336"; page -all; /* btd8 * Both operands use only simple register modification. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. */ inst btd -nt "binary -> 9-bit leading sign" -mf1 reg -mf2 reg; desc 1 -nn 8; desc 2 -nn 22 -sd l; data 1 124 570 642 000 000 375 125 743; data 2 "+781551372002965892067"; page -all; /* btd9 * An indirect descriptor is used by the binary operand. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. * The eis instruction itself spans a page boundary. * No modifications are made to the decimal operand. */ inst btd -nt "binary -> 4-bit unsigned decimal" -mf1 id -io 1; desc 1 -nn 1; desc 2 -tn 4 -nn 2 -sd n; data 1 034; data 2 050 000; page -all; /* btd10 * Address register modification is used for the binary operand. * No modifications are made to the decimal operand. * Both operands span a page boundary. */ inst btd -nt "binary to 4-bit leading sign" -mf1 ar -io 1; desc 1 -nn 2; desc 2 -tn 4 -nn 6 -sd l; data 1 -do -1 127 531; data 2 -do -4 304110211000 000000; page -all; /* btd11 * Address register modification is used for the decimal operand. * No modifications are made to the binary operand. * Only the decimal operand spans a page boundary. * The eis instruction itself spans a page boundary. */ inst btd -nt "binary -> 4-bit trailing sign" -mf2 ar -io2; desc 1 -nn 3; desc 2 -tn 4 -nn 9 -sd t; data 1 211 664 372; data 2 -do -8 066023162020 300000000000000; page -all; /* btd12 * Indirect descriptors are used for both operands. * No address register modification is used. * Neither operand spans a page boundary. * Both operands begin on the 1st byte of a page. * The eis instruction itself spans a page boundary. */ inst btd -nt "binary -> 4-bit unsigned decimal" -mf1 id -mf2 id -io 2; desc 1 -nn 4; desc 2 -tn 4 -nn 10 -sd n; data 1 111 222 333 444; data 2 230066047225 210000000000; page -all; /* btd13 * No modifications are made to the binary operand. * Address register modification is used for the decimal operand. * An indirect descriptor is used by the decimal operand. * Both operands span a page boundary. */ inst btd -nt "binary -> 4-bit leading sign" -mf2 ar id -io 1; desc 1 -nn 5; desc 2 -tn 4 -nn 15 -sd l; data 1 -do -4 333 444 333 222 111; data 2 -do -8 301120210201 104146022020; page -all; /* btd14 * Indirect descriptors are used by both operands. * Both operands span a page boundary. */ inst btd -nt "binary -> 4-bit trailing sign" -mf1 idr -mf2 ida; desc 1 -nn 6; desc 2 -tn 4 -nn 17 -sd t; data 1 -do -4 123 456 765 432 123 456; data 2 -do -16 051101022064 202071144142 300; page -all; /* btd15 * Indirect descriptors are used for both operands. * Address register modification is used for both operands. * Both operands span a page boundary. * The eis instruction itself spans a page boundary. */ inst btd -nt "binary -> 4-bit unsigned decimal" -mf1 id ar -mf2 id ar -io1; desc 1 -nn 7; desc 2 -tn 4 -nn 19 -sd n; data 1 -do -6 321 456 372 415 210 000 000; data 2 -do -1 067165145041 204206031146 063140; page -all; /* btd16 * Indirect descriptors are used by both operands. * Address register modification is used by both operands. * Neither operand spans a page boundary. * Both operands begin in the middle of a page. */ inst btd -nt "binary -> 4-bit leading sign" -mf1 idb ar -mf2 idb ar; desc 1 -nn 8; desc 2 -tn 4 -nn 22 -sd l; data 1 -do 14 124 570 642 000 000 375 125 743; data 2 -do 100 307201125023162000051145 211040147000; page -all;