![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subf.lst CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to subf.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: 1 00000000 LL0: ! 2: 2 00000000 .data ! 3: 3 00000d28 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _subf ! 6: 6 00000000 _subf: ! 7: 7 0000E0A4 0000 .word L215 ! 8: 8 0000E0A6 # ! 9: 9 0000E0A6 # #include "fpp_defs.h" ! 10: 10 0000E0A6 # ! 11: 11 0000E0A6 # ! 12: 12 0000E0A6 # /***************************************************************************** ! 13: 13 0000E0A6 # * ! 14: 14 0000E0A6 # * SUBF - SINGLE PRECISION FLOATING POINT ADD TEST ! 15: 15 0000E0A6 # * ! 16: 16 0000E0A6 # *****************************************************************************/ ! 17: 17 0000E0A6 # subf() ! 18: 18 0000E0A6 # { ! 19: 19 0000E0A6 11 64 jbr L217 ! 20: 20 0000E0A8 L218: ! 21: 21 0000E0A8 # asm(".globl _subf_t"); ! 22: 22 0000E0A8 .globl _subf_t ! 23: 23 0000E0A8 # asm("_subf_t:"); /* entry address */ ! 24: 24 0000E0A8 _subf_t: ! 25: 25 0000E0A8 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 26: 26 0000E0A8 1d effffffff6 01 cmpl _cycle,$1 ! 27: 27 0000E0AF 21 15 jneq L219 ! 28: 28 0000E0B1 5d efffffffed tstl _prt_hdrs ! 29: 29 0000E0B7 31 0d jeql L219 ! 30: 30 0000E0B9 # writes(" SUBF"); ! 31: 31 0000E0B9 .data 1 ! 32: 32 00000d28 * L221: ! 33: 33 00000d28 * 205355424600 .ascii " SUBF\0" ! 34: 34 00000d2e * .text ! 35: 35 0000E0B9 dd 8f00000d28 pushl $L221 ! 36: 36 0000E0BF fe 08 efffffffde callf $8,_writes ! 37: 37 0000E0C6 # subf_1(); /* subract through a register */ ! 38: 38 0000E0C6 L219: ! 39: 39 0000E0C6 fe 04 ef00000041 callf $4,_subf_1 ! 40: 40 0000E0CD # subf_2(); /* subract through the cache */ ! 41: 41 0000E0CD fe 04 ef00000160 callf $4,_subf_2 ! 42: 42 0000E0D4 # subf_3(); /* wait 3 NOPs */ ! 43: 43 0000E0D4 fe 04 ef00000279 callf $4,_subf_3 ! 44: 44 0000E0DB # subf_4(); /* wait 2 NOPs */ ! 45: 45 0000E0DB fe 04 ef00000396 callf $4,_subf_4 ! 46: 46 0000E0E2 # subf_5(); /* wait 1 NOP before storing */ ! 47: 47 0000E0E2 fe 04 ef000004b3 callf $4,_subf_5 ! 48: 48 0000E0E9 # subf_6(); /* register stability test */ ! 49: 49 0000E0E9 fe 04 ef000005ce callf $4,_subf_6 ! 50: 50 0000E0F0 # subf_7(); /* PSL stability test */ ! 51: 51 0000E0F0 fe 04 ef00000777 callf $4,_subf_7 ! 52: 52 0000E0F7 # subf_8(); /* pipelined entry test */ ! 53: 53 0000E0F7 fe 04 ef0000092a callf $4,_subf_8 ! 54: 54 0000E0FE # subf_9(); /* pipelined exit test */ ! 55: 55 0000E0FE fe 04 ef00000a49 callf $4,_subf_9 ! 56: 56 0000E105 # asm("jmp *return"); /* return to the test monitor */ ! 57: 57 0000E105 71 ffffffff99 jmp *return ! 58: 58 0000E10B # } ! 59: 59 0000E10B 40 ret#2 ! 60: 60 0000E10C .set L215,0x0 ! 61: 61 0000E10C L217: ! 62: 62 0000E10C 11 9a jbr L218 ! 63: 63 0000E10E .data ! 64: 64 00000d28 * .text ! 65: 65 0000E10E .align 1 ! 66: 66 0000E10E .globl _subf_1 ! 67: 67 0000E10E _subf_1: ! 68: 68 0000E10E 0000 .word L231 ! 69: 69 0000E110 # ! 70: 70 0000E110 # ! 71: 71 0000E110 # ! 72: 72 0000E110 # /************************************************************************ ! 73: 73 0000E110 # * ! 74: 74 0000E110 # * SUBTEST 1 - subract through a register ! 75: 75 0000E110 # * ! 76: 76 0000E110 # ************************************************************************/ ! 77: 77 0000E110 # subf_1() ! 78: 78 0000E110 # { ! 79: 79 0000E110 13 011e jbr L233 ! 80: 80 0000E113 L234: ! 81: 81 0000E113 # force_loop = FALSE; ! 82: 82 0000E113 4d efffffff8b clrl _force_loop ! 83: 83 0000E119 # subtest = 1; ! 84: 84 0000E119 0d 01 efffffff84 movl $1,_subtest ! 85: 85 0000E120 # for( index = 0; index < max_subf_1_index; index++ ) { ! 86: 86 0000E120 4d efffffff7e clrl _index ! 87: 87 0000E126 L237: ! 88: 88 0000E126 1d efffffff78 efffffff73 cmpl _index,_max_subf_1_index ! 89: 89 0000E131 91 03 13 00fa jgeq L236 ! 90: 90 0000E136 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 91: 91 0000E136 5c 0c efffffff67 50 mull3 $12,_index,r0 ! 92: 92 0000E13E 0d e000000000 efffffff5b movl _subf_1_data(r0),_sgl_ld_acc ! 93: 93 0000E149 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 94: 94 0000E149 5c 0c efffffff54 50 mull3 $12,_index,r0 ! 95: 95 0000E151 0d e000000004 efffffff48 movl _subf_1_data+4(r0),_sgl_value_1 ! 96: 96 0000E15C # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 97: 97 0000E15C 5c 0c efffffff41 50 mull3 $12,_index,r0 ! 98: 98 0000E164 0d e000000008 efffffff35 movl _subf_1_data+8(r0),_sgl_expected ! 99: 99 0000E16F # /* ! 100: 100 0000E16F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 101: 101 0000E16F # * The force loop flag is set after the first error. ! 102: 102 0000E16F # */ ! 103: 103 0000E16F # asm("_subf_1_lp1:"); ! 104: 104 0000E16F _subf_1_lp1: ! 105: 105 0000E16F # asm("movl _sgl_ld_acc,r3"); /* move the 1st data to r3 */ ! 106: 106 0000E16F 0d efffffff2f 53 movl _sgl_ld_acc,r3 ! 107: 107 0000E176 # asm("movl _sgl_value_1,r4"); /* move the 2nd data to r4 */ ! 108: 108 0000E176 0d efffffff28 54 movl _sgl_value_1,r4 ! 109: 109 0000E17D # asm("ldf r3"); /* load the 1st operand */ ! 110: 110 0000E17D 06 53 ldf r3 ! 111: 111 0000E17F # asm("subf r4"); /* subract the 2nd operand */ ! 112: 112 0000E17F d6 54 subf r4 ! 113: 113 0000E181 # asm("stf _sgl_st_acc"); /* store the result */ ! 114: 114 0000E181 26 efffffff1d stf _sgl_st_acc ! 115: 115 0000E187 # if( force_loop ) ! 116: 116 0000E187 5d efffffff17 tstl _force_loop ! 117: 117 0000E18D 31 02 jeql L238 ! 118: 118 0000E18F # asm("brb _subf_1_lp1");; /* loop on the error */ ! 119: 119 0000E18F 11 de brb _subf_1_lp1 ! 120: 120 0000E191 L238: ! 121: 121 0000E191 # /* ! 122: 122 0000E191 # * end error loop - test the results ! 123: 123 0000E191 # */ ! 124: 124 0000E191 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 125: 125 0000E191 1d efffffff0d efffffff08 cmpl _sgl_st_acc,_sgl_expected ! 126: 126 0000E19C 21 03 13 0086 jeql L239 ! 127: 127 0000E1A1 # errcnt++; /* bump the error count */ ! 128: 128 0000E1A1 6d effffffefd incl _errcnt ! 129: 129 0000E1A7 # if( prt_error ) { ! 130: 130 0000E1A7 5d effffffef7 tstl _prt_error ! 131: 131 0000E1AD 31 55 jeql L240 ! 132: 132 0000E1AF # writes(" \n"); /* start a new print line */ ! 133: 133 0000E1AF .data 1 ! 134: 134 00000d2e * L241: ! 135: 135 00000d2e * 200A00 .ascii " \12\0" ! 136: 136 00000d31 * .text ! 137: 137 0000E1AF dd 8f00000d2e pushl $L241 ! 138: 138 0000E1B5 fe 08 effffffee8 callf $8,_writes ! 139: 139 0000E1BC # writes("cycle: "); ! 140: 140 0000E1BC .data 1 ! 141: 141 00000d31 * L242: ! 142: 142 00000d31 * 6379636C653A2000 .ascii "cycle: \0" ! 143: 143 00000d39 * .text ! 144: 144 0000E1BC dd 8f00000d31 pushl $L242 ! 145: 145 0000E1C2 fe 08 effffffedb callf $8,_writes ! 146: 146 0000E1C9 # writed( cycle ); ! 147: 147 0000E1C9 dd effffffed5 pushl _cycle ! 148: 148 0000E1CF fe 08 effffffece callf $8,_writed ! 149: 149 0000E1D6 # writes(" SUBF test "); ! 150: 150 0000E1D6 .data 1 ! 151: 151 00000d39 * L244: ! 152: 152 00000d39 * 2020535542462074657374200 .ascii " SUBF test \0" ! 153: 0 ! 154: 153 00000d46 * .text ! 155: 154 0000E1D6 dd 8f00000d39 pushl $L244 ! 156: 155 0000E1DC fe 08 effffffec1 callf $8,_writes ! 157: 156 0000E1E3 # writed( test_no ); ! 158: 157 0000E1E3 dd effffffebb pushl _test_no ! 159: 158 0000E1E9 fe 08 effffffeb4 callf $8,_writed ! 160: 159 0000E1F0 # writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n"); ! 161: 160 0000E1F0 .data 1 ! 162: 161 00000d46 * L245: ! 163: 162 00000d46 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL ACC\12\0" ! 164: 85265672E204461746129202D ! 165: 204241442046494E414C20414 ! 166: 3430A00 ! 167: 163 00000d6f * .text ! 168: 164 0000E1F0 dd 8f00000d46 pushl $L245 ! 169: 165 0000E1F6 fe 08 effffffea7 callf $8,_writes ! 170: 166 0000E1FD # print_subf_data(); ! 171: 167 0000E1FD fe 04 ef00000a70 callf $4,_print_subf_data ! 172: 168 0000E204 # } ! 173: 169 0000E204 # if( halt_flg ) ! 174: 170 0000E204 L240: ! 175: 171 0000E204 5d effffffe9a tstl _halt_flg ! 176: 172 0000E20A 31 09 jeql L247 ! 177: 173 0000E20C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 178: 174 0000E20C dd 01 pushl $1 ! 179: 175 0000E20E fe 08 ef00000afd callf $8,_subf_er_halt ! 180: 176 0000E215 # if( loop_on_err ) { ! 181: 177 0000E215 L247: ! 182: 178 0000E215 5d effffffe89 tstl _loop_on_err ! 183: 179 0000E21B 31 0a jeql L249 ! 184: 180 0000E21D # force_loop = TRUE; /* set the force loop flag */ ! 185: 181 0000E21D 0d 01 effffffe80 movl $1,_force_loop ! 186: 182 0000E224 # asm("brw _subf_1_lp1");; /* and loop on the error */ ! 187: 183 0000E224 13 ff48 brw _subf_1_lp1 ! 188: 184 0000E227 # } /* end of loop on error */ ! 189: 185 0000E227 # } /* end of compare error */ ! 190: 186 0000E227 L249: ! 191: 187 0000E227 # } /* end of WHILE loop */ ! 192: 188 0000E227 L239: ! 193: 189 0000E227 L235: ! 194: 190 0000E227 6d effffffe77 incl _index ! 195: 191 0000E22D 13 fef6 jbr L237 ! 196: 192 0000E230 L236: ! 197: 193 0000E230 # } /* end of subtest 1 */ ! 198: 194 0000E230 40 ret#2 ! 199: 195 0000E231 .set L231,0x0 ! 200: 196 0000E231 L233: ! 201: 197 0000E231 13 fedf jbr L234 ! 202: 198 0000E234 .data ! 203: 199 00000d28 * .text ! 204: 200 0000E234 .align 1 ! 205: 201 0000E234 .globl _subf_2 ! 206: 202 0000E234 _subf_2: ! 207: 203 0000E234 0000 .word L250 ! 208: 204 0000E236 # ! 209: 205 0000E236 # ! 210: 206 0000E236 # ! 211: 207 0000E236 # /************************************************************************ ! 212: 208 0000E236 # * ! 213: 209 0000E236 # * SUBTEST 2 - subract through memory ! 214: 210 0000E236 # * ! 215: 211 0000E236 # ************************************************************************/ ! 216: 212 0000E236 # subf_2() ! 217: 213 0000E236 # { ! 218: 214 0000E236 13 0118 jbr L252 ! 219: 215 0000E239 L253: ! 220: 216 0000E239 # force_loop = FALSE; ! 221: 217 0000E239 4d effffffe65 clrl _force_loop ! 222: 218 0000E23F # subtest = 2; ! 223: 219 0000E23F 0d 02 effffffe5e movl $2,_subtest ! 224: 220 0000E246 # for( index = 0; index < max_subf_1_index; index++ ) { ! 225: 221 0000E246 4d effffffe58 clrl _index ! 226: 222 0000E24C L256: ! 227: 223 0000E24C 1d effffffe52 effffffe4d cmpl _index,_max_subf_1_index ! 228: 224 0000E257 91 03 13 00f4 jgeq L255 ! 229: 225 0000E25C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 230: 226 0000E25C 5c 0c effffffe41 50 mull3 $12,_index,r0 ! 231: 227 0000E264 0d e000000000 effffffe35 movl _subf_1_data(r0),_sgl_ld_acc ! 232: 228 0000E26F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 233: 229 0000E26F 5c 0c effffffe2e 50 mull3 $12,_index,r0 ! 234: 230 0000E277 0d e000000004 effffffe22 movl _subf_1_data+4(r0),_sgl_value_1 ! 235: 231 0000E282 # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 236: 232 0000E282 5c 0c effffffe1b 50 mull3 $12,_index,r0 ! 237: 233 0000E28A 0d e000000008 effffffe0f movl _subf_1_data+8(r0),_sgl_expected ! 238: 234 0000E295 # /* ! 239: 235 0000E295 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 240: 236 0000E295 # * The force loop flag is set after the first error. ! 241: 237 0000E295 # */ ! 242: 238 0000E295 # asm("_subf_2_lp1:"); ! 243: 239 0000E295 _subf_2_lp1: ! 244: 240 0000E295 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 245: 241 0000E295 06 effffffe09 ldf _sgl_ld_acc ! 246: 242 0000E29B # asm("subf _sgl_value_1"); /* sub the 2nd operand */ ! 247: 243 0000E29B d6 effffffe03 subf _sgl_value_1 ! 248: 244 0000E2A1 # asm("stf _sgl_st_acc"); /* store the result */ ! 249: 245 0000E2A1 26 effffffdfd stf _sgl_st_acc ! 250: 246 0000E2A7 # if( force_loop ) ! 251: 247 0000E2A7 5d effffffdf7 tstl _force_loop ! 252: 248 0000E2AD 31 02 jeql L257 ! 253: 249 0000E2AF # asm("brb _subf_2_lp1");; /* loop on the error */ ! 254: 250 0000E2AF 11 e4 brb _subf_2_lp1 ! 255: 251 0000E2B1 L257: ! 256: 252 0000E2B1 # /* ! 257: 253 0000E2B1 # * end error loop - test the results ! 258: 254 0000E2B1 # */ ! 259: 255 0000E2B1 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 260: 256 0000E2B1 1d effffffded effffffde8 cmpl _sgl_st_acc,_sgl_expected ! 261: 257 0000E2BC 21 03 13 0086 jeql L258 ! 262: 258 0000E2C1 # errcnt++; /* bump the error count */ ! 263: 259 0000E2C1 6d effffffddd incl _errcnt ! 264: 260 0000E2C7 # if( prt_error ) { ! 265: 261 0000E2C7 5d effffffdd7 tstl _prt_error ! 266: 262 0000E2CD 31 55 jeql L259 ! 267: 263 0000E2CF # writes(" \n"); /* start a new print line */ ! 268: 264 0000E2CF .data 1 ! 269: 265 00000d6f * L260: ! 270: 266 00000d6f * 200A00 .ascii " \12\0" ! 271: 267 00000d72 * .text ! 272: 268 0000E2CF dd 8f00000d6f pushl $L260 ! 273: 269 0000E2D5 fe 08 effffffdc8 callf $8,_writes ! 274: 270 0000E2DC # writes("cycle: "); ! 275: 271 0000E2DC .data 1 ! 276: 272 00000d72 * L261: ! 277: 273 00000d72 * 6379636C653A2000 .ascii "cycle: \0" ! 278: 274 00000d7a * .text ! 279: 275 0000E2DC dd 8f00000d72 pushl $L261 ! 280: 276 0000E2E2 fe 08 effffffdbb callf $8,_writes ! 281: 277 0000E2E9 # writed( cycle ); ! 282: 278 0000E2E9 dd effffffdb5 pushl _cycle ! 283: 279 0000E2EF fe 08 effffffdae callf $8,_writed ! 284: 280 0000E2F6 # writes(" SUBF test "); ! 285: 281 0000E2F6 .data 1 ! 286: 282 00000d7a * L262: ! 287: 283 00000d7a * 2020535542462074657374200 .ascii " SUBF test \0" ! 288: 0 ! 289: 284 00000d87 * .text ! 290: 285 0000E2F6 dd 8f00000d7a pushl $L262 ! 291: 286 0000E2FC fe 08 effffffda1 callf $8,_writes ! 292: 287 0000E303 # writed( test_no ); ! 293: 288 0000E303 dd effffffd9b pushl _test_no ! 294: 289 0000E309 fe 08 effffffd94 callf $8,_writed ! 295: 290 0000E310 # writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n"); ! 296: 291 0000E310 .data 1 ! 297: 292 00000d87 * L263: ! 298: 293 00000d87 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL ACC\12\0" ! 299: 8436163686520446174612920 ! 300: 2D204241442046494E414C204 ! 301: 143430A00 ! 302: 294 00000db1 * .text ! 303: 295 0000E310 dd 8f00000d87 pushl $L263 ! 304: 296 0000E316 fe 08 effffffd87 callf $8,_writes ! 305: 297 0000E31D # print_subf_data(); ! 306: 298 0000E31D fe 04 ef00000950 callf $4,_print_subf_data ! 307: 299 0000E324 # } ! 308: 300 0000E324 # if( halt_flg ) ! 309: 301 0000E324 L259: ! 310: 302 0000E324 5d effffffd7a tstl _halt_flg ! 311: 303 0000E32A 31 09 jeql L264 ! 312: 304 0000E32C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 313: 305 0000E32C dd 01 pushl $1 ! 314: 306 0000E32E fe 08 ef000009dd callf $8,_subf_er_halt ! 315: 307 0000E335 # if( loop_on_err ) { ! 316: 308 0000E335 L264: ! 317: 309 0000E335 5d effffffd69 tstl _loop_on_err ! 318: 310 0000E33B 31 0a jeql L265 ! 319: 311 0000E33D # force_loop = TRUE; /* set the force loop flag */ ! 320: 312 0000E33D 0d 01 effffffd60 movl $1,_force_loop ! 321: 313 0000E344 # asm("brw _subf_2_lp1");; /* and loop on the error */ ! 322: 314 0000E344 13 ff4e brw _subf_2_lp1 ! 323: 315 0000E347 # } /* end of loop on error */ ! 324: 316 0000E347 # } /* end of compare error */ ! 325: 317 0000E347 L265: ! 326: 318 0000E347 # } /* end of WHILE loop */ ! 327: 319 0000E347 L258: ! 328: 320 0000E347 L254: ! 329: 321 0000E347 6d effffffd57 incl _index ! 330: 322 0000E34D 13 fefc jbr L256 ! 331: 323 0000E350 L255: ! 332: 324 0000E350 # } /* end of subtest 2 */ ! 333: 325 0000E350 40 ret#2 ! 334: 326 0000E351 .set L250,0x0 ! 335: 327 0000E351 L252: ! 336: 328 0000E351 13 fee5 jbr L253 ! 337: 329 0000E354 .data ! 338: 330 00000d28 * .text ! 339: 331 0000E354 .align 1 ! 340: 332 0000E354 .globl _subf_3 ! 341: 333 0000E354 _subf_3: ! 342: 334 0000E354 0000 .word L266 ! 343: 335 0000E356 # ! 344: 336 0000E356 # ! 345: 337 0000E356 # ! 346: 338 0000E356 # /************************************************************************ ! 347: 339 0000E356 # * ! 348: 340 0000E356 # * SUBTEST 3 - Wait 3 NOPs before storing the results ! 349: 341 0000E356 # * ! 350: 342 0000E356 # ************************************************************************/ ! 351: 343 0000E356 # subf_3() ! 352: 344 0000E356 # { ! 353: 345 0000E356 13 011c jbr L268 ! 354: 346 0000E359 L269: ! 355: 347 0000E359 # force_loop = FALSE; ! 356: 348 0000E359 4d effffffd45 clrl _force_loop ! 357: 349 0000E35F # subtest = 3; ! 358: 350 0000E35F 0d 03 effffffd3e movl $3,_subtest ! 359: 351 0000E366 # for( index = 0; index < max_subf_1_index; index++ ) { ! 360: 352 0000E366 4d effffffd38 clrl _index ! 361: 353 0000E36C L272: ! 362: 354 0000E36C 1d effffffd32 effffffd2d cmpl _index,_max_subf_1_index ! 363: 355 0000E377 91 03 13 00f8 jgeq L271 ! 364: 356 0000E37C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 365: 357 0000E37C 5c 0c effffffd21 50 mull3 $12,_index,r0 ! 366: 358 0000E384 0d e000000000 effffffd15 movl _subf_1_data(r0),_sgl_ld_acc ! 367: 359 0000E38F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 368: 360 0000E38F 5c 0c effffffd0e 50 mull3 $12,_index,r0 ! 369: 361 0000E397 0d e000000004 effffffd02 movl _subf_1_data+4(r0),_sgl_value_1 ! 370: 362 0000E3A2 # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 371: 363 0000E3A2 5c 0c effffffcfb 50 mull3 $12,_index,r0 ! 372: 364 0000E3AA 0d e000000008 effffffcef movl _subf_1_data+8(r0),_sgl_expected ! 373: 365 0000E3B5 # /* ! 374: 366 0000E3B5 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 375: 367 0000E3B5 # * The force loop flag is set after the first error. ! 376: 368 0000E3B5 # */ ! 377: 369 0000E3B5 # asm("_subf_3_lp1:"); ! 378: 370 0000E3B5 _subf_3_lp1: ! 379: 371 0000E3B5 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 380: 372 0000E3B5 06 effffffce9 ldf _sgl_ld_acc ! 381: 373 0000E3BB # asm("nop"); /* delay */ ! 382: 374 0000E3BB 10 nop ! 383: 375 0000E3BC # asm("subf _sgl_value_1"); /* sub the 2nd operand */ ! 384: 376 0000E3BC d6 effffffce2 subf _sgl_value_1 ! 385: 377 0000E3C2 # asm("nop"); /* delay before ... */ ! 386: 378 0000E3C2 10 nop ! 387: 379 0000E3C3 # asm("nop"); ! 388: 380 0000E3C3 10 nop ! 389: 381 0000E3C4 # asm("nop"); /* ... storing the result */ ! 390: 382 0000E3C4 10 nop ! 391: 383 0000E3C5 # asm("stf _sgl_st_acc"); /* store the result */ ! 392: 384 0000E3C5 26 effffffcd9 stf _sgl_st_acc ! 393: 385 0000E3CB # if( force_loop ) ! 394: 386 0000E3CB 5d effffffcd3 tstl _force_loop ! 395: 387 0000E3D1 31 02 jeql L273 ! 396: 388 0000E3D3 # asm("brb _subf_3_lp1");; /* loop on the error */ ! 397: 389 0000E3D3 11 e0 brb _subf_3_lp1 ! 398: 390 0000E3D5 L273: ! 399: 391 0000E3D5 # /* ! 400: 392 0000E3D5 # * end error loop - test the results ! 401: 393 0000E3D5 # */ ! 402: 394 0000E3D5 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 403: 395 0000E3D5 1d effffffcc9 effffffcc4 cmpl _sgl_st_acc,_sgl_expected ! 404: 396 0000E3E0 21 03 13 0086 jeql L274 ! 405: 397 0000E3E5 # errcnt++; /* bump the error count */ ! 406: 398 0000E3E5 6d effffffcb9 incl _errcnt ! 407: 399 0000E3EB # if( prt_error ) { ! 408: 400 0000E3EB 5d effffffcb3 tstl _prt_error ! 409: 401 0000E3F1 31 55 jeql L275 ! 410: 402 0000E3F3 # writes(" \n"); /* start a new print line */ ! 411: 403 0000E3F3 .data 1 ! 412: 404 00000db1 * L276: ! 413: 405 00000db1 * 200A00 .ascii " \12\0" ! 414: 406 00000db4 * .text ! 415: 407 0000E3F3 dd 8f00000db1 pushl $L276 ! 416: 408 0000E3F9 fe 08 effffffca4 callf $8,_writes ! 417: 409 0000E400 # writes("cycle: "); ! 418: 410 0000E400 .data 1 ! 419: 411 00000db4 * L277: ! 420: 412 00000db4 * 6379636C653A2000 .ascii "cycle: \0" ! 421: 413 00000dbc * .text ! 422: 414 0000E400 dd 8f00000db4 pushl $L277 ! 423: 415 0000E406 fe 08 effffffc97 callf $8,_writes ! 424: 416 0000E40D # writed( cycle ); ! 425: 417 0000E40D dd effffffc91 pushl _cycle ! 426: 418 0000E413 fe 08 effffffc8a callf $8,_writed ! 427: 419 0000E41A # writes(" SUBF test "); ! 428: 420 0000E41A .data 1 ! 429: 421 00000dbc * L278: ! 430: 422 00000dbc * 2020535542462074657374200 .ascii " SUBF test \0" ! 431: 0 ! 432: 423 00000dc9 * .text ! 433: 424 0000E41A dd 8f00000dbc pushl $L278 ! 434: 425 0000E420 fe 08 effffffc7d callf $8,_writes ! 435: 426 0000E427 # writed( test_no ); ! 436: 427 0000E427 dd effffffc77 pushl _test_no ! 437: 428 0000E42D fe 08 effffffc70 callf $8,_writed ! 438: 429 0000E434 # writes(", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\n"); ! 439: 430 0000E434 .data 1 ! 440: 431 00000dc9 * L279: ! 441: 432 00000dc9 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\12\0" ! 442: 843616368652044617461202D ! 443: 2033204E4F505329202D20424 ! 444: 1442046494E414C204143430A ! 445: 00 ! 446: 433 00000dfc * .text ! 447: 434 0000E434 dd 8f00000dc9 pushl $L279 ! 448: 435 0000E43A fe 08 effffffc63 callf $8,_writes ! 449: 436 0000E441 # print_subf_data(); ! 450: 437 0000E441 fe 04 ef0000082c callf $4,_print_subf_data ! 451: 438 0000E448 # } ! 452: 439 0000E448 # if( halt_flg ) ! 453: 440 0000E448 L275: ! 454: 441 0000E448 5d effffffc56 tstl _halt_flg ! 455: 442 0000E44E 31 09 jeql L280 ! 456: 443 0000E450 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 457: 444 0000E450 dd 01 pushl $1 ! 458: 445 0000E452 fe 08 ef000008b9 callf $8,_subf_er_halt ! 459: 446 0000E459 # if( loop_on_err ) { ! 460: 447 0000E459 L280: ! 461: 448 0000E459 5d effffffc45 tstl _loop_on_err ! 462: 449 0000E45F 31 0a jeql L281 ! 463: 450 0000E461 # force_loop = TRUE; /* set the force loop flag */ ! 464: 451 0000E461 0d 01 effffffc3c movl $1,_force_loop ! 465: 452 0000E468 # asm("brw _subf_3_lp1");; /* and loop on the error */ ! 466: 453 0000E468 13 ff4a brw _subf_3_lp1 ! 467: 454 0000E46B # } /* end of loop on error */ ! 468: 455 0000E46B # } /* end of compare error */ ! 469: 456 0000E46B L281: ! 470: 457 0000E46B # } /* end of WHILE loop */ ! 471: 458 0000E46B L274: ! 472: 459 0000E46B L270: ! 473: 460 0000E46B 6d effffffc33 incl _index ! 474: 461 0000E471 13 fef8 jbr L272 ! 475: 462 0000E474 L271: ! 476: 463 0000E474 # } /* end of subtest 3 */ ! 477: 464 0000E474 40 ret#2 ! 478: 465 0000E475 .set L266,0x0 ! 479: 466 0000E475 L268: ! 480: 467 0000E475 13 fee1 jbr L269 ! 481: 468 0000E478 .data ! 482: 469 00000d28 * .text ! 483: 470 0000E478 .align 1 ! 484: 471 0000E478 .globl _subf_4 ! 485: 472 0000E478 _subf_4: ! 486: 473 0000E478 0000 .word L282 ! 487: 474 0000E47A # ! 488: 475 0000E47A # ! 489: 476 0000E47A # ! 490: 477 0000E47A # /************************************************************************ ! 491: 478 0000E47A # * ! 492: 479 0000E47A # * SUBTEST 4 - Wait 2 NOPs before storing the results ! 493: 480 0000E47A # * ! 494: 481 0000E47A # ************************************************************************/ ! 495: 482 0000E47A # subf_4() ! 496: 483 0000E47A # { ! 497: 484 0000E47A 13 011b jbr L284 ! 498: 485 0000E47D L285: ! 499: 486 0000E47D # force_loop = FALSE; ! 500: 487 0000E47D 4d effffffc21 clrl _force_loop ! 501: 488 0000E483 # subtest = 4; ! 502: 489 0000E483 0d 04 effffffc1a movl $4,_subtest ! 503: 490 0000E48A # for( index = 0; index < max_subf_1_index; index++ ) { ! 504: 491 0000E48A 4d effffffc14 clrl _index ! 505: 492 0000E490 L288: ! 506: 493 0000E490 1d effffffc0e effffffc09 cmpl _index,_max_subf_1_index ! 507: 494 0000E49B 91 03 13 00f7 jgeq L287 ! 508: 495 0000E4A0 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 509: 496 0000E4A0 5c 0c effffffbfd 50 mull3 $12,_index,r0 ! 510: 497 0000E4A8 0d e000000000 effffffbf1 movl _subf_1_data(r0),_sgl_ld_acc ! 511: 498 0000E4B3 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 512: 499 0000E4B3 5c 0c effffffbea 50 mull3 $12,_index,r0 ! 513: 500 0000E4BB 0d e000000004 effffffbde movl _subf_1_data+4(r0),_sgl_value_1 ! 514: 501 0000E4C6 # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 515: 502 0000E4C6 5c 0c effffffbd7 50 mull3 $12,_index,r0 ! 516: 503 0000E4CE 0d e000000008 effffffbcb movl _subf_1_data+8(r0),_sgl_expected ! 517: 504 0000E4D9 # /* ! 518: 505 0000E4D9 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 519: 506 0000E4D9 # * The force loop flag is set after the first error. ! 520: 507 0000E4D9 # */ ! 521: 508 0000E4D9 # asm("_subf_4_lp1:"); ! 522: 509 0000E4D9 _subf_4_lp1: ! 523: 510 0000E4D9 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 524: 511 0000E4D9 06 effffffbc5 ldf _sgl_ld_acc ! 525: 512 0000E4DF # asm("nop"); /* delay */ ! 526: 513 0000E4DF 10 nop ! 527: 514 0000E4E0 # asm("subf _sgl_value_1"); /* subract the 2nd operand */ ! 528: 515 0000E4E0 d6 effffffbbe subf _sgl_value_1 ! 529: 516 0000E4E6 # asm("nop"); /* delay before ... */ ! 530: 517 0000E4E6 10 nop ! 531: 518 0000E4E7 # asm("nop"); /* ... storing the result */ ! 532: 519 0000E4E7 10 nop ! 533: 520 0000E4E8 # asm("stf _sgl_st_acc"); /* store the result */ ! 534: 521 0000E4E8 26 effffffbb6 stf _sgl_st_acc ! 535: 522 0000E4EE # if( force_loop ) ! 536: 523 0000E4EE 5d effffffbb0 tstl _force_loop ! 537: 524 0000E4F4 31 02 jeql L289 ! 538: 525 0000E4F6 # asm("brb _subf_4_lp1");; /* loop on the error */ ! 539: 526 0000E4F6 11 e1 brb _subf_4_lp1 ! 540: 527 0000E4F8 L289: ! 541: 528 0000E4F8 # /* ! 542: 529 0000E4F8 # * end error loop - test the results ! 543: 530 0000E4F8 # */ ! 544: 531 0000E4F8 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 545: 532 0000E4F8 1d effffffba6 effffffba1 cmpl _sgl_st_acc,_sgl_expected ! 546: 533 0000E503 21 03 13 0086 jeql L290 ! 547: 534 0000E508 # errcnt++; /* bump the error count */ ! 548: 535 0000E508 6d effffffb96 incl _errcnt ! 549: 536 0000E50E # if( prt_error ) { ! 550: 537 0000E50E 5d effffffb90 tstl _prt_error ! 551: 538 0000E514 31 55 jeql L291 ! 552: 539 0000E516 # writes(" \n"); /* start a new print line */ ! 553: 540 0000E516 .data 1 ! 554: 541 00000dfc * L292: ! 555: 542 00000dfc * 200A00 .ascii " \12\0" ! 556: 543 00000dff * .text ! 557: 544 0000E516 dd 8f00000dfc pushl $L292 ! 558: 545 0000E51C fe 08 effffffb81 callf $8,_writes ! 559: 546 0000E523 # writes("cycle: "); ! 560: 547 0000E523 .data 1 ! 561: 548 00000dff * L293: ! 562: 549 00000dff * 6379636C653A2000 .ascii "cycle: \0" ! 563: 550 00000e07 * .text ! 564: 551 0000E523 dd 8f00000dff pushl $L293 ! 565: 552 0000E529 fe 08 effffffb74 callf $8,_writes ! 566: 553 0000E530 # writed( cycle ); ! 567: 554 0000E530 dd effffffb6e pushl _cycle ! 568: 555 0000E536 fe 08 effffffb67 callf $8,_writed ! 569: 556 0000E53D # writes(" SUBF test "); ! 570: 557 0000E53D .data 1 ! 571: 558 00000e07 * L294: ! 572: 559 00000e07 * 2020535542462074657374200 .ascii " SUBF test \0" ! 573: 0 ! 574: 560 00000e14 * .text ! 575: 561 0000E53D dd 8f00000e07 pushl $L294 ! 576: 562 0000E543 fe 08 effffffb5a callf $8,_writes ! 577: 563 0000E54A # writed( test_no ); ! 578: 564 0000E54A dd effffffb54 pushl _test_no ! 579: 565 0000E550 fe 08 effffffb4d callf $8,_writed ! 580: 566 0000E557 # writes(", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\n"); ! 581: 567 0000E557 .data 1 ! 582: 568 00000e14 * L295: ! 583: 569 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\12\0" ! 584: 843616368652044617461202D ! 585: 2032204E4F505329202D20424 ! 586: 1442046494E414C204143430A ! 587: 00 ! 588: 570 00000e47 * .text ! 589: 571 0000E557 dd 8f00000e14 pushl $L295 ! 590: 572 0000E55D fe 08 effffffb40 callf $8,_writes ! 591: 573 0000E564 # print_subf_data(); ! 592: 574 0000E564 fe 04 ef00000709 callf $4,_print_subf_data ! 593: 575 0000E56B # } ! 594: 576 0000E56B # if( halt_flg ) ! 595: 577 0000E56B L291: ! 596: 578 0000E56B 5d effffffb33 tstl _halt_flg ! 597: 579 0000E571 31 09 jeql L296 ! 598: 580 0000E573 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 599: 581 0000E573 dd 01 pushl $1 ! 600: 582 0000E575 fe 08 ef00000796 callf $8,_subf_er_halt ! 601: 583 0000E57C # if( loop_on_err ) { ! 602: 584 0000E57C L296: ! 603: 585 0000E57C 5d effffffb22 tstl _loop_on_err ! 604: 586 0000E582 31 0a jeql L297 ! 605: 587 0000E584 # force_loop = TRUE; /* set the force loop flag */ ! 606: 588 0000E584 0d 01 effffffb19 movl $1,_force_loop ! 607: 589 0000E58B # asm("brw _subf_4_lp1");; /* and loop on the error */ ! 608: 590 0000E58B 13 ff4b brw _subf_4_lp1 ! 609: 591 0000E58E # } /* end of loop on error */ ! 610: 592 0000E58E # } /* end of compare error */ ! 611: 593 0000E58E L297: ! 612: 594 0000E58E # } /* end of WHILE loop */ ! 613: 595 0000E58E L290: ! 614: 596 0000E58E L286: ! 615: 597 0000E58E 6d effffffb10 incl _index ! 616: 598 0000E594 13 fef9 jbr L288 ! 617: 599 0000E597 L287: ! 618: 600 0000E597 # } /* end of subtest 4 */ ! 619: 601 0000E597 40 ret#2 ! 620: 602 0000E598 .set L282,0x0 ! 621: 603 0000E598 L284: ! 622: 604 0000E598 13 fee2 jbr L285 ! 623: 605 0000E59B .data ! 624: 606 00000d28 * .text ! 625: 607 0000E59B 00 .align 1 ! 626: 608 0000E59C .globl _subf_5 ! 627: 609 0000E59C _subf_5: ! 628: 610 0000E59C 0000 .word L298 ! 629: 611 0000E59E # ! 630: 612 0000E59E # ! 631: 613 0000E59E # ! 632: 614 0000E59E # /************************************************************************ ! 633: 615 0000E59E # * ! 634: 616 0000E59E # * SUBTEST 5 - Wait 1 NOP before storing the results ! 635: 617 0000E59E # * ! 636: 618 0000E59E # ************************************************************************/ ! 637: 619 0000E59E # subf_5() ! 638: 620 0000E59E # { ! 639: 621 0000E59E 13 011a jbr L300 ! 640: 622 0000E5A1 L301: ! 641: 623 0000E5A1 # force_loop = FALSE; ! 642: 624 0000E5A1 4d effffffafd clrl _force_loop ! 643: 625 0000E5A7 # subtest = 5; ! 644: 626 0000E5A7 0d 05 effffffaf6 movl $5,_subtest ! 645: 627 0000E5AE # for( index = 0; index < max_subf_1_index; index++ ) { ! 646: 628 0000E5AE 4d effffffaf0 clrl _index ! 647: 629 0000E5B4 L304: ! 648: 630 0000E5B4 1d effffffaea effffffae5 cmpl _index,_max_subf_1_index ! 649: 631 0000E5BF 91 03 13 00f6 jgeq L303 ! 650: 632 0000E5C4 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 651: 633 0000E5C4 5c 0c effffffad9 50 mull3 $12,_index,r0 ! 652: 634 0000E5CC 0d e000000000 effffffacd movl _subf_1_data(r0),_sgl_ld_acc ! 653: 635 0000E5D7 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 654: 636 0000E5D7 5c 0c effffffac6 50 mull3 $12,_index,r0 ! 655: 637 0000E5DF 0d e000000004 effffffaba movl _subf_1_data+4(r0),_sgl_value_1 ! 656: 638 0000E5EA # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 657: 639 0000E5EA 5c 0c effffffab3 50 mull3 $12,_index,r0 ! 658: 640 0000E5F2 0d e000000008 effffffaa7 movl _subf_1_data+8(r0),_sgl_expected ! 659: 641 0000E5FD # /* ! 660: 642 0000E5FD # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 661: 643 0000E5FD # * The force loop flag is set after the first error. ! 662: 644 0000E5FD # */ ! 663: 645 0000E5FD # asm("_subf_5_lp1:"); ! 664: 646 0000E5FD _subf_5_lp1: ! 665: 647 0000E5FD # asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 666: 648 0000E5FD 06 effffffaa1 ldf _sgl_ld_acc ! 667: 649 0000E603 # asm("nop"); /* delay */ ! 668: 650 0000E603 10 nop ! 669: 651 0000E604 # asm("subf _sgl_value_1"); /* subract the 2nd operand */ ! 670: 652 0000E604 d6 effffffa9a subf _sgl_value_1 ! 671: 653 0000E60A # asm("nop"); /* delay before storing */ ! 672: 654 0000E60A 10 nop ! 673: 655 0000E60B # asm("stf _sgl_st_acc"); /* store the result */ ! 674: 656 0000E60B 26 effffffa93 stf _sgl_st_acc ! 675: 657 0000E611 # if( force_loop ) ! 676: 658 0000E611 5d effffffa8d tstl _force_loop ! 677: 659 0000E617 31 02 jeql L305 ! 678: 660 0000E619 # asm("brb _subf_5_lp1");; /* loop on the error */ ! 679: 661 0000E619 11 e2 brb _subf_5_lp1 ! 680: 662 0000E61B L305: ! 681: 663 0000E61B # /* ! 682: 664 0000E61B # * end error loop - test the results ! 683: 665 0000E61B # */ ! 684: 666 0000E61B # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 685: 667 0000E61B 1d effffffa83 effffffa7e cmpl _sgl_st_acc,_sgl_expected ! 686: 668 0000E626 21 03 13 0086 jeql L306 ! 687: 669 0000E62B # errcnt++; /* bump the error count */ ! 688: 670 0000E62B 6d effffffa73 incl _errcnt ! 689: 671 0000E631 # if( prt_error ) { ! 690: 672 0000E631 5d effffffa6d tstl _prt_error ! 691: 673 0000E637 31 55 jeql L307 ! 692: 674 0000E639 # writes(" \n"); /* start a new print line */ ! 693: 675 0000E639 .data 1 ! 694: 676 00000e47 * L308: ! 695: 677 00000e47 * 200A00 .ascii " \12\0" ! 696: 678 00000e4a * .text ! 697: 679 0000E639 dd 8f00000e47 pushl $L308 ! 698: 680 0000E63F fe 08 effffffa5e callf $8,_writes ! 699: 681 0000E646 # writes("cycle: "); ! 700: 682 0000E646 .data 1 ! 701: 683 00000e4a * L309: ! 702: 684 00000e4a * 6379636C653A2000 .ascii "cycle: \0" ! 703: 685 00000e52 * .text ! 704: 686 0000E646 dd 8f00000e4a pushl $L309 ! 705: 687 0000E64C fe 08 effffffa51 callf $8,_writes ! 706: 688 0000E653 # writed( cycle ); ! 707: 689 0000E653 dd effffffa4b pushl _cycle ! 708: 690 0000E659 fe 08 effffffa44 callf $8,_writed ! 709: 691 0000E660 # writes(" SUBF test "); ! 710: 692 0000E660 .data 1 ! 711: 693 00000e52 * L310: ! 712: 694 00000e52 * 2020535542462074657374200 .ascii " SUBF test \0" ! 713: 0 ! 714: 695 00000e5f * .text ! 715: 696 0000E660 dd 8f00000e52 pushl $L310 ! 716: 697 0000E666 fe 08 effffffa37 callf $8,_writes ! 717: 698 0000E66D # writed( test_no ); ! 718: 699 0000E66D dd effffffa31 pushl _test_no ! 719: 700 0000E673 fe 08 effffffa2a callf $8,_writed ! 720: 701 0000E67A # writes(", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\n"); ! 721: 702 0000E67A .data 1 ! 722: 703 00000e5f * L311: ! 723: 704 00000e5f * 2C20737562746573742035202 .ascii ", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\12\0" ! 724: 843616368652044617461202D ! 725: 2031204E4F505329202D20424 ! 726: 1442046494E414C204143430A ! 727: 00 ! 728: 705 00000e92 * .text ! 729: 706 0000E67A dd 8f00000e5f pushl $L311 ! 730: 707 0000E680 fe 08 effffffa1d callf $8,_writes ! 731: 708 0000E687 # print_subf_data(); ! 732: 709 0000E687 fe 04 ef000005e6 callf $4,_print_subf_data ! 733: 710 0000E68E # } ! 734: 711 0000E68E # if( halt_flg ) ! 735: 712 0000E68E L307: ! 736: 713 0000E68E 5d effffffa10 tstl _halt_flg ! 737: 714 0000E694 31 09 jeql L312 ! 738: 715 0000E696 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 739: 716 0000E696 dd 01 pushl $1 ! 740: 717 0000E698 fe 08 ef00000673 callf $8,_subf_er_halt ! 741: 718 0000E69F # if( loop_on_err ) { ! 742: 719 0000E69F L312: ! 743: 720 0000E69F 5d effffff9ff tstl _loop_on_err ! 744: 721 0000E6A5 31 0a jeql L313 ! 745: 722 0000E6A7 # force_loop = TRUE; /* set the force loop flag */ ! 746: 723 0000E6A7 0d 01 effffff9f6 movl $1,_force_loop ! 747: 724 0000E6AE # asm("brw _subf_5_lp1");; /* and loop on the error */ ! 748: 725 0000E6AE 13 ff4c brw _subf_5_lp1 ! 749: 726 0000E6B1 # } /* end of loop on error */ ! 750: 727 0000E6B1 # } /* end of compare error */ ! 751: 728 0000E6B1 L313: ! 752: 729 0000E6B1 # } /* end of WHILE loop */ ! 753: 730 0000E6B1 L306: ! 754: 731 0000E6B1 L302: ! 755: 732 0000E6B1 6d effffff9ed incl _index ! 756: 733 0000E6B7 13 fefa jbr L304 ! 757: 734 0000E6BA L303: ! 758: 735 0000E6BA # } /* end of subtest 5 */ ! 759: 736 0000E6BA 40 ret#2 ! 760: 737 0000E6BB .set L298,0x0 ! 761: 738 0000E6BB L300: ! 762: 739 0000E6BB 13 fee3 jbr L301 ! 763: 740 0000E6BE .data ! 764: 741 00000d28 * .text ! 765: 742 0000E6BE .align 1 ! 766: 743 0000E6BE .globl _subf_6 ! 767: 744 0000E6BE _subf_6: ! 768: 745 0000E6BE 0000 .word L314 ! 769: 746 0000E6C0 # ! 770: 747 0000E6C0 # ! 771: 748 0000E6C0 # ! 772: 749 0000E6C0 # /************************************************************************ ! 773: 750 0000E6C0 # * ! 774: 751 0000E6C0 # * SUBTEST 6 - Check for register corruption ! 775: 752 0000E6C0 # * ! 776: 753 0000E6C0 # ************************************************************************/ ! 777: 754 0000E6C0 # subf_6() ! 778: 755 0000E6C0 # { ! 779: 756 0000E6C0 13 01a7 jbr L316 ! 780: 757 0000E6C3 L317: ! 781: 758 0000E6C3 # force_loop = FALSE; /* clear force_loop flg */ ! 782: 759 0000E6C3 4d effffff9db clrl _force_loop ! 783: 760 0000E6C9 # subtest = 6; ! 784: 761 0000E6C9 0d 06 effffff9d4 movl $6,_subtest ! 785: 762 0000E6D0 # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 786: 763 0000E6D0 dd 8f00000000 pushl $_load_regs ! 787: 764 0000E6D6 fe 08 effffff9c7 callf $8,_fill_reg_buf ! 788: 765 0000E6DD # index = 0; ! 789: 766 0000E6DD 4d effffff9c1 clrl _index ! 790: 767 0000E6E3 # sgl_ld_acc = subf_1_data[0].op_1; /* get operand 1 */ ! 791: 768 0000E6E3 0d effffff9bb effffff9b6 movl _subf_1_data,_sgl_ld_acc ! 792: 769 0000E6EE # sgl_value_1 = subf_1_data[0].op_2; /* get operand 2 */ ! 793: 770 0000E6EE 0d effffff9b4 effffff9ab movl _subf_1_data+4,_sgl_value_1 ! 794: 771 0000E6F9 # sgl_expected = subf_1_data[0].exp; /* get expected result */ ! 795: 772 0000E6F9 0d effffff9ad effffff9a0 movl _subf_1_data+8,_sgl_expected ! 796: 773 0000E704 # /* ! 797: 774 0000E704 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 798: 775 0000E704 # * The force loop flag is set after the first error. ! 799: 776 0000E704 # */ ! 800: 777 0000E704 # asm("_subf_6_lp1:"); ! 801: 778 0000E704 _subf_6_lp1: ! 802: 779 0000E704 # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 803: 780 0000E704 06 effffff99a ldf _sgl_ld_acc ! 804: 781 0000E70A # asm("nop"); ! 805: 782 0000E70A 10 nop ! 806: 783 0000E70B # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 807: 784 0000E70B ab 891fff effffff990 loadr $0x1fff,_load_regs ! 808: 785 0000E714 # asm("nop"); ! 809: 786 0000E714 10 nop ! 810: 787 0000E715 # asm("subf _sgl_value_1"); /* do the subraction */ ! 811: 788 0000E715 d6 effffff989 subf _sgl_value_1 ! 812: 789 0000E71B # asm("nop"); ! 813: 790 0000E71B 10 nop ! 814: 791 0000E71C # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 815: 792 0000E71C bb 891fff effffff97f storer $0x1fff,_store_regs ! 816: 793 0000E725 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 817: 794 0000E725 26 effffff979 stf _sgl_st_acc ! 818: 795 0000E72B # if( force_loop ) ! 819: 796 0000E72B 5d effffff973 tstl _force_loop ! 820: 797 0000E731 31 02 jeql L319 ! 821: 798 0000E733 # asm("brb _subf_6_lp1");; /* loop on the error */ ! 822: 799 0000E733 11 cf brb _subf_6_lp1 ! 823: 800 0000E735 L319: ! 824: 801 0000E735 # /* ! 825: 802 0000E735 # * Now compare the stored register values to those that were loaded ! 826: 803 0000E735 # */ ! 827: 804 0000E735 # index2 = 0; ! 828: 805 0000E735 4d effffff969 clrl _index2 ! 829: 806 0000E73B # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) ) ! 830: 807 0000E73B L320: ! 831: 808 0000E73B 0d effffff963 50 movl _index2,r0 ! 832: 809 0000E742 0d effffff95c 51 movl _index2,r1 ! 833: 810 0000E749 1d 40effffff954 cmpl _load_regs[r0],_store_regs[r1] ! 834: 41effffff94e ! 835: 811 0000E756 21 11 jneq L321 ! 836: 812 0000E758 1d effffff946 0d cmpl _index2,$13 ! 837: 813 0000E75F 81 08 jgeq L321 ! 838: 814 0000E761 # index2++; /* check reg values */ ! 839: 815 0000E761 6d effffff93d incl _index2 ! 840: 816 0000E767 11 d2 jbr L320 ! 841: 817 0000E769 L321: ! 842: 818 0000E769 # if( index2 < 13 ) { /* error if index2 < 13 */ ! 843: 819 0000E769 1d effffff935 0d cmpl _index2,$13 ! 844: 820 0000E770 91 03 13 00f4 jgeq L322 ! 845: 821 0000E775 # errcnt++; /* bump the error count */ ! 846: 822 0000E775 6d effffff929 incl _errcnt ! 847: 823 0000E77B # if( prt_error ) { ! 848: 824 0000E77B 5d effffff923 tstl _prt_error ! 849: 825 0000E781 21 03 13 00c0 jeql L323 ! 850: 826 0000E786 # writes(" \n"); /* start a new print line */ ! 851: 827 0000E786 .data 1 ! 852: 828 00000e92 * L324: ! 853: 829 00000e92 * 200A00 .ascii " \12\0" ! 854: 830 00000e95 * .text ! 855: 831 0000E786 dd 8f00000e92 pushl $L324 ! 856: 832 0000E78C fe 08 effffff911 callf $8,_writes ! 857: 833 0000E793 # writes("cycle: "); ! 858: 834 0000E793 .data 1 ! 859: 835 00000e95 * L325: ! 860: 836 00000e95 * 6379636C653A2000 .ascii "cycle: \0" ! 861: 837 00000e9d * .text ! 862: 838 0000E793 dd 8f00000e95 pushl $L325 ! 863: 839 0000E799 fe 08 effffff904 callf $8,_writes ! 864: 840 0000E7A0 # writed( cycle ); ! 865: 841 0000E7A0 dd effffff8fe pushl _cycle ! 866: 842 0000E7A6 fe 08 effffff8f7 callf $8,_writed ! 867: 843 0000E7AD # writes(" SUBF test "); ! 868: 844 0000E7AD .data 1 ! 869: 845 00000e9d * L326: ! 870: 846 00000e9d * 2020535542462074657374200 .ascii " SUBF test \0" ! 871: 0 ! 872: 847 00000eaa * .text ! 873: 848 0000E7AD dd 8f00000e9d pushl $L326 ! 874: 849 0000E7B3 fe 08 effffff8ea callf $8,_writes ! 875: 850 0000E7BA # writed( test_no ); ! 876: 851 0000E7BA dd effffff8e4 pushl _test_no ! 877: 852 0000E7C0 fe 08 effffff8dd callf $8,_writed ! 878: 853 0000E7C7 # writes(", subtest 6 - A REGISTER WAS MODIFIED\n"); ! 879: 854 0000E7C7 .data 1 ! 880: 855 00000eaa * L327: ! 881: 856 00000eaa * 2C20737562746573742036202 .ascii ", subtest 6 - A REGISTER WAS MODIFIED\12\0" ! 882: D204120524547495354455220 ! 883: 574153204D4F4449464945440 ! 884: A00 ! 885: 857 00000ed1 * .text ! 886: 858 0000E7C7 dd 8f00000eaa pushl $L327 ! 887: 859 0000E7CD fe 08 effffff8d0 callf $8,_writes ! 888: 860 0000E7D4 # print_subf_data(); /* print the operands */ ! 889: 861 0000E7D4 fe 04 ef00000499 callf $4,_print_subf_data ! 890: 862 0000E7DB # writes("register "); /* print the information */ ! 891: 863 0000E7DB .data 1 ! 892: 864 00000ed1 * L328: ! 893: 865 00000ed1 * 72656769737465722000 .ascii "register \0" ! 894: 866 00000edb * .text ! 895: 867 0000E7DB dd 8f00000ed1 pushl $L328 ! 896: 868 0000E7E1 fe 08 effffff8bc callf $8,_writes ! 897: 869 0000E7E8 # writed( index2 ); /* about the corrupted */ ! 898: 870 0000E7E8 dd effffff8b6 pushl _index2 ! 899: 871 0000E7EE fe 08 effffff8af callf $8,_writed ! 900: 872 0000E7F5 # writes(" = "); /* register */ ! 901: 873 0000E7F5 .data 1 ! 902: 874 00000edb * L329: ! 903: 875 00000edb * 203D2000 .ascii " = \0" ! 904: 876 00000edf * .text ! 905: 877 0000E7F5 dd 8f00000edb pushl $L329 ! 906: 878 0000E7FB fe 08 effffff8a2 callf $8,_writes ! 907: 879 0000E802 # write32h( store_regs[index2] ); ! 908: 880 0000E802 0d effffff89c 50 movl _index2,r0 ! 909: 881 0000E809 dd 40effffff894 pushl _store_regs[r0] ! 910: 882 0000E810 fe 08 effffff88d callf $8,_write32h ! 911: 883 0000E817 # writes(", should be = "); ! 912: 884 0000E817 .data 1 ! 913: 885 00000edf * L331: ! 914: 886 00000edf * 2C202073686F756C642062652 .ascii ", should be = \0" ! 915: 03D2000 ! 916: 887 00000eef * .text ! 917: 888 0000E817 dd 8f00000edf pushl $L331 ! 918: 889 0000E81D fe 08 effffff880 callf $8,_writes ! 919: 890 0000E824 # write32h( load_regs[index2] ); ! 920: 891 0000E824 0d effffff87a 50 movl _index2,r0 ! 921: 892 0000E82B dd 40effffff872 pushl _load_regs[r0] ! 922: 893 0000E832 fe 08 effffff86b callf $8,_write32h ! 923: 894 0000E839 # writes("\n"); ! 924: 895 0000E839 .data 1 ! 925: 896 00000eef * L332: ! 926: 897 00000eef * 0A00 .ascii "\12\0" ! 927: 898 00000ef1 * .text ! 928: 899 0000E839 dd 8f00000eef pushl $L332 ! 929: 900 0000E83F fe 08 effffff85e callf $8,_writes ! 930: 901 0000E846 # } ! 931: 902 0000E846 # if( halt_flg ) ! 932: 903 0000E846 L323: ! 933: 904 0000E846 5d effffff858 tstl _halt_flg ! 934: 905 0000E84C 31 09 jeql L333 ! 935: 906 0000E84E # subf_er_halt( BAD_REG_HLT ); /* halt on the error */ ! 936: 907 0000E84E dd 02 pushl $2 ! 937: 908 0000E850 fe 08 ef000004bb callf $8,_subf_er_halt ! 938: 909 0000E857 # if( loop_on_err ) { ! 939: 910 0000E857 L333: ! 940: 911 0000E857 5d effffff847 tstl _loop_on_err ! 941: 912 0000E85D 31 0a jeql L334 ! 942: 913 0000E85F # force_loop = TRUE; /* set the force loop flag */ ! 943: 914 0000E85F 0d 01 effffff83e movl $1,_force_loop ! 944: 915 0000E866 # asm("brw _subf_6_lp1");; /* and loop on the error */ ! 945: 916 0000E866 13 fe9b brw _subf_6_lp1 ! 946: 917 0000E869 # } /* end of loop on error */ ! 947: 918 0000E869 # } /* end of register corruption error */ ! 948: 919 0000E869 L334: ! 949: 920 0000E869 # } /* end of subtest 6 */ ! 950: 921 0000E869 L322: ! 951: 922 0000E869 40 ret#2 ! 952: 923 0000E86A .set L314,0x0 ! 953: 924 0000E86A L316: ! 954: 925 0000E86A 13 fe56 jbr L317 ! 955: 926 0000E86D .data ! 956: 927 00000d28 * .text ! 957: 928 0000E86D 00 .align 1 ! 958: 929 0000E86E .globl _subf_7 ! 959: 930 0000E86E _subf_7: ! 960: 931 0000E86E 0000 .word L335 ! 961: 932 0000E870 # ! 962: 933 0000E870 # ! 963: 934 0000E870 # ! 964: 935 0000E870 # /************************************************************************ ! 965: 936 0000E870 # * ! 966: 937 0000E870 # * SUBTEST 7 - Check for PSL corruption ! 967: 938 0000E870 # * ! 968: 939 0000E870 # ************************************************************************/ ! 969: 940 0000E870 # subf_7() ! 970: 941 0000E870 # { ! 971: 942 0000E870 13 01b1 jbr L337 ! 972: 943 0000E873 L338: ! 973: 944 0000E873 # force_loop = FALSE; /* clear force_loop flg */ ! 974: 945 0000E873 4d effffff82b clrl _force_loop ! 975: 946 0000E879 # subtest = 7; ! 976: 947 0000E879 0d 07 effffff824 movl $7,_subtest ! 977: 948 0000E880 # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 978: 949 0000E880 dd 8f00000000 pushl $_load_regs ! 979: 950 0000E886 fe 08 effffff817 callf $8,_fill_reg_buf ! 980: 951 0000E88D # for( index = 0; index < 3; index++ ) { ! 981: 952 0000E88D 4d effffff811 clrl _index ! 982: 953 0000E893 L341: ! 983: 954 0000E893 1d effffff80b 03 cmpl _index,$3 ! 984: 955 0000E89A 91 03 13 0184 jgeq L340 ! 985: 956 0000E89F # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 986: 957 0000E89F 5c 0c effffff7fe 50 mull3 $12,_index,r0 ! 987: 958 0000E8A7 0d e000000000 effffff7f2 movl _subf_1_data(r0),_sgl_ld_acc ! 988: 959 0000E8B2 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 989: 960 0000E8B2 5c 0c effffff7eb 50 mull3 $12,_index,r0 ! 990: 961 0000E8BA 0d e000000004 effffff7df movl _subf_1_data+4(r0),_sgl_value_1 ! 991: 962 0000E8C5 # sgl_expected = subf_1_data[index].exp; /* get expected */ ! 992: 963 0000E8C5 5c 0c effffff7d8 50 mull3 $12,_index,r0 ! 993: 964 0000E8CD 0d e000000008 effffff7cc movl _subf_1_data+8(r0),_sgl_expected ! 994: 965 0000E8D8 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 995: 966 0000E8D8 0d effffff7c6 50 movl _status_index,r0 ! 996: 967 0000E8DF 0d 40effffff7be movl _status_array[r0],_sgl_dummy1 ! 997: effffff7b9 ! 998: 968 0000E8EB # /* ! 999: 969 0000E8EB # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1000: 970 0000E8EB # * The force loop flag is set after the first error. ! 1001: 971 0000E8EB # */ ! 1002: 972 0000E8EB # asm("_subf_7_lp1:"); ! 1003: 973 0000E8EB _subf_7_lp1: ! 1004: 974 0000E8EB # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 1005: 975 0000E8EB 06 effffff7b3 ldf _sgl_ld_acc ! 1006: 976 0000E8F1 # asm("nop"); ! 1007: 977 0000E8F1 10 nop ! 1008: 978 0000E8F2 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 1009: 979 0000E8F2 5d effffff7ac tstl _sgl_dummy1 ! 1010: 980 0000E8F8 # asm("movpsl _init_psl"); /* save the initial PSL */ ! 1011: 981 0000E8F8 cd effffff7a6 movpsl _init_psl ! 1012: 982 0000E8FE # asm("subf _sgl_value_1"); /* do the subract */ ! 1013: 983 0000E8FE d6 effffff7a0 subf _sgl_value_1 ! 1014: 984 0000E904 # asm("nop"); ! 1015: 985 0000E904 10 nop ! 1016: 986 0000E905 # asm("movpsl _psl_val"); /* save the final PSL */ ! 1017: 987 0000E905 cd effffff799 movpsl _psl_val ! 1018: 988 0000E90B # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 1019: 989 0000E90B 26 effffff793 stf _sgl_st_acc ! 1020: 990 0000E911 # if( force_loop ) ! 1021: 991 0000E911 5d effffff78d tstl _force_loop ! 1022: 992 0000E917 31 02 jeql L342 ! 1023: 993 0000E919 # asm("brb _subf_7_lp1");; /* loop on the error */ ! 1024: 994 0000E919 11 d0 brb _subf_7_lp1 ! 1025: 995 0000E91B L342: ! 1026: 996 0000E91B # /* ! 1027: 997 0000E91B # * Now compare the final PSL to the initial PSL -they should be the same ! 1028: 998 0000E91B # */ ! 1029: 999 0000E91B # exp_psl = init_psl; ! 1030: 1000 0000E91B 0d effffff783 effffff77e movl _init_psl,_exp_psl ! 1031: 1001 0000E926 # if( psl_val != init_psl ) { ! 1032: 1002 0000E926 1d effffff778 effffff773 cmpl _psl_val,_init_psl ! 1033: 1003 0000E931 21 03 13 00e4 jeql L343 ! 1034: 1004 0000E936 # errcnt++; /* bump the error count */ ! 1035: 1005 0000E936 6d effffff768 incl _errcnt ! 1036: 1006 0000E93C # if( prt_error ) { ! 1037: 1007 0000E93C 5d effffff762 tstl _prt_error ! 1038: 1008 0000E942 21 03 13 00b0 jeql L344 ! 1039: 1009 0000E947 # writes(" \n"); /* start a new print line */ ! 1040: 1010 0000E947 .data 1 ! 1041: 1011 00000ef1 * L345: ! 1042: 1012 00000ef1 * 200A00 .ascii " \12\0" ! 1043: 1013 00000ef4 * .text ! 1044: 1014 0000E947 dd 8f00000ef1 pushl $L345 ! 1045: 1015 0000E94D fe 08 effffff750 callf $8,_writes ! 1046: 1016 0000E954 # writes("cycle: "); ! 1047: 1017 0000E954 .data 1 ! 1048: 1018 00000ef4 * L346: ! 1049: 1019 00000ef4 * 6379636C653A2000 .ascii "cycle: \0" ! 1050: 1020 00000efc * .text ! 1051: 1021 0000E954 dd 8f00000ef4 pushl $L346 ! 1052: 1022 0000E95A fe 08 effffff743 callf $8,_writes ! 1053: 1023 0000E961 # writed( cycle ); ! 1054: 1024 0000E961 dd effffff73d pushl _cycle ! 1055: 1025 0000E967 fe 08 effffff736 callf $8,_writed ! 1056: 1026 0000E96E # writes(" SUBF test "); ! 1057: 1027 0000E96E .data 1 ! 1058: 1028 00000efc * L347: ! 1059: 1029 00000efc * 2020535542462074657374200 .ascii " SUBF test \0" ! 1060: 0 ! 1061: 1030 00000f09 * .text ! 1062: 1031 0000E96E dd 8f00000efc pushl $L347 ! 1063: 1032 0000E974 fe 08 effffff729 callf $8,_writes ! 1064: 1033 0000E97B # writed( test_no ); ! 1065: 1034 0000E97B dd effffff723 pushl _test_no ! 1066: 1035 0000E981 fe 08 effffff71c callf $8,_writed ! 1067: 1036 0000E988 # writes(", subtest 7 - INCORRECT FINAL PSL\n"); ! 1068: 1037 0000E988 .data 1 ! 1069: 1038 00000f09 * L348: ! 1070: 1039 00000f09 * 2C20737562746573742037202 .ascii ", subtest 7 - INCORRECT FINAL PSL\12\0" ! 1071: D20494E434F52524543542046 ! 1072: 494E414C2050534C0A00 ! 1073: 1040 00000f2c * .text ! 1074: 1041 0000E988 dd 8f00000f09 pushl $L348 ! 1075: 1042 0000E98E fe 08 effffff70f callf $8,_writes ! 1076: 1043 0000E995 # print_subf_data(); /* print the operands */ ! 1077: 1044 0000E995 fe 04 ef000002d8 callf $4,_print_subf_data ! 1078: 1045 0000E99C # writes("initial PSL = "); ! 1079: 1046 0000E99C .data 1 ! 1080: 1047 00000f2c * L349: ! 1081: 1048 00000f2c * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 1082: D2000 ! 1083: 1049 00000f3b * .text ! 1084: 1050 0000E99C dd 8f00000f2c pushl $L349 ! 1085: 1051 0000E9A2 fe 08 effffff6fb callf $8,_writes ! 1086: 1052 0000E9A9 # write32h( init_psl ); ! 1087: 1053 0000E9A9 dd effffff6f5 pushl _init_psl ! 1088: 1054 0000E9AF fe 08 effffff6ee callf $8,_write32h ! 1089: 1055 0000E9B6 # writes(", final PSL = "); ! 1090: 1056 0000E9B6 .data 1 ! 1091: 1057 00000f3b * L350: ! 1092: 1058 00000f3b * 2C2066696E616C2050534C203 .ascii ", final PSL = \0" ! 1093: D2000 ! 1094: 1059 00000f4a * .text ! 1095: 1060 0000E9B6 dd 8f00000f3b pushl $L350 ! 1096: 1061 0000E9BC fe 08 effffff6e1 callf $8,_writes ! 1097: 1062 0000E9C3 # write32h( psl_val ); ! 1098: 1063 0000E9C3 dd effffff6db pushl _psl_val ! 1099: 1064 0000E9C9 fe 08 effffff6d4 callf $8,_write32h ! 1100: 1065 0000E9D0 # writes(", expected PSL = "); ! 1101: 1066 0000E9D0 .data 1 ! 1102: 1067 00000f4a * L351: ! 1103: 1068 00000f4a * 2C20657870656374656420505 .ascii ", expected PSL = \0" ! 1104: 34C203D2000 ! 1105: 1069 00000f5c * .text ! 1106: 1070 0000E9D0 dd 8f00000f4a pushl $L351 ! 1107: 1071 0000E9D6 fe 08 effffff6c7 callf $8,_writes ! 1108: 1072 0000E9DD # write32h( exp_psl ); ! 1109: 1073 0000E9DD dd effffff6c1 pushl _exp_psl ! 1110: 1074 0000E9E3 fe 08 effffff6ba callf $8,_write32h ! 1111: 1075 0000E9EA # writes("\n"); ! 1112: 1076 0000E9EA .data 1 ! 1113: 1077 00000f5c * L352: ! 1114: 1078 00000f5c * 0A00 .ascii "\12\0" ! 1115: 1079 00000f5e * .text ! 1116: 1080 0000E9EA dd 8f00000f5c pushl $L352 ! 1117: 1081 0000E9F0 fe 08 effffff6ad callf $8,_writes ! 1118: 1082 0000E9F7 # } ! 1119: 1083 0000E9F7 # if( halt_flg ) ! 1120: 1084 0000E9F7 L344: ! 1121: 1085 0000E9F7 5d effffff6a7 tstl _halt_flg ! 1122: 1086 0000E9FD 31 09 jeql L353 ! 1123: 1087 0000E9FF # subf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 1124: 1088 0000E9FF dd 03 pushl $3 ! 1125: 1089 0000EA01 fe 08 ef0000030a callf $8,_subf_er_halt ! 1126: 1090 0000EA08 # if( loop_on_err ) { ! 1127: 1091 0000EA08 L353: ! 1128: 1092 0000EA08 5d effffff696 tstl _loop_on_err ! 1129: 1093 0000EA0E 31 0a jeql L354 ! 1130: 1094 0000EA10 # force_loop = TRUE; /* set the force loop flag */ ! 1131: 1095 0000EA10 0d 01 effffff68d movl $1,_force_loop ! 1132: 1096 0000EA17 # asm("brw _subf_7_lp1");; /* and loop on the error */ ! 1133: 1097 0000EA17 13 fed1 brw _subf_7_lp1 ! 1134: 1098 0000EA1A # } /* end of loop on error */ ! 1135: 1099 0000EA1A # } /* end of PSL corruption error */ ! 1136: 1100 0000EA1A L354: ! 1137: 1101 0000EA1A # } /* end of WHILE loop */ ! 1138: 1102 0000EA1A L343: ! 1139: 1103 0000EA1A L339: ! 1140: 1104 0000EA1A 6d effffff684 incl _index ! 1141: 1105 0000EA20 13 fe70 jbr L341 ! 1142: 1106 0000EA23 L340: ! 1143: 1107 0000EA23 # } /* end of subtest 7 */ ! 1144: 1108 0000EA23 40 ret#2 ! 1145: 1109 0000EA24 .set L335,0x0 ! 1146: 1110 0000EA24 L337: ! 1147: 1111 0000EA24 13 fe4c jbr L338 ! 1148: 1112 0000EA27 .data ! 1149: 1113 00000d28 * .text ! 1150: 1114 0000EA27 00 .align 1 ! 1151: 1115 0000EA28 .globl _subf_8 ! 1152: 1116 0000EA28 _subf_8: ! 1153: 1117 0000EA28 0000 .word L355 ! 1154: 1118 0000EA2A # ! 1155: 1119 0000EA2A # ! 1156: 1120 0000EA2A # ! 1157: 1121 0000EA2A # /************************************************************************ ! 1158: 1122 0000EA2A # * ! 1159: 1123 0000EA2A # * SUBTEST 8 - pipelined entry test ! 1160: 1124 0000EA2A # * ! 1161: 1125 0000EA2A # ************************************************************************/ ! 1162: 1126 0000EA2A # subf_8() ! 1163: 1127 0000EA2A # { ! 1164: 1128 0000EA2A 13 011d jbr L357 ! 1165: 1129 0000EA2D L358: ! 1166: 1130 0000EA2D # force_loop = FALSE; ! 1167: 1131 0000EA2D 4d effffff671 clrl _force_loop ! 1168: 1132 0000EA33 # subtest = 8; ! 1169: 1133 0000EA33 0d 08 effffff66a movl $8,_subtest ! 1170: 1134 0000EA3A # for( index = 0; index < max_subf_1_index; index++ ) { ! 1171: 1135 0000EA3A 4d effffff664 clrl _index ! 1172: 1136 0000EA40 L361: ! 1173: 1137 0000EA40 1d effffff65e effffff659 cmpl _index,_max_subf_1_index ! 1174: 1138 0000EA4B 91 03 13 00f9 jgeq L360 ! 1175: 1139 0000EA50 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 1176: 1140 0000EA50 5c 0c effffff64d 50 mull3 $12,_index,r0 ! 1177: 1141 0000EA58 0d e000000000 effffff641 movl _subf_1_data(r0),_sgl_ld_acc ! 1178: 1142 0000EA63 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 1179: 1143 0000EA63 5c 0c effffff63a 50 mull3 $12,_index,r0 ! 1180: 1144 0000EA6B 0d e000000004 effffff62e movl _subf_1_data+4(r0),_sgl_value_1 ! 1181: 1145 0000EA76 # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 1182: 1146 0000EA76 5c 0c effffff627 50 mull3 $12,_index,r0 ! 1183: 1147 0000EA7E 0d e000000008 effffff61b movl _subf_1_data+8(r0),_sgl_expected ! 1184: 1148 0000EA89 # /* ! 1185: 1149 0000EA89 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1186: 1150 0000EA89 # * The force loop flag is set after the first error. ! 1187: 1151 0000EA89 # */ ! 1188: 1152 0000EA89 # asm("_subf_8_lp1:"); ! 1189: 1153 0000EA89 _subf_8_lp1: ! 1190: 1154 0000EA89 # asm("movl $0,r0"); /* clear r0 */ ! 1191: 1155 0000EA89 0d 00 50 movl $0,r0 ! 1192: 1156 0000EA8C # asm("ldf r0"); /* load the Acc. with 0.0 */ ! 1193: 1157 0000EA8C 06 50 ldf r0 ! 1194: 1158 0000EA8E # asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 1195: 1159 0000EA8E c6 effffff610 addf _sgl_ld_acc ! 1196: 1160 0000EA94 # asm("subf _sgl_value_1"); /* subract the 2nd operand */ ! 1197: 1161 0000EA94 d6 effffff60a subf _sgl_value_1 ! 1198: 1162 0000EA9A # asm("stf _sgl_st_acc"); /* store the result */ ! 1199: 1163 0000EA9A 26 effffff604 stf _sgl_st_acc ! 1200: 1164 0000EAA0 # if( force_loop ) ! 1201: 1165 0000EAA0 5d effffff5fe tstl _force_loop ! 1202: 1166 0000EAA6 31 02 jeql L362 ! 1203: 1167 0000EAA8 # asm("brb _subf_8_lp1");; /* loop on the error */ ! 1204: 1168 0000EAA8 11 df brb _subf_8_lp1 ! 1205: 1169 0000EAAA L362: ! 1206: 1170 0000EAAA # /* ! 1207: 1171 0000EAAA # * end error loop - test the results ! 1208: 1172 0000EAAA # */ ! 1209: 1173 0000EAAA # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1210: 1174 0000EAAA 1d effffff5f4 effffff5ef cmpl _sgl_st_acc,_sgl_expected ! 1211: 1175 0000EAB5 21 03 13 0086 jeql L363 ! 1212: 1176 0000EABA # errcnt++; /* bump the error count */ ! 1213: 1177 0000EABA 6d effffff5e4 incl _errcnt ! 1214: 1178 0000EAC0 # if( prt_error ) { ! 1215: 1179 0000EAC0 5d effffff5de tstl _prt_error ! 1216: 1180 0000EAC6 31 55 jeql L364 ! 1217: 1181 0000EAC8 # writes(" \n"); /* start a new print line */ ! 1218: 1182 0000EAC8 .data 1 ! 1219: 1183 00000f5e * L365: ! 1220: 1184 00000f5e * 200A00 .ascii " \12\0" ! 1221: 1185 00000f61 * .text ! 1222: 1186 0000EAC8 dd 8f00000f5e pushl $L365 ! 1223: 1187 0000EACE fe 08 effffff5cf callf $8,_writes ! 1224: 1188 0000EAD5 # writes("cycle: "); ! 1225: 1189 0000EAD5 .data 1 ! 1226: 1190 00000f61 * L366: ! 1227: 1191 00000f61 * 6379636C653A2000 .ascii "cycle: \0" ! 1228: 1192 00000f69 * .text ! 1229: 1193 0000EAD5 dd 8f00000f61 pushl $L366 ! 1230: 1194 0000EADB fe 08 effffff5c2 callf $8,_writes ! 1231: 1195 0000EAE2 # writed( cycle ); ! 1232: 1196 0000EAE2 dd effffff5bc pushl _cycle ! 1233: 1197 0000EAE8 fe 08 effffff5b5 callf $8,_writed ! 1234: 1198 0000EAEF # writes(" SUBF test "); ! 1235: 1199 0000EAEF .data 1 ! 1236: 1200 00000f69 * L367: ! 1237: 1201 00000f69 * 2020535542462074657374200 .ascii " SUBF test \0" ! 1238: 0 ! 1239: 1202 00000f76 * .text ! 1240: 1203 0000EAEF dd 8f00000f69 pushl $L367 ! 1241: 1204 0000EAF5 fe 08 effffff5a8 callf $8,_writes ! 1242: 1205 0000EAFC # writed( test_no ); ! 1243: 1206 0000EAFC dd effffff5a2 pushl _test_no ! 1244: 1207 0000EB02 fe 08 effffff59b callf $8,_writed ! 1245: 1208 0000EB09 # writes(", subtest 8 (Piped Entry) - BAD FINAL ACC\n"); ! 1246: 1209 0000EB09 .data 1 ! 1247: 1210 00000f76 * L368: ! 1248: 1211 00000f76 * 2C20737562746573742038202 .ascii ", subtest 8 (Piped Entry) - BAD FINAL ACC\12\0" ! 1249: 8506970656420456E74727929 ! 1250: 202D204241442046494E414C2 ! 1251: 04143430A00 ! 1252: 1212 00000fa1 * .text ! 1253: 1213 0000EB09 dd 8f00000f76 pushl $L368 ! 1254: 1214 0000EB0F fe 08 effffff58e callf $8,_writes ! 1255: 1215 0000EB16 # print_subf_data(); ! 1256: 1216 0000EB16 fe 04 ef00000157 callf $4,_print_subf_data ! 1257: 1217 0000EB1D # } ! 1258: 1218 0000EB1D # if( halt_flg ) ! 1259: 1219 0000EB1D L364: ! 1260: 1220 0000EB1D 5d effffff581 tstl _halt_flg ! 1261: 1221 0000EB23 31 09 jeql L369 ! 1262: 1222 0000EB25 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1263: 1223 0000EB25 dd 01 pushl $1 ! 1264: 1224 0000EB27 fe 08 ef000001e4 callf $8,_subf_er_halt ! 1265: 1225 0000EB2E # if( loop_on_err ) { ! 1266: 1226 0000EB2E L369: ! 1267: 1227 0000EB2E 5d effffff570 tstl _loop_on_err ! 1268: 1228 0000EB34 31 0a jeql L370 ! 1269: 1229 0000EB36 # force_loop = TRUE; /* set the force loop flag */ ! 1270: 1230 0000EB36 0d 01 effffff567 movl $1,_force_loop ! 1271: 1231 0000EB3D # asm("brw _subf_8_lp1");; /* and loop on the error */ ! 1272: 1232 0000EB3D 13 ff49 brw _subf_8_lp1 ! 1273: 1233 0000EB40 # } /* end of loop on error */ ! 1274: 1234 0000EB40 # } /* end of compare error */ ! 1275: 1235 0000EB40 L370: ! 1276: 1236 0000EB40 # } /* end of WHILE loop */ ! 1277: 1237 0000EB40 L363: ! 1278: 1238 0000EB40 L359: ! 1279: 1239 0000EB40 6d effffff55e incl _index ! 1280: 1240 0000EB46 13 fef7 jbr L361 ! 1281: 1241 0000EB49 L360: ! 1282: 1242 0000EB49 # } /* end of subtest 8 */ ! 1283: 1243 0000EB49 40 ret#2 ! 1284: 1244 0000EB4A .set L355,0x0 ! 1285: 1245 0000EB4A L357: ! 1286: 1246 0000EB4A 13 fee0 jbr L358 ! 1287: 1247 0000EB4D .data ! 1288: 1248 00000d28 * .text ! 1289: 1249 0000EB4D 00 .align 1 ! 1290: 1250 0000EB4E .globl _subf_9 ! 1291: 1251 0000EB4E _subf_9: ! 1292: 1252 0000EB4E 0000 .word L371 ! 1293: 1253 0000EB50 # ! 1294: 1254 0000EB50 # ! 1295: 1255 0000EB50 # ! 1296: 1256 0000EB50 # /************************************************************************ ! 1297: 1257 0000EB50 # * ! 1298: 1258 0000EB50 # * SUBTEST 9 - pipelined exit test ! 1299: 1259 0000EB50 # * ! 1300: 1260 0000EB50 # ************************************************************************/ ! 1301: 1261 0000EB50 # subf_9() ! 1302: 1262 0000EB50 # { ! 1303: 1263 0000EB50 13 011d jbr L373 ! 1304: 1264 0000EB53 L374: ! 1305: 1265 0000EB53 # force_loop = FALSE; ! 1306: 1266 0000EB53 4d effffff54b clrl _force_loop ! 1307: 1267 0000EB59 # subtest = 9; ! 1308: 1268 0000EB59 0d 09 effffff544 movl $9,_subtest ! 1309: 1269 0000EB60 # for( index = 0; index < max_subf_1_index; index++ ) { ! 1310: 1270 0000EB60 4d effffff53e clrl _index ! 1311: 1271 0000EB66 L377: ! 1312: 1272 0000EB66 1d effffff538 effffff533 cmpl _index,_max_subf_1_index ! 1313: 1273 0000EB71 91 03 13 00f9 jgeq L376 ! 1314: 1274 0000EB76 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */ ! 1315: 1275 0000EB76 5c 0c effffff527 50 mull3 $12,_index,r0 ! 1316: 1276 0000EB7E 0d e000000000 effffff51b movl _subf_1_data(r0),_sgl_ld_acc ! 1317: 1277 0000EB89 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */ ! 1318: 1278 0000EB89 5c 0c effffff514 50 mull3 $12,_index,r0 ! 1319: 1279 0000EB91 0d e000000004 effffff508 movl _subf_1_data+4(r0),_sgl_value_1 ! 1320: 1280 0000EB9C # sgl_expected = subf_1_data[index].exp; /* get expected result */ ! 1321: 1281 0000EB9C 5c 0c effffff501 50 mull3 $12,_index,r0 ! 1322: 1282 0000EBA4 0d e000000008 effffff4f5 movl _subf_1_data+8(r0),_sgl_expected ! 1323: 1283 0000EBAF # /* ! 1324: 1284 0000EBAF # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1325: 1285 0000EBAF # * The force loop flag is set after the first error. ! 1326: 1286 0000EBAF # */ ! 1327: 1287 0000EBAF # asm("_subf_9_lp1:"); ! 1328: 1288 0000EBAF _subf_9_lp1: ! 1329: 1289 0000EBAF # asm("movl $0,r0"); /* clear r0 */ ! 1330: 1290 0000EBAF 0d 00 50 movl $0,r0 ! 1331: 1291 0000EBB2 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */ ! 1332: 1292 0000EBB2 06 effffff4ec ldf _sgl_ld_acc ! 1333: 1293 0000EBB8 # asm("subf _sgl_value_1"); /* subract the 2nd operand */ ! 1334: 1294 0000EBB8 d6 effffff4e6 subf _sgl_value_1 ! 1335: 1295 0000EBBE # asm("addf r0"); /* add a 0.0 to the result */ ! 1336: 1296 0000EBBE c6 50 addf r0 ! 1337: 1297 0000EBC0 # asm("stf _sgl_st_acc"); /* store the result */ ! 1338: 1298 0000EBC0 26 effffff4de stf _sgl_st_acc ! 1339: 1299 0000EBC6 # if( force_loop ) ! 1340: 1300 0000EBC6 5d effffff4d8 tstl _force_loop ! 1341: 1301 0000EBCC 31 02 jeql L378 ! 1342: 1302 0000EBCE # asm("brb _subf_9_lp1");; /* loop on the error */ ! 1343: 1303 0000EBCE 11 df brb _subf_9_lp1 ! 1344: 1304 0000EBD0 L378: ! 1345: 1305 0000EBD0 # /* ! 1346: 1306 0000EBD0 # * end error loop - test the results ! 1347: 1307 0000EBD0 # */ ! 1348: 1308 0000EBD0 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1349: 1309 0000EBD0 1d effffff4ce effffff4c9 cmpl _sgl_st_acc,_sgl_expected ! 1350: 1310 0000EBDB 21 03 13 0086 jeql L379 ! 1351: 1311 0000EBE0 # errcnt++; /* bump the error count */ ! 1352: 1312 0000EBE0 6d effffff4be incl _errcnt ! 1353: 1313 0000EBE6 # if( prt_error ) { ! 1354: 1314 0000EBE6 5d effffff4b8 tstl _prt_error ! 1355: 1315 0000EBEC 31 55 jeql L380 ! 1356: 1316 0000EBEE # writes(" \n"); /* start a new print line */ ! 1357: 1317 0000EBEE .data 1 ! 1358: 1318 00000fa1 * L381: ! 1359: 1319 00000fa1 * 200A00 .ascii " \12\0" ! 1360: 1320 00000fa4 * .text ! 1361: 1321 0000EBEE dd 8f00000fa1 pushl $L381 ! 1362: 1322 0000EBF4 fe 08 effffff4a9 callf $8,_writes ! 1363: 1323 0000EBFB # writes("cycle: "); ! 1364: 1324 0000EBFB .data 1 ! 1365: 1325 00000fa4 * L382: ! 1366: 1326 00000fa4 * 6379636C653A2000 .ascii "cycle: \0" ! 1367: 1327 00000fac * .text ! 1368: 1328 0000EBFB dd 8f00000fa4 pushl $L382 ! 1369: 1329 0000EC01 fe 08 effffff49c callf $8,_writes ! 1370: 1330 0000EC08 # writed( cycle ); ! 1371: 1331 0000EC08 dd effffff496 pushl _cycle ! 1372: 1332 0000EC0E fe 08 effffff48f callf $8,_writed ! 1373: 1333 0000EC15 # writes(" SUBF test "); ! 1374: 1334 0000EC15 .data 1 ! 1375: 1335 00000fac * L383: ! 1376: 1336 00000fac * 2020535542462074657374200 .ascii " SUBF test \0" ! 1377: 0 ! 1378: 1337 00000fb9 * .text ! 1379: 1338 0000EC15 dd 8f00000fac pushl $L383 ! 1380: 1339 0000EC1B fe 08 effffff482 callf $8,_writes ! 1381: 1340 0000EC22 # writed( test_no ); ! 1382: 1341 0000EC22 dd effffff47c pushl _test_no ! 1383: 1342 0000EC28 fe 08 effffff475 callf $8,_writed ! 1384: 1343 0000EC2F # writes(", subtest 9 (Piped Exit) - BAD FINAL ACC\n"); ! 1385: 1344 0000EC2F .data 1 ! 1386: 1345 00000fb9 * L384: ! 1387: 1346 00000fb9 * 2C20737562746573742039202 .ascii ", subtest 9 (Piped Exit) - BAD FINAL ACC\12\0" ! 1388: 8506970656420457869742920 ! 1389: 2D204241442046494E414C204 ! 1390: 143430A00 ! 1391: 1347 00000fe3 * .text ! 1392: 1348 0000EC2F dd 8f00000fb9 pushl $L384 ! 1393: 1349 0000EC35 fe 08 effffff468 callf $8,_writes ! 1394: 1350 0000EC3C # print_subf_data(); ! 1395: 1351 0000EC3C fe 04 ef00000031 callf $4,_print_subf_data ! 1396: 1352 0000EC43 # } ! 1397: 1353 0000EC43 # if( halt_flg ) ! 1398: 1354 0000EC43 L380: ! 1399: 1355 0000EC43 5d effffff45b tstl _halt_flg ! 1400: 1356 0000EC49 31 09 jeql L385 ! 1401: 1357 0000EC4B # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1402: 1358 0000EC4B dd 01 pushl $1 ! 1403: 1359 0000EC4D fe 08 ef000000be callf $8,_subf_er_halt ! 1404: 1360 0000EC54 # if( loop_on_err ) { ! 1405: 1361 0000EC54 L385: ! 1406: 1362 0000EC54 5d effffff44a tstl _loop_on_err ! 1407: 1363 0000EC5A 31 0a jeql L386 ! 1408: 1364 0000EC5C # force_loop = TRUE; /* set the force loop flag */ ! 1409: 1365 0000EC5C 0d 01 effffff441 movl $1,_force_loop ! 1410: 1366 0000EC63 # asm("brw _subf_9_lp1");; /* and loop on the error */ ! 1411: 1367 0000EC63 13 ff49 brw _subf_9_lp1 ! 1412: 1368 0000EC66 # } /* end of loop on error */ ! 1413: 1369 0000EC66 # } /* end of compare error */ ! 1414: 1370 0000EC66 L386: ! 1415: 1371 0000EC66 # } /* end of WHILE loop */ ! 1416: 1372 0000EC66 L379: ! 1417: 1373 0000EC66 L375: ! 1418: 1374 0000EC66 6d effffff438 incl _index ! 1419: 1375 0000EC6C 13 fef7 jbr L377 ! 1420: 1376 0000EC6F L376: ! 1421: 1377 0000EC6F # } /* end of subtest 9 */ ! 1422: 1378 0000EC6F 40 ret#2 ! 1423: 1379 0000EC70 .set L371,0x0 ! 1424: 1380 0000EC70 L373: ! 1425: 1381 0000EC70 13 fee0 jbr L374 ! 1426: 1382 0000EC73 .data ! 1427: 1383 00000d28 * .text ! 1428: 1384 0000EC73 00 .align 1 ! 1429: 1385 0000EC74 .globl _print_subf_data ! 1430: 1386 0000EC74 _print_subf_data: ! 1431: 1387 0000EC74 0000 .word L387 ! 1432: 1388 0000EC76 # ! 1433: 1389 0000EC76 # ! 1434: 1390 0000EC76 # ! 1435: 1391 0000EC76 # /************************************************************************** ! 1436: 1392 0000EC76 # * ! 1437: 1393 0000EC76 # * PRINT THE DATA AND STORE RESULTS ! 1438: 1394 0000EC76 # * ! 1439: 1395 0000EC76 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 1440: 1396 0000EC76 # * operand = xxxxxxxx, expected = xxxxxxxx ! 1441: 1397 0000EC76 # **************************************************************************/ ! 1442: 1398 0000EC76 # print_subf_data() ! 1443: 1399 0000EC76 # { ! 1444: 1400 0000EC76 13 0095 jbr L389 ! 1445: 1401 0000EC79 L390: ! 1446: 1402 0000EC79 # writes("initial Acc = "); ! 1447: 1403 0000EC79 .data 1 ! 1448: 1404 00000fe3 * L391: ! 1449: 1405 00000fe3 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1450: D2000 ! 1451: 1406 00000ff2 * .text ! 1452: 1407 0000EC79 dd 8f00000fe3 pushl $L391 ! 1453: 1408 0000EC7F fe 08 effffff41e callf $8,_writes ! 1454: 1409 0000EC86 # write32h( sgl_ld_acc ); ! 1455: 1410 0000EC86 dd effffff418 pushl _sgl_ld_acc ! 1456: 1411 0000EC8C fe 08 effffff411 callf $8,_write32h ! 1457: 1412 0000EC93 # writes(", stored = "); ! 1458: 1413 0000EC93 .data 1 ! 1459: 1414 00000ff2 * L392: ! 1460: 1415 00000ff2 * 2C2020202073746F726564203 .ascii ", stored = \0" ! 1461: D2000 ! 1462: 1416 00001001 * .text ! 1463: 1417 0000EC93 dd 8f00000ff2 pushl $L392 ! 1464: 1418 0000EC99 fe 08 effffff404 callf $8,_writes ! 1465: 1419 0000ECA0 # write32h( sgl_st_acc ); ! 1466: 1420 0000ECA0 dd effffff3fe pushl _sgl_st_acc ! 1467: 1421 0000ECA6 fe 08 effffff3f7 callf $8,_write32h ! 1468: 1422 0000ECAD # writes(", data index = "); ! 1469: 1423 0000ECAD .data 1 ! 1470: 1424 00001001 * L393: ! 1471: 1425 00001001 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1472: 8203D2000 ! 1473: 1426 00001012 * .text ! 1474: 1427 0000ECAD dd 8f00001001 pushl $L393 ! 1475: 1428 0000ECB3 fe 08 effffff3ea callf $8,_writes ! 1476: 1429 0000ECBA # writed( index ); ! 1477: 1430 0000ECBA dd effffff3e4 pushl _index ! 1478: 1431 0000ECC0 fe 08 effffff3dd callf $8,_writed ! 1479: 1432 0000ECC7 # writec('\n'); ! 1480: 1433 0000ECC7 dd 0a pushl $10 ! 1481: 1434 0000ECC9 fe 08 effffff3d4 callf $8,_writec ! 1482: 1435 0000ECD0 # writes(" operand = "); ! 1483: 1436 0000ECD0 .data 1 ! 1484: 1437 00001012 * L395: ! 1485: 1438 00001012 * 202020206F706572616E64203 .ascii " operand = \0" ! 1486: D2000 ! 1487: 1439 00001021 * .text ! 1488: 1440 0000ECD0 dd 8f00001012 pushl $L395 ! 1489: 1441 0000ECD6 fe 08 effffff3c7 callf $8,_writes ! 1490: 1442 0000ECDD # write32h( sgl_value_1 ); ! 1491: 1443 0000ECDD dd effffff3c1 pushl _sgl_value_1 ! 1492: 1444 0000ECE3 fe 08 effffff3ba callf $8,_write32h ! 1493: 1445 0000ECEA # writes(", expected = "); ! 1494: 1446 0000ECEA .data 1 ! 1495: 1447 00001021 * L396: ! 1496: 1448 00001021 * 2C20206578706563746564203 .ascii ", expected = \0" ! 1497: D2000 ! 1498: 1449 00001030 * .text ! 1499: 1450 0000ECEA dd 8f00001021 pushl $L396 ! 1500: 1451 0000ECF0 fe 08 effffff3ad callf $8,_writes ! 1501: 1452 0000ECF7 # write32h( sgl_expected ); ! 1502: 1453 0000ECF7 dd effffff3a7 pushl _sgl_expected ! 1503: 1454 0000ECFD fe 08 effffff3a0 callf $8,_write32h ! 1504: 1455 0000ED04 # writec('\n'); ! 1505: 1456 0000ED04 dd 0a pushl $10 ! 1506: 1457 0000ED06 fe 08 effffff397 callf $8,_writec ! 1507: 1458 0000ED0D # } ! 1508: 1459 0000ED0D 40 ret#2 ! 1509: 1460 0000ED0E .set L387,0x0 ! 1510: 1461 0000ED0E L389: ! 1511: 1462 0000ED0E 13 ff68 jbr L390 ! 1512: 1463 0000ED11 .data ! 1513: 1464 00000d28 * .text ! 1514: 1465 0000ED11 00 .align 1 ! 1515: 1466 0000ED12 .globl _subf_er_halt ! 1516: 1467 0000ED12 _subf_er_halt: ! 1517: 1468 0000ED12 0000 .word L397 ! 1518: 1469 0000ED14 # ! 1519: 1470 0000ED14 # ! 1520: 1471 0000ED14 # ! 1521: 1472 0000ED14 # /************************************************************************** ! 1522: 1473 0000ED14 # * ! 1523: 1474 0000ED14 # * HALT ON ERROR ROUTINE ! 1524: 1475 0000ED14 # * ! 1525: 1476 0000ED14 # **************************************************************************/ ! 1526: 1477 0000ED14 # subf_er_halt( halt_code ) ! 1527: 1478 0000ED14 # int halt_code; ! 1528: 1479 0000ED14 # { ! 1529: 1480 0000ED14 13 00af jbr L399 ! 1530: 1481 0000ED17 L400: ! 1531: 1482 0000ED17 # sgl_dummy1 = halt_code; /* get the error type */ ! 1532: 1483 0000ED17 0d ad04 effffff385 movl 4(fp),_sgl_dummy1 ! 1533: 1484 0000ED1F # asm("movl _test_no,r0"); /* r0 = test number */ ! 1534: 1485 0000ED1F 0d effffff37f 50 movl _test_no,r0 ! 1535: 1486 0000ED26 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1536: 1487 0000ED26 0d effffff378 51 movl _subtest,r1 ! 1537: 1488 0000ED2D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1538: 1489 0000ED2D 0d effffff371 52 movl _sgl_dummy1,r2 ! 1539: 1490 0000ED34 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1540: 1491 0000ED34 0d effffff36a 53 movl _cycle,r3 ! 1541: 1492 0000ED3B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 1542: 1493 0000ED3B 0d effffff363 54 movl _sgl_ld_acc,r4 ! 1543: 1494 0000ED42 # asm("movl _sgl_value_1,r5"); /* r5 = data subtracted */ ! 1544: 1495 0000ED42 0d effffff35c 55 movl _sgl_value_1,r5 ! 1545: 1496 0000ED49 # asm("movl _sgl_st_acc,r6"); /* r6 = data stored */ ! 1546: 1497 0000ED49 0d effffff355 56 movl _sgl_st_acc,r6 ! 1547: 1498 0000ED50 # if(halt_code == BAD_ACC_HLT ) { ! 1548: 1499 0000ED50 1d ad04 01 cmpl 4(fp),$1 ! 1549: 1500 0000ED54 21 10 jneq L401 ! 1550: 1501 0000ED56 # asm("movl _sgl_expected,r7"); /* r7 = data expected */ ! 1551: 1502 0000ED56 0d effffff348 57 movl _sgl_expected,r7 ! 1552: 1503 0000ED5D # asm("movl _index,r8"); /* r8 = data index */ ! 1553: 1504 0000ED5D 0d effffff341 58 movl _index,r8 ! 1554: 1505 0000ED64 # } else ! 1555: 1506 0000ED64 11 5e jbr L402 ! 1556: 1507 0000ED66 L401: ! 1557: 1508 0000ED66 # if( halt_code == BAD_REG_HLT ) { ! 1558: 1509 0000ED66 1d ad04 02 cmpl 4(fp),$2 ! 1559: 1510 0000ED6A 21 3d jneq L403 ! 1560: 1511 0000ED6C # sgl_dummy1 = load_regs[index2]; ! 1561: 1512 0000ED6C 0d effffff332 50 movl _index2,r0 ! 1562: 1513 0000ED73 0d 40effffff32a movl _load_regs[r0],_sgl_dummy1 ! 1563: effffff325 ! 1564: 1514 0000ED7F # sgl_dummy2 = store_regs[index2]; ! 1565: 1515 0000ED7F 0d effffff31f 50 movl _index2,r0 ! 1566: 1516 0000ED86 0d 40effffff317 movl _store_regs[r0],_sgl_dummy2 ! 1567: effffff312 ! 1568: 1517 0000ED92 # asm("movl _index2,r7"); /* r7 = bad register # */ ! 1569: 1518 0000ED92 0d effffff30c 57 movl _index2,r7 ! 1570: 1519 0000ED99 # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */ ! 1571: 1520 0000ED99 0d effffff305 58 movl _sgl_dummy2,r8 ! 1572: 1521 0000EDA0 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */ ! 1573: 1522 0000EDA0 0d effffff2fe 59 movl _sgl_dummy1,r9 ! 1574: 1523 0000EDA7 # } else ! 1575: 1524 0000EDA7 11 1b jbr L404 ! 1576: 1525 0000EDA9 L403: ! 1577: 1526 0000EDA9 # if( halt_code == BAD_PSL_HLT ) { ! 1578: 1527 0000EDA9 1d ad04 03 cmpl 4(fp),$3 ! 1579: 1528 0000EDAD 21 15 jneq L405 ! 1580: 1529 0000EDAF # asm("movl _init_psl,r7"); /* r7 = initial PSL */ ! 1581: 1530 0000EDAF 0d effffff2ef 57 movl _init_psl,r7 ! 1582: 1531 0000EDB6 # asm("movl _psl_val,r8"); /* r8 = final PSL */ ! 1583: 1532 0000EDB6 0d effffff2e8 58 movl _psl_val,r8 ! 1584: 1533 0000EDBD # asm("movl _exp_psl,r9"); /* r9 = expected PSL */ ! 1585: 1534 0000EDBD 0d effffff2e1 59 movl _exp_psl,r9 ! 1586: 1535 0000EDC4 # }; ! 1587: 1536 0000EDC4 L405: ! 1588: 1537 0000EDC4 L404: ! 1589: 1538 0000EDC4 L402: ! 1590: 1539 0000EDC4 # asm("halt"); /* HALT ... */ ! 1591: 1540 0000EDC4 00 halt ! 1592: 1541 0000EDC5 # } ! 1593: 1542 0000EDC5 40 ret#2 ! 1594: 1543 0000EDC6 .set L397,0x0 ! 1595: 1544 0000EDC6 L399: ! 1596: 1545 0000EDC6 13 ff4e jbr L400 ! 1597: 1546 0000EDC9 .data ! 1598: 1546 0001CE6D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.