![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expf.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 expf.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 00000a60 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _expf ! 6: 6 00000000 _expf: ! 7: 7 00020B5C 0000 .word L215 ! 8: 8 00020B5E # #include "fpp_defs.h" ! 9: 9 00020B5E # ! 10: 10 00020B5E # ! 11: 11 00020B5E # ! 12: 12 00020B5E # /*************************************************************************** ! 13: 13 00020B5E # * ! 14: 14 00020B5E # * EXPF - SINGLE PRECISION FLOATING POINT EXPF FUNCTION TEST ! 15: 15 00020B5E # * ! 16: 16 00020B5E # * EXPF TEST MONITOR ! 17: 17 00020B5E # * ! 18: 18 00020B5E # *****************************************************************************/ ! 19: 19 00020B5E # expf() ! 20: 20 00020B5E # { ! 21: 21 00020B5E 11 4f jbr L217 ! 22: 22 00020B60 L218: ! 23: 23 00020B60 # asm(".globl _expf_t"); ! 24: 24 00020B60 .globl _expf_t ! 25: 25 00020B60 # asm("_expf_t:"); /* entry address */ ! 26: 26 00020B60 _expf_t: ! 27: 27 00020B60 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 28: 28 00020B60 1d effffffff6 01 cmpl _cycle,$1 ! 29: 29 00020B67 21 15 jneq L219 ! 30: 30 00020B69 5d efffffffed tstl _prt_hdrs ! 31: 31 00020B6F 31 0d jeql L219 ! 32: 32 00020B71 # { ! 33: 33 00020B71 # writes(" EXPF"); ! 34: 34 00020B71 .data 1 ! 35: 35 00000a60 * L221: ! 36: 36 00000a60 * 204558504600 .ascii " EXPF\0" ! 37: 37 00000a66 * .text ! 38: 38 00020B71 dd 8f00000a60 pushl $L221 ! 39: 39 00020B77 fe 08 efffffffde callf $8,_writes ! 40: 40 00020B7E # } ! 41: 41 00020B7E # expf_1(); /* test expf with delay */ ! 42: 42 00020B7E L219: ! 43: 43 00020B7E fe 04 ef0000002d callf $4,_expf_1 ! 44: 44 00020B85 # expf_2(); /* test expf */ ! 45: 45 00020B85 fe 04 ef00000198 callf $4,_expf_2 ! 46: 46 00020B8C # expf_3(); /* register corruption */ ! 47: 47 00020B8C fe 04 ef000002f1 callf $4,_expf_3 ! 48: 48 00020B93 # expf_4(); /* test the PSL */ ! 49: 49 00020B93 fe 04 ef000004d4 callf $4,_expf_4 ! 50: 50 00020B9A # expf_5(); /* pipelined entry */ ! 51: 51 00020B9A fe 04 ef0000067d callf $4,_expf_5 ! 52: 52 00020BA1 # expf_6(); /* pipelined exit */ ! 53: 53 00020BA1 fe 04 ef000007d2 callf $4,_expf_6 ! 54: 54 00020BA8 # asm("jmp *return"); /* return to the test monitor */ ! 55: 55 00020BA8 71 ffffffffae jmp *return ! 56: 56 00020BAE # } ! 57: 57 00020BAE 40 ret#2 ! 58: 58 00020BAF .set L215,0x0 ! 59: 59 00020BAF L217: ! 60: 60 00020BAF 11 af jbr L218 ! 61: 61 00020BB1 .data ! 62: 62 00000a60 * .text ! 63: 63 00020BB1 00 .align 1 ! 64: 64 00020BB2 .globl _expf_1 ! 65: 65 00020BB2 _expf_1: ! 66: 66 00020BB2 0000 .word L228 ! 67: 67 00020BB4 # ! 68: 68 00020BB4 # ! 69: 69 00020BB4 # ! 70: 70 00020BB4 # /*************************************************************************** ! 71: 71 00020BB4 # * ! 72: 72 00020BB4 # * SUBTEST 1 - EXPF ! 73: 73 00020BB4 # * ! 74: 74 00020BB4 # ***************************************************************************/ ! 75: 75 00020BB4 # expf_1() ! 76: 76 00020BB4 # { ! 77: 77 00020BB4 13 016a jbr L230 ! 78: 78 00020BB7 L231: ! 79: 79 00020BB7 # #define DELAY 10 /* wait 20 ticks between EXPF & STF */ ! 80: 80 00020BB7 # force_loop = FALSE; /* clear the LOOP flag */ ! 81: 81 00020BB7 4d efffffff9f clrl _force_loop ! 82: 82 00020BBD # subtest = 1; ! 83: 83 00020BBD 0d 01 efffffff98 movl $1,_subtest ! 84: 84 00020BC4 # index = 0; ! 85: 85 00020BC4 4d efffffff92 clrl _index ! 86: 86 00020BCA # do ! 87: 87 00020BCA L234: ! 88: 88 00020BCA # { ! 89: 89 00020BCA # sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 90: 90 00020BCA 0d efffffff8c 50 movl _index,r0 ! 91: 91 00020BD1 48 03 50 50 shll $3,r0,r0 ! 92: 92 00020BD5 0d e000000000 efffffff7c movl _expf_1_data(r0),_sgl_ld_acc ! 93: 93 00020BE0 # sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 94: 94 00020BE0 0d efffffff76 50 movl _index,r0 ! 95: 95 00020BE7 48 03 50 50 shll $3,r0,r0 ! 96: 96 00020BEB 0d e000000004 efffffff66 movl _expf_1_data+4(r0),_sgl_expected ! 97: 97 00020BF6 # sgl_dummy1 = DELAY; ! 98: 98 00020BF6 0d 0a efffffff5f movl $10,_sgl_dummy1 ! 99: 99 00020BFD # /* ! 100: 100 00020BFD # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 101: 101 00020BFD # * The force loop flag is set after the first error. ! 102: 102 00020BFD # */ ! 103: 103 00020BFD # asm("_expf_1_lp1:"); ! 104: 104 00020BFD _expf_1_lp1: ! 105: 105 00020BFD # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 106: 106 00020BFD 0d efffffff59 54 movl _sgl_ld_acc,r4 ! 107: 107 00020C04 # asm("ldf r4"); /* load the accumulator */ ! 108: 108 00020C04 06 54 ldf r4 ! 109: 109 00020C06 # asm("movl _sgl_dummy1,r0"); /* get the delay factor */ ! 110: 110 00020C06 0d efffffff50 50 movl _sgl_dummy1,r0 ! 111: 111 00020C0D # asm("expf"); /* get ACC.s' exponent */ ! 112: 112 00020C0D 55 expf ! 113: 113 00020C0E # asm("1:"); ! 114: 114 00020C0E 1: ! 115: 115 00020C0E # asm("decl r0"); /* delay to let the EXPF */ ! 116: 116 00020C0E 7d 50 decl r0 ! 117: 117 00020C10 # asm("bgtr 1b"); /* instruction finish */ ! 118: 118 00020C10 41 fc bgtr 1b ! 119: 119 00020C12 # asm("stf r5"); /* store the result */ ! 120: 120 00020C12 26 55 stf r5 ! 121: 121 00020C14 # if( force_loop ) ! 122: 122 00020C14 5d efffffff42 tstl _force_loop ! 123: 123 00020C1A 31 02 jeql L235 ! 124: 124 00020C1C # asm("brb _expf_1_lp1");; /* loop on the error */ ! 125: 125 00020C1C 11 df brb _expf_1_lp1 ! 126: 126 00020C1E L235: ! 127: 127 00020C1E # /* ! 128: 128 00020C1E # * end error loop ! 129: 129 00020C1E # */ ! 130: 130 00020C1E # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 131: 131 00020C1E 0d 55 efffffff37 movl r5,_sgl_st_acc ! 132: 132 00020C25 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 133: 133 00020C25 1d efffffff31 efffffff2c cmpl _sgl_st_acc,_sgl_expected ! 134: 134 00020C30 21 03 13 00d2 jeql L236 ! 135: 135 00020C35 # { ! 136: 136 00020C35 # errcnt++; /* bump the error count */ ! 137: 137 00020C35 6d efffffff21 incl _errcnt ! 138: 138 00020C3B # if ( prt_error ) ! 139: 139 00020C3B 5d efffffff1b tstl _prt_error ! 140: 140 00020C41 21 03 13 009b jeql L237 ! 141: 141 00020C46 # { ! 142: 142 00020C46 # writes(" \n"); /* start a new print line */ ! 143: 143 00020C46 .data 1 ! 144: 144 00000a66 * L238: ! 145: 145 00000a66 * 200A00 .ascii " \12\0" ! 146: 146 00000a69 * .text ! 147: 147 00020C46 dd 8f00000a66 pushl $L238 ! 148: 148 00020C4C fe 08 efffffff09 callf $8,_writes ! 149: 149 00020C53 # writes("cycle: "); ! 150: 150 00020C53 .data 1 ! 151: 151 00000a69 * L239: ! 152: 152 00000a69 * 6379636C653A2000 .ascii "cycle: \0" ! 153: 153 00000a71 * .text ! 154: 154 00020C53 dd 8f00000a69 pushl $L239 ! 155: 155 00020C59 fe 08 effffffefc callf $8,_writes ! 156: 156 00020C60 # writed( cycle ); ! 157: 157 00020C60 dd effffffef6 pushl _cycle ! 158: 158 00020C66 fe 08 effffffeef callf $8,_writed ! 159: 159 00020C6D # writes(" EXPF test "); ! 160: 160 00020C6D .data 1 ! 161: 161 00000a71 * L241: ! 162: 162 00000a71 * 2020204558504620746573742 .ascii " EXPF test \0" ! 163: 000 ! 164: 163 00000a7f * .text ! 165: 164 00020C6D dd 8f00000a71 pushl $L241 ! 166: 165 00020C73 fe 08 effffffee2 callf $8,_writes ! 167: 166 00020C7A # writed( test_no ); ! 168: 167 00020C7A dd effffffedc pushl _test_no ! 169: 168 00020C80 fe 08 effffffed5 callf $8,_writed ! 170: 169 00020C87 # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n"); ! 171: 170 00020C87 .data 1 ! 172: 171 00000a7f * L242: ! 173: 172 00000a7f * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0" ! 174: 864656C617965642073746F72 ! 175: 6529202D204241442046494E4 ! 176: 14C204143430A00 ! 177: 173 00000aac * .text ! 178: 174 00020C87 dd 8f00000a7f pushl $L242 ! 179: 175 00020C8D fe 08 effffffec8 callf $8,_writes ! 180: 176 00020C94 # print_expf_data(); ! 181: 177 00020C94 fe 04 ef0000083b callf $4,_print_expf_data ! 182: 178 00020C9B # writes(", data index = "); ! 183: 179 00020C9B .data 1 ! 184: 180 00000aac * L244: ! 185: 181 00000aac * 2C20206461746120696E64657 .ascii ", data index = \0" ! 186: 8203D2000 ! 187: 182 00000abd * .text ! 188: 183 00020C9B dd 8f00000aac pushl $L244 ! 189: 184 00020CA1 fe 08 effffffeb4 callf $8,_writes ! 190: 185 00020CA8 # writed( index ); ! 191: 186 00020CA8 dd effffffeae pushl _index ! 192: 187 00020CAE fe 08 effffffea7 callf $8,_writed ! 193: 188 00020CB5 # writec('\n'); ! 194: 189 00020CB5 dd 0a pushl $10 ! 195: 190 00020CB7 fe 08 effffffe9e callf $8,_writec ! 196: 191 00020CBE # writes(" Acc expected = "); ! 197: 192 00020CBE .data 1 ! 198: 193 00000abd * L246: ! 199: 194 00000abd * 2020202020202020202020202 .ascii " Acc expected = \0" ! 200: 0202020202020202020416363 ! 201: 206578706563746564203D200 ! 202: 0 ! 203: 195 00000ae3 * .text ! 204: 196 00020CBE dd 8f00000abd pushl $L246 ! 205: 197 00020CC4 fe 08 effffffe91 callf $8,_writes ! 206: 198 00020CCB # write32h( sgl_expected ); ! 207: 199 00020CCB dd effffffe8b pushl _sgl_expected ! 208: 200 00020CD1 fe 08 effffffe84 callf $8,_write32h ! 209: 201 00020CD8 # writec('\n'); ! 210: 202 00020CD8 dd 0a pushl $10 ! 211: 203 00020CDA fe 08 effffffe7b callf $8,_writec ! 212: 204 00020CE1 # } ! 213: 205 00020CE1 # if ( halt_flg ) /* halt on error? */ ! 214: 206 00020CE1 L237: ! 215: 207 00020CE1 5d effffffe75 tstl _halt_flg ! 216: 208 00020CE7 31 09 jeql L248 ! 217: 209 00020CE9 # expf_er_halt( BAD_ACC_HLT ); ! 218: 210 00020CE9 dd 01 pushl $1 ! 219: 211 00020CEB fe 08 ef00000820 callf $8,_expf_er_halt ! 220: 212 00020CF2 # if ( loop_on_err ) ! 221: 213 00020CF2 L248: ! 222: 214 00020CF2 5d effffffe64 tstl _loop_on_err ! 223: 215 00020CF8 31 0d jeql L250 ! 224: 216 00020CFA # { ! 225: 217 00020CFA # force_loop = TRUE; /* set the force loop flag */ ! 226: 218 00020CFA 0d 01 effffffe5b movl $1,_force_loop ! 227: 219 00020D01 # asm("jmp _expf_1_lp1"); /* and loop */ ! 228: 220 00020D01 71 effffffef6 jmp _expf_1_lp1 ! 229: 221 00020D07 # } ! 230: 222 00020D07 # } /* end of compare error */ ! 231: 223 00020D07 L250: ! 232: 224 00020D07 # } while( index++ < max_expf_1_index ); ! 233: 225 00020D07 L236: ! 234: 226 00020D07 L233: ! 235: 227 00020D07 0d effffffe4f 50 movl _index,r0 ! 236: 228 00020D0E 6d effffffe48 incl _index ! 237: 229 00020D14 1d 50 effffffe41 cmpl r0,_max_expf_1_index ! 238: 230 00020D1B 81 03 13 feaa jlss L234 ! 239: 231 00020D20 L232: ! 240: 232 00020D20 # } /* end of subtest 1 */ ! 241: 233 00020D20 40 ret#2 ! 242: 234 00020D21 .set L228,0x0 ! 243: 235 00020D21 L230: ! 244: 236 00020D21 13 fe93 jbr L231 ! 245: 237 00020D24 .data ! 246: 238 00000a60 * .text ! 247: 239 00020D24 .align 1 ! 248: 240 00020D24 .globl _expf_2 ! 249: 241 00020D24 _expf_2: ! 250: 242 00020D24 0000 .word L251 ! 251: 243 00020D26 # ! 252: 244 00020D26 # ! 253: 245 00020D26 # ! 254: 246 00020D26 # /*************************************************************************** ! 255: 247 00020D26 # * ! 256: 248 00020D26 # * SUBTEST 2 - EXPF FUNCTION ! 257: 249 00020D26 # * ! 258: 250 00020D26 # ***************************************************************************/ ! 259: 251 00020D26 # expf_2() ! 260: 252 00020D26 # { ! 261: 253 00020D26 13 0158 jbr L253 ! 262: 254 00020D29 L254: ! 263: 255 00020D29 # force_loop = FALSE; /* clear the LOOP flag */ ! 264: 256 00020D29 4d effffffe2d clrl _force_loop ! 265: 257 00020D2F # subtest = 2; ! 266: 258 00020D2F 0d 02 effffffe26 movl $2,_subtest ! 267: 259 00020D36 # index = 0; ! 268: 260 00020D36 4d effffffe20 clrl _index ! 269: 261 00020D3C # do ! 270: 262 00020D3C L257: ! 271: 263 00020D3C # { ! 272: 264 00020D3C # sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 273: 265 00020D3C 0d effffffe1a 50 movl _index,r0 ! 274: 266 00020D43 48 03 50 50 shll $3,r0,r0 ! 275: 267 00020D47 0d e000000000 effffffe0a movl _expf_1_data(r0),_sgl_ld_acc ! 276: 268 00020D52 # sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 277: 269 00020D52 0d effffffe04 50 movl _index,r0 ! 278: 270 00020D59 48 03 50 50 shll $3,r0,r0 ! 279: 271 00020D5D 0d e000000004 effffffdf4 movl _expf_1_data+4(r0),_sgl_expected ! 280: 272 00020D68 # /* ! 281: 273 00020D68 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 282: 274 00020D68 # * The force loop flag is set after the first error. ! 283: 275 00020D68 # */ ! 284: 276 00020D68 # asm("_expf_2_lp1:"); ! 285: 277 00020D68 _expf_2_lp1: ! 286: 278 00020D68 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 287: 279 00020D68 0d effffffdee 54 movl _sgl_ld_acc,r4 ! 288: 280 00020D6F # asm("ldf r4"); /* load the accumulator */ ! 289: 281 00020D6F 06 54 ldf r4 ! 290: 282 00020D71 # asm("expf"); /* get ACC.'s exponent */ ! 291: 283 00020D71 55 expf ! 292: 284 00020D72 # asm("stf r5"); /* store the result */ ! 293: 285 00020D72 26 55 stf r5 ! 294: 286 00020D74 # if( force_loop ) ! 295: 287 00020D74 5d effffffde2 tstl _force_loop ! 296: 288 00020D7A 31 02 jeql L258 ! 297: 289 00020D7C # asm("brb _expf_2_lp1");; /* loop on the error */ ! 298: 290 00020D7C 11 ea brb _expf_2_lp1 ! 299: 291 00020D7E L258: ! 300: 292 00020D7E # /* ! 301: 293 00020D7E # * end error loop ! 302: 294 00020D7E # */ ! 303: 295 00020D7E # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 304: 296 00020D7E 0d 55 effffffdd7 movl r5,_sgl_st_acc ! 305: 297 00020D85 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 306: 298 00020D85 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected ! 307: 299 00020D90 21 03 13 00d2 jeql L259 ! 308: 300 00020D95 # { ! 309: 301 00020D95 # errcnt++; /* bump the error count */ ! 310: 302 00020D95 6d effffffdc1 incl _errcnt ! 311: 303 00020D9B # if ( prt_error ) ! 312: 304 00020D9B 5d effffffdbb tstl _prt_error ! 313: 305 00020DA1 21 03 13 009b jeql L260 ! 314: 306 00020DA6 # { ! 315: 307 00020DA6 # writes(" \n"); /* start a new print line */ ! 316: 308 00020DA6 .data 1 ! 317: 309 00000ae3 * L261: ! 318: 310 00000ae3 * 200A00 .ascii " \12\0" ! 319: 311 00000ae6 * .text ! 320: 312 00020DA6 dd 8f00000ae3 pushl $L261 ! 321: 313 00020DAC fe 08 effffffda9 callf $8,_writes ! 322: 314 00020DB3 # writes("cycle: "); ! 323: 315 00020DB3 .data 1 ! 324: 316 00000ae6 * L262: ! 325: 317 00000ae6 * 6379636C653A2000 .ascii "cycle: \0" ! 326: 318 00000aee * .text ! 327: 319 00020DB3 dd 8f00000ae6 pushl $L262 ! 328: 320 00020DB9 fe 08 effffffd9c callf $8,_writes ! 329: 321 00020DC0 # writed( cycle ); ! 330: 322 00020DC0 dd effffffd96 pushl _cycle ! 331: 323 00020DC6 fe 08 effffffd8f callf $8,_writed ! 332: 324 00020DCD # writes(" EXPF test "); ! 333: 325 00020DCD .data 1 ! 334: 326 00000aee * L263: ! 335: 327 00000aee * 2020204558504620746573742 .ascii " EXPF test \0" ! 336: 000 ! 337: 328 00000afc * .text ! 338: 329 00020DCD dd 8f00000aee pushl $L263 ! 339: 330 00020DD3 fe 08 effffffd82 callf $8,_writes ! 340: 331 00020DDA # writed( test_no ); ! 341: 332 00020DDA dd effffffd7c pushl _test_no ! 342: 333 00020DE0 fe 08 effffffd75 callf $8,_writed ! 343: 334 00020DE7 # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n"); ! 344: 335 00020DE7 .data 1 ! 345: 336 00000afc * L264: ! 346: 337 00000afc * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0" ! 347: 8696D6D656469617465207374 ! 348: 6F726529202D2042414420464 ! 349: 94E414C204143430A00 ! 350: 338 00000b2b * .text ! 351: 339 00020DE7 dd 8f00000afc pushl $L264 ! 352: 340 00020DED fe 08 effffffd68 callf $8,_writes ! 353: 341 00020DF4 # print_expf_data(); ! 354: 342 00020DF4 fe 04 ef000006db callf $4,_print_expf_data ! 355: 343 00020DFB # writes(", data index = "); ! 356: 344 00020DFB .data 1 ! 357: 345 00000b2b * L265: ! 358: 346 00000b2b * 2C20206461746120696E64657 .ascii ", data index = \0" ! 359: 8203D2000 ! 360: 347 00000b3c * .text ! 361: 348 00020DFB dd 8f00000b2b pushl $L265 ! 362: 349 00020E01 fe 08 effffffd54 callf $8,_writes ! 363: 350 00020E08 # writed( index ); ! 364: 351 00020E08 dd effffffd4e pushl _index ! 365: 352 00020E0E fe 08 effffffd47 callf $8,_writed ! 366: 353 00020E15 # writec('\n'); ! 367: 354 00020E15 dd 0a pushl $10 ! 368: 355 00020E17 fe 08 effffffd3e callf $8,_writec ! 369: 356 00020E1E # writes(" Acc expected = "); ! 370: 357 00020E1E .data 1 ! 371: 358 00000b3c * L266: ! 372: 359 00000b3c * 2020202020202020202020202 .ascii " Acc expected = \0" ! 373: 0202020202020202020416363 ! 374: 206578706563746564203D200 ! 375: 0 ! 376: 360 00000b62 * .text ! 377: 361 00020E1E dd 8f00000b3c pushl $L266 ! 378: 362 00020E24 fe 08 effffffd31 callf $8,_writes ! 379: 363 00020E2B # write32h( sgl_expected ); ! 380: 364 00020E2B dd effffffd2b pushl _sgl_expected ! 381: 365 00020E31 fe 08 effffffd24 callf $8,_write32h ! 382: 366 00020E38 # writec('\n'); ! 383: 367 00020E38 dd 0a pushl $10 ! 384: 368 00020E3A fe 08 effffffd1b callf $8,_writec ! 385: 369 00020E41 # } ! 386: 370 00020E41 # if ( halt_flg ) /* halt on error? */ ! 387: 371 00020E41 L260: ! 388: 372 00020E41 5d effffffd15 tstl _halt_flg ! 389: 373 00020E47 31 09 jeql L267 ! 390: 374 00020E49 # expf_er_halt( BAD_ACC_HLT ); ! 391: 375 00020E49 dd 01 pushl $1 ! 392: 376 00020E4B fe 08 ef000006c0 callf $8,_expf_er_halt ! 393: 377 00020E52 # if ( loop_on_err ) ! 394: 378 00020E52 L267: ! 395: 379 00020E52 5d effffffd04 tstl _loop_on_err ! 396: 380 00020E58 31 0d jeql L268 ! 397: 381 00020E5A # { ! 398: 382 00020E5A # force_loop = TRUE; /* set the force loop flag */ ! 399: 383 00020E5A 0d 01 effffffcfb movl $1,_force_loop ! 400: 384 00020E61 # asm("jmp _expf_2_lp1"); /* and loop */ ! 401: 385 00020E61 71 efffffff01 jmp _expf_2_lp1 ! 402: 386 00020E67 # } ! 403: 387 00020E67 # } /* end of compare error */ ! 404: 388 00020E67 L268: ! 405: 389 00020E67 # } while( index++ < max_expf_1_index ); ! 406: 390 00020E67 L259: ! 407: 391 00020E67 L256: ! 408: 392 00020E67 0d effffffcef 50 movl _index,r0 ! 409: 393 00020E6E 6d effffffce8 incl _index ! 410: 394 00020E74 1d 50 effffffce1 cmpl r0,_max_expf_1_index ! 411: 395 00020E7B 81 03 13 febc jlss L257 ! 412: 396 00020E80 L255: ! 413: 397 00020E80 # } /* end of subtest 2 */ ! 414: 398 00020E80 40 ret#2 ! 415: 399 00020E81 .set L251,0x0 ! 416: 400 00020E81 L253: ! 417: 401 00020E81 13 fea5 jbr L254 ! 418: 402 00020E84 .data ! 419: 403 00000a60 * .text ! 420: 404 00020E84 .align 1 ! 421: 405 00020E84 .globl _expf_3 ! 422: 406 00020E84 _expf_3: ! 423: 407 00020E84 0000 .word L269 ! 424: 408 00020E86 # ! 425: 409 00020E86 # ! 426: 410 00020E86 # ! 427: 411 00020E86 # /*************************************************************************** ! 428: 412 00020E86 # * ! 429: 413 00020E86 # * SUBTEST 3 - REGISTER INTEGRITY WITH THE EXPF FUNCTION ! 430: 414 00020E86 # * ! 431: 415 00020E86 # ***************************************************************************/ ! 432: 416 00020E86 # expf_3() ! 433: 417 00020E86 # { ! 434: 418 00020E86 13 01e1 jbr L271 ! 435: 419 00020E89 L272: ! 436: 420 00020E89 # fill_reg_buf( load_regs ); /* set reg values to load */ ! 437: 421 00020E89 dd 8f00000000 pushl $_load_regs ! 438: 422 00020E8F fe 08 effffffcc6 callf $8,_fill_reg_buf ! 439: 423 00020E96 # force_loop = FALSE; /* clear the LOOP flag */ ! 440: 424 00020E96 4d effffffcc0 clrl _force_loop ! 441: 425 00020E9C # subtest = 3; ! 442: 426 00020E9C 0d 03 effffffcb9 movl $3,_subtest ! 443: 427 00020EA3 # index = 0; ! 444: 428 00020EA3 4d effffffcb3 clrl _index ! 445: 429 00020EA9 # do ! 446: 430 00020EA9 L276: ! 447: 431 00020EA9 # { ! 448: 432 00020EA9 # sgl_ld_acc = expf_1_data[index].ld; /* get the operand */ ! 449: 433 00020EA9 0d effffffcad 50 movl _index,r0 ! 450: 434 00020EB0 48 03 50 50 shll $3,r0,r0 ! 451: 435 00020EB4 0d e000000000 effffffc9d movl _expf_1_data(r0),_sgl_ld_acc ! 452: 436 00020EBF # sgl_expected = expf_1_data[index].exp; /* get expected results */ ! 453: 437 00020EBF 0d effffffc97 50 movl _index,r0 ! 454: 438 00020EC6 48 03 50 50 shll $3,r0,r0 ! 455: 439 00020ECA 0d e000000004 effffffc87 movl _expf_1_data+4(r0),_sgl_expected ! 456: 440 00020ED5 # /* ! 457: 441 00020ED5 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 458: 442 00020ED5 # * The force loop flag is set after the first error. ! 459: 443 00020ED5 # */ ! 460: 444 00020ED5 # asm("_expf_3_lp1:"); ! 461: 445 00020ED5 _expf_3_lp1: ! 462: 446 00020ED5 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 (FP) */ ! 463: 447 00020ED5 ab 891fff effffffc7e loadr $0x1fff,_load_regs ! 464: 448 00020EDE # asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 465: 449 00020EDE 06 effffffc78 ldf _sgl_ld_acc ! 466: 450 00020EE4 # asm("expf"); /* get ACC.'s exponent */ ! 467: 451 00020EE4 55 expf ! 468: 452 00020EE5 # asm("stf _sgl_st_acc"); /* store the result */ ! 469: 453 00020EE5 26 effffffc71 stf _sgl_st_acc ! 470: 454 00020EEB # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 471: 455 00020EEB bb 891fff effffffc68 storer $0x1fff,_store_regs ! 472: 456 00020EF4 # if( force_loop ) ! 473: 457 00020EF4 5d effffffc62 tstl _force_loop ! 474: 458 00020EFA 31 02 jeql L277 ! 475: 459 00020EFC # asm("brb _expf_3_lp1");; /* loop on the error */ ! 476: 460 00020EFC 11 d7 brb _expf_3_lp1 ! 477: 461 00020EFE L277: ! 478: 462 00020EFE # /* ! 479: 463 00020EFE # * end error loop ! 480: 464 00020EFE # */ ! 481: 465 00020EFE # reg_no = 0; ! 482: 466 00020EFE 4d effffffc58 clrl _reg_no ! 483: 467 00020F04 # regs_ok = TRUE; ! 484: 468 00020F04 0d 01 effffffc51 movl $1,_regs_ok ! 485: 469 00020F0B # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */ ! 486: 470 00020F0B L278: ! 487: 471 00020F0B 1d effffffc4b 0d cmpl _reg_no,$13 ! 488: 472 00020F12 81 35 jgeq L279 ! 489: 473 00020F14 5d effffffc42 tstl _regs_ok ! 490: 474 00020F1A 31 2d jeql L279 ! 491: 475 00020F1C # if( store_regs[ reg_no ] == load_regs[ reg_no ] ) ! 492: 476 00020F1C 0d effffffc3a 50 movl _reg_no,r0 ! 493: 477 00020F23 0d effffffc33 51 movl _reg_no,r1 ! 494: 478 00020F2A 1d 40effffffc2b cmpl _store_regs[r0],_load_regs[r1] ! 495: 41effffffc25 ! 496: 479 00020F37 21 08 jneq L280 ! 497: 480 00020F39 # reg_no++; ! 498: 481 00020F39 6d effffffc1d incl _reg_no ! 499: 482 00020F3F # else ! 500: 483 00020F3F 11 06 jbr L281 ! 501: 484 00020F41 L280: ! 502: 485 00020F41 # regs_ok = FALSE; ! 503: 486 00020F41 4d effffffc15 clrl _regs_ok ! 504: 487 00020F47 L281: ! 505: 488 00020F47 11 c2 jbr L278 ! 506: 489 00020F49 L279: ! 507: 490 00020F49 # if( !regs_ok ) ! 508: 491 00020F49 5d effffffc0d tstl _regs_ok ! 509: 492 00020F4F 31 03 13 00fc jneq L282 ! 510: 493 00020F54 # { ! 511: 494 00020F54 # errcnt++; /* bump the error count */ ! 512: 495 00020F54 6d effffffc02 incl _errcnt ! 513: 496 00020F5A # if ( prt_error ) ! 514: 497 00020F5A 5d effffffbfc tstl _prt_error ! 515: 498 00020F60 21 03 13 00eb jeql L283 ! 516: 499 00020F65 # { ! 517: 500 00020F65 # writes(" \n"); /* start a new print line */ ! 518: 501 00020F65 .data 1 ! 519: 502 00000b62 * L284: ! 520: 503 00000b62 * 200A00 .ascii " \12\0" ! 521: 504 00000b65 * .text ! 522: 505 00020F65 dd 8f00000b62 pushl $L284 ! 523: 506 00020F6B fe 08 effffffbea callf $8,_writes ! 524: 507 00020F72 # writes("cycle: "); ! 525: 508 00020F72 .data 1 ! 526: 509 00000b65 * L285: ! 527: 510 00000b65 * 6379636C653A2000 .ascii "cycle: \0" ! 528: 511 00000b6d * .text ! 529: 512 00020F72 dd 8f00000b65 pushl $L285 ! 530: 513 00020F78 fe 08 effffffbdd callf $8,_writes ! 531: 514 00020F7F # writed( cycle ); ! 532: 515 00020F7F dd effffffbd7 pushl _cycle ! 533: 516 00020F85 fe 08 effffffbd0 callf $8,_writed ! 534: 517 00020F8C # writes(" EXPF test "); ! 535: 518 00020F8C .data 1 ! 536: 519 00000b6d * L286: ! 537: 520 00000b6d * 2020204558504620746573742 .ascii " EXPF test \0" ! 538: 000 ! 539: 521 00000b7b * .text ! 540: 522 00020F8C dd 8f00000b6d pushl $L286 ! 541: 523 00020F92 fe 08 effffffbc3 callf $8,_writes ! 542: 524 00020F99 # writed( test_no ); ! 543: 525 00020F99 dd effffffbbd pushl _test_no ! 544: 526 00020F9F fe 08 effffffbb6 callf $8,_writed ! 545: 527 00020FA6 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); { ! 546: 528 00020FA6 .data 1 ! 547: 529 00000b7b * L287: ! 548: 530 00000b7b * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0" ! 549: D204120524547495354455220 ! 550: 574153204D4F4449464945440 ! 551: A00 ! 552: 531 00000ba2 * .text ! 553: 532 00020FA6 dd 8f00000b7b pushl $L287 ! 554: 533 00020FAC fe 08 effffffba9 callf $8,_writes ! 555: 534 00020FB3 # print_expf_data(); ! 556: 535 00020FB3 fe 04 ef0000051c callf $4,_print_expf_data ! 557: 536 00020FBA # writec('\n'); ! 558: 537 00020FBA dd 0a pushl $10 ! 559: 538 00020FBC fe 08 effffffb99 callf $8,_writec ! 560: 539 00020FC3 # writes("register "); ! 561: 540 00020FC3 .data 1 ! 562: 541 00000ba2 * L288: ! 563: 542 00000ba2 * 72656769737465722000 .ascii "register \0" ! 564: 543 00000bac * .text ! 565: 544 00020FC3 dd 8f00000ba2 pushl $L288 ! 566: 545 00020FC9 fe 08 effffffb8c callf $8,_writes ! 567: 546 00020FD0 # writed( reg_no ); ! 568: 547 00020FD0 dd effffffb86 pushl _reg_no ! 569: 548 00020FD6 fe 08 effffffb7f callf $8,_writed ! 570: 549 00020FDD # writes(" = "); ! 571: 550 00020FDD .data 1 ! 572: 551 00000bac * L289: ! 573: 552 00000bac * 203D2000 .ascii " = \0" ! 574: 553 00000bb0 * .text ! 575: 554 00020FDD dd 8f00000bac pushl $L289 ! 576: 555 00020FE3 fe 08 effffffb72 callf $8,_writes ! 577: 556 00020FEA # write32h( load_regs[reg_no] ); ! 578: 557 00020FEA 0d effffffb6c 50 movl _reg_no,r0 ! 579: 558 00020FF1 dd 40effffffb64 pushl _load_regs[r0] ! 580: 559 00020FF8 fe 08 effffffb5d callf $8,_write32h ! 581: 560 00020FFF # writes(", should be = "); ! 582: 561 00020FFF .data 1 ! 583: 562 00000bb0 * L290: ! 584: 563 00000bb0 * 2C202073686F756C642062652 .ascii ", should be = \0" ! 585: 03D2000 ! 586: 564 00000bc0 * .text ! 587: 565 00020FFF dd 8f00000bb0 pushl $L290 ! 588: 566 00021005 fe 08 effffffb50 callf $8,_writes ! 589: 567 0002100C # write32h( store_regs[reg_no] ); ! 590: 568 0002100C 0d effffffb4a 50 movl _reg_no,r0 ! 591: 569 00021013 dd 40effffffb42 pushl _store_regs[r0] ! 592: 570 0002101A fe 08 effffffb3b callf $8,_write32h ! 593: 571 00021021 # writec('\n'); ! 594: 572 00021021 dd 0a pushl $10 ! 595: 573 00021023 fe 08 effffffb32 callf $8,_writec ! 596: 574 0002102A # } ! 597: 575 0002102A # if ( halt_flg ) /* halt on error? */ ! 598: 576 0002102A 5d effffffb2c tstl _halt_flg ! 599: 577 00021030 31 09 jeql L291 ! 600: 578 00021032 # expf_er_halt( BAD_REG_HLT ); ! 601: 579 00021032 dd 02 pushl $2 ! 602: 580 00021034 fe 08 ef000004d7 callf $8,_expf_er_halt ! 603: 581 0002103B # if ( loop_on_err ) ! 604: 582 0002103B L291: ! 605: 583 0002103B 5d effffffb1b tstl _loop_on_err ! 606: 584 00021041 31 0d jeql L292 ! 607: 585 00021043 # { ! 608: 586 00021043 # force_loop = TRUE; /* get the force loop flag */ ! 609: 587 00021043 0d 01 effffffb12 movl $1,_force_loop ! 610: 588 0002104A # asm("jmp _expf_3_lp1"); /* and loop */ ! 611: 589 0002104A 71 effffffe85 jmp _expf_3_lp1 ! 612: 590 00021050 # } ! 613: 591 00021050 # } /* end of compare error */ ! 614: 592 00021050 L292: ! 615: 593 00021050 # } /* end of while loop */ ! 616: 594 00021050 L283: ! 617: 595 00021050 # } while( index++ < max_expf_1_index ); ! 618: 596 00021050 L282: ! 619: 597 00021050 L275: ! 620: 598 00021050 0d effffffb06 50 movl _index,r0 ! 621: 599 00021057 6d effffffaff incl _index ! 622: 600 0002105D 1d 50 effffffaf8 cmpl r0,_max_expf_1_index ! 623: 601 00021064 81 03 13 fe40 jlss L276 ! 624: 602 00021069 L274: ! 625: 603 00021069 # } /* end of subtest 3 */ ! 626: 604 00021069 40 ret#2 ! 627: 605 0002106A .set L269,0x0 ! 628: 606 0002106A L271: ! 629: 607 0002106A 13 fe1c jbr L272 ! 630: 608 0002106D .data ! 631: 609 00000a60 * .text ! 632: 610 0002106D 00 .align 1 ! 633: 611 0002106E .globl _expf_4 ! 634: 612 0002106E _expf_4: ! 635: 613 0002106E 0000 .word L293 ! 636: 614 00021070 # ! 637: 615 00021070 # ! 638: 616 00021070 # ! 639: 617 00021070 # /************************************************************************ ! 640: 618 00021070 # * ! 641: 619 00021070 # * SUBTEST 4 - Check for PSL corruption ! 642: 620 00021070 # * ! 643: 621 00021070 # ************************************************************************/ ! 644: 622 00021070 # expf_4() ! 645: 623 00021070 # { ! 646: 624 00021070 13 01a8 jbr L295 ! 647: 625 00021073 L296: ! 648: 626 00021073 # force_loop = FALSE; /* clear force_loop flg */ ! 649: 627 00021073 4d effffffae3 clrl _force_loop ! 650: 628 00021079 # subtest = 4; ! 651: 629 00021079 0d 04 effffffadc movl $4,_subtest ! 652: 630 00021080 # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 653: 631 00021080 dd 8f00000000 pushl $_load_regs ! 654: 632 00021086 fe 08 effffffacf callf $8,_fill_reg_buf ! 655: 633 0002108D # for( index = 0; index < 3; index++ ) { ! 656: 634 0002108D 4d effffffac9 clrl _index ! 657: 635 00021093 L299: ! 658: 636 00021093 1d effffffac3 03 cmpl _index,$3 ! 659: 637 0002109A 91 03 13 017b jgeq L298 ! 660: 638 0002109F # sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 661: 639 0002109F 0d effffffab7 50 movl _index,r0 ! 662: 640 000210A6 48 03 50 50 shll $3,r0,r0 ! 663: 641 000210AA 0d e000000000 effffffaa7 movl _expf_1_data(r0),_sgl_ld_acc ! 664: 642 000210B5 # sgl_expected = expf_1_data[index].exp; /* get expected */ ! 665: 643 000210B5 0d effffffaa1 50 movl _index,r0 ! 666: 644 000210BC 48 03 50 50 shll $3,r0,r0 ! 667: 645 000210C0 0d e000000004 effffffa91 movl _expf_1_data+4(r0),_sgl_expected ! 668: 646 000210CB # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 669: 647 000210CB 0d effffffa8b 50 movl _status_index,r0 ! 670: 648 000210D2 0d 40effffffa83 movl _status_array[r0],_sgl_dummy1 ! 671: effffffa7e ! 672: 649 000210DE # /* ! 673: 650 000210DE # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 674: 651 000210DE # * The force loop flag is set after the first error. ! 675: 652 000210DE # */ ! 676: 653 000210DE # asm("_expf_4_lp1:"); ! 677: 654 000210DE _expf_4_lp1: ! 678: 655 000210DE # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 679: 656 000210DE 06 effffffa78 ldf _sgl_ld_acc ! 680: 657 000210E4 # asm("nop"); ! 681: 658 000210E4 10 nop ! 682: 659 000210E5 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 683: 660 000210E5 5d effffffa71 tstl _sgl_dummy1 ! 684: 661 000210EB # asm("movpsl _init_psl"); /* save the initial PSL */ ! 685: 662 000210EB cd effffffa6b movpsl _init_psl ! 686: 663 000210F1 # asm("expf"); /* do the expf */ ! 687: 664 000210F1 55 expf ! 688: 665 000210F2 # asm("nop"); ! 689: 666 000210F2 10 nop ! 690: 667 000210F3 # asm("movpsl _psl_val"); /* save the final PSL */ ! 691: 668 000210F3 cd effffffa63 movpsl _psl_val ! 692: 669 000210F9 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 693: 670 000210F9 26 effffffa5d stf _sgl_st_acc ! 694: 671 000210FF # if( force_loop ) ! 695: 672 000210FF 5d effffffa57 tstl _force_loop ! 696: 673 00021105 31 02 jeql L300 ! 697: 674 00021107 # asm("brb _expf_4_lp1");; /* loop on the error */ ! 698: 675 00021107 11 d5 brb _expf_4_lp1 ! 699: 676 00021109 L300: ! 700: 677 00021109 # /* ! 701: 678 00021109 # * Now compare the final PSL to the initial PSL -they should be the same ! 702: 679 00021109 # */ ! 703: 680 00021109 # exp_psl = init_psl; ! 704: 681 00021109 0d effffffa4d effffffa48 movl _init_psl,_exp_psl ! 705: 682 00021114 # if( psl_val != exp_psl ) { ! 706: 683 00021114 1d effffffa42 effffffa3d cmpl _psl_val,_exp_psl ! 707: 684 0002111F 21 03 13 00ed jeql L301 ! 708: 685 00021124 # errcnt++; /* bump the error count */ ! 709: 686 00021124 6d effffffa32 incl _errcnt ! 710: 687 0002112A # if( prt_error ) { ! 711: 688 0002112A 5d effffffa2c tstl _prt_error ! 712: 689 00021130 21 03 13 00b9 jeql L302 ! 713: 690 00021135 # writes(" \n"); /* start a new print line */ ! 714: 691 00021135 .data 1 ! 715: 692 00000bc0 * L303: ! 716: 693 00000bc0 * 200A00 .ascii " \12\0" ! 717: 694 00000bc3 * .text ! 718: 695 00021135 dd 8f00000bc0 pushl $L303 ! 719: 696 0002113B fe 08 effffffa1a callf $8,_writes ! 720: 697 00021142 # writes("cycle: "); ! 721: 698 00021142 .data 1 ! 722: 699 00000bc3 * L304: ! 723: 700 00000bc3 * 6379636C653A2000 .ascii "cycle: \0" ! 724: 701 00000bcb * .text ! 725: 702 00021142 dd 8f00000bc3 pushl $L304 ! 726: 703 00021148 fe 08 effffffa0d callf $8,_writes ! 727: 704 0002114F # writed( cycle ); ! 728: 705 0002114F dd effffffa07 pushl _cycle ! 729: 706 00021155 fe 08 effffffa00 callf $8,_writed ! 730: 707 0002115C # writes(" EXPF test "); ! 731: 708 0002115C .data 1 ! 732: 709 00000bcb * L305: ! 733: 710 00000bcb * 2020204558504620746573742 .ascii " EXPF test \0" ! 734: 000 ! 735: 711 00000bd9 * .text ! 736: 712 0002115C dd 8f00000bcb pushl $L305 ! 737: 713 00021162 fe 08 effffff9f3 callf $8,_writes ! 738: 714 00021169 # writed( test_no ); ! 739: 715 00021169 dd effffff9ed pushl _test_no ! 740: 716 0002116F fe 08 effffff9e6 callf $8,_writed ! 741: 717 00021176 # writes(", subtest 4 - INCORRECT FINAL PSL\n"); ! 742: 718 00021176 .data 1 ! 743: 719 00000bd9 * L306: ! 744: 720 00000bd9 * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0" ! 745: D20494E434F52524543542046 ! 746: 494E414C2050534C0A00 ! 747: 721 00000bfc * .text ! 748: 722 00021176 dd 8f00000bd9 pushl $L306 ! 749: 723 0002117C fe 08 effffff9d9 callf $8,_writes ! 750: 724 00021183 # print_expf_data(); /* print the operands */ ! 751: 725 00021183 fe 04 ef0000034c callf $4,_print_expf_data ! 752: 726 0002118A # writec('\n'); ! 753: 727 0002118A dd 0a pushl $10 ! 754: 728 0002118C fe 08 effffff9c9 callf $8,_writec ! 755: 729 00021193 # writes("initial PSL = "); ! 756: 730 00021193 .data 1 ! 757: 731 00000bfc * L307: ! 758: 732 00000bfc * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 759: D2000 ! 760: 733 00000c0b * .text ! 761: 734 00021193 dd 8f00000bfc pushl $L307 ! 762: 735 00021199 fe 08 effffff9bc callf $8,_writes ! 763: 736 000211A0 # write32h( init_psl ); ! 764: 737 000211A0 dd effffff9b6 pushl _init_psl ! 765: 738 000211A6 fe 08 effffff9af callf $8,_write32h ! 766: 739 000211AD # writes(", final PSL = "); ! 767: 740 000211AD .data 1 ! 768: 741 00000c0b * L308: ! 769: 742 00000c0b * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 770: 03D2000 ! 771: 743 00000c1b * .text ! 772: 744 000211AD dd 8f00000c0b pushl $L308 ! 773: 745 000211B3 fe 08 effffff9a2 callf $8,_writes ! 774: 746 000211BA # write32h( psl_val ); ! 775: 747 000211BA dd effffff99c pushl _psl_val ! 776: 748 000211C0 fe 08 effffff995 callf $8,_write32h ! 777: 749 000211C7 # writes(", expected PSL = "); ! 778: 750 000211C7 .data 1 ! 779: 751 00000c1b * L309: ! 780: 752 00000c1b * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 781: 0534C203D2000 ! 782: 753 00000c2e * .text ! 783: 754 000211C7 dd 8f00000c1b pushl $L309 ! 784: 755 000211CD fe 08 effffff988 callf $8,_writes ! 785: 756 000211D4 # write32h( exp_psl ); ! 786: 757 000211D4 dd effffff982 pushl _exp_psl ! 787: 758 000211DA fe 08 effffff97b callf $8,_write32h ! 788: 759 000211E1 # writes("\n"); ! 789: 760 000211E1 .data 1 ! 790: 761 00000c2e * L310: ! 791: 762 00000c2e * 0A00 .ascii "\12\0" ! 792: 763 00000c30 * .text ! 793: 764 000211E1 dd 8f00000c2e pushl $L310 ! 794: 765 000211E7 fe 08 effffff96e callf $8,_writes ! 795: 766 000211EE # } ! 796: 767 000211EE # if( halt_flg ) ! 797: 768 000211EE L302: ! 798: 769 000211EE 5d effffff968 tstl _halt_flg ! 799: 770 000211F4 31 09 jeql L311 ! 800: 771 000211F6 # expf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 801: 772 000211F6 dd 03 pushl $3 ! 802: 773 000211F8 fe 08 ef00000313 callf $8,_expf_er_halt ! 803: 774 000211FF # if( loop_on_err ) { ! 804: 775 000211FF L311: ! 805: 776 000211FF 5d effffff957 tstl _loop_on_err ! 806: 777 00021205 31 0a jeql L312 ! 807: 778 00021207 # force_loop = TRUE; /* set the force loop flag */ ! 808: 779 00021207 0d 01 effffff94e movl $1,_force_loop ! 809: 780 0002120E # asm("brw _expf_4_lp1");; /* and loop on the error */ ! 810: 781 0002120E 13 fecd brw _expf_4_lp1 ! 811: 782 00021211 # } /* end of loop on error */ ! 812: 783 00021211 # } /* end of PSL corruption error */ ! 813: 784 00021211 L312: ! 814: 785 00021211 # } /* end of WHILE loop */ ! 815: 786 00021211 L301: ! 816: 787 00021211 L297: ! 817: 788 00021211 6d effffff945 incl _index ! 818: 789 00021217 13 fe79 jbr L299 ! 819: 790 0002121A L298: ! 820: 791 0002121A # } /* end of subtest 4 */ ! 821: 792 0002121A 40 ret#2 ! 822: 793 0002121B .set L293,0x0 ! 823: 794 0002121B L295: ! 824: 795 0002121B 13 fe55 jbr L296 ! 825: 796 0002121E .data ! 826: 797 00000a60 * .text ! 827: 798 0002121E .align 1 ! 828: 799 0002121E .globl _expf_5 ! 829: 800 0002121E _expf_5: ! 830: 801 0002121E 0000 .word L313 ! 831: 802 00021220 # ! 832: 803 00021220 # ! 833: 804 00021220 # ! 834: 805 00021220 # /************************************************************************ ! 835: 806 00021220 # * ! 836: 807 00021220 # * SUBTEST 5 - pipelined entry test ! 837: 808 00021220 # * ! 838: 809 00021220 # ************************************************************************/ ! 839: 810 00021220 # expf_5() ! 840: 811 00021220 # { ! 841: 812 00021220 13 0154 jbr L315 ! 842: 813 00021223 L316: ! 843: 814 00021223 # force_loop = FALSE; ! 844: 815 00021223 4d effffff933 clrl _force_loop ! 845: 816 00021229 # subtest = 8; ! 846: 817 00021229 0d 08 effffff92c movl $8,_subtest ! 847: 818 00021230 # for( index = 0; index < max_expf_1_index; index++ ) { ! 848: 819 00021230 4d effffff926 clrl _index ! 849: 820 00021236 L319: ! 850: 821 00021236 1d effffff920 effffff91b cmpl _index,_max_expf_1_index ! 851: 822 00021241 91 03 13 0130 jgeq L318 ! 852: 823 00021246 # sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 853: 824 00021246 0d effffff910 50 movl _index,r0 ! 854: 825 0002124D 48 03 50 50 shll $3,r0,r0 ! 855: 826 00021251 0d e000000000 effffff900 movl _expf_1_data(r0),_sgl_ld_acc ! 856: 827 0002125C # sgl_expected = expf_1_data[index].exp; /* get expected result */ ! 857: 828 0002125C 0d effffff8fa 50 movl _index,r0 ! 858: 829 00021263 48 03 50 50 shll $3,r0,r0 ! 859: 830 00021267 0d e000000004 effffff8ea movl _expf_1_data+4(r0),_sgl_expected ! 860: 831 00021272 # /* ! 861: 832 00021272 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 862: 833 00021272 # * The force loop flag is set after the first error. ! 863: 834 00021272 # */ ! 864: 835 00021272 # asm("_expf_5_lp1:"); ! 865: 836 00021272 _expf_5_lp1: ! 866: 837 00021272 # asm("movl $0,r0"); /* clear r0 */ ! 867: 838 00021272 0d 00 50 movl $0,r0 ! 868: 839 00021275 # asm("ldf r0"); /* load the Acc. with 0.0 */ ! 869: 840 00021275 06 50 ldf r0 ! 870: 841 00021277 # asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 871: 842 00021277 c6 effffff8df addf _sgl_ld_acc ! 872: 843 0002127D # asm("expf"); /* get the expf */ ! 873: 844 0002127D 55 expf ! 874: 845 0002127E # asm("stf _sgl_st_acc"); /* store the result */ ! 875: 846 0002127E 26 effffff8d8 stf _sgl_st_acc ! 876: 847 00021284 # if( force_loop ) ! 877: 848 00021284 5d effffff8d2 tstl _force_loop ! 878: 849 0002128A 31 02 jeql L320 ! 879: 850 0002128C # asm("brb _expf_5_lp1");; /* loop on the error */ ! 880: 851 0002128C 11 e4 brb _expf_5_lp1 ! 881: 852 0002128E L320: ! 882: 853 0002128E # /* ! 883: 854 0002128E # * end error loop - test the results ! 884: 855 0002128E # */ ! 885: 856 0002128E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 886: 857 0002128E 1d effffff8c8 effffff8c3 cmpl _sgl_st_acc,_sgl_expected ! 887: 858 00021299 21 03 13 00cf jeql L321 ! 888: 859 0002129E # errcnt++; /* bump the error count */ ! 889: 860 0002129E 6d effffff8b8 incl _errcnt ! 890: 861 000212A4 # if( prt_error ) { ! 891: 862 000212A4 5d effffff8b2 tstl _prt_error ! 892: 863 000212AA 21 03 13 009b jeql L322 ! 893: 864 000212AF # writes(" \n"); /* start a new print line */ ! 894: 865 000212AF .data 1 ! 895: 866 00000c30 * L323: ! 896: 867 00000c30 * 200A00 .ascii " \12\0" ! 897: 868 00000c33 * .text ! 898: 869 000212AF dd 8f00000c30 pushl $L323 ! 899: 870 000212B5 fe 08 effffff8a0 callf $8,_writes ! 900: 871 000212BC # writes("cycle: "); ! 901: 872 000212BC .data 1 ! 902: 873 00000c33 * L324: ! 903: 874 00000c33 * 6379636C653A2000 .ascii "cycle: \0" ! 904: 875 00000c3b * .text ! 905: 876 000212BC dd 8f00000c33 pushl $L324 ! 906: 877 000212C2 fe 08 effffff893 callf $8,_writes ! 907: 878 000212C9 # writed( cycle ); ! 908: 879 000212C9 dd effffff88d pushl _cycle ! 909: 880 000212CF fe 08 effffff886 callf $8,_writed ! 910: 881 000212D6 # writes(" EXPF test "); ! 911: 882 000212D6 .data 1 ! 912: 883 00000c3b * L325: ! 913: 884 00000c3b * 2020204558504620746573742 .ascii " EXPF test \0" ! 914: 000 ! 915: 885 00000c49 * .text ! 916: 886 000212D6 dd 8f00000c3b pushl $L325 ! 917: 887 000212DC fe 08 effffff879 callf $8,_writes ! 918: 888 000212E3 # writed( test_no ); ! 919: 889 000212E3 dd effffff873 pushl _test_no ! 920: 890 000212E9 fe 08 effffff86c callf $8,_writed ! 921: 891 000212F0 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n"); ! 922: 892 000212F0 .data 1 ! 923: 893 00000c49 * L326: ! 924: 894 00000c49 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0" ! 925: 8506970656420456E74727929 ! 926: 202D204241442046494E414C2 ! 927: 04143430A00 ! 928: 895 00000c74 * .text ! 929: 896 000212F0 dd 8f00000c49 pushl $L326 ! 930: 897 000212F6 fe 08 effffff85f callf $8,_writes ! 931: 898 000212FD # print_expf_data(); ! 932: 899 000212FD fe 04 ef000001d2 callf $4,_print_expf_data ! 933: 900 00021304 # writes(", data index = "); ! 934: 901 00021304 .data 1 ! 935: 902 00000c74 * L327: ! 936: 903 00000c74 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 937: 8203D2000 ! 938: 904 00000c85 * .text ! 939: 905 00021304 dd 8f00000c74 pushl $L327 ! 940: 906 0002130A fe 08 effffff84b callf $8,_writes ! 941: 907 00021311 # writed( index ); ! 942: 908 00021311 dd effffff845 pushl _index ! 943: 909 00021317 fe 08 effffff83e callf $8,_writed ! 944: 910 0002131E # writec('\n'); ! 945: 911 0002131E dd 0a pushl $10 ! 946: 912 00021320 fe 08 effffff835 callf $8,_writec ! 947: 913 00021327 # writes(" Acc expected = "); ! 948: 914 00021327 .data 1 ! 949: 915 00000c85 * L328: ! 950: 916 00000c85 * 2020202020202020202020202 .ascii " Acc expected = \0" ! 951: 0202020202020202020416363 ! 952: 206578706563746564203D200 ! 953: 0 ! 954: 917 00000cab * .text ! 955: 918 00021327 dd 8f00000c85 pushl $L328 ! 956: 919 0002132D fe 08 effffff828 callf $8,_writes ! 957: 920 00021334 # write32h( sgl_expected ); ! 958: 921 00021334 dd effffff822 pushl _sgl_expected ! 959: 922 0002133A fe 08 effffff81b callf $8,_write32h ! 960: 923 00021341 # writec('\n'); ! 961: 924 00021341 dd 0a pushl $10 ! 962: 925 00021343 fe 08 effffff812 callf $8,_writec ! 963: 926 0002134A # } ! 964: 927 0002134A # if( halt_flg ) ! 965: 928 0002134A L322: ! 966: 929 0002134A 5d effffff80c tstl _halt_flg ! 967: 930 00021350 31 09 jeql L329 ! 968: 931 00021352 # expf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 969: 932 00021352 dd 01 pushl $1 ! 970: 933 00021354 fe 08 ef000001b7 callf $8,_expf_er_halt ! 971: 934 0002135B # if( loop_on_err ) { ! 972: 935 0002135B L329: ! 973: 936 0002135B 5d effffff7fb tstl _loop_on_err ! 974: 937 00021361 31 0a jeql L330 ! 975: 938 00021363 # force_loop = TRUE; /* set the force loop flag */ ! 976: 939 00021363 0d 01 effffff7f2 movl $1,_force_loop ! 977: 940 0002136A # asm("brw _expf_5_lp1");; /* and loop on the error */ ! 978: 941 0002136A 13 ff05 brw _expf_5_lp1 ! 979: 942 0002136D # } /* end of loop on error */ ! 980: 943 0002136D # } /* end of compare error */ ! 981: 944 0002136D L330: ! 982: 945 0002136D # } /* end of WHILE loop */ ! 983: 946 0002136D L321: ! 984: 947 0002136D L317: ! 985: 948 0002136D 6d effffff7e9 incl _index ! 986: 949 00021373 13 fec0 jbr L319 ! 987: 950 00021376 L318: ! 988: 951 00021376 # } /* end of subtest 5 */ ! 989: 952 00021376 40 ret#2 ! 990: 953 00021377 .set L313,0x0 ! 991: 954 00021377 L315: ! 992: 955 00021377 13 fea9 jbr L316 ! 993: 956 0002137A .data ! 994: 957 00000a60 * .text ! 995: 958 0002137A .align 1 ! 996: 959 0002137A .globl _expf_6 ! 997: 960 0002137A _expf_6: ! 998: 961 0002137A 0000 .word L331 ! 999: 962 0002137C # ! 1000: 963 0002137C # ! 1001: 964 0002137C # ! 1002: 965 0002137C # /************************************************************************ ! 1003: 966 0002137C # * ! 1004: 967 0002137C # * SUBTEST 6 - pipelined exit test ! 1005: 968 0002137C # * ! 1006: 969 0002137C # ************************************************************************/ ! 1007: 970 0002137C # expf_6() ! 1008: 971 0002137C # { ! 1009: 972 0002137C 13 0154 jbr L333 ! 1010: 973 0002137F L334: ! 1011: 974 0002137F # force_loop = FALSE; ! 1012: 975 0002137F 4d effffff7d7 clrl _force_loop ! 1013: 976 00021385 # subtest = 8; ! 1014: 977 00021385 0d 08 effffff7d0 movl $8,_subtest ! 1015: 978 0002138C # for( index = 0; index < max_expf_1_index; index++ ) { ! 1016: 979 0002138C 4d effffff7ca clrl _index ! 1017: 980 00021392 L337: ! 1018: 981 00021392 1d effffff7c4 effffff7bf cmpl _index,_max_expf_1_index ! 1019: 982 0002139D 91 03 13 0130 jgeq L336 ! 1020: 983 000213A2 # sgl_ld_acc = expf_1_data[index].ld; /* get operand 1 */ ! 1021: 984 000213A2 0d effffff7b4 50 movl _index,r0 ! 1022: 985 000213A9 48 03 50 50 shll $3,r0,r0 ! 1023: 986 000213AD 0d e000000000 effffff7a4 movl _expf_1_data(r0),_sgl_ld_acc ! 1024: 987 000213B8 # sgl_expected = expf_1_data[index].exp; /* get expected result */ ! 1025: 988 000213B8 0d effffff79e 50 movl _index,r0 ! 1026: 989 000213BF 48 03 50 50 shll $3,r0,r0 ! 1027: 990 000213C3 0d e000000004 effffff78e movl _expf_1_data+4(r0),_sgl_expected ! 1028: 991 000213CE # /* ! 1029: 992 000213CE # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1030: 993 000213CE # * The force loop flag is set after the first error. ! 1031: 994 000213CE # */ ! 1032: 995 000213CE # asm("_expf_6_lp1:"); ! 1033: 996 000213CE _expf_6_lp1: ! 1034: 997 000213CE # asm("movl $0,r0"); /* clear r0 */ ! 1035: 998 000213CE 0d 00 50 movl $0,r0 ! 1036: 999 000213D1 # asm("ldf _sgl_ld_acc"); /* load the Acc. */ ! 1037: 1000 000213D1 06 effffff785 ldf _sgl_ld_acc ! 1038: 1001 000213D7 # asm("expf"); /* get the expf */ ! 1039: 1002 000213D7 55 expf ! 1040: 1003 000213D8 # asm("addf r0"); /* add a zero to the acc */ ! 1041: 1004 000213D8 c6 50 addf r0 ! 1042: 1005 000213DA # asm("stf _sgl_st_acc"); /* store the result */ ! 1043: 1006 000213DA 26 effffff77c stf _sgl_st_acc ! 1044: 1007 000213E0 # if( force_loop ) ! 1045: 1008 000213E0 5d effffff776 tstl _force_loop ! 1046: 1009 000213E6 31 02 jeql L338 ! 1047: 1010 000213E8 # asm("brb _expf_6_lp1");; /* loop on the error */ ! 1048: 1011 000213E8 11 e4 brb _expf_6_lp1 ! 1049: 1012 000213EA L338: ! 1050: 1013 000213EA # /* ! 1051: 1014 000213EA # * end error loop - test the results ! 1052: 1015 000213EA # */ ! 1053: 1016 000213EA # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1054: 1017 000213EA 1d effffff76c effffff767 cmpl _sgl_st_acc,_sgl_expected ! 1055: 1018 000213F5 21 03 13 00cf jeql L339 ! 1056: 1019 000213FA # errcnt++; /* bump the error count */ ! 1057: 1020 000213FA 6d effffff75c incl _errcnt ! 1058: 1021 00021400 # if( prt_error ) { ! 1059: 1022 00021400 5d effffff756 tstl _prt_error ! 1060: 1023 00021406 21 03 13 009b jeql L340 ! 1061: 1024 0002140B # writes(" \n"); /* start a new print line */ ! 1062: 1025 0002140B .data 1 ! 1063: 1026 00000cab * L341: ! 1064: 1027 00000cab * 200A00 .ascii " \12\0" ! 1065: 1028 00000cae * .text ! 1066: 1029 0002140B dd 8f00000cab pushl $L341 ! 1067: 1030 00021411 fe 08 effffff744 callf $8,_writes ! 1068: 1031 00021418 # writes("cycle: "); ! 1069: 1032 00021418 .data 1 ! 1070: 1033 00000cae * L342: ! 1071: 1034 00000cae * 6379636C653A2000 .ascii "cycle: \0" ! 1072: 1035 00000cb6 * .text ! 1073: 1036 00021418 dd 8f00000cae pushl $L342 ! 1074: 1037 0002141E fe 08 effffff737 callf $8,_writes ! 1075: 1038 00021425 # writed( cycle ); ! 1076: 1039 00021425 dd effffff731 pushl _cycle ! 1077: 1040 0002142B fe 08 effffff72a callf $8,_writed ! 1078: 1041 00021432 # writes(" EXPF test "); ! 1079: 1042 00021432 .data 1 ! 1080: 1043 00000cb6 * L343: ! 1081: 1044 00000cb6 * 2020204558504620746573742 .ascii " EXPF test \0" ! 1082: 000 ! 1083: 1045 00000cc4 * .text ! 1084: 1046 00021432 dd 8f00000cb6 pushl $L343 ! 1085: 1047 00021438 fe 08 effffff71d callf $8,_writes ! 1086: 1048 0002143F # writed( test_no ); ! 1087: 1049 0002143F dd effffff717 pushl _test_no ! 1088: 1050 00021445 fe 08 effffff710 callf $8,_writed ! 1089: 1051 0002144C # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n"); ! 1090: 1052 0002144C .data 1 ! 1091: 1053 00000cc4 * L344: ! 1092: 1054 00000cc4 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0" ! 1093: 8506970656420457869742920 ! 1094: 2D204241442046494E414C204 ! 1095: 143430A00 ! 1096: 1055 00000cee * .text ! 1097: 1056 0002144C dd 8f00000cc4 pushl $L344 ! 1098: 1057 00021452 fe 08 effffff703 callf $8,_writes ! 1099: 1058 00021459 # print_expf_data(); ! 1100: 1059 00021459 fe 04 ef00000076 callf $4,_print_expf_data ! 1101: 1060 00021460 # writes(", data index = "); ! 1102: 1061 00021460 .data 1 ! 1103: 1062 00000cee * L345: ! 1104: 1063 00000cee * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1105: 8203D2000 ! 1106: 1064 00000cff * .text ! 1107: 1065 00021460 dd 8f00000cee pushl $L345 ! 1108: 1066 00021466 fe 08 effffff6ef callf $8,_writes ! 1109: 1067 0002146D # writed( index ); ! 1110: 1068 0002146D dd effffff6e9 pushl _index ! 1111: 1069 00021473 fe 08 effffff6e2 callf $8,_writed ! 1112: 1070 0002147A # writec('\n'); ! 1113: 1071 0002147A dd 0a pushl $10 ! 1114: 1072 0002147C fe 08 effffff6d9 callf $8,_writec ! 1115: 1073 00021483 # writes(" Acc expected = "); ! 1116: 1074 00021483 .data 1 ! 1117: 1075 00000cff * L346: ! 1118: 1076 00000cff * 2020202020202020202020202 .ascii " Acc expected = \0" ! 1119: 0202020202020202020416363 ! 1120: 206578706563746564203D200 ! 1121: 0 ! 1122: 1077 00000d25 * .text ! 1123: 1078 00021483 dd 8f00000cff pushl $L346 ! 1124: 1079 00021489 fe 08 effffff6cc callf $8,_writes ! 1125: 1080 00021490 # write32h( sgl_expected ); ! 1126: 1081 00021490 dd effffff6c6 pushl _sgl_expected ! 1127: 1082 00021496 fe 08 effffff6bf callf $8,_write32h ! 1128: 1083 0002149D # writec('\n'); ! 1129: 1084 0002149D dd 0a pushl $10 ! 1130: 1085 0002149F fe 08 effffff6b6 callf $8,_writec ! 1131: 1086 000214A6 # } ! 1132: 1087 000214A6 # if( halt_flg ) ! 1133: 1088 000214A6 L340: ! 1134: 1089 000214A6 5d effffff6b0 tstl _halt_flg ! 1135: 1090 000214AC 31 09 jeql L347 ! 1136: 1091 000214AE # expf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1137: 1092 000214AE dd 01 pushl $1 ! 1138: 1093 000214B0 fe 08 ef0000005b callf $8,_expf_er_halt ! 1139: 1094 000214B7 # if( loop_on_err ) { ! 1140: 1095 000214B7 L347: ! 1141: 1096 000214B7 5d effffff69f tstl _loop_on_err ! 1142: 1097 000214BD 31 0a jeql L348 ! 1143: 1098 000214BF # force_loop = TRUE; /* set the force loop flag */ ! 1144: 1099 000214BF 0d 01 effffff696 movl $1,_force_loop ! 1145: 1100 000214C6 # asm("brw _expf_6_lp1");; /* and loop on the error */ ! 1146: 1101 000214C6 13 ff05 brw _expf_6_lp1 ! 1147: 1102 000214C9 # } /* end of loop on error */ ! 1148: 1103 000214C9 # } /* end of compare error */ ! 1149: 1104 000214C9 L348: ! 1150: 1105 000214C9 # } /* end of WHILE loop */ ! 1151: 1106 000214C9 L339: ! 1152: 1107 000214C9 L335: ! 1153: 1108 000214C9 6d effffff68d incl _index ! 1154: 1109 000214CF 13 fec0 jbr L337 ! 1155: 1110 000214D2 L336: ! 1156: 1111 000214D2 # } /* end of subtest 6 */ ! 1157: 1112 000214D2 40 ret#2 ! 1158: 1113 000214D3 .set L331,0x0 ! 1159: 1114 000214D3 L333: ! 1160: 1115 000214D3 13 fea9 jbr L334 ! 1161: 1116 000214D6 .data ! 1162: 1117 00000a60 * .text ! 1163: 1118 000214D6 .align 1 ! 1164: 1119 000214D6 .globl _print_expf_data ! 1165: 1120 000214D6 _print_expf_data: ! 1166: 1121 000214D6 0000 .word L349 ! 1167: 1122 000214D8 # ! 1168: 1123 000214D8 # ! 1169: 1124 000214D8 # ! 1170: 1125 000214D8 # /************************************************************************** ! 1171: 1126 000214D8 # * ! 1172: 1127 000214D8 # * PRINT THE DATA AND STORE RESULTS ! 1173: 1128 000214D8 # * ! 1174: 1129 000214D8 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 1175: 1130 000214D8 # * Acc expected = xxxxxxxx ! 1176: 1131 000214D8 # **************************************************************************/ ! 1177: 1132 000214D8 # print_expf_data() ! 1178: 1133 000214D8 # { ! 1179: 1134 000214D8 11 35 jbr L351 ! 1180: 1135 000214DA L352: ! 1181: 1136 000214DA # writes("initial Acc = "); ! 1182: 1137 000214DA .data 1 ! 1183: 1138 00000d25 * L353: ! 1184: 1139 00000d25 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1185: D2000 ! 1186: 1140 00000d34 * .text ! 1187: 1141 000214DA dd 8f00000d25 pushl $L353 ! 1188: 1142 000214E0 fe 08 effffff675 callf $8,_writes ! 1189: 1143 000214E7 # write32h( sgl_ld_acc ); ! 1190: 1144 000214E7 dd effffff66f pushl _sgl_ld_acc ! 1191: 1145 000214ED fe 08 effffff668 callf $8,_write32h ! 1192: 1146 000214F4 # writes(", final Acc = "); ! 1193: 1147 000214F4 .data 1 ! 1194: 1148 00000d34 * L354: ! 1195: 1149 00000d34 * 2C202066696E616C204163632 .ascii ", final Acc = \0" ! 1196: 03D2000 ! 1197: 1150 00000d44 * .text ! 1198: 1151 000214F4 dd 8f00000d34 pushl $L354 ! 1199: 1152 000214FA fe 08 effffff65b callf $8,_writes ! 1200: 1153 00021501 # write32h( sgl_st_acc ); ! 1201: 1154 00021501 dd effffff655 pushl _sgl_st_acc ! 1202: 1155 00021507 fe 08 effffff64e callf $8,_write32h ! 1203: 1156 0002150E # } ! 1204: 1157 0002150E 40 ret#2 ! 1205: 1158 0002150F .set L349,0x0 ! 1206: 1159 0002150F L351: ! 1207: 1160 0002150F 11 c9 jbr L352 ! 1208: 1161 00021511 .data ! 1209: 1162 00000a60 * .text ! 1210: 1163 00021511 00 .align 1 ! 1211: 1164 00021512 .globl _expf_er_halt ! 1212: 1165 00021512 _expf_er_halt: ! 1213: 1166 00021512 0000 .word L355 ! 1214: 1167 00021514 # ! 1215: 1168 00021514 # ! 1216: 1169 00021514 # ! 1217: 1170 00021514 # /************************************************************************** ! 1218: 1171 00021514 # * ! 1219: 1172 00021514 # * HALT ON ERROR ROUTINE ! 1220: 1173 00021514 # * ! 1221: 1174 00021514 # **************************************************************************/ ! 1222: 1175 00021514 # expf_er_halt( halt_code ) ! 1223: 1176 00021514 # int halt_code; ! 1224: 1177 00021514 # { ! 1225: 1178 00021514 13 00a0 jbr L357 ! 1226: 1179 00021517 L358: ! 1227: 1180 00021517 # sgl_dummy1 = halt_code; /* get the error type */ ! 1228: 1181 00021517 0d ad04 effffff63d movl 4(fp),_sgl_dummy1 ! 1229: 1182 0002151F # asm("movl _test_no,r0"); /* r0 = test number */ ! 1230: 1183 0002151F 0d effffff637 50 movl _test_no,r0 ! 1231: 1184 00021526 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1232: 1185 00021526 0d effffff630 51 movl _subtest,r1 ! 1233: 1186 0002152D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1234: 1187 0002152D 0d effffff629 52 movl _sgl_dummy1,r2 ! 1235: 1188 00021534 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1236: 1189 00021534 0d effffff622 53 movl _cycle,r3 ! 1237: 1190 0002153B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 1238: 1191 0002153B 0d effffff61b 54 movl _sgl_ld_acc,r4 ! 1239: 1192 00021542 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */ ! 1240: 1193 00021542 0d effffff614 55 movl _sgl_st_acc,r5 ! 1241: 1194 00021549 # asm("movl _sgl_expected,r6"); /* r6 = data expected */ ! 1242: 1195 00021549 0d effffff60d 56 movl _sgl_expected,r6 ! 1243: 1196 00021550 # asm("movl _index,r7"); /* r7 = data index */ ! 1244: 1197 00021550 0d effffff606 57 movl _index,r7 ! 1245: 1198 00021557 # if( halt_code == BAD_REG_HLT ) { ! 1246: 1199 00021557 1d ad04 02 cmpl 4(fp),$2 ! 1247: 1200 0002155B 21 3d jneq L359 ! 1248: 1201 0002155D # sgl_dummy1 = load_regs[index2]; ! 1249: 1202 0002155D 0d effffff5f9 50 movl _index2,r0 ! 1250: 1203 00021564 0d 40effffff5f1 movl _load_regs[r0],_sgl_dummy1 ! 1251: effffff5ec ! 1252: 1204 00021570 # sgl_dummy2 = store_regs[index2]; ! 1253: 1205 00021570 0d effffff5e6 50 movl _index2,r0 ! 1254: 1206 00021577 0d 40effffff5de movl _store_regs[r0],_sgl_dummy2 ! 1255: effffff5d9 ! 1256: 1207 00021583 # asm("movl _index2,r6"); /* r6 = bad register # */ ! 1257: 1208 00021583 0d effffff5d3 56 movl _index2,r6 ! 1258: 1209 0002158A # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 1259: 1210 0002158A 0d effffff5cc 57 movl _sgl_dummy2,r7 ! 1260: 1211 00021591 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 1261: 1212 00021591 0d effffff5c5 58 movl _sgl_dummy1,r8 ! 1262: 1213 00021598 # } else ! 1263: 1214 00021598 11 1b jbr L360 ! 1264: 1215 0002159A L359: ! 1265: 1216 0002159A # if( halt_code == BAD_PSL_HLT ) { ! 1266: 1217 0002159A 1d ad04 03 cmpl 4(fp),$3 ! 1267: 1218 0002159E 21 15 jneq L361 ! 1268: 1219 000215A0 # asm("movl _init_psl,r6"); /* r6 = initial PSL */ ! 1269: 1220 000215A0 0d effffff5b6 56 movl _init_psl,r6 ! 1270: 1221 000215A7 # asm("movl _psl_val,r7"); /* r7 = final PSL */ ! 1271: 1222 000215A7 0d effffff5af 57 movl _psl_val,r7 ! 1272: 1223 000215AE # asm("movl _exp_psl,r8"); /* r8 = expected PSL */ ! 1273: 1224 000215AE 0d effffff5a8 58 movl _exp_psl,r8 ! 1274: 1225 000215B5 # }; ! 1275: 1226 000215B5 L361: ! 1276: 1227 000215B5 L360: ! 1277: 1228 000215B5 # asm("halt"); /* HALT ... */ ! 1278: 1229 000215B5 00 halt ! 1279: 1230 000215B6 # } ! 1280: 1231 000215B6 40 ret#2 ! 1281: 1232 000215B7 .set L355,0x0 ! 1282: 1233 000215B7 L357: ! 1283: 1234 000215B7 13 ff5d jbr L358 ! 1284: 1235 000215BA .data ! 1285: 1235 00042116 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.