![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtpr.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 mtpr.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 00000678 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _mtpr_tst ! 6: 6 00000000 _mtpr_tst: ! 7: 7 000259C4 0000 .word L215 ! 8: 8 000259C6 # ! 9: 9 000259C6 # #include "fpp_defs.h" ! 10: 10 000259C6 # ! 11: 11 000259C6 # #define TBL_SIZE 1024 /* size of the prom table */ ! 12: 12 000259C6 # ! 13: 13 000259C6 # /***************************************************************************** ! 14: 14 000259C6 # * ! 15: 15 000259C6 # * MTPR - TEST THE "READ TABLE DATA" MTPR INSTRUCTION ! 16: 16 000259C6 # * ! 17: 17 000259C6 # * This test checks the ability to use an MTPR to the Diagnostic Control ! 18: 18 000259C6 # * Register (DCR) to read an entry in the FPP tables. ! 19: 19 000259C6 # * ! 20: 20 000259C6 # * The instruction is: ! 21: 21 000259C6 # * MTPR $2048,$DCR ! 22: 22 000259C6 # * R0 = the table address to check ! 23: 23 000259C6 # * ! 24: 24 000259C6 # * The MTPR instruction will put the table data into R1. ! 25: 25 000259C6 # * ! 26: 26 000259C6 # *****************************************************************************/ ! 27: 27 000259C6 # mtpr_tst() ! 28: 28 000259C6 # { ! 29: 29 000259C6 11 3a jbr L217 ! 30: 30 000259C8 L218: ! 31: 31 000259C8 # asm(".globl _mtpr_t"); ! 32: 32 000259C8 .globl _mtpr_t ! 33: 33 000259C8 # asm("_mtpr_t:"); /* entry address */ ! 34: 34 000259C8 _mtpr_t: ! 35: 35 000259C8 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 36: 36 000259C8 1d effffffff6 01 cmpl _cycle,$1 ! 37: 37 000259CF 21 15 jneq L219 ! 38: 38 000259D1 5d efffffffed tstl _prt_hdrs ! 39: 39 000259D7 31 0d jeql L219 ! 40: 40 000259D9 # writes(" MTPR"); ! 41: 41 000259D9 .data 1 ! 42: 42 00000678 * L221: ! 43: 43 00000678 * 204D54505200 .ascii " MTPR\0" ! 44: 44 0000067e * .text ! 45: 45 000259D9 dd 8f00000678 pushl $L221 ! 46: 46 000259DF fe 08 efffffffde callf $8,_writes ! 47: 47 000259E6 # mtpr_1(); /* read w/ sgl accumulator */ ! 48: 48 000259E6 L219: ! 49: 49 000259E6 fe 04 ef00000017 callf $4,_mtpr_1 ! 50: 50 000259ED # mtpr_2(); /* read w/ dbl accumulator */ ! 51: 51 000259ED fe 04 ef0000010a callf $4,_mtpr_2 ! 52: 52 000259F4 # mtpr_3(); /* read during "sinf" */ ! 53: 53 000259F4 fe 04 ef0000021b callf $4,_mtpr_3 ! 54: 54 000259FB # asm("jmp *return"); /* return to the test monitor */ ! 55: 55 000259FB 71 ffffffffc3 jmp *return ! 56: 56 00025A01 # } ! 57: 57 00025A01 40 ret#2 ! 58: 58 00025A02 .set L215,0x0 ! 59: 59 00025A02 L217: ! 60: 60 00025A02 11 c4 jbr L218 ! 61: 61 00025A04 .data ! 62: 62 00000678 * .text ! 63: 63 00025A04 .align 1 ! 64: 64 00025A04 .globl _mtpr_1 ! 65: 65 00025A04 _mtpr_1: ! 66: 66 00025A04 0000 .word L225 ! 67: 67 00025A06 # ! 68: 68 00025A06 # ! 69: 69 00025A06 # ! 70: 70 00025A06 # /************************************************************************ ! 71: 71 00025A06 # * ! 72: 72 00025A06 # * SUBTEST 1 - Read the tables with a single precision accumulator ! 73: 73 00025A06 # * ! 74: 74 00025A06 # ************************************************************************/ ! 75: 75 00025A06 # mtpr_1() ! 76: 76 00025A06 # { ! 77: 77 00025A06 13 00f2 jbr L227 ! 78: 78 00025A09 L228: ! 79: 79 00025A09 # force_loop = FALSE; ! 80: 80 00025A09 4d efffffffb5 clrl _force_loop ! 81: 81 00025A0F # subtest = 1; ! 82: 82 00025A0F 0d 01 efffffffae movl $1,_subtest ! 83: 83 00025A16 # index = 0; ! 84: 84 00025A16 4d efffffffa8 clrl _index ! 85: 85 00025A1C # for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) { ! 86: 86 00025A1C 4d efffffffa2 clrl _sgl_value_1 ! 87: 87 00025A22 L231: ! 88: 88 00025A22 1d efffffff9c 890400 cmpl _sgl_value_1,$1024 ! 89: 89 00025A2B 91 03 13 00ca jgeq L230 ! 90: 90 00025A30 # sgl_ld_acc = ldf_1_data[index].ld; /* get a sgl value */ ! 91: 91 00025A30 0d efffffff8e 50 movl _index,r0 ! 92: 92 00025A37 48 03 50 50 shll $3,r0,r0 ! 93: 93 00025A3B 0d e000000000 efffffff7e movl _ldf_1_data(r0),_sgl_ld_acc ! 94: 94 00025A46 # sgl_expected = ldf_1_data[index].exp; /* & expected acc. */ ! 95: 95 00025A46 0d efffffff78 50 movl _index,r0 ! 96: 96 00025A4D 48 03 50 50 shll $3,r0,r0 ! 97: 97 00025A51 0d e000000004 efffffff68 movl _ldf_1_data+4(r0),_sgl_expected ! 98: 98 00025A5C # /* ! 99: 99 00025A5C # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 100: 100 00025A5C # * The force loop flag is set after the first error. ! 101: 101 00025A5C # */ ! 102: 102 00025A5C # asm("_mtpr_1_lp1:"); ! 103: 103 00025A5C _mtpr_1_lp1: ! 104: 104 00025A5C # asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 105: 105 00025A5C 06 efffffff62 ldf _sgl_ld_acc ! 106: 106 00025A62 # asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 107: 107 00025A62 0d efffffff5c 50 movl _sgl_value_1,r0 ! 108: 108 00025A69 # asm("clrl r1"); /* clear R1 */ ! 109: 109 00025A69 4d 51 clrl r1 ! 110: 110 00025A6B # asm("mtpr $0x800,$27"); /* read the table entry */ ! 111: 111 00025A6B ad 890800 1b mtpr $0x800,$27 ! 112: 112 00025A70 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 113: 113 00025A70 26 efffffff4e stf _sgl_st_acc ! 114: 114 00025A76 # asm("movl r1,_sgl_value_2"); /* save the value read */ ! 115: 115 00025A76 0d 51 efffffff47 movl r1,_sgl_value_2 ! 116: 116 00025A7D # if( force_loop ) ! 117: 117 00025A7D 5d efffffff41 tstl _force_loop ! 118: 118 00025A83 31 02 jeql L232 ! 119: 119 00025A85 # asm("brb _mtpr_1_lp1");; /* loop on the error */ ! 120: 120 00025A85 11 d5 brb _mtpr_1_lp1 ! 121: 121 00025A87 L232: ! 122: 122 00025A87 # /* ! 123: 123 00025A87 # * end error loop ! 124: 124 00025A87 # */ ! 125: 125 00025A87 # if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */ ! 126: 126 00025A87 1d efffffff37 efffffff32 cmpl _sgl_st_acc,_sgl_expected ! 127: 127 00025A92 31 41 jeql L233 ! 128: 128 00025A94 # errcnt++; /* bump the error count */ ! 129: 129 00025A94 6d efffffff2a incl _errcnt ! 130: 130 00025A9A # if( prt_error ) ! 131: 131 00025A9A 5d efffffff24 tstl _prt_error ! 132: 132 00025AA0 31 0d jeql L234 ! 133: 133 00025AA2 # print_mtpr_error( ! 134: 134 00025AA2 # " (SGL Accumulator) -THE ACC WAS MODIFIED"); ! 135: 135 00025AA2 .data 1 ! 136: 136 0000067e * L236: ! 137: 137 0000067e * 202853474C20416363756D756 .ascii " (SGL Accumulator) -THE ACC WAS MODIFIED\0" ! 138: C61746F7229202D5448452041 ! 139: 434320574153204D4F4449464 ! 140: 9454400 ! 141: 138 000006a7 * .text ! 142: 139 00025AA2 dd 8f0000067e pushl $L236 ! 143: 140 00025AA8 fe 08 ef000002eb callf $8,_print_mtpr_error ! 144: 141 00025AAF # if( halt_flg ) ! 145: 142 00025AAF L234: ! 146: 143 00025AAF 5d efffffff0f tstl _halt_flg ! 147: 144 00025AB5 31 09 jeql L237 ! 148: 145 00025AB7 # mtpr_er_halt( 2 ); ! 149: 146 00025AB7 dd 02 pushl $2 ! 150: 147 00025AB9 fe 08 ef000004a6 callf $8,_mtpr_er_halt ! 151: 148 00025AC0 # if( loop_on_err ) { ! 152: 149 00025AC0 L237: ! 153: 150 00025AC0 5d effffffefe tstl _loop_on_err ! 154: 151 00025AC6 31 0d jeql L239 ! 155: 152 00025AC8 # force_loop = TRUE; /* set the force loop flag */ ! 156: 153 00025AC8 0d 01 effffffef5 movl $1,_force_loop ! 157: 154 00025ACF # asm("jmp _mtpr_1_lp1"); /* and loop */ ! 158: 155 00025ACF 71 efffffff87 jmp _mtpr_1_lp1 ! 159: 156 00025AD5 # } ! 160: 157 00025AD5 # } /* end of compare error */ ! 161: 158 00025AD5 L239: ! 162: 159 00025AD5 # if( ++index > max_ldf_1_index ) ! 163: 160 00025AD5 L233: ! 164: 161 00025AD5 6d effffffee9 incl _index ! 165: 162 00025ADB 0d effffffee3 50 movl _index,r0 ! 166: 163 00025AE2 1d 50 effffffedb cmpl r0,_max_ldf_1_index ! 167: 164 00025AE9 51 06 jleq L240 ! 168: 165 00025AEB # index = 0; /* reset the Acc's index */ ! 169: 166 00025AEB 4d effffffed3 clrl _index ! 170: 167 00025AF1 # } ! 171: 168 00025AF1 L240: ! 172: 169 00025AF1 L229: ! 173: 170 00025AF1 6d effffffecd incl _sgl_value_1 ! 174: 171 00025AF7 13 ff28 jbr L231 ! 175: 172 00025AFA L230: ! 176: 173 00025AFA # } /* end of subtest 1 */ ! 177: 174 00025AFA 40 ret#2 ! 178: 175 00025AFB .set L225,0x0 ! 179: 176 00025AFB L227: ! 180: 177 00025AFB 13 ff0b jbr L228 ! 181: 178 00025AFE .data ! 182: 179 00000678 * .text ! 183: 180 00025AFE .align 1 ! 184: 181 00025AFE .globl _mtpr_2 ! 185: 182 00025AFE _mtpr_2: ! 186: 183 00025AFE 0000 .word L241 ! 187: 184 00025B00 # ! 188: 185 00025B00 # ! 189: 186 00025B00 # ! 190: 187 00025B00 # ! 191: 188 00025B00 # ! 192: 189 00025B00 # /************************************************************************ ! 193: 190 00025B00 # * ! 194: 191 00025B00 # * SUBTEST 2 - Read the tables with a double precision accumulator ! 195: 192 00025B00 # * ! 196: 193 00025B00 # ************************************************************************/ ! 197: 194 00025B00 # mtpr_2() ! 198: 195 00025B00 # { ! 199: 196 00025B00 13 010f jbr L243 ! 200: 197 00025B03 L244: ! 201: 198 00025B03 # force_loop = FALSE; ! 202: 199 00025B03 4d effffffebb clrl _force_loop ! 203: 200 00025B09 # subtest = 2; ! 204: 201 00025B09 0d 02 effffffeb4 movl $2,_subtest ! 205: 202 00025B10 # index = 0; ! 206: 203 00025B10 4d effffffeae clrl _index ! 207: 204 00025B16 # for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) { ! 208: 205 00025B16 4d effffffea8 clrl _sgl_value_1 ! 209: 206 00025B1C L247: ! 210: 207 00025B1C 1d effffffea2 890400 cmpl _sgl_value_1,$1024 ! 211: 208 00025B25 91 03 13 00e7 jgeq L246 ! 212: 209 00025B2A # dbl_ld_acc = ldd_1_data[index].ld; /* get a dbl value */ ! 213: 210 00025B2A 48 04 effffffe93 50 shll $4,_index,r0 ! 214: 211 00025B32 0c 8f00000000 50 addl2 $_ldd_1_data,r0 ! 215: 212 00025B39 0d a004 effffffe87 movl 4(r0),_dbl_ld_acc+4 ! 216: 213 00025B41 0d 60 effffffe7c movl (r0),_dbl_ld_acc ! 217: 214 00025B48 # dbl_expected = ldd_1_data[index].exp; /* & expected acc. */ ! 218: 215 00025B48 48 04 effffffe75 50 shll $4,_index,r0 ! 219: 216 00025B50 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0 ! 220: 217 00025B57 0d a004 effffffe69 movl 4(r0),_dbl_expected+4 ! 221: 218 00025B5F 0d 60 effffffe5e movl (r0),_dbl_expected ! 222: 219 00025B66 # /* ! 223: 220 00025B66 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 224: 221 00025B66 # * The force loop flag is set after the first error. ! 225: 222 00025B66 # */ ! 226: 223 00025B66 # asm("_mtpr_2_lp1:"); ! 227: 224 00025B66 _mtpr_2_lp1: ! 228: 225 00025B66 # asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 229: 226 00025B66 07 effffffe58 ldd _dbl_ld_acc ! 230: 227 00025B6C # asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 231: 228 00025B6C 0d effffffe52 50 movl _sgl_value_1,r0 ! 232: 229 00025B73 # asm("clrl r1"); /* clear R1 */ ! 233: 230 00025B73 4d 51 clrl r1 ! 234: 231 00025B75 # asm("mtpr $0x800,$27"); /* read the table entry */ ! 235: 232 00025B75 ad 890800 1b mtpr $0x800,$27 ! 236: 233 00025B7A # asm("std _dbl_st_acc"); /* save the accumulator */ ! 237: 234 00025B7A 27 effffffe44 std _dbl_st_acc ! 238: 235 00025B80 # asm("movl r1,_sgl_value_2"); /* save the value read */ ! 239: 236 00025B80 0d 51 effffffe3d movl r1,_sgl_value_2 ! 240: 237 00025B87 # if( force_loop ) ! 241: 238 00025B87 5d effffffe37 tstl _force_loop ! 242: 239 00025B8D 31 02 jeql L248 ! 243: 240 00025B8F # asm("brb _mtpr_2_lp1");; /* loop on the error */ ! 244: 241 00025B8F 11 d5 brb _mtpr_2_lp1 ! 245: 242 00025B91 L248: ! 246: 243 00025B91 # /* ! 247: 244 00025B91 # * end error loop ! 248: 245 00025B91 # */ ! 249: 246 00025B91 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the acc. */ ! 250: 247 00025B91 # (dbl_st_acc.l != dbl_expected.l) ) { ! 251: 248 00025B91 1d effffffe2d effffffe28 cmpl _dbl_st_acc,_dbl_expected ! 252: 249 00025B9C 21 0d jneq L9999 ! 253: 250 00025B9E 1d effffffe24 effffffe1f cmpl _dbl_st_acc+4,_dbl_expected+4 ! 254: 251 00025BA9 31 41 jeql L249 ! 255: 252 00025BAB L9999: ! 256: 253 00025BAB # errcnt++; /* bump the error count */ ! 257: 254 00025BAB 6d effffffe13 incl _errcnt ! 258: 255 00025BB1 # if( prt_error ) ! 259: 256 00025BB1 5d effffffe0d tstl _prt_error ! 260: 257 00025BB7 31 0d jeql L250 ! 261: 258 00025BB9 # print_mtpr_error( ! 262: 259 00025BB9 # " (DBL Accumulator) -THE ACC WAS MODIFIED"); ! 263: 260 00025BB9 .data 1 ! 264: 261 000006a7 * L251: ! 265: 262 000006a7 * 202844424C20416363756D756 .ascii " (DBL Accumulator) -THE ACC WAS MODIFIED\0" ! 266: C61746F7229202D5448452041 ! 267: 434320574153204D4F4449464 ! 268: 9454400 ! 269: 263 000006d0 * .text ! 270: 264 00025BB9 dd 8f000006a7 pushl $L251 ! 271: 265 00025BBF fe 08 ef000001d4 callf $8,_print_mtpr_error ! 272: 266 00025BC6 # if( halt_flg ) ! 273: 267 00025BC6 L250: ! 274: 268 00025BC6 5d effffffdf8 tstl _halt_flg ! 275: 269 00025BCC 31 09 jeql L252 ! 276: 270 00025BCE # mtpr_er_halt( 2 ); ! 277: 271 00025BCE dd 02 pushl $2 ! 278: 272 00025BD0 fe 08 ef0000038f callf $8,_mtpr_er_halt ! 279: 273 00025BD7 # if( loop_on_err ) { ! 280: 274 00025BD7 L252: ! 281: 275 00025BD7 5d effffffde7 tstl _loop_on_err ! 282: 276 00025BDD 31 0d jeql L253 ! 283: 277 00025BDF # force_loop = TRUE; /* set the force loop flag */ ! 284: 278 00025BDF 0d 01 effffffdde movl $1,_force_loop ! 285: 279 00025BE6 # asm("jmp _mtpr_2_lp1"); /* and loop */ ! 286: 280 00025BE6 71 efffffff7a jmp _mtpr_2_lp1 ! 287: 281 00025BEC # } ! 288: 282 00025BEC # } /* end of compare error */ ! 289: 283 00025BEC L253: ! 290: 284 00025BEC # if( ++index > max_ldf_1_index ) ! 291: 285 00025BEC L249: ! 292: 286 00025BEC 6d effffffdd2 incl _index ! 293: 287 00025BF2 0d effffffdcc 50 movl _index,r0 ! 294: 288 00025BF9 1d 50 effffffdc4 cmpl r0,_max_ldf_1_index ! 295: 289 00025C00 51 06 jleq L254 ! 296: 290 00025C02 # index = 0; /* reset the Acc's index */ ! 297: 291 00025C02 4d effffffdbc clrl _index ! 298: 292 00025C08 # } ! 299: 293 00025C08 L254: ! 300: 294 00025C08 L245: ! 301: 295 00025C08 6d effffffdb6 incl _sgl_value_1 ! 302: 296 00025C0E 13 ff0b jbr L247 ! 303: 297 00025C11 L246: ! 304: 298 00025C11 # } /* end of subtest 2 */ ! 305: 299 00025C11 40 ret#2 ! 306: 300 00025C12 .set L241,0x0 ! 307: 301 00025C12 L243: ! 308: 302 00025C12 13 feee jbr L244 ! 309: 303 00025C15 .data ! 310: 304 00000678 * .text ! 311: 305 00025C15 00 .align 1 ! 312: 306 00025C16 .globl _mtpr_3 ! 313: 307 00025C16 _mtpr_3: ! 314: 308 00025C16 0000 .word L255 ! 315: 309 00025C18 # ! 316: 310 00025C18 # ! 317: 311 00025C18 # ! 318: 312 00025C18 # ! 319: 313 00025C18 # ! 320: 314 00025C18 # /************************************************************************ ! 321: 315 00025C18 # * ! 322: 316 00025C18 # * SUBTEST 3 - Read table data during a SINF function ! 323: 317 00025C18 # * ! 324: 318 00025C18 # * Read every 10th table entry while doing SINF's. ! 325: 319 00025C18 # * Read the entry once, read it again during a SINF, verify that the SINF ! 326: 320 00025C18 # * result is correct and that the same table data was read. ! 327: 321 00025C18 # ************************************************************************/ ! 328: 322 00025C18 # mtpr_3() ! 329: 323 00025C18 # { ! 330: 324 00025C18 13 0178 jbr L257 ! 331: 325 00025C1B L258: ! 332: 326 00025C1B # int max_index; ! 333: 327 00025C1B # force_loop = FALSE; ! 334: 328 00025C1B 4d effffffda3 clrl _force_loop ! 335: 329 00025C21 # subtest = 3; ! 336: 330 00025C21 0d 03 effffffd9c movl $3,_subtest ! 337: 331 00025C28 # max_index = TBL_SIZE / 10; ! 338: 332 00025C28 0d 8866 adc8 movl $102,-56(fp) ! 339: 333 00025C2D # if( max_index > max_sinf_1_index ) /* don't go over the SIN data */ ! 340: 334 00025C2D 1d adc8 effffffd8f cmpl -56(fp),_max_sinf_1_index ! 341: 335 00025C35 51 08 jleq L259 ! 342: 336 00025C37 # max_index = max_sinf_1_index; /* set the max index value */ ! 343: 337 00025C37 0d effffffd87 adc8 movl _max_sinf_1_index,-56(fp) ! 344: 338 00025C3F # for( index = 0; index < max_sinf_1_index; index++ ) { ! 345: 339 00025C3F L259: ! 346: 340 00025C3F 4d effffffd7f clrl _index ! 347: 341 00025C45 L262: ! 348: 342 00025C45 1d effffffd79 effffffd74 cmpl _index,_max_sinf_1_index ! 349: 343 00025C50 91 03 13 013d jgeq L261 ! 350: 344 00025C55 # sgl_value_1 = index * 10; /* get table entry to read */ ! 351: 345 00025C55 5c 0a effffffd68 50 mull3 $10,_index,r0 ! 352: 346 00025C5D 0d 50 effffffd60 movl r0,_sgl_value_1 ! 353: 347 00025C64 # sgl_ld_acc = sinf_1_data[index].ld; /* get a sgl value */ ! 354: 348 00025C64 0d effffffd5a 50 movl _index,r0 ! 355: 349 00025C6B 48 03 50 50 shll $3,r0,r0 ! 356: 350 00025C6F 0d e000000000 effffffd4a movl _sinf_1_data(r0),_sgl_ld_acc ! 357: 351 00025C7A # sgl_expected = sinf_1_data[index].exp; /* & expected acc. */ ! 358: 352 00025C7A 0d effffffd44 50 movl _index,r0 ! 359: 353 00025C81 48 03 50 50 shll $3,r0,r0 ! 360: 354 00025C85 0d e000000004 effffffd34 movl _sinf_1_data+4(r0),_sgl_expected ! 361: 355 00025C90 # asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 362: 356 00025C90 0d effffffd2e 50 movl _sgl_value_1,r0 ! 363: 357 00025C97 # asm("clrl r1"); /* clear R1 */ ! 364: 358 00025C97 4d 51 clrl r1 ! 365: 359 00025C99 # asm("mtpr $0x800,$27"); /* read the table entry */ ! 366: 360 00025C99 ad 890800 1b mtpr $0x800,$27 ! 367: 361 00025C9E # asm("movl r1,_sgl_value_3"); /* save the value read */ ! 368: 362 00025C9E 0d 51 effffffd1f movl r1,_sgl_value_3 ! 369: 363 00025CA5 # /* ! 370: 364 00025CA5 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 371: 365 00025CA5 # * The force loop flag is set after the first error. ! 372: 366 00025CA5 # */ ! 373: 367 00025CA5 # asm("_mtpr_3_lp1:"); ! 374: 368 00025CA5 _mtpr_3_lp1: ! 375: 369 00025CA5 # asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 376: 370 00025CA5 06 effffffd19 ldf _sgl_ld_acc ! 377: 371 00025CAB # asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 378: 372 00025CAB 0d effffffd13 50 movl _sgl_value_1,r0 ! 379: 373 00025CB2 # asm("clrl r1"); /* clear R1 */ ! 380: 374 00025CB2 4d 51 clrl r1 ! 381: 375 00025CB4 # asm("sinf"); /* start the SIN function */ ! 382: 376 00025CB4 05 sinf ! 383: 377 00025CB5 # asm("mtpr $0x800,$27"); /* read the table entry */ ! 384: 378 00025CB5 ad 890800 1b mtpr $0x800,$27 ! 385: 379 00025CBA # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 386: 380 00025CBA 26 effffffd04 stf _sgl_st_acc ! 387: 381 00025CC0 # asm("movl r1,_sgl_value_2"); /* save the value read */ ! 388: 382 00025CC0 0d 51 effffffcfd movl r1,_sgl_value_2 ! 389: 383 00025CC7 # if( force_loop ) ! 390: 384 00025CC7 5d effffffcf7 tstl _force_loop ! 391: 385 00025CCD 31 02 jeql L263 ! 392: 386 00025CCF # asm("brb _mtpr_3_lp1");; /* loop on the error */ ! 393: 387 00025CCF 11 d4 brb _mtpr_3_lp1 ! 394: 388 00025CD1 L263: ! 395: 389 00025CD1 # /* ! 396: 390 00025CD1 # * end error loop ! 397: 391 00025CD1 # */ ! 398: 392 00025CD1 # if( sgl_value_2 != sgl_value_3 ) { /* verify the data read */ ! 399: 393 00025CD1 1d effffffced effffffce8 cmpl _sgl_value_2,_sgl_value_3 ! 400: 394 00025CDC 31 41 jeql L264 ! 401: 395 00025CDE # errcnt++; /* bump the error count */ ! 402: 396 00025CDE 6d effffffce0 incl _errcnt ! 403: 397 00025CE4 # if( prt_error ) ! 404: 398 00025CE4 5d effffffcda tstl _prt_error ! 405: 399 00025CEA 31 0d jeql L265 ! 406: 400 00025CEC # print_mtpr_error( bad_tbl_entry_msg ); ! 407: 401 00025CEC dd effffffcd2 pushl _bad_tbl_entry_msg ! 408: 402 00025CF2 fe 08 ef000000a1 callf $8,_print_mtpr_error ! 409: 403 00025CF9 # if( halt_flg ) ! 410: 404 00025CF9 L265: ! 411: 405 00025CF9 5d effffffcc5 tstl _halt_flg ! 412: 406 00025CFF 31 09 jeql L266 ! 413: 407 00025D01 # mtpr_er_halt( 1 ); ! 414: 408 00025D01 dd 01 pushl $1 ! 415: 409 00025D03 fe 08 ef0000025c callf $8,_mtpr_er_halt ! 416: 410 00025D0A # if( loop_on_err ) { ! 417: 411 00025D0A L266: ! 418: 412 00025D0A 5d effffffcb4 tstl _loop_on_err ! 419: 413 00025D10 31 0d jeql L267 ! 420: 414 00025D12 # force_loop = TRUE; /* set the force loop flag */ ! 421: 415 00025D12 0d 01 effffffcab movl $1,_force_loop ! 422: 416 00025D19 # asm("jmp _mtpr_3_lp1"); /* and loop */ ! 423: 417 00025D19 71 efffffff86 jmp _mtpr_3_lp1 ! 424: 418 00025D1F # } ! 425: 419 00025D1F # } /* end of table data compare error */ ! 426: 420 00025D1F L267: ! 427: 421 00025D1F # if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */ ! 428: 422 00025D1F L264: ! 429: 423 00025D1F 1d effffffc9f effffffc9a cmpl _sgl_st_acc,_sgl_expected ! 430: 424 00025D2A 31 41 jeql L268 ! 431: 425 00025D2C # errcnt++; /* bump the error count */ ! 432: 426 00025D2C 6d effffffc92 incl _errcnt ! 433: 427 00025D32 # if( prt_error ) ! 434: 428 00025D32 5d effffffc8c tstl _prt_error ! 435: 429 00025D38 31 0d jeql L269 ! 436: 430 00025D3A # print_mtpr_error(" -BAD FINAL ACC"); ! 437: 431 00025D3A .data 1 ! 438: 432 000006d0 * L270: ! 439: 433 000006d0 * 20202D4241442046494E414C2 .ascii " -BAD FINAL ACC\0" ! 440: 041434300 ! 441: 434 000006e1 * .text ! 442: 435 00025D3A dd 8f000006d0 pushl $L270 ! 443: 436 00025D40 fe 08 ef00000053 callf $8,_print_mtpr_error ! 444: 437 00025D47 # if( halt_flg ) ! 445: 438 00025D47 L269: ! 446: 439 00025D47 5d effffffc77 tstl _halt_flg ! 447: 440 00025D4D 31 09 jeql L271 ! 448: 441 00025D4F # mtpr_er_halt( 3 ); ! 449: 442 00025D4F dd 03 pushl $3 ! 450: 443 00025D51 fe 08 ef0000020e callf $8,_mtpr_er_halt ! 451: 444 00025D58 # if( loop_on_err ) { ! 452: 445 00025D58 L271: ! 453: 446 00025D58 5d effffffc66 tstl _loop_on_err ! 454: 447 00025D5E 31 0d jeql L272 ! 455: 448 00025D60 # force_loop = TRUE; /* set the force loop flag */ ! 456: 449 00025D60 0d 01 effffffc5d movl $1,_force_loop ! 457: 450 00025D67 # asm("jmp _mtpr_3_lp1"); /* and loop */ ! 458: 451 00025D67 71 efffffff38 jmp _mtpr_3_lp1 ! 459: 452 00025D6D # } ! 460: 453 00025D6D # } /* end of SINF compare error */ ! 461: 454 00025D6D L272: ! 462: 455 00025D6D # if( ++index > max_sinf_1_index ) ! 463: 456 00025D6D L268: ! 464: 457 00025D6D 6d effffffc51 incl _index ! 465: 458 00025D73 0d effffffc4b 50 movl _index,r0 ! 466: 459 00025D7A 1d 50 effffffc43 cmpl r0,_max_sinf_1_index ! 467: 460 00025D81 51 06 jleq L273 ! 468: 461 00025D83 # index = 0; /* reset the Acc's index */ ! 469: 462 00025D83 4d effffffc3b clrl _index ! 470: 463 00025D89 # } ! 471: 464 00025D89 L273: ! 472: 465 00025D89 L260: ! 473: 466 00025D89 6d effffffc35 incl _index ! 474: 467 00025D8F 13 feb3 jbr L262 ! 475: 468 00025D92 L261: ! 476: 469 00025D92 # } /* end of subtest 3 */ ! 477: 470 00025D92 40 ret#2 ! 478: 471 00025D93 .set L255,0x0 ! 479: 472 00025D93 L257: ! 480: 473 00025D93 3c 38 5d 5e subl3 $56,fp,sp ! 481: 474 00025D97 13 fe81 jbr L258 ! 482: 475 00025D9A .data ! 483: 476 00000678 * .text ! 484: 477 00025D9A .align 1 ! 485: 478 00025D9A .globl _print_mtpr_error ! 486: 479 00025D9A _print_mtpr_error: ! 487: 480 00025D9A 0000 .word L274 ! 488: 481 00025D9C # ! 489: 482 00025D9C # ! 490: 483 00025D9C # ! 491: 484 00025D9C # /****************************************************************************** ! 492: 485 00025D9C # * ! 493: 486 00025D9C # * Print an error message of the form: ! 494: 487 00025D9C # * ! 495: 488 00025D9C # * cycle: xx MTPR test xx, subtest xx <your message here> ! 496: 489 00025D9C # * table index = xxxxxxxx, table entry read = xxxxxxxx (2nd read) ! 497: 490 00025D9C # * expected entry = xxxxxxxx (1st read) ! 498: 491 00025D9C # * or ! 499: 492 00025D9C # * cycle: xx MTPR test xx, subtest xx <your message here> ! 500: 493 00025D9C # * table index = xxxxxxxx, table entry = xxxxxxxx ! 501: 494 00025D9C # * initial Acc = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx ! 502: 495 00025D9C # * expected Acc = xxxxxxxx xxxxxxxx ! 503: 496 00025D9C # ******************************************************************************/ ! 504: 497 00025D9C # print_mtpr_error( msg ) ! 505: 498 00025D9C # char *msg; ! 506: 499 00025D9C # { ! 507: 500 00025D9C 13 01c3 jbr L276 ! 508: 501 00025D9F L277: ! 509: 502 00025D9F # writes(" \n"); /* start a new print line */ ! 510: 503 00025D9F .data 1 ! 511: 504 000006e1 * L278: ! 512: 505 000006e1 * 200A00 .ascii " \12\0" ! 513: 506 000006e4 * .text ! 514: 507 00025D9F dd 8f000006e1 pushl $L278 ! 515: 508 00025DA5 fe 08 effffffc18 callf $8,_writes ! 516: 509 00025DAC # writes("cycle: "); ! 517: 510 00025DAC .data 1 ! 518: 511 000006e4 * L279: ! 519: 512 000006e4 * 6379636C653A2000 .ascii "cycle: \0" ! 520: 513 000006ec * .text ! 521: 514 00025DAC dd 8f000006e4 pushl $L279 ! 522: 515 00025DB2 fe 08 effffffc0b callf $8,_writes ! 523: 516 00025DB9 # writed( cycle ); ! 524: 517 00025DB9 dd effffffc05 pushl _cycle ! 525: 518 00025DBF fe 08 effffffbfe callf $8,_writed ! 526: 519 00025DC6 # writes(" MTPR test "); ! 527: 520 00025DC6 .data 1 ! 528: 521 000006ec * L281: ! 529: 522 000006ec * 20204D5450522074657374200 .ascii " MTPR test \0" ! 530: 0 ! 531: 523 000006f9 * .text ! 532: 524 00025DC6 dd 8f000006ec pushl $L281 ! 533: 525 00025DCC fe 08 effffffbf1 callf $8,_writes ! 534: 526 00025DD3 # writed( test_no ); ! 535: 527 00025DD3 dd effffffbeb pushl _test_no ! 536: 528 00025DD9 fe 08 effffffbe4 callf $8,_writed ! 537: 529 00025DE0 # writes( msg ); ! 538: 530 00025DE0 dd ad04 pushl 4(fp) ! 539: 531 00025DE3 fe 08 effffffbda callf $8,_writes ! 540: 532 00025DEA # writes("\ntable index = "); ! 541: 533 00025DEA .data 1 ! 542: 534 000006f9 * L282: ! 543: 535 000006f9 * 0A7461626C6520696E6465782 .ascii "\12table index = \0" ! 544: 03D2000 ! 545: 536 00000709 * .text ! 546: 537 00025DEA dd 8f000006f9 pushl $L282 ! 547: 538 00025DF0 fe 08 effffffbcd callf $8,_writes ! 548: 539 00025DF7 # write32h( sgl_value_1 ); ! 549: 540 00025DF7 dd effffffbc7 pushl _sgl_value_1 ! 550: 541 00025DFD fe 08 effffffbc0 callf $8,_write32h ! 551: 542 00025E04 # if( msg == bad_tbl_entry_msg ) { /* bad data read? */ ! 552: 543 00025E04 1d ad04 effffffbb8 cmpl 4(fp),_bad_tbl_entry_msg ! 553: 544 00025E0C 21 51 jneq L284 ! 554: 545 00025E0E # writes(", table entry = "); ! 555: 546 00025E0E .data 1 ! 556: 547 00000709 * L285: ! 557: 548 00000709 * 2C20207461626C6520656E747 .ascii ", table entry = \0" ! 558: 279203D2000 ! 559: 549 0000071b * .text ! 560: 550 00025E0E dd 8f00000709 pushl $L285 ! 561: 551 00025E14 fe 08 effffffba9 callf $8,_writes ! 562: 552 00025E1B # write32h( sgl_value_2 ); ! 563: 553 00025E1B dd effffffba3 pushl _sgl_value_2 ! 564: 554 00025E21 fe 08 effffffb9c callf $8,_write32h ! 565: 555 00025E28 # writes(" (2nd read)\n"); ! 566: 556 00025E28 .data 1 ! 567: 557 0000071b * L286: ! 568: 558 0000071b * 20202028326E6420726561642 .ascii " (2nd read)\12\0" ! 569: 90A00 ! 570: 559 0000072a * .text ! 571: 560 00025E28 dd 8f0000071b pushl $L286 ! 572: 561 00025E2E fe 08 effffffb8f callf $8,_writes ! 573: 562 00025E35 # writes(" entry expected = "); ! 574: 563 00025E35 .data 1 ! 575: 564 0000072a * L287: ! 576: 565 0000072a * 2020202020202020202020202 .ascii " entry expected = \0" ! 577: 0202020202020202020656E74 ! 578: 7279206578706563746564203 ! 579: D2000 ! 580: 566 00000752 * .text ! 581: 567 00025E35 dd 8f0000072a pushl $L287 ! 582: 568 00025E3B fe 08 effffffb82 callf $8,_writes ! 583: 569 00025E42 # write32h( sgl_value_3 ); ! 584: 570 00025E42 dd effffffb7c pushl _sgl_value_3 ! 585: 571 00025E48 fe 08 effffffb75 callf $8,_write32h ! 586: 572 00025E4F # writes(" (1st read)\n"); ! 587: 573 00025E4F .data 1 ! 588: 574 00000752 * L288: ! 589: 575 00000752 * 2020202831737420726561642 .ascii " (1st read)\12\0" ! 590: 90A00 ! 591: 576 00000761 * .text ! 592: 577 00025E4F dd 8f00000752 pushl $L288 ! 593: 578 00025E55 fe 08 effffffb68 callf $8,_writes ! 594: 579 00025E5C # } else { /* bad accumulator error */ ! 595: 580 00025E5C 13 0102 jbr L289 ! 596: 581 00025E5F L284: ! 597: 582 00025E5F # writes(", table entry = "); ! 598: 583 00025E5F .data 1 ! 599: 584 00000761 * L290: ! 600: 585 00000761 * 2C20207461626C6520656E747 .ascii ", table entry = \0" ! 601: 279203D2000 ! 602: 586 00000773 * .text ! 603: 587 00025E5F dd 8f00000761 pushl $L290 ! 604: 588 00025E65 fe 08 effffffb58 callf $8,_writes ! 605: 589 00025E6C # write32h( sgl_value_2 ); ! 606: 590 00025E6C dd effffffb52 pushl _sgl_value_2 ! 607: 591 00025E72 fe 08 effffffb4b callf $8,_write32h ! 608: 592 00025E79 # writes("\ninitial Acc = "); ! 609: 593 00025E79 .data 1 ! 610: 594 00000773 * L291: ! 611: 595 00000773 * 0A696E697469616C204163632 .ascii "\12initial Acc = \0" ! 612: 03D2000 ! 613: 596 00000783 * .text ! 614: 597 00025E79 dd 8f00000773 pushl $L291 ! 615: 598 00025E7F fe 08 effffffb3e callf $8,_writes ! 616: 599 00025E86 # if( subtest == 2 ) { /* DBL precision? */ ! 617: 600 00025E86 1d effffffb38 02 cmpl _subtest,$2 ! 618: 601 00025E8D 31 03 13 0085 jneq L292 ! 619: 602 00025E92 # write32h( dbl_ld_acc.m ); ! 620: 603 00025E92 dd effffffb2c pushl _dbl_ld_acc ! 621: 604 00025E98 fe 08 effffffb25 callf $8,_write32h ! 622: 605 00025E9F # writec(' '); ! 623: 606 00025E9F dd 20 pushl $32 ! 624: 607 00025EA1 fe 08 effffffb1c callf $8,_writec ! 625: 608 00025EA8 # write32h( dbl_ld_acc.l ); ! 626: 609 00025EA8 dd effffffb1a pushl _dbl_ld_acc+4 ! 627: 610 00025EAE fe 08 effffffb0f callf $8,_write32h ! 628: 611 00025EB5 # writes(", final Acc = "); ! 629: 612 00025EB5 .data 1 ! 630: 613 00000783 * L294: ! 631: 614 00000783 * 2C2020202066696E616C20416 .ascii ", final Acc = \0" ! 632: 363203D2000 ! 633: 615 00000795 * .text ! 634: 616 00025EB5 dd 8f00000783 pushl $L294 ! 635: 617 00025EBB fe 08 effffffb02 callf $8,_writes ! 636: 618 00025EC2 # write32h( dbl_st_acc.m ); ! 637: 619 00025EC2 dd effffffafc pushl _dbl_st_acc ! 638: 620 00025EC8 fe 08 effffffaf5 callf $8,_write32h ! 639: 621 00025ECF # writec(' '); ! 640: 622 00025ECF dd 20 pushl $32 ! 641: 623 00025ED1 fe 08 effffffaec callf $8,_writec ! 642: 624 00025ED8 # write32h( dbl_st_acc.l ); ! 643: 625 00025ED8 dd effffffaea pushl _dbl_st_acc+4 ! 644: 626 00025EDE fe 08 effffffadf callf $8,_write32h ! 645: 627 00025EE5 # writes("\n expected Acc = "); ! 646: 628 00025EE5 .data 1 ! 647: 629 00000795 * L295: ! 648: 630 00000795 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0" ! 649: 0202020202020202020202020 ! 650: 2020202020202020206578706 ! 651: 56374656420416363203D2000 ! 652: 631 000007c7 * .text ! 653: 632 00025EE5 dd 8f00000795 pushl $L295 ! 654: 633 00025EEB fe 08 effffffad2 callf $8,_writes ! 655: 634 00025EF2 # write32h( dbl_expected.m ); ! 656: 635 00025EF2 dd effffffacc pushl _dbl_expected ! 657: 636 00025EF8 fe 08 effffffac5 callf $8,_write32h ! 658: 637 00025EFF # writec(' '); ! 659: 638 00025EFF dd 20 pushl $32 ! 660: 639 00025F01 fe 08 effffffabc callf $8,_writec ! 661: 640 00025F08 # write32h( dbl_expected.l ); ! 662: 641 00025F08 dd effffffaba pushl _dbl_expected+4 ! 663: 642 00025F0E fe 08 effffffaaf callf $8,_write32h ! 664: 643 00025F15 # } else { /* SGL precision */ ! 665: 644 00025F15 11 41 jbr L296 ! 666: 645 00025F17 L292: ! 667: 646 00025F17 # write32h( sgl_ld_acc ); ! 668: 647 00025F17 dd effffffaa7 pushl _sgl_ld_acc ! 669: 648 00025F1D fe 08 effffffaa0 callf $8,_write32h ! 670: 649 00025F24 # writes(", final Acc = "); ! 671: 650 00025F24 .data 1 ! 672: 651 000007c7 * L297: ! 673: 652 000007c7 * 2C2020202066696E616C20416 .ascii ", final Acc = \0" ! 674: 363203D2000 ! 675: 653 000007d9 * .text ! 676: 654 00025F24 dd 8f000007c7 pushl $L297 ! 677: 655 00025F2A fe 08 effffffa93 callf $8,_writes ! 678: 656 00025F31 # write32h( sgl_st_acc ); ! 679: 657 00025F31 dd effffffa8d pushl _sgl_st_acc ! 680: 658 00025F37 fe 08 effffffa86 callf $8,_write32h ! 681: 659 00025F3E # writes("\n expected Acc = "); ! 682: 660 00025F3E .data 1 ! 683: 661 000007d9 * L298: ! 684: 662 000007d9 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0" ! 685: 0202020202020202020202020 ! 686: 6578706563746564204163632 ! 687: 03D2000 ! 688: 663 00000802 * .text ! 689: 664 00025F3E dd 8f000007d9 pushl $L298 ! 690: 665 00025F44 fe 08 effffffa79 callf $8,_writes ! 691: 666 00025F4B # write32h( sgl_expected ); ! 692: 667 00025F4B dd effffffa73 pushl _sgl_expected ! 693: 668 00025F51 fe 08 effffffa6c callf $8,_write32h ! 694: 669 00025F58 # } ! 695: 670 00025F58 L296: ! 696: 671 00025F58 # writec('\n'); ! 697: 672 00025F58 dd 0a pushl $10 ! 698: 673 00025F5A fe 08 effffffa63 callf $8,_writec ! 699: 674 00025F61 # } ! 700: 675 00025F61 L289: ! 701: 676 00025F61 # } ! 702: 677 00025F61 40 ret#2 ! 703: 678 00025F62 .set L274,0x0 ! 704: 679 00025F62 L276: ! 705: 680 00025F62 13 fe3a jbr L277 ! 706: 681 00025F65 .data ! 707: 682 00000678 * .text ! 708: 683 00025F65 00 .align 1 ! 709: 684 00025F66 .globl _mtpr_er_halt ! 710: 685 00025F66 _mtpr_er_halt: ! 711: 686 00025F66 0000 .word L299 ! 712: 687 00025F68 # ! 713: 688 00025F68 # ! 714: 689 00025F68 # ! 715: 690 00025F68 # ! 716: 691 00025F68 # /****************************************************************************** ! 717: 692 00025F68 # * ! 718: 693 00025F68 # * halt with the failure information in registers ! 719: 694 00025F68 # * ! 720: 695 00025F68 # ******************************************************************************/ ! 721: 696 00025F68 # mtpr_er_halt( code ) ! 722: 697 00025F68 # int code; /* error code to halt with */ ! 723: 698 00025F68 # { ! 724: 699 00025F68 13 00cc jbr L301 ! 725: 700 00025F6B L302: ! 726: 701 00025F6B # sgl_dummy1 = code; /* get the halt code */ ! 727: 702 00025F6B 0d ad04 effffffa51 movl 4(fp),_sgl_dummy1 ! 728: 703 00025F73 # if( subtest != 2 ) { /* check for DBL accumulator */ ! 729: 704 00025F73 1d effffffa4b 02 cmpl _subtest,$2 ! 730: 705 00025F7A 31 33 jeql L303 ! 731: 706 00025F7C # dbl_ld_acc.m = sgl_ld_acc; /* get the init Acc */ ! 732: 707 00025F7C 0d effffffa42 effffffa3d movl _sgl_ld_acc,_dbl_ld_acc ! 733: 708 00025F87 # dbl_ld_acc.l = 0; ! 734: 709 00025F87 4d effffffa3b clrl _dbl_ld_acc+4 ! 735: 710 00025F8D # dbl_st_acc.m = sgl_st_acc; /* get the final Acc */ ! 736: 711 00025F8D 0d effffffa31 effffffa2c movl _sgl_st_acc,_dbl_st_acc ! 737: 712 00025F98 # dbl_st_acc.l = 0; ! 738: 713 00025F98 4d effffffa2a clrl _dbl_st_acc+4 ! 739: 714 00025F9E # dbl_expected.m = sgl_expected; /* get the expected Acc */ ! 740: 715 00025F9E 0d effffffa20 effffffa1b movl _sgl_expected,_dbl_expected ! 741: 716 00025FA9 # dbl_expected.l = 0; ! 742: 717 00025FA9 4d effffffa19 clrl _dbl_expected+4 ! 743: 718 00025FAF # } ! 744: 719 00025FAF # asm("movl _test_no,r0"); /* r0 = test number */ ! 745: 720 00025FAF L303: ! 746: 721 00025FAF 0d effffffa0f 50 movl _test_no,r0 ! 747: 722 00025FB6 # asm("movl _subtest,r1"); /* r1 = subtest # */ ! 748: 723 00025FB6 0d effffffa08 51 movl _subtest,r1 ! 749: 724 00025FBD # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 750: 725 00025FBD 0d effffffa01 52 movl _sgl_dummy1,r2 ! 751: 726 00025FC4 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 752: 727 00025FC4 0d effffff9fa 53 movl _cycle,r3 ! 753: 728 00025FCB # if( code == 2 ) { /* corrupted Acc */ ! 754: 729 00025FCB 1d ad04 02 cmpl 4(fp),$2 ! 755: 730 00025FCF 21 3a jneq L304 ! 756: 731 00025FD1 # asm("movl _dbl_ld_acc,r4"); /* r4 = MS initial Acc */ ! 757: 732 00025FD1 0d effffff9ed 54 movl _dbl_ld_acc,r4 ! 758: 733 00025FD8 # asm("movl _dbl_ld_acc+4,r5"); /* r5 = LS initial Acc */ ! 759: 734 00025FD8 0d effffff9ea 55 movl _dbl_ld_acc+4,r5 ! 760: 735 00025FDF # asm("movl _dbl_st_acc,r6"); /* r6 = MS final Acc */ ! 761: 736 00025FDF 0d effffff9df 56 movl _dbl_st_acc,r6 ! 762: 737 00025FE6 # asm("movl _dbl_st_acc+4,r7"); /* r7 = LS final Acc */ ! 763: 738 00025FE6 0d effffff9dc 57 movl _dbl_st_acc+4,r7 ! 764: 739 00025FED # asm("movl _dbl_expected,r8"); /* r8 = MS expected */ ! 765: 740 00025FED 0d effffff9d1 58 movl _dbl_expected,r8 ! 766: 741 00025FF4 # asm("movl _dbl_expected+4,r9"); /* r9 = LS expected */ ! 767: 742 00025FF4 0d effffff9ce 59 movl _dbl_expected+4,r9 ! 768: 743 00025FFB # asm("movl _sgl_value_1,r10"); /* r10 = table addr. */ ! 769: 744 00025FFB 0d effffff9c3 5a movl _sgl_value_1,r10 ! 770: 745 00026002 # asm("movl _sgl_value_2,r11");; /* r11 = entry read */ ! 771: 746 00026002 0d effffff9bc 5b movl _sgl_value_2,r11 ! 772: 747 00026009 # } else { /* wrong data read or wrong final Acc */ ! 773: 748 00026009 11 2a jbr L305 ! 774: 749 0002600B L304: ! 775: 750 0002600B # asm("movl _sgl_value_1,r4"); /* r4 = table addr. */ ! 776: 751 0002600B 0d effffff9b3 54 movl _sgl_value_1,r4 ! 777: 752 00026012 # asm("movl _sgl_value_2,r5"); /* r5 = entry read */ ! 778: 753 00026012 0d effffff9ac 55 movl _sgl_value_2,r5 ! 779: 754 00026019 # asm("movl _sgl_value_3,r6"); /* r6 = expected entry */ ! 780: 755 00026019 0d effffff9a5 56 movl _sgl_value_3,r6 ! 781: 756 00026020 # asm("movl _sgl_ld_acc,r7"); /* r7 = initial Acc */ ! 782: 757 00026020 0d effffff99e 57 movl _sgl_ld_acc,r7 ! 783: 758 00026027 # asm("movl _sgl_st_acc,r8"); /* r8 = final Acc */ ! 784: 759 00026027 0d effffff997 58 movl _sgl_st_acc,r8 ! 785: 760 0002602E # asm("movl _sgl_expected,r9");; /* r9 = sgl expected */ ! 786: 761 0002602E 0d effffff990 59 movl _sgl_expected,r9 ! 787: 762 00026035 # }; ! 788: 763 00026035 L305: ! 789: 764 00026035 # asm("halt");; /* HALT ... */ ! 790: 765 00026035 00 halt ! 791: 766 00026036 # } ! 792: 767 00026036 40 ret#2 ! 793: 768 00026037 .set L299,0x0 ! 794: 769 00026037 L301: ! 795: 770 00026037 13 ff31 jbr L302 ! 796: 771 0002603A .data ! 797: 771 0004B9FE .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.