![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sqrtf.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 sqrtf.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 _sqrtf ! 6: 6 00000000 _sqrtf: ! 7: 7 000200FC 0000 .word L215 ! 8: 8 000200FE # #include "fpp_defs.h" ! 9: 9 000200FE # ! 10: 10 000200FE # ! 11: 11 000200FE # ! 12: 12 000200FE # /*************************************************************************** ! 13: 13 000200FE # * ! 14: 14 000200FE # * SQRTF - SINGLE PRECISION FLOATING POINT SQUARE-ROOT FUNCTION TEST ! 15: 15 000200FE # * ! 16: 16 000200FE # * SQRTF TEST MONITOR ! 17: 17 000200FE # * ! 18: 18 000200FE # *****************************************************************************/ ! 19: 19 000200FE # sqrtf() ! 20: 20 000200FE # { ! 21: 21 000200FE 11 4f jbr L217 ! 22: 22 00020100 L218: ! 23: 23 00020100 # asm(".globl _sqrtf_t"); ! 24: 24 00020100 .globl _sqrtf_t ! 25: 25 00020100 # asm("_sqrtf_t:"); /* entry address */ ! 26: 26 00020100 _sqrtf_t: ! 27: 27 00020100 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 28: 28 00020100 1d effffffff6 01 cmpl _cycle,$1 ! 29: 29 00020107 21 15 jneq L219 ! 30: 30 00020109 5d efffffffed tstl _prt_hdrs ! 31: 31 0002010F 31 0d jeql L219 ! 32: 32 00020111 # { ! 33: 33 00020111 # writes(" SQRTF"); ! 34: 34 00020111 .data 1 ! 35: 35 00000a60 * L221: ! 36: 36 00000a60 * 20535152544600 .ascii " SQRTF\0" ! 37: 37 00000a67 * .text ! 38: 38 00020111 dd 8f00000a60 pushl $L221 ! 39: 39 00020117 fe 08 efffffffde callf $8,_writes ! 40: 40 0002011E # } ! 41: 41 0002011E # sqrtf_1(); /* test square root w/ delay */ ! 42: 42 0002011E L219: ! 43: 43 0002011E fe 04 ef0000002d callf $4,_sqrtf_1 ! 44: 44 00020125 # sqrtf_2(); /* test square root */ ! 45: 45 00020125 fe 04 ef00000198 callf $4,_sqrtf_2 ! 46: 46 0002012C # sqrtf_3(); /* register corruption */ ! 47: 47 0002012C fe 04 ef000002f1 callf $4,_sqrtf_3 ! 48: 48 00020133 # sqrtf_4(); /* test the PSL */ ! 49: 49 00020133 fe 04 ef000004d4 callf $4,_sqrtf_4 ! 50: 50 0002013A # sqrtf_5(); /* pipelined entry */ ! 51: 51 0002013A fe 04 ef0000067d callf $4,_sqrtf_5 ! 52: 52 00020141 # sqrtf_6(); /* pipelined exit */ ! 53: 53 00020141 fe 04 ef000007d2 callf $4,_sqrtf_6 ! 54: 54 00020148 # asm("jmp *return"); /* return to the test monitor */ ! 55: 55 00020148 71 ffffffffae jmp *return ! 56: 56 0002014E # } ! 57: 57 0002014E 40 ret#2 ! 58: 58 0002014F .set L215,0x0 ! 59: 59 0002014F L217: ! 60: 60 0002014F 11 af jbr L218 ! 61: 61 00020151 .data ! 62: 62 00000a60 * .text ! 63: 63 00020151 00 .align 1 ! 64: 64 00020152 .globl _sqrtf_1 ! 65: 65 00020152 _sqrtf_1: ! 66: 66 00020152 0000 .word L228 ! 67: 67 00020154 # ! 68: 68 00020154 # /*************************************************************************** ! 69: 69 00020154 # * ! 70: 70 00020154 # * SUBTEST 1 - SQUARE-ROOT FUNCTION ! 71: 71 00020154 # * ! 72: 72 00020154 # ***************************************************************************/ ! 73: 73 00020154 # sqrtf_1() ! 74: 74 00020154 # { ! 75: 75 00020154 13 016a jbr L230 ! 76: 76 00020157 L231: ! 77: 77 00020157 # #define DELAY 5 /* wait 10 ticks between SQRTF & STF */ ! 78: 78 00020157 # force_loop = FALSE; /* clear the LOOP flag */ ! 79: 79 00020157 4d efffffff9f clrl _force_loop ! 80: 80 0002015D # subtest = 1; ! 81: 81 0002015D 0d 01 efffffff98 movl $1,_subtest ! 82: 82 00020164 # index = 0; ! 83: 83 00020164 4d efffffff92 clrl _index ! 84: 84 0002016A # do ! 85: 85 0002016A L234: ! 86: 86 0002016A # { ! 87: 87 0002016A # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */ ! 88: 88 0002016A 0d efffffff8c 50 movl _index,r0 ! 89: 89 00020171 48 03 50 50 shll $3,r0,r0 ! 90: 90 00020175 0d e000000000 efffffff7c movl _sqrtf_1_data(r0),_sgl_ld_acc ! 91: 91 00020180 # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */ ! 92: 92 00020180 0d efffffff76 50 movl _index,r0 ! 93: 93 00020187 48 03 50 50 shll $3,r0,r0 ! 94: 94 0002018B 0d e000000004 efffffff66 movl _sqrtf_1_data+4(r0),_sgl_expected ! 95: 95 00020196 # sgl_dummy1 = DELAY; ! 96: 96 00020196 0d 05 efffffff5f movl $5,_sgl_dummy1 ! 97: 97 0002019D # /* ! 98: 98 0002019D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 99: 99 0002019D # * The force loop flag is set after the first error. ! 100: 100 0002019D # */ ! 101: 101 0002019D # asm("_sqrtf_1_lp1:"); ! 102: 102 0002019D _sqrtf_1_lp1: ! 103: 103 0002019D # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 104: 104 0002019D 0d efffffff59 54 movl _sgl_ld_acc,r4 ! 105: 105 000201A4 # asm("ldf r4"); /* load the accumulator */ ! 106: 106 000201A4 06 54 ldf r4 ! 107: 107 000201A6 # asm("movl _sgl_dummy1,r0"); /* get the delay factor */ ! 108: 108 000201A6 0d efffffff50 50 movl _sgl_dummy1,r0 ! 109: 109 000201AD # asm("sqrtf"); /* get ACC.'s square root */ ! 110: 110 000201AD 45 sqrtf ! 111: 111 000201AE # asm("1:"); ! 112: 112 000201AE 1: ! 113: 113 000201AE # asm("decl r0"); /* delay to let the SQRTF */ ! 114: 114 000201AE 7d 50 decl r0 ! 115: 115 000201B0 # asm("bgtr 1b"); /* instruction finish */ ! 116: 116 000201B0 41 fc bgtr 1b ! 117: 117 000201B2 # asm("stf r5"); /* store the result */ ! 118: 118 000201B2 26 55 stf r5 ! 119: 119 000201B4 # if( force_loop ) ! 120: 120 000201B4 5d efffffff42 tstl _force_loop ! 121: 121 000201BA 31 02 jeql L235 ! 122: 122 000201BC # asm("brb _sqrtf_1_lp1");; /* loop on the error */ ! 123: 123 000201BC 11 df brb _sqrtf_1_lp1 ! 124: 124 000201BE L235: ! 125: 125 000201BE # /* ! 126: 126 000201BE # * end error loop ! 127: 127 000201BE # */ ! 128: 128 000201BE # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 129: 129 000201BE 0d 55 efffffff37 movl r5,_sgl_st_acc ! 130: 130 000201C5 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 131: 131 000201C5 1d efffffff31 efffffff2c cmpl _sgl_st_acc,_sgl_expected ! 132: 132 000201D0 21 03 13 00d2 jeql L236 ! 133: 133 000201D5 # { ! 134: 134 000201D5 # errcnt++; /* bump the error count */ ! 135: 135 000201D5 6d efffffff21 incl _errcnt ! 136: 136 000201DB # if ( prt_error ) { ! 137: 137 000201DB 5d efffffff1b tstl _prt_error ! 138: 138 000201E1 21 03 13 009b jeql L237 ! 139: 139 000201E6 # writes(" \n"); /* start a new print line */ ! 140: 140 000201E6 .data 1 ! 141: 141 00000a67 * L238: ! 142: 142 00000a67 * 200A00 .ascii " \12\0" ! 143: 143 00000a6a * .text ! 144: 144 000201E6 dd 8f00000a67 pushl $L238 ! 145: 145 000201EC fe 08 efffffff09 callf $8,_writes ! 146: 146 000201F3 # writes("cycle: "); ! 147: 147 000201F3 .data 1 ! 148: 148 00000a6a * L239: ! 149: 149 00000a6a * 6379636C653A2000 .ascii "cycle: \0" ! 150: 150 00000a72 * .text ! 151: 151 000201F3 dd 8f00000a6a pushl $L239 ! 152: 152 000201F9 fe 08 effffffefc callf $8,_writes ! 153: 153 00020200 # writed( cycle ); ! 154: 154 00020200 dd effffffef6 pushl _cycle ! 155: 155 00020206 fe 08 effffffeef callf $8,_writed ! 156: 156 0002020D # writes(" SQRTF test "); ! 157: 157 0002020D .data 1 ! 158: 158 00000a72 * L241: ! 159: 159 00000a72 * 2020535152544620746573742 .ascii " SQRTF test \0" ! 160: 000 ! 161: 160 00000a80 * .text ! 162: 161 0002020D dd 8f00000a72 pushl $L241 ! 163: 162 00020213 fe 08 effffffee2 callf $8,_writes ! 164: 163 0002021A # writed( test_no ); ! 165: 164 0002021A dd effffffedc pushl _test_no ! 166: 165 00020220 fe 08 effffffed5 callf $8,_writed ! 167: 166 00020227 # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n"); ! 168: 167 00020227 .data 1 ! 169: 168 00000a80 * L242: ! 170: 169 00000a80 * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0" ! 171: 864656C617965642073746F72 ! 172: 6529202D204241442046494E4 ! 173: 14C204143430A00 ! 174: 170 00000aad * .text ! 175: 171 00020227 dd 8f00000a80 pushl $L242 ! 176: 172 0002022D fe 08 effffffec8 callf $8,_writes ! 177: 173 00020234 # print_sqrtf_data(); ! 178: 174 00020234 fe 04 ef0000083b callf $4,_print_sqrtf_data ! 179: 175 0002023B # writes(", data index = "); ! 180: 176 0002023B .data 1 ! 181: 177 00000aad * L244: ! 182: 178 00000aad * 2C20206461746120696E64657 .ascii ", data index = \0" ! 183: 8203D2000 ! 184: 179 00000abe * .text ! 185: 180 0002023B dd 8f00000aad pushl $L244 ! 186: 181 00020241 fe 08 effffffeb4 callf $8,_writes ! 187: 182 00020248 # writed( index ); ! 188: 183 00020248 dd effffffeae pushl _index ! 189: 184 0002024E fe 08 effffffea7 callf $8,_writed ! 190: 185 00020255 # writec('\n'); ! 191: 186 00020255 dd 0a pushl $10 ! 192: 187 00020257 fe 08 effffffe9e callf $8,_writec ! 193: 188 0002025E # writes(" Acc expected = "); ! 194: 189 0002025E .data 1 ! 195: 190 00000abe * L246: ! 196: 191 00000abe * 2020202020202020202020202 .ascii " Acc expected = \0" ! 197: 0202020202020202020416363 ! 198: 206578706563746564203D200 ! 199: 0 ! 200: 192 00000ae4 * .text ! 201: 193 0002025E dd 8f00000abe pushl $L246 ! 202: 194 00020264 fe 08 effffffe91 callf $8,_writes ! 203: 195 0002026B # write32h( sgl_expected ); ! 204: 196 0002026B dd effffffe8b pushl _sgl_expected ! 205: 197 00020271 fe 08 effffffe84 callf $8,_write32h ! 206: 198 00020278 # writec('\n'); ! 207: 199 00020278 dd 0a pushl $10 ! 208: 200 0002027A fe 08 effffffe7b callf $8,_writec ! 209: 201 00020281 # } ! 210: 202 00020281 # if ( halt_flg ) /* halt on error? */ ! 211: 203 00020281 L237: ! 212: 204 00020281 5d effffffe75 tstl _halt_flg ! 213: 205 00020287 31 09 jeql L248 ! 214: 206 00020289 # sqrtf_er_halt( BAD_ACC_HLT ); ! 215: 207 00020289 dd 01 pushl $1 ! 216: 208 0002028B fe 08 ef00000820 callf $8,_sqrtf_er_halt ! 217: 209 00020292 # if ( loop_on_err ) ! 218: 210 00020292 L248: ! 219: 211 00020292 5d effffffe64 tstl _loop_on_err ! 220: 212 00020298 31 0d jeql L250 ! 221: 213 0002029A # { ! 222: 214 0002029A # force_loop = TRUE; /* set the force loop flag */ ! 223: 215 0002029A 0d 01 effffffe5b movl $1,_force_loop ! 224: 216 000202A1 # asm("jmp _sqrtf_1_lp1"); /* and loop */ ! 225: 217 000202A1 71 effffffef6 jmp _sqrtf_1_lp1 ! 226: 218 000202A7 # } ! 227: 219 000202A7 # } /* end of compare error */ ! 228: 220 000202A7 L250: ! 229: 221 000202A7 # } while( index++ < max_sqrtf_1_index ); ! 230: 222 000202A7 L236: ! 231: 223 000202A7 L233: ! 232: 224 000202A7 0d effffffe4f 50 movl _index,r0 ! 233: 225 000202AE 6d effffffe48 incl _index ! 234: 226 000202B4 1d 50 effffffe41 cmpl r0,_max_sqrtf_1_index ! 235: 227 000202BB 81 03 13 feaa jlss L234 ! 236: 228 000202C0 L232: ! 237: 229 000202C0 # } /* end of subtest 1 */ ! 238: 230 000202C0 40 ret#2 ! 239: 231 000202C1 .set L228,0x0 ! 240: 232 000202C1 L230: ! 241: 233 000202C1 13 fe93 jbr L231 ! 242: 234 000202C4 .data ! 243: 235 00000a60 * .text ! 244: 236 000202C4 .align 1 ! 245: 237 000202C4 .globl _sqrtf_2 ! 246: 238 000202C4 _sqrtf_2: ! 247: 239 000202C4 0000 .word L251 ! 248: 240 000202C6 # ! 249: 241 000202C6 # ! 250: 242 000202C6 # ! 251: 243 000202C6 # /*************************************************************************** ! 252: 244 000202C6 # * ! 253: 245 000202C6 # * SUBTEST 2 - SQUARE-ROOT FUNCTION ! 254: 246 000202C6 # * ! 255: 247 000202C6 # ***************************************************************************/ ! 256: 248 000202C6 # sqrtf_2() ! 257: 249 000202C6 # { ! 258: 250 000202C6 13 0158 jbr L253 ! 259: 251 000202C9 L254: ! 260: 252 000202C9 # force_loop = FALSE; /* clear the LOOP flag */ ! 261: 253 000202C9 4d effffffe2d clrl _force_loop ! 262: 254 000202CF # subtest = 2; ! 263: 255 000202CF 0d 02 effffffe26 movl $2,_subtest ! 264: 256 000202D6 # index = 0; ! 265: 257 000202D6 4d effffffe20 clrl _index ! 266: 258 000202DC # do ! 267: 259 000202DC L257: ! 268: 260 000202DC # { ! 269: 261 000202DC # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */ ! 270: 262 000202DC 0d effffffe1a 50 movl _index,r0 ! 271: 263 000202E3 48 03 50 50 shll $3,r0,r0 ! 272: 264 000202E7 0d e000000000 effffffe0a movl _sqrtf_1_data(r0),_sgl_ld_acc ! 273: 265 000202F2 # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */ ! 274: 266 000202F2 0d effffffe04 50 movl _index,r0 ! 275: 267 000202F9 48 03 50 50 shll $3,r0,r0 ! 276: 268 000202FD 0d e000000004 effffffdf4 movl _sqrtf_1_data+4(r0),_sgl_expected ! 277: 269 00020308 # /* ! 278: 270 00020308 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 279: 271 00020308 # * The force loop flag is set after the first error. ! 280: 272 00020308 # */ ! 281: 273 00020308 # asm("_sqrtf_2_lp1:"); ! 282: 274 00020308 _sqrtf_2_lp1: ! 283: 275 00020308 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 284: 276 00020308 0d effffffdee 54 movl _sgl_ld_acc,r4 ! 285: 277 0002030F # asm("ldf r4"); /* load the accumulator */ ! 286: 278 0002030F 06 54 ldf r4 ! 287: 279 00020311 # asm("sqrtf"); /* get ACC.'s square root */ ! 288: 280 00020311 45 sqrtf ! 289: 281 00020312 # asm("stf r5"); /* store the result */ ! 290: 282 00020312 26 55 stf r5 ! 291: 283 00020314 # if( force_loop ) ! 292: 284 00020314 5d effffffde2 tstl _force_loop ! 293: 285 0002031A 31 02 jeql L258 ! 294: 286 0002031C # asm("brb _sqrtf_2_lp1");; /* loop on the error */ ! 295: 287 0002031C 11 ea brb _sqrtf_2_lp1 ! 296: 288 0002031E L258: ! 297: 289 0002031E # /* ! 298: 290 0002031E # * end error loop ! 299: 291 0002031E # */ ! 300: 292 0002031E # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 301: 293 0002031E 0d 55 effffffdd7 movl r5,_sgl_st_acc ! 302: 294 00020325 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 303: 295 00020325 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected ! 304: 296 00020330 21 03 13 00d2 jeql L259 ! 305: 297 00020335 # { ! 306: 298 00020335 # errcnt++; /* bump the error count */ ! 307: 299 00020335 6d effffffdc1 incl _errcnt ! 308: 300 0002033B # if ( prt_error ) { ! 309: 301 0002033B 5d effffffdbb tstl _prt_error ! 310: 302 00020341 21 03 13 009b jeql L260 ! 311: 303 00020346 # writes(" \n"); /* start a new print line */ ! 312: 304 00020346 .data 1 ! 313: 305 00000ae4 * L261: ! 314: 306 00000ae4 * 200A00 .ascii " \12\0" ! 315: 307 00000ae7 * .text ! 316: 308 00020346 dd 8f00000ae4 pushl $L261 ! 317: 309 0002034C fe 08 effffffda9 callf $8,_writes ! 318: 310 00020353 # writes("cycle: "); ! 319: 311 00020353 .data 1 ! 320: 312 00000ae7 * L262: ! 321: 313 00000ae7 * 6379636C653A2000 .ascii "cycle: \0" ! 322: 314 00000aef * .text ! 323: 315 00020353 dd 8f00000ae7 pushl $L262 ! 324: 316 00020359 fe 08 effffffd9c callf $8,_writes ! 325: 317 00020360 # writed( cycle ); ! 326: 318 00020360 dd effffffd96 pushl _cycle ! 327: 319 00020366 fe 08 effffffd8f callf $8,_writed ! 328: 320 0002036D # writes(" SQRTF test "); ! 329: 321 0002036D .data 1 ! 330: 322 00000aef * L263: ! 331: 323 00000aef * 2020535152544620746573742 .ascii " SQRTF test \0" ! 332: 000 ! 333: 324 00000afd * .text ! 334: 325 0002036D dd 8f00000aef pushl $L263 ! 335: 326 00020373 fe 08 effffffd82 callf $8,_writes ! 336: 327 0002037A # writed( test_no ); ! 337: 328 0002037A dd effffffd7c pushl _test_no ! 338: 329 00020380 fe 08 effffffd75 callf $8,_writed ! 339: 330 00020387 # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n"); ! 340: 331 00020387 .data 1 ! 341: 332 00000afd * L264: ! 342: 333 00000afd * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0" ! 343: 8696D6D656469617465207374 ! 344: 6F726529202D2042414420464 ! 345: 94E414C204143430A00 ! 346: 334 00000b2c * .text ! 347: 335 00020387 dd 8f00000afd pushl $L264 ! 348: 336 0002038D fe 08 effffffd68 callf $8,_writes ! 349: 337 00020394 # print_sqrtf_data(); ! 350: 338 00020394 fe 04 ef000006db callf $4,_print_sqrtf_data ! 351: 339 0002039B # writes(", data index = "); ! 352: 340 0002039B .data 1 ! 353: 341 00000b2c * L265: ! 354: 342 00000b2c * 2C20206461746120696E64657 .ascii ", data index = \0" ! 355: 8203D2000 ! 356: 343 00000b3d * .text ! 357: 344 0002039B dd 8f00000b2c pushl $L265 ! 358: 345 000203A1 fe 08 effffffd54 callf $8,_writes ! 359: 346 000203A8 # writed( index ); ! 360: 347 000203A8 dd effffffd4e pushl _index ! 361: 348 000203AE fe 08 effffffd47 callf $8,_writed ! 362: 349 000203B5 # writec('\n'); ! 363: 350 000203B5 dd 0a pushl $10 ! 364: 351 000203B7 fe 08 effffffd3e callf $8,_writec ! 365: 352 000203BE # writes(" Acc expected = "); ! 366: 353 000203BE .data 1 ! 367: 354 00000b3d * L266: ! 368: 355 00000b3d * 2020202020202020202020202 .ascii " Acc expected = \0" ! 369: 0202020202020202020416363 ! 370: 206578706563746564203D200 ! 371: 0 ! 372: 356 00000b63 * .text ! 373: 357 000203BE dd 8f00000b3d pushl $L266 ! 374: 358 000203C4 fe 08 effffffd31 callf $8,_writes ! 375: 359 000203CB # write32h( sgl_expected ); ! 376: 360 000203CB dd effffffd2b pushl _sgl_expected ! 377: 361 000203D1 fe 08 effffffd24 callf $8,_write32h ! 378: 362 000203D8 # writec('\n'); ! 379: 363 000203D8 dd 0a pushl $10 ! 380: 364 000203DA fe 08 effffffd1b callf $8,_writec ! 381: 365 000203E1 # } ! 382: 366 000203E1 # if ( halt_flg ) /* halt on error? */ ! 383: 367 000203E1 L260: ! 384: 368 000203E1 5d effffffd15 tstl _halt_flg ! 385: 369 000203E7 31 09 jeql L267 ! 386: 370 000203E9 # sqrtf_er_halt( BAD_ACC_HLT ); ! 387: 371 000203E9 dd 01 pushl $1 ! 388: 372 000203EB fe 08 ef000006c0 callf $8,_sqrtf_er_halt ! 389: 373 000203F2 # if ( loop_on_err ) ! 390: 374 000203F2 L267: ! 391: 375 000203F2 5d effffffd04 tstl _loop_on_err ! 392: 376 000203F8 31 0d jeql L268 ! 393: 377 000203FA # { ! 394: 378 000203FA # force_loop = TRUE; /* set the force loop flag */ ! 395: 379 000203FA 0d 01 effffffcfb movl $1,_force_loop ! 396: 380 00020401 # asm("jmp _sqrtf_2_lp1"); /* and loop */ ! 397: 381 00020401 71 efffffff01 jmp _sqrtf_2_lp1 ! 398: 382 00020407 # } ! 399: 383 00020407 # } /* end of compare error */ ! 400: 384 00020407 L268: ! 401: 385 00020407 # } while( index++ < max_sqrtf_1_index ); ! 402: 386 00020407 L259: ! 403: 387 00020407 L256: ! 404: 388 00020407 0d effffffcef 50 movl _index,r0 ! 405: 389 0002040E 6d effffffce8 incl _index ! 406: 390 00020414 1d 50 effffffce1 cmpl r0,_max_sqrtf_1_index ! 407: 391 0002041B 81 03 13 febc jlss L257 ! 408: 392 00020420 L255: ! 409: 393 00020420 # } /* end of subtest 2 */ ! 410: 394 00020420 40 ret#2 ! 411: 395 00020421 .set L251,0x0 ! 412: 396 00020421 L253: ! 413: 397 00020421 13 fea5 jbr L254 ! 414: 398 00020424 .data ! 415: 399 00000a60 * .text ! 416: 400 00020424 .align 1 ! 417: 401 00020424 .globl _sqrtf_3 ! 418: 402 00020424 _sqrtf_3: ! 419: 403 00020424 0000 .word L269 ! 420: 404 00020426 # ! 421: 405 00020426 # ! 422: 406 00020426 # ! 423: 407 00020426 # /*************************************************************************** ! 424: 408 00020426 # * ! 425: 409 00020426 # * SUBTEST 3 - REGISTER INTEGRITY WITH THE SQRTF FUNCTION ! 426: 410 00020426 # * ! 427: 411 00020426 # ***************************************************************************/ ! 428: 412 00020426 # sqrtf_3() ! 429: 413 00020426 # { ! 430: 414 00020426 13 01e1 jbr L271 ! 431: 415 00020429 L272: ! 432: 416 00020429 # fill_reg_buf( load_regs ); /* set reg values to load */ ! 433: 417 00020429 dd 8f00000000 pushl $_load_regs ! 434: 418 0002042F fe 08 effffffcc6 callf $8,_fill_reg_buf ! 435: 419 00020436 # force_loop = FALSE; /* clear the LOOP flag */ ! 436: 420 00020436 4d effffffcc0 clrl _force_loop ! 437: 421 0002043C # subtest = 3; ! 438: 422 0002043C 0d 03 effffffcb9 movl $3,_subtest ! 439: 423 00020443 # index = 0; ! 440: 424 00020443 4d effffffcb3 clrl _index ! 441: 425 00020449 # do ! 442: 426 00020449 L276: ! 443: 427 00020449 # { ! 444: 428 00020449 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get the operand */ ! 445: 429 00020449 0d effffffcad 50 movl _index,r0 ! 446: 430 00020450 48 03 50 50 shll $3,r0,r0 ! 447: 431 00020454 0d e000000000 effffffc9d movl _sqrtf_1_data(r0),_sgl_ld_acc ! 448: 432 0002045F # sgl_expected = sqrtf_1_data[index].exp; /* get expected results */ ! 449: 433 0002045F 0d effffffc97 50 movl _index,r0 ! 450: 434 00020466 48 03 50 50 shll $3,r0,r0 ! 451: 435 0002046A 0d e000000004 effffffc87 movl _sqrtf_1_data+4(r0),_sgl_expected ! 452: 436 00020475 # /* ! 453: 437 00020475 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 454: 438 00020475 # * The force loop flag is set after the first error. ! 455: 439 00020475 # */ ! 456: 440 00020475 # asm("_sqrtf_3_lp1:"); ! 457: 441 00020475 _sqrtf_3_lp1: ! 458: 442 00020475 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 459: 443 00020475 ab 891fff effffffc7e loadr $0x1fff,_load_regs ! 460: 444 0002047E # asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 461: 445 0002047E 06 effffffc78 ldf _sgl_ld_acc ! 462: 446 00020484 # asm("sqrtf"); /* get ACC.'s sqrt */ ! 463: 447 00020484 45 sqrtf ! 464: 448 00020485 # asm("stf _sgl_st_acc"); /* store the result */ ! 465: 449 00020485 26 effffffc71 stf _sgl_st_acc ! 466: 450 0002048B # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 467: 451 0002048B bb 891fff effffffc68 storer $0x1fff,_store_regs ! 468: 452 00020494 # if( force_loop ) ! 469: 453 00020494 5d effffffc62 tstl _force_loop ! 470: 454 0002049A 31 02 jeql L277 ! 471: 455 0002049C # asm("brb _sqrtf_3_lp1");; /* loop on the error */ ! 472: 456 0002049C 11 d7 brb _sqrtf_3_lp1 ! 473: 457 0002049E L277: ! 474: 458 0002049E # /* ! 475: 459 0002049E # * end error loop ! 476: 460 0002049E # */ ! 477: 461 0002049E # reg_no = 0; ! 478: 462 0002049E 4d effffffc58 clrl _reg_no ! 479: 463 000204A4 # regs_ok = TRUE; ! 480: 464 000204A4 0d 01 effffffc51 movl $1,_regs_ok ! 481: 465 000204AB # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */ ! 482: 466 000204AB L278: ! 483: 467 000204AB 1d effffffc4b 0d cmpl _reg_no,$13 ! 484: 468 000204B2 81 35 jgeq L279 ! 485: 469 000204B4 5d effffffc42 tstl _regs_ok ! 486: 470 000204BA 31 2d jeql L279 ! 487: 471 000204BC # if( store_regs[ reg_no ] == load_regs[ reg_no ] ) ! 488: 472 000204BC 0d effffffc3a 50 movl _reg_no,r0 ! 489: 473 000204C3 0d effffffc33 51 movl _reg_no,r1 ! 490: 474 000204CA 1d 40effffffc2b cmpl _store_regs[r0],_load_regs[r1] ! 491: 41effffffc25 ! 492: 475 000204D7 21 08 jneq L280 ! 493: 476 000204D9 # reg_no++; ! 494: 477 000204D9 6d effffffc1d incl _reg_no ! 495: 478 000204DF # else ! 496: 479 000204DF 11 06 jbr L281 ! 497: 480 000204E1 L280: ! 498: 481 000204E1 # regs_ok = FALSE; ! 499: 482 000204E1 4d effffffc15 clrl _regs_ok ! 500: 483 000204E7 L281: ! 501: 484 000204E7 11 c2 jbr L278 ! 502: 485 000204E9 L279: ! 503: 486 000204E9 # if( !regs_ok ) ! 504: 487 000204E9 5d effffffc0d tstl _regs_ok ! 505: 488 000204EF 31 03 13 00fc jneq L282 ! 506: 489 000204F4 # { ! 507: 490 000204F4 # errcnt++; /* bump the error count */ ! 508: 491 000204F4 6d effffffc02 incl _errcnt ! 509: 492 000204FA # if ( prt_error ) { ! 510: 493 000204FA 5d effffffbfc tstl _prt_error ! 511: 494 00020500 21 03 13 00eb jeql L283 ! 512: 495 00020505 # writes(" \n"); /* start a new print line */ ! 513: 496 00020505 .data 1 ! 514: 497 00000b63 * L284: ! 515: 498 00000b63 * 200A00 .ascii " \12\0" ! 516: 499 00000b66 * .text ! 517: 500 00020505 dd 8f00000b63 pushl $L284 ! 518: 501 0002050B fe 08 effffffbea callf $8,_writes ! 519: 502 00020512 # writes("cycle: "); ! 520: 503 00020512 .data 1 ! 521: 504 00000b66 * L285: ! 522: 505 00000b66 * 6379636C653A2000 .ascii "cycle: \0" ! 523: 506 00000b6e * .text ! 524: 507 00020512 dd 8f00000b66 pushl $L285 ! 525: 508 00020518 fe 08 effffffbdd callf $8,_writes ! 526: 509 0002051F # writed( cycle ); ! 527: 510 0002051F dd effffffbd7 pushl _cycle ! 528: 511 00020525 fe 08 effffffbd0 callf $8,_writed ! 529: 512 0002052C # writes(" SQRTF test "); ! 530: 513 0002052C .data 1 ! 531: 514 00000b6e * L286: ! 532: 515 00000b6e * 2020535152544620746573742 .ascii " SQRTF test \0" ! 533: 000 ! 534: 516 00000b7c * .text ! 535: 517 0002052C dd 8f00000b6e pushl $L286 ! 536: 518 00020532 fe 08 effffffbc3 callf $8,_writes ! 537: 519 00020539 # writed( test_no ); ! 538: 520 00020539 dd effffffbbd pushl _test_no ! 539: 521 0002053F fe 08 effffffbb6 callf $8,_writed ! 540: 522 00020546 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); { ! 541: 523 00020546 .data 1 ! 542: 524 00000b7c * L287: ! 543: 525 00000b7c * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0" ! 544: D204120524547495354455220 ! 545: 574153204D4F4449464945440 ! 546: A00 ! 547: 526 00000ba3 * .text ! 548: 527 00020546 dd 8f00000b7c pushl $L287 ! 549: 528 0002054C fe 08 effffffba9 callf $8,_writes ! 550: 529 00020553 # print_sqrtf_data(); ! 551: 530 00020553 fe 04 ef0000051c callf $4,_print_sqrtf_data ! 552: 531 0002055A # writec('\n'); ! 553: 532 0002055A dd 0a pushl $10 ! 554: 533 0002055C fe 08 effffffb99 callf $8,_writec ! 555: 534 00020563 # writes("register "); ! 556: 535 00020563 .data 1 ! 557: 536 00000ba3 * L288: ! 558: 537 00000ba3 * 72656769737465722000 .ascii "register \0" ! 559: 538 00000bad * .text ! 560: 539 00020563 dd 8f00000ba3 pushl $L288 ! 561: 540 00020569 fe 08 effffffb8c callf $8,_writes ! 562: 541 00020570 # writed( reg_no ); ! 563: 542 00020570 dd effffffb86 pushl _reg_no ! 564: 543 00020576 fe 08 effffffb7f callf $8,_writed ! 565: 544 0002057D # writes(" = "); ! 566: 545 0002057D .data 1 ! 567: 546 00000bad * L289: ! 568: 547 00000bad * 203D2000 .ascii " = \0" ! 569: 548 00000bb1 * .text ! 570: 549 0002057D dd 8f00000bad pushl $L289 ! 571: 550 00020583 fe 08 effffffb72 callf $8,_writes ! 572: 551 0002058A # write32h( load_regs[reg_no] ); ! 573: 552 0002058A 0d effffffb6c 50 movl _reg_no,r0 ! 574: 553 00020591 dd 40effffffb64 pushl _load_regs[r0] ! 575: 554 00020598 fe 08 effffffb5d callf $8,_write32h ! 576: 555 0002059F # writes(", should be = "); ! 577: 556 0002059F .data 1 ! 578: 557 00000bb1 * L290: ! 579: 558 00000bb1 * 2C202073686F756C642062652 .ascii ", should be = \0" ! 580: 03D2000 ! 581: 559 00000bc1 * .text ! 582: 560 0002059F dd 8f00000bb1 pushl $L290 ! 583: 561 000205A5 fe 08 effffffb50 callf $8,_writes ! 584: 562 000205AC # write32h( store_regs[reg_no] ); ! 585: 563 000205AC 0d effffffb4a 50 movl _reg_no,r0 ! 586: 564 000205B3 dd 40effffffb42 pushl _store_regs[r0] ! 587: 565 000205BA fe 08 effffffb3b callf $8,_write32h ! 588: 566 000205C1 # writec('\n'); ! 589: 567 000205C1 dd 0a pushl $10 ! 590: 568 000205C3 fe 08 effffffb32 callf $8,_writec ! 591: 569 000205CA # } ! 592: 570 000205CA # if ( halt_flg ) /* halt on error? */ ! 593: 571 000205CA 5d effffffb2c tstl _halt_flg ! 594: 572 000205D0 31 09 jeql L291 ! 595: 573 000205D2 # sqrtf_er_halt( BAD_REG_HLT ); ! 596: 574 000205D2 dd 02 pushl $2 ! 597: 575 000205D4 fe 08 ef000004d7 callf $8,_sqrtf_er_halt ! 598: 576 000205DB # if ( loop_on_err ) ! 599: 577 000205DB L291: ! 600: 578 000205DB 5d effffffb1b tstl _loop_on_err ! 601: 579 000205E1 31 0d jeql L292 ! 602: 580 000205E3 # { ! 603: 581 000205E3 # force_loop = TRUE; /* get the force loop flag */ ! 604: 582 000205E3 0d 01 effffffb12 movl $1,_force_loop ! 605: 583 000205EA # asm("jmp _sqrtf_3_lp1"); /* and loop */ ! 606: 584 000205EA 71 effffffe85 jmp _sqrtf_3_lp1 ! 607: 585 000205F0 # } ! 608: 586 000205F0 # } /* end of compare error */ ! 609: 587 000205F0 L292: ! 610: 588 000205F0 # } /* end of while loop */ ! 611: 589 000205F0 L283: ! 612: 590 000205F0 # } while( index++ < max_sqrtf_1_index ); ! 613: 591 000205F0 L282: ! 614: 592 000205F0 L275: ! 615: 593 000205F0 0d effffffb06 50 movl _index,r0 ! 616: 594 000205F7 6d effffffaff incl _index ! 617: 595 000205FD 1d 50 effffffaf8 cmpl r0,_max_sqrtf_1_index ! 618: 596 00020604 81 03 13 fe40 jlss L276 ! 619: 597 00020609 L274: ! 620: 598 00020609 # } /* end of subtest 3 */ ! 621: 599 00020609 40 ret#2 ! 622: 600 0002060A .set L269,0x0 ! 623: 601 0002060A L271: ! 624: 602 0002060A 13 fe1c jbr L272 ! 625: 603 0002060D .data ! 626: 604 00000a60 * .text ! 627: 605 0002060D 00 .align 1 ! 628: 606 0002060E .globl _sqrtf_4 ! 629: 607 0002060E _sqrtf_4: ! 630: 608 0002060E 0000 .word L293 ! 631: 609 00020610 # ! 632: 610 00020610 # ! 633: 611 00020610 # ! 634: 612 00020610 # /************************************************************************ ! 635: 613 00020610 # * ! 636: 614 00020610 # * SUBTEST 4 - Check for PSL corruption ! 637: 615 00020610 # * ! 638: 616 00020610 # ************************************************************************/ ! 639: 617 00020610 # sqrtf_4() ! 640: 618 00020610 # { ! 641: 619 00020610 13 01a8 jbr L295 ! 642: 620 00020613 L296: ! 643: 621 00020613 # force_loop = FALSE; /* clear force_loop flg */ ! 644: 622 00020613 4d effffffae3 clrl _force_loop ! 645: 623 00020619 # subtest = 4; ! 646: 624 00020619 0d 04 effffffadc movl $4,_subtest ! 647: 625 00020620 # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 648: 626 00020620 dd 8f00000000 pushl $_load_regs ! 649: 627 00020626 fe 08 effffffacf callf $8,_fill_reg_buf ! 650: 628 0002062D # for( index = 0; index < 3; index++ ) { ! 651: 629 0002062D 4d effffffac9 clrl _index ! 652: 630 00020633 L299: ! 653: 631 00020633 1d effffffac3 03 cmpl _index,$3 ! 654: 632 0002063A 91 03 13 017b jgeq L298 ! 655: 633 0002063F # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */ ! 656: 634 0002063F 0d effffffab7 50 movl _index,r0 ! 657: 635 00020646 48 03 50 50 shll $3,r0,r0 ! 658: 636 0002064A 0d e000000000 effffffaa7 movl _sqrtf_1_data(r0),_sgl_ld_acc ! 659: 637 00020655 # sgl_expected = sqrtf_1_data[index].exp; /* get expected */ ! 660: 638 00020655 0d effffffaa1 50 movl _index,r0 ! 661: 639 0002065C 48 03 50 50 shll $3,r0,r0 ! 662: 640 00020660 0d e000000004 effffffa91 movl _sqrtf_1_data+4(r0),_sgl_expected ! 663: 641 0002066B # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 664: 642 0002066B 0d effffffa8b 50 movl _status_index,r0 ! 665: 643 00020672 0d 40effffffa83 movl _status_array[r0],_sgl_dummy1 ! 666: effffffa7e ! 667: 644 0002067E # /* ! 668: 645 0002067E # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 669: 646 0002067E # * The force loop flag is set after the first error. ! 670: 647 0002067E # */ ! 671: 648 0002067E # asm("_sqrtf_4_lp1:"); ! 672: 649 0002067E _sqrtf_4_lp1: ! 673: 650 0002067E # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 674: 651 0002067E 06 effffffa78 ldf _sgl_ld_acc ! 675: 652 00020684 # asm("nop"); ! 676: 653 00020684 10 nop ! 677: 654 00020685 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 678: 655 00020685 5d effffffa71 tstl _sgl_dummy1 ! 679: 656 0002068B # asm("movpsl _init_psl"); /* save the initial PSL */ ! 680: 657 0002068B cd effffffa6b movpsl _init_psl ! 681: 658 00020691 # asm("sqrtf"); /* do the sqrt */ ! 682: 659 00020691 45 sqrtf ! 683: 660 00020692 # asm("nop"); ! 684: 661 00020692 10 nop ! 685: 662 00020693 # asm("movpsl _psl_val"); /* save the final PSL */ ! 686: 663 00020693 cd effffffa63 movpsl _psl_val ! 687: 664 00020699 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 688: 665 00020699 26 effffffa5d stf _sgl_st_acc ! 689: 666 0002069F # if( force_loop ) ! 690: 667 0002069F 5d effffffa57 tstl _force_loop ! 691: 668 000206A5 31 02 jeql L300 ! 692: 669 000206A7 # asm("brb _sqrtf_4_lp1");; /* loop on the error */ ! 693: 670 000206A7 11 d5 brb _sqrtf_4_lp1 ! 694: 671 000206A9 L300: ! 695: 672 000206A9 # /* ! 696: 673 000206A9 # * Now compare the final PSL to the initial PSL -they should be the same ! 697: 674 000206A9 # */ ! 698: 675 000206A9 # exp_psl = init_psl; ! 699: 676 000206A9 0d effffffa4d effffffa48 movl _init_psl,_exp_psl ! 700: 677 000206B4 # if( psl_val != exp_psl ) { ! 701: 678 000206B4 1d effffffa42 effffffa3d cmpl _psl_val,_exp_psl ! 702: 679 000206BF 21 03 13 00ed jeql L301 ! 703: 680 000206C4 # errcnt++; /* bump the error count */ ! 704: 681 000206C4 6d effffffa32 incl _errcnt ! 705: 682 000206CA # if( prt_error ) { ! 706: 683 000206CA 5d effffffa2c tstl _prt_error ! 707: 684 000206D0 21 03 13 00b9 jeql L302 ! 708: 685 000206D5 # writes(" \n"); /* start a new print line */ ! 709: 686 000206D5 .data 1 ! 710: 687 00000bc1 * L303: ! 711: 688 00000bc1 * 200A00 .ascii " \12\0" ! 712: 689 00000bc4 * .text ! 713: 690 000206D5 dd 8f00000bc1 pushl $L303 ! 714: 691 000206DB fe 08 effffffa1a callf $8,_writes ! 715: 692 000206E2 # writes("cycle: "); ! 716: 693 000206E2 .data 1 ! 717: 694 00000bc4 * L304: ! 718: 695 00000bc4 * 6379636C653A2000 .ascii "cycle: \0" ! 719: 696 00000bcc * .text ! 720: 697 000206E2 dd 8f00000bc4 pushl $L304 ! 721: 698 000206E8 fe 08 effffffa0d callf $8,_writes ! 722: 699 000206EF # writed( cycle ); ! 723: 700 000206EF dd effffffa07 pushl _cycle ! 724: 701 000206F5 fe 08 effffffa00 callf $8,_writed ! 725: 702 000206FC # writes(" SQRTF test "); ! 726: 703 000206FC .data 1 ! 727: 704 00000bcc * L305: ! 728: 705 00000bcc * 2020535152544620746573742 .ascii " SQRTF test \0" ! 729: 000 ! 730: 706 00000bda * .text ! 731: 707 000206FC dd 8f00000bcc pushl $L305 ! 732: 708 00020702 fe 08 effffff9f3 callf $8,_writes ! 733: 709 00020709 # writed( test_no ); ! 734: 710 00020709 dd effffff9ed pushl _test_no ! 735: 711 0002070F fe 08 effffff9e6 callf $8,_writed ! 736: 712 00020716 # writes(", subtest 4 - INCORRECT FINAL PSL\n"); ! 737: 713 00020716 .data 1 ! 738: 714 00000bda * L306: ! 739: 715 00000bda * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0" ! 740: D20494E434F52524543542046 ! 741: 494E414C2050534C0A00 ! 742: 716 00000bfd * .text ! 743: 717 00020716 dd 8f00000bda pushl $L306 ! 744: 718 0002071C fe 08 effffff9d9 callf $8,_writes ! 745: 719 00020723 # print_sqrtf_data(); /* print the operands */ ! 746: 720 00020723 fe 04 ef0000034c callf $4,_print_sqrtf_data ! 747: 721 0002072A # writec('\n'); ! 748: 722 0002072A dd 0a pushl $10 ! 749: 723 0002072C fe 08 effffff9c9 callf $8,_writec ! 750: 724 00020733 # writes("initial PSL = "); ! 751: 725 00020733 .data 1 ! 752: 726 00000bfd * L307: ! 753: 727 00000bfd * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 754: D2000 ! 755: 728 00000c0c * .text ! 756: 729 00020733 dd 8f00000bfd pushl $L307 ! 757: 730 00020739 fe 08 effffff9bc callf $8,_writes ! 758: 731 00020740 # write32h( init_psl ); ! 759: 732 00020740 dd effffff9b6 pushl _init_psl ! 760: 733 00020746 fe 08 effffff9af callf $8,_write32h ! 761: 734 0002074D # writes(", final PSL = "); ! 762: 735 0002074D .data 1 ! 763: 736 00000c0c * L308: ! 764: 737 00000c0c * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 765: 03D2000 ! 766: 738 00000c1c * .text ! 767: 739 0002074D dd 8f00000c0c pushl $L308 ! 768: 740 00020753 fe 08 effffff9a2 callf $8,_writes ! 769: 741 0002075A # write32h( psl_val ); ! 770: 742 0002075A dd effffff99c pushl _psl_val ! 771: 743 00020760 fe 08 effffff995 callf $8,_write32h ! 772: 744 00020767 # writes(", expected PSL = "); ! 773: 745 00020767 .data 1 ! 774: 746 00000c1c * L309: ! 775: 747 00000c1c * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 776: 0534C203D2000 ! 777: 748 00000c2f * .text ! 778: 749 00020767 dd 8f00000c1c pushl $L309 ! 779: 750 0002076D fe 08 effffff988 callf $8,_writes ! 780: 751 00020774 # write32h( exp_psl ); ! 781: 752 00020774 dd effffff982 pushl _exp_psl ! 782: 753 0002077A fe 08 effffff97b callf $8,_write32h ! 783: 754 00020781 # writes("\n"); ! 784: 755 00020781 .data 1 ! 785: 756 00000c2f * L310: ! 786: 757 00000c2f * 0A00 .ascii "\12\0" ! 787: 758 00000c31 * .text ! 788: 759 00020781 dd 8f00000c2f pushl $L310 ! 789: 760 00020787 fe 08 effffff96e callf $8,_writes ! 790: 761 0002078E # } ! 791: 762 0002078E # if( halt_flg ) ! 792: 763 0002078E L302: ! 793: 764 0002078E 5d effffff968 tstl _halt_flg ! 794: 765 00020794 31 09 jeql L311 ! 795: 766 00020796 # sqrtf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 796: 767 00020796 dd 03 pushl $3 ! 797: 768 00020798 fe 08 ef00000313 callf $8,_sqrtf_er_halt ! 798: 769 0002079F # if( loop_on_err ) { ! 799: 770 0002079F L311: ! 800: 771 0002079F 5d effffff957 tstl _loop_on_err ! 801: 772 000207A5 31 0a jeql L312 ! 802: 773 000207A7 # force_loop = TRUE; /* set the force loop flag */ ! 803: 774 000207A7 0d 01 effffff94e movl $1,_force_loop ! 804: 775 000207AE # asm("brw _sqrtf_4_lp1");; /* and loop on the error */ ! 805: 776 000207AE 13 fecd brw _sqrtf_4_lp1 ! 806: 777 000207B1 # } /* end of loop on error */ ! 807: 778 000207B1 # } /* end of PSL corruption error */ ! 808: 779 000207B1 L312: ! 809: 780 000207B1 # } /* end of WHILE loop */ ! 810: 781 000207B1 L301: ! 811: 782 000207B1 L297: ! 812: 783 000207B1 6d effffff945 incl _index ! 813: 784 000207B7 13 fe79 jbr L299 ! 814: 785 000207BA L298: ! 815: 786 000207BA # } /* end of subtest 4 */ ! 816: 787 000207BA 40 ret#2 ! 817: 788 000207BB .set L293,0x0 ! 818: 789 000207BB L295: ! 819: 790 000207BB 13 fe55 jbr L296 ! 820: 791 000207BE .data ! 821: 792 00000a60 * .text ! 822: 793 000207BE .align 1 ! 823: 794 000207BE .globl _sqrtf_5 ! 824: 795 000207BE _sqrtf_5: ! 825: 796 000207BE 0000 .word L313 ! 826: 797 000207C0 # ! 827: 798 000207C0 # ! 828: 799 000207C0 # ! 829: 800 000207C0 # /************************************************************************ ! 830: 801 000207C0 # * ! 831: 802 000207C0 # * SUBTEST 5 - pipelined entry test ! 832: 803 000207C0 # * ! 833: 804 000207C0 # ************************************************************************/ ! 834: 805 000207C0 # sqrtf_5() ! 835: 806 000207C0 # { ! 836: 807 000207C0 13 0154 jbr L315 ! 837: 808 000207C3 L316: ! 838: 809 000207C3 # force_loop = FALSE; ! 839: 810 000207C3 4d effffff933 clrl _force_loop ! 840: 811 000207C9 # subtest = 8; ! 841: 812 000207C9 0d 08 effffff92c movl $8,_subtest ! 842: 813 000207D0 # for( index = 0; index < max_sqrtf_1_index; index++ ) { ! 843: 814 000207D0 4d effffff926 clrl _index ! 844: 815 000207D6 L319: ! 845: 816 000207D6 1d effffff920 effffff91b cmpl _index,_max_sqrtf_1_index ! 846: 817 000207E1 91 03 13 0130 jgeq L318 ! 847: 818 000207E6 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */ ! 848: 819 000207E6 0d effffff910 50 movl _index,r0 ! 849: 820 000207ED 48 03 50 50 shll $3,r0,r0 ! 850: 821 000207F1 0d e000000000 effffff900 movl _sqrtf_1_data(r0),_sgl_ld_acc ! 851: 822 000207FC # sgl_expected = sqrtf_1_data[index].exp; /* get expected result */ ! 852: 823 000207FC 0d effffff8fa 50 movl _index,r0 ! 853: 824 00020803 48 03 50 50 shll $3,r0,r0 ! 854: 825 00020807 0d e000000004 effffff8ea movl _sqrtf_1_data+4(r0),_sgl_expected ! 855: 826 00020812 # /* ! 856: 827 00020812 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 857: 828 00020812 # * The force loop flag is set after the first error. ! 858: 829 00020812 # */ ! 859: 830 00020812 # asm("_sqrtf_5_lp1:"); ! 860: 831 00020812 _sqrtf_5_lp1: ! 861: 832 00020812 # asm("movl $0,r0"); /* clear r0 */ ! 862: 833 00020812 0d 00 50 movl $0,r0 ! 863: 834 00020815 # asm("ldf r0"); /* load the Acc. with 0.0 */ ! 864: 835 00020815 06 50 ldf r0 ! 865: 836 00020817 # asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 866: 837 00020817 c6 effffff8df addf _sgl_ld_acc ! 867: 838 0002081D # asm("sqrtf"); /* get the sqrt */ ! 868: 839 0002081D 45 sqrtf ! 869: 840 0002081E # asm("stf _sgl_st_acc"); /* store the result */ ! 870: 841 0002081E 26 effffff8d8 stf _sgl_st_acc ! 871: 842 00020824 # if( force_loop ) ! 872: 843 00020824 5d effffff8d2 tstl _force_loop ! 873: 844 0002082A 31 02 jeql L320 ! 874: 845 0002082C # asm("brb _sqrtf_5_lp1");; /* loop on the error */ ! 875: 846 0002082C 11 e4 brb _sqrtf_5_lp1 ! 876: 847 0002082E L320: ! 877: 848 0002082E # /* ! 878: 849 0002082E # * end error loop - test the results ! 879: 850 0002082E # */ ! 880: 851 0002082E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 881: 852 0002082E 1d effffff8c8 effffff8c3 cmpl _sgl_st_acc,_sgl_expected ! 882: 853 00020839 21 03 13 00cf jeql L321 ! 883: 854 0002083E # errcnt++; /* bump the error count */ ! 884: 855 0002083E 6d effffff8b8 incl _errcnt ! 885: 856 00020844 # if( prt_error ) { ! 886: 857 00020844 5d effffff8b2 tstl _prt_error ! 887: 858 0002084A 21 03 13 009b jeql L322 ! 888: 859 0002084F # writes(" \n"); /* start a new print line */ ! 889: 860 0002084F .data 1 ! 890: 861 00000c31 * L323: ! 891: 862 00000c31 * 200A00 .ascii " \12\0" ! 892: 863 00000c34 * .text ! 893: 864 0002084F dd 8f00000c31 pushl $L323 ! 894: 865 00020855 fe 08 effffff8a0 callf $8,_writes ! 895: 866 0002085C # writes("cycle: "); ! 896: 867 0002085C .data 1 ! 897: 868 00000c34 * L324: ! 898: 869 00000c34 * 6379636C653A2000 .ascii "cycle: \0" ! 899: 870 00000c3c * .text ! 900: 871 0002085C dd 8f00000c34 pushl $L324 ! 901: 872 00020862 fe 08 effffff893 callf $8,_writes ! 902: 873 00020869 # writed( cycle ); ! 903: 874 00020869 dd effffff88d pushl _cycle ! 904: 875 0002086F fe 08 effffff886 callf $8,_writed ! 905: 876 00020876 # writes(" SQRTF test "); ! 906: 877 00020876 .data 1 ! 907: 878 00000c3c * L325: ! 908: 879 00000c3c * 2020535152544620746573742 .ascii " SQRTF test \0" ! 909: 000 ! 910: 880 00000c4a * .text ! 911: 881 00020876 dd 8f00000c3c pushl $L325 ! 912: 882 0002087C fe 08 effffff879 callf $8,_writes ! 913: 883 00020883 # writed( test_no ); ! 914: 884 00020883 dd effffff873 pushl _test_no ! 915: 885 00020889 fe 08 effffff86c callf $8,_writed ! 916: 886 00020890 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n"); ! 917: 887 00020890 .data 1 ! 918: 888 00000c4a * L326: ! 919: 889 00000c4a * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0" ! 920: 8506970656420456E74727929 ! 921: 202D204241442046494E414C2 ! 922: 04143430A00 ! 923: 890 00000c75 * .text ! 924: 891 00020890 dd 8f00000c4a pushl $L326 ! 925: 892 00020896 fe 08 effffff85f callf $8,_writes ! 926: 893 0002089D # print_sqrtf_data(); ! 927: 894 0002089D fe 04 ef000001d2 callf $4,_print_sqrtf_data ! 928: 895 000208A4 # writes(", data index = "); ! 929: 896 000208A4 .data 1 ! 930: 897 00000c75 * L327: ! 931: 898 00000c75 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 932: 8203D2000 ! 933: 899 00000c86 * .text ! 934: 900 000208A4 dd 8f00000c75 pushl $L327 ! 935: 901 000208AA fe 08 effffff84b callf $8,_writes ! 936: 902 000208B1 # writed( index ); ! 937: 903 000208B1 dd effffff845 pushl _index ! 938: 904 000208B7 fe 08 effffff83e callf $8,_writed ! 939: 905 000208BE # writec('\n'); ! 940: 906 000208BE dd 0a pushl $10 ! 941: 907 000208C0 fe 08 effffff835 callf $8,_writec ! 942: 908 000208C7 # writes(" Acc expected = "); ! 943: 909 000208C7 .data 1 ! 944: 910 00000c86 * L328: ! 945: 911 00000c86 * 2020202020202020202020202 .ascii " Acc expected = \0" ! 946: 0202020202020202020416363 ! 947: 206578706563746564203D200 ! 948: 0 ! 949: 912 00000cac * .text ! 950: 913 000208C7 dd 8f00000c86 pushl $L328 ! 951: 914 000208CD fe 08 effffff828 callf $8,_writes ! 952: 915 000208D4 # write32h( sgl_expected ); ! 953: 916 000208D4 dd effffff822 pushl _sgl_expected ! 954: 917 000208DA fe 08 effffff81b callf $8,_write32h ! 955: 918 000208E1 # writec('\n'); ! 956: 919 000208E1 dd 0a pushl $10 ! 957: 920 000208E3 fe 08 effffff812 callf $8,_writec ! 958: 921 000208EA # } ! 959: 922 000208EA # if( halt_flg ) ! 960: 923 000208EA L322: ! 961: 924 000208EA 5d effffff80c tstl _halt_flg ! 962: 925 000208F0 31 09 jeql L329 ! 963: 926 000208F2 # sqrtf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 964: 927 000208F2 dd 01 pushl $1 ! 965: 928 000208F4 fe 08 ef000001b7 callf $8,_sqrtf_er_halt ! 966: 929 000208FB # if( loop_on_err ) { ! 967: 930 000208FB L329: ! 968: 931 000208FB 5d effffff7fb tstl _loop_on_err ! 969: 932 00020901 31 0a jeql L330 ! 970: 933 00020903 # force_loop = TRUE; /* set the force loop flag */ ! 971: 934 00020903 0d 01 effffff7f2 movl $1,_force_loop ! 972: 935 0002090A # asm("brw _sqrtf_5_lp1");; /* and loop on the error */ ! 973: 936 0002090A 13 ff05 brw _sqrtf_5_lp1 ! 974: 937 0002090D # } /* end of loop on error */ ! 975: 938 0002090D # } /* end of compare error */ ! 976: 939 0002090D L330: ! 977: 940 0002090D # } /* end of WHILE loop */ ! 978: 941 0002090D L321: ! 979: 942 0002090D L317: ! 980: 943 0002090D 6d effffff7e9 incl _index ! 981: 944 00020913 13 fec0 jbr L319 ! 982: 945 00020916 L318: ! 983: 946 00020916 # } /* end of subtest 5 */ ! 984: 947 00020916 40 ret#2 ! 985: 948 00020917 .set L313,0x0 ! 986: 949 00020917 L315: ! 987: 950 00020917 13 fea9 jbr L316 ! 988: 951 0002091A .data ! 989: 952 00000a60 * .text ! 990: 953 0002091A .align 1 ! 991: 954 0002091A .globl _sqrtf_6 ! 992: 955 0002091A _sqrtf_6: ! 993: 956 0002091A 0000 .word L331 ! 994: 957 0002091C # ! 995: 958 0002091C # ! 996: 959 0002091C # ! 997: 960 0002091C # /************************************************************************ ! 998: 961 0002091C # * ! 999: 962 0002091C # * SUBTEST 6 - pipelined exit test ! 1000: 963 0002091C # * ! 1001: 964 0002091C # ************************************************************************/ ! 1002: 965 0002091C # sqrtf_6() ! 1003: 966 0002091C # { ! 1004: 967 0002091C 13 0154 jbr L333 ! 1005: 968 0002091F L334: ! 1006: 969 0002091F # force_loop = FALSE; ! 1007: 970 0002091F 4d effffff7d7 clrl _force_loop ! 1008: 971 00020925 # subtest = 8; ! 1009: 972 00020925 0d 08 effffff7d0 movl $8,_subtest ! 1010: 973 0002092C # for( index = 0; index < max_sqrtf_1_index; index++ ) { ! 1011: 974 0002092C 4d effffff7ca clrl _index ! 1012: 975 00020932 L337: ! 1013: 976 00020932 1d effffff7c4 effffff7bf cmpl _index,_max_sqrtf_1_index ! 1014: 977 0002093D 91 03 13 0130 jgeq L336 ! 1015: 978 00020942 # sgl_ld_acc = sqrtf_1_data[index].ld; /* get operand 1 */ ! 1016: 979 00020942 0d effffff7b4 50 movl _index,r0 ! 1017: 980 00020949 48 03 50 50 shll $3,r0,r0 ! 1018: 981 0002094D 0d e000000000 effffff7a4 movl _sqrtf_1_data(r0),_sgl_ld_acc ! 1019: 982 00020958 # sgl_expected = sqrtf_1_data[index].exp; /* get expected result */ ! 1020: 983 00020958 0d effffff79e 50 movl _index,r0 ! 1021: 984 0002095F 48 03 50 50 shll $3,r0,r0 ! 1022: 985 00020963 0d e000000004 effffff78e movl _sqrtf_1_data+4(r0),_sgl_expected ! 1023: 986 0002096E # /* ! 1024: 987 0002096E # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1025: 988 0002096E # * The force loop flag is set after the first error. ! 1026: 989 0002096E # */ ! 1027: 990 0002096E # asm("_sqrtf_6_lp1:"); ! 1028: 991 0002096E _sqrtf_6_lp1: ! 1029: 992 0002096E # asm("movl $0,r0"); /* clear r0 */ ! 1030: 993 0002096E 0d 00 50 movl $0,r0 ! 1031: 994 00020971 # asm("ldf _sgl_ld_acc"); /* load the Acc. */ ! 1032: 995 00020971 06 effffff785 ldf _sgl_ld_acc ! 1033: 996 00020977 # asm("sqrtf"); /* get the sqrt */ ! 1034: 997 00020977 45 sqrtf ! 1035: 998 00020978 # asm("addf r0"); /* add a zero to the acc */ ! 1036: 999 00020978 c6 50 addf r0 ! 1037: 1000 0002097A # asm("stf _sgl_st_acc"); /* store the result */ ! 1038: 1001 0002097A 26 effffff77c stf _sgl_st_acc ! 1039: 1002 00020980 # if( force_loop ) ! 1040: 1003 00020980 5d effffff776 tstl _force_loop ! 1041: 1004 00020986 31 02 jeql L338 ! 1042: 1005 00020988 # asm("brb _sqrtf_6_lp1");; /* loop on the error */ ! 1043: 1006 00020988 11 e4 brb _sqrtf_6_lp1 ! 1044: 1007 0002098A L338: ! 1045: 1008 0002098A # /* ! 1046: 1009 0002098A # * end error loop - test the results ! 1047: 1010 0002098A # */ ! 1048: 1011 0002098A # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1049: 1012 0002098A 1d effffff76c effffff767 cmpl _sgl_st_acc,_sgl_expected ! 1050: 1013 00020995 21 03 13 00cf jeql L339 ! 1051: 1014 0002099A # errcnt++; /* bump the error count */ ! 1052: 1015 0002099A 6d effffff75c incl _errcnt ! 1053: 1016 000209A0 # if( prt_error ) { ! 1054: 1017 000209A0 5d effffff756 tstl _prt_error ! 1055: 1018 000209A6 21 03 13 009b jeql L340 ! 1056: 1019 000209AB # writes(" \n"); /* start a new print line */ ! 1057: 1020 000209AB .data 1 ! 1058: 1021 00000cac * L341: ! 1059: 1022 00000cac * 200A00 .ascii " \12\0" ! 1060: 1023 00000caf * .text ! 1061: 1024 000209AB dd 8f00000cac pushl $L341 ! 1062: 1025 000209B1 fe 08 effffff744 callf $8,_writes ! 1063: 1026 000209B8 # writes("cycle: "); ! 1064: 1027 000209B8 .data 1 ! 1065: 1028 00000caf * L342: ! 1066: 1029 00000caf * 6379636C653A2000 .ascii "cycle: \0" ! 1067: 1030 00000cb7 * .text ! 1068: 1031 000209B8 dd 8f00000caf pushl $L342 ! 1069: 1032 000209BE fe 08 effffff737 callf $8,_writes ! 1070: 1033 000209C5 # writed( cycle ); ! 1071: 1034 000209C5 dd effffff731 pushl _cycle ! 1072: 1035 000209CB fe 08 effffff72a callf $8,_writed ! 1073: 1036 000209D2 # writes(" SQRTF test "); ! 1074: 1037 000209D2 .data 1 ! 1075: 1038 00000cb7 * L343: ! 1076: 1039 00000cb7 * 2020535152544620746573742 .ascii " SQRTF test \0" ! 1077: 000 ! 1078: 1040 00000cc5 * .text ! 1079: 1041 000209D2 dd 8f00000cb7 pushl $L343 ! 1080: 1042 000209D8 fe 08 effffff71d callf $8,_writes ! 1081: 1043 000209DF # writed( test_no ); ! 1082: 1044 000209DF dd effffff717 pushl _test_no ! 1083: 1045 000209E5 fe 08 effffff710 callf $8,_writed ! 1084: 1046 000209EC # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n"); ! 1085: 1047 000209EC .data 1 ! 1086: 1048 00000cc5 * L344: ! 1087: 1049 00000cc5 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0" ! 1088: 8506970656420457869742920 ! 1089: 2D204241442046494E414C204 ! 1090: 143430A00 ! 1091: 1050 00000cef * .text ! 1092: 1051 000209EC dd 8f00000cc5 pushl $L344 ! 1093: 1052 000209F2 fe 08 effffff703 callf $8,_writes ! 1094: 1053 000209F9 # print_sqrtf_data(); ! 1095: 1054 000209F9 fe 04 ef00000076 callf $4,_print_sqrtf_data ! 1096: 1055 00020A00 # writes(", data index = "); ! 1097: 1056 00020A00 .data 1 ! 1098: 1057 00000cef * L345: ! 1099: 1058 00000cef * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1100: 8203D2000 ! 1101: 1059 00000d00 * .text ! 1102: 1060 00020A00 dd 8f00000cef pushl $L345 ! 1103: 1061 00020A06 fe 08 effffff6ef callf $8,_writes ! 1104: 1062 00020A0D # writed( index ); ! 1105: 1063 00020A0D dd effffff6e9 pushl _index ! 1106: 1064 00020A13 fe 08 effffff6e2 callf $8,_writed ! 1107: 1065 00020A1A # writec('\n'); ! 1108: 1066 00020A1A dd 0a pushl $10 ! 1109: 1067 00020A1C fe 08 effffff6d9 callf $8,_writec ! 1110: 1068 00020A23 # writes(" Acc expected = "); ! 1111: 1069 00020A23 .data 1 ! 1112: 1070 00000d00 * L346: ! 1113: 1071 00000d00 * 2020202020202020202020202 .ascii " Acc expected = \0" ! 1114: 0202020202020202020416363 ! 1115: 206578706563746564203D200 ! 1116: 0 ! 1117: 1072 00000d26 * .text ! 1118: 1073 00020A23 dd 8f00000d00 pushl $L346 ! 1119: 1074 00020A29 fe 08 effffff6cc callf $8,_writes ! 1120: 1075 00020A30 # write32h( sgl_expected ); ! 1121: 1076 00020A30 dd effffff6c6 pushl _sgl_expected ! 1122: 1077 00020A36 fe 08 effffff6bf callf $8,_write32h ! 1123: 1078 00020A3D # writec('\n'); ! 1124: 1079 00020A3D dd 0a pushl $10 ! 1125: 1080 00020A3F fe 08 effffff6b6 callf $8,_writec ! 1126: 1081 00020A46 # } ! 1127: 1082 00020A46 # if( halt_flg ) ! 1128: 1083 00020A46 L340: ! 1129: 1084 00020A46 5d effffff6b0 tstl _halt_flg ! 1130: 1085 00020A4C 31 09 jeql L347 ! 1131: 1086 00020A4E # sqrtf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1132: 1087 00020A4E dd 01 pushl $1 ! 1133: 1088 00020A50 fe 08 ef0000005b callf $8,_sqrtf_er_halt ! 1134: 1089 00020A57 # if( loop_on_err ) { ! 1135: 1090 00020A57 L347: ! 1136: 1091 00020A57 5d effffff69f tstl _loop_on_err ! 1137: 1092 00020A5D 31 0a jeql L348 ! 1138: 1093 00020A5F # force_loop = TRUE; /* set the force loop flag */ ! 1139: 1094 00020A5F 0d 01 effffff696 movl $1,_force_loop ! 1140: 1095 00020A66 # asm("brw _sqrtf_6_lp1");; /* and loop on the error */ ! 1141: 1096 00020A66 13 ff05 brw _sqrtf_6_lp1 ! 1142: 1097 00020A69 # } /* end of loop on error */ ! 1143: 1098 00020A69 # } /* end of compare error */ ! 1144: 1099 00020A69 L348: ! 1145: 1100 00020A69 # } /* end of WHILE loop */ ! 1146: 1101 00020A69 L339: ! 1147: 1102 00020A69 L335: ! 1148: 1103 00020A69 6d effffff68d incl _index ! 1149: 1104 00020A6F 13 fec0 jbr L337 ! 1150: 1105 00020A72 L336: ! 1151: 1106 00020A72 # } /* end of subtest 6 */ ! 1152: 1107 00020A72 40 ret#2 ! 1153: 1108 00020A73 .set L331,0x0 ! 1154: 1109 00020A73 L333: ! 1155: 1110 00020A73 13 fea9 jbr L334 ! 1156: 1111 00020A76 .data ! 1157: 1112 00000a60 * .text ! 1158: 1113 00020A76 .align 1 ! 1159: 1114 00020A76 .globl _print_sqrtf_data ! 1160: 1115 00020A76 _print_sqrtf_data: ! 1161: 1116 00020A76 0000 .word L349 ! 1162: 1117 00020A78 # ! 1163: 1118 00020A78 # ! 1164: 1119 00020A78 # ! 1165: 1120 00020A78 # /************************************************************************** ! 1166: 1121 00020A78 # * ! 1167: 1122 00020A78 # * PRINT THE DATA AND STORE RESULTS ! 1168: 1123 00020A78 # * ! 1169: 1124 00020A78 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 1170: 1125 00020A78 # * Acc expected = xxxxxxxx ! 1171: 1126 00020A78 # **************************************************************************/ ! 1172: 1127 00020A78 # print_sqrtf_data() ! 1173: 1128 00020A78 # { ! 1174: 1129 00020A78 11 35 jbr L351 ! 1175: 1130 00020A7A L352: ! 1176: 1131 00020A7A # writes("initial Acc = "); ! 1177: 1132 00020A7A .data 1 ! 1178: 1133 00000d26 * L353: ! 1179: 1134 00000d26 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1180: D2000 ! 1181: 1135 00000d35 * .text ! 1182: 1136 00020A7A dd 8f00000d26 pushl $L353 ! 1183: 1137 00020A80 fe 08 effffff675 callf $8,_writes ! 1184: 1138 00020A87 # write32h( sgl_ld_acc ); ! 1185: 1139 00020A87 dd effffff66f pushl _sgl_ld_acc ! 1186: 1140 00020A8D fe 08 effffff668 callf $8,_write32h ! 1187: 1141 00020A94 # writes(", final Acc = "); ! 1188: 1142 00020A94 .data 1 ! 1189: 1143 00000d35 * L354: ! 1190: 1144 00000d35 * 2C202066696E616C204163632 .ascii ", final Acc = \0" ! 1191: 03D2000 ! 1192: 1145 00000d45 * .text ! 1193: 1146 00020A94 dd 8f00000d35 pushl $L354 ! 1194: 1147 00020A9A fe 08 effffff65b callf $8,_writes ! 1195: 1148 00020AA1 # write32h( sgl_st_acc ); ! 1196: 1149 00020AA1 dd effffff655 pushl _sgl_st_acc ! 1197: 1150 00020AA7 fe 08 effffff64e callf $8,_write32h ! 1198: 1151 00020AAE # } ! 1199: 1152 00020AAE 40 ret#2 ! 1200: 1153 00020AAF .set L349,0x0 ! 1201: 1154 00020AAF L351: ! 1202: 1155 00020AAF 11 c9 jbr L352 ! 1203: 1156 00020AB1 .data ! 1204: 1157 00000a60 * .text ! 1205: 1158 00020AB1 00 .align 1 ! 1206: 1159 00020AB2 .globl _sqrtf_er_halt ! 1207: 1160 00020AB2 _sqrtf_er_halt: ! 1208: 1161 00020AB2 0000 .word L355 ! 1209: 1162 00020AB4 # ! 1210: 1163 00020AB4 # ! 1211: 1164 00020AB4 # ! 1212: 1165 00020AB4 # /************************************************************************** ! 1213: 1166 00020AB4 # * ! 1214: 1167 00020AB4 # * HALT ON ERROR ROUTINE ! 1215: 1168 00020AB4 # * ! 1216: 1169 00020AB4 # **************************************************************************/ ! 1217: 1170 00020AB4 # sqrtf_er_halt( halt_code ) ! 1218: 1171 00020AB4 # int halt_code; ! 1219: 1172 00020AB4 # { ! 1220: 1173 00020AB4 13 00a0 jbr L357 ! 1221: 1174 00020AB7 L358: ! 1222: 1175 00020AB7 # sgl_dummy1 = halt_code; /* get the error type */ ! 1223: 1176 00020AB7 0d ad04 effffff63d movl 4(fp),_sgl_dummy1 ! 1224: 1177 00020ABF # asm("movl _test_no,r0"); /* r0 = test number */ ! 1225: 1178 00020ABF 0d effffff637 50 movl _test_no,r0 ! 1226: 1179 00020AC6 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1227: 1180 00020AC6 0d effffff630 51 movl _subtest,r1 ! 1228: 1181 00020ACD # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1229: 1182 00020ACD 0d effffff629 52 movl _sgl_dummy1,r2 ! 1230: 1183 00020AD4 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1231: 1184 00020AD4 0d effffff622 53 movl _cycle,r3 ! 1232: 1185 00020ADB # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 1233: 1186 00020ADB 0d effffff61b 54 movl _sgl_ld_acc,r4 ! 1234: 1187 00020AE2 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */ ! 1235: 1188 00020AE2 0d effffff614 55 movl _sgl_st_acc,r5 ! 1236: 1189 00020AE9 # asm("movl _sgl_expected,r6"); /* r6 = data expected */ ! 1237: 1190 00020AE9 0d effffff60d 56 movl _sgl_expected,r6 ! 1238: 1191 00020AF0 # asm("movl _index,r7"); /* r7 = data index */ ! 1239: 1192 00020AF0 0d effffff606 57 movl _index,r7 ! 1240: 1193 00020AF7 # if( halt_code == BAD_REG_HLT ) { ! 1241: 1194 00020AF7 1d ad04 02 cmpl 4(fp),$2 ! 1242: 1195 00020AFB 21 3d jneq L359 ! 1243: 1196 00020AFD # sgl_dummy1 = load_regs[index2]; ! 1244: 1197 00020AFD 0d effffff5f9 50 movl _index2,r0 ! 1245: 1198 00020B04 0d 40effffff5f1 movl _load_regs[r0],_sgl_dummy1 ! 1246: effffff5ec ! 1247: 1199 00020B10 # sgl_dummy2 = store_regs[index2]; ! 1248: 1200 00020B10 0d effffff5e6 50 movl _index2,r0 ! 1249: 1201 00020B17 0d 40effffff5de movl _store_regs[r0],_sgl_dummy2 ! 1250: effffff5d9 ! 1251: 1202 00020B23 # asm("movl _index2,r6"); /* r6 = bad register # */ ! 1252: 1203 00020B23 0d effffff5d3 56 movl _index2,r6 ! 1253: 1204 00020B2A # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 1254: 1205 00020B2A 0d effffff5cc 57 movl _sgl_dummy2,r7 ! 1255: 1206 00020B31 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 1256: 1207 00020B31 0d effffff5c5 58 movl _sgl_dummy1,r8 ! 1257: 1208 00020B38 # } else ! 1258: 1209 00020B38 11 1b jbr L360 ! 1259: 1210 00020B3A L359: ! 1260: 1211 00020B3A # if( halt_code == BAD_PSL_HLT ) { ! 1261: 1212 00020B3A 1d ad04 03 cmpl 4(fp),$3 ! 1262: 1213 00020B3E 21 15 jneq L361 ! 1263: 1214 00020B40 # asm("movl _init_psl,r6"); /* r6 = initial PSL */ ! 1264: 1215 00020B40 0d effffff5b6 56 movl _init_psl,r6 ! 1265: 1216 00020B47 # asm("movl _psl_val,r7"); /* r7 = final PSL */ ! 1266: 1217 00020B47 0d effffff5af 57 movl _psl_val,r7 ! 1267: 1218 00020B4E # asm("movl _exp_psl,r8"); /* r8 = expected PSL */ ! 1268: 1219 00020B4E 0d effffff5a8 58 movl _exp_psl,r8 ! 1269: 1220 00020B55 # }; ! 1270: 1221 00020B55 L361: ! 1271: 1222 00020B55 L360: ! 1272: 1223 00020B55 # asm("halt"); /* HALT ... */ ! 1273: 1224 00020B55 00 halt ! 1274: 1225 00020B56 # } ! 1275: 1226 00020B56 40 ret#2 ! 1276: 1227 00020B57 .set L355,0x0 ! 1277: 1228 00020B57 L357: ! 1278: 1229 00020B57 13 ff5d jbr L358 ! 1279: 1230 00020B5A .data ! 1280: 1230 00040C56 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.