![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 000005a8 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_11 ! 6: 6 00000000 _pipe_11: ! 7: 7 0002CF54 0000 .word L215 ! 8: 8 0002CF56 # #include "fpp_defs.h" ! 9: 9 0002CF56 # ! 10: 10 0002CF56 # ! 11: 11 0002CF56 # /***************************************************************************** ! 12: 12 0002CF56 # * ! 13: 13 0002CF56 # * PIPELINE TEST #11 MONITOR ! 14: 14 0002CF56 # * ! 15: 15 0002CF56 # * This test will do a series of 2, 3, 4, 5, and 6 NEGFs. ! 16: 16 0002CF56 # * ! 17: 17 0002CF56 # *****************************************************************************/ ! 18: 18 0002CF56 # pipe_11() ! 19: 19 0002CF56 # { ! 20: 20 0002CF56 11 48 jbr L217 ! 21: 21 0002CF58 L218: ! 22: 22 0002CF58 # asm(".globl _pipeline_11_t"); ! 23: 23 0002CF58 .globl _pipeline_11_t ! 24: 24 0002CF58 # asm("_pipeline_11_t:"); /* entry address */ ! 25: 25 0002CF58 _pipeline_11_t: ! 26: 26 0002CF58 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 27: 27 0002CF58 1d effffffff6 01 cmpl _cycle,$1 ! 28: 28 0002CF5F 21 15 jneq L219 ! 29: 29 0002CF61 5d efffffffed tstl _prt_hdrs ! 30: 30 0002CF67 31 0d jeql L219 ! 31: 31 0002CF69 # { ! 32: 32 0002CF69 # writes(" PIPE_11"); ! 33: 33 0002CF69 .data 1 ! 34: 34 000005a8 * L221: ! 35: 35 000005a8 * 20504950455F313100 .ascii " PIPE_11\0" ! 36: 36 000005b1 * .text ! 37: 37 0002CF69 dd 8f000005a8 pushl $L221 ! 38: 38 0002CF6F fe 08 efffffffde callf $8,_writes ! 39: 39 0002CF76 # } ! 40: 40 0002CF76 # pipe11_1(); /* do 2 NEGFs */ ! 41: 41 0002CF76 L219: ! 42: 42 0002CF76 fe 04 ef00000025 callf $4,_pipe11_1 ! 43: 43 0002CF7D # pipe11_2(); /* do 3 NEGFs */ ! 44: 44 0002CF7D fe 04 ef000000e2 callf $4,_pipe11_2 ! 45: 45 0002CF84 # pipe11_3(); /* do 4 NEGFs */ ! 46: 46 0002CF84 fe 04 ef000001b3 callf $4,_pipe11_3 ! 47: 47 0002CF8B # pipe11_4(); /* do 5 NEGFs */ ! 48: 48 0002CF8B fe 04 ef00000272 callf $4,_pipe11_4 ! 49: 49 0002CF92 # pipe11_5(); /* do 6 NEGFs */ ! 50: 50 0002CF92 fe 04 ef00000345 callf $4,_pipe11_5 ! 51: 51 0002CF99 # asm("jmp *return"); /* return to the test monitor */ ! 52: 52 0002CF99 71 ffffffffb5 jmp *return ! 53: 53 0002CF9F # } ! 54: 54 0002CF9F 40 ret#2 ! 55: 55 0002CFA0 .set L215,0x0 ! 56: 56 0002CFA0 L217: ! 57: 57 0002CFA0 11 b6 jbr L218 ! 58: 58 0002CFA2 .data ! 59: 59 000005a8 * .text ! 60: 60 0002CFA2 .align 1 ! 61: 61 0002CFA2 .globl _pipe11_1 ! 62: 62 0002CFA2 _pipe11_1: ! 63: 63 0002CFA2 0000 .word L227 ! 64: 64 0002CFA4 # ! 65: 65 0002CFA4 # ! 66: 66 0002CFA4 # ! 67: 67 0002CFA4 # ! 68: 68 0002CFA4 # ! 69: 69 0002CFA4 # ! 70: 70 0002CFA4 # /************************************************************************ ! 71: 71 0002CFA4 # * ! 72: 72 0002CFA4 # * SUBTEST 1 : 2 NEGFs ! 73: 73 0002CFA4 # * ! 74: 74 0002CFA4 # ************************************************************************/ ! 75: 75 0002CFA4 # pipe11_1() ! 76: 76 0002CFA4 # { ! 77: 77 0002CFA4 13 00bb jbr L229 ! 78: 78 0002CFA7 L230: ! 79: 79 0002CFA7 # subtest = 1; ! 80: 80 0002CFA7 0d 01 efffffffa6 movl $1,_subtest ! 81: 81 0002CFAE # force_loop = FALSE; ! 82: 82 0002CFAE 4d efffffffa0 clrl _force_loop ! 83: 83 0002CFB4 # for( index = 0; index < max_ldf_1_index; index++ ) ! 84: 84 0002CFB4 4d efffffff9a clrl _index ! 85: 85 0002CFBA L233: ! 86: 86 0002CFBA 1d efffffff94 efffffff8f cmpl _index,_max_ldf_1_index ! 87: 87 0002CFC5 91 03 13 0097 jgeq L232 ! 88: 88 0002CFCA # { ! 89: 89 0002CFCA # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 90: 90 0002CFCA 0d efffffff84 50 movl _index,r0 ! 91: 91 0002CFD1 48 03 50 50 shll $3,r0,r0 ! 92: 92 0002CFD5 0d e000000000 efffffff74 movl _ldf_1_data(r0),_sgl_value_1 ! 93: 93 0002CFE0 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 94: 94 0002CFE0 0d efffffff6e 50 movl _index,r0 ! 95: 95 0002CFE7 48 03 50 50 shll $3,r0,r0 ! 96: 96 0002CFEB 0d e000000004 efffffff5e movl _ldf_1_data+4(r0),_sgl_expected ! 97: 97 0002CFF6 # /* ! 98: 98 0002CFF6 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 99: 99 0002CFF6 # * The force loop flag is set after the first error. ! 100: 100 0002CFF6 # */ ! 101: 101 0002CFF6 # asm("_pipe11_1_lp1:"); ! 102: 102 0002CFF6 _pipe11_1_lp1: ! 103: 103 0002CFF6 # asm("ldf _sgl_value_1"); /* load the operand */ ! 104: 104 0002CFF6 06 efffffff58 ldf _sgl_value_1 ! 105: 105 0002CFFC # asm("negf"); /* negate it ( twice ) */ ! 106: 106 0002CFFC b6 negf ! 107: 107 0002CFFD # asm("negf"); ! 108: 108 0002CFFD b6 negf ! 109: 109 0002CFFE # asm("stf _sgl_st_acc"); /* store the result */ ! 110: 110 0002CFFE 26 efffffff50 stf _sgl_st_acc ! 111: 111 0002D004 # if( force_loop ) ! 112: 112 0002D004 5d efffffff4a tstl _force_loop ! 113: 113 0002D00A 31 02 jeql L234 ! 114: 114 0002D00C # asm("brb _pipe11_1_lp1"); /* loop on an error */ ! 115: 115 0002D00C 11 e8 brb _pipe11_1_lp1 ! 116: 116 0002D00E # /* ! 117: 117 0002D00E # * verify the results ! 118: 118 0002D00E # */ ! 119: 119 0002D00E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 120: 120 0002D00E L234: ! 121: 121 0002D00E 1d efffffff40 efffffff3b cmpl _sgl_st_acc,_sgl_expected ! 122: 122 0002D019 31 3d jeql L235 ! 123: 123 0002D01B # errcnt++; /* bump the error count */ ! 124: 124 0002D01B 6d efffffff33 incl _errcnt ! 125: 125 0002D021 # if( prt_error ) ! 126: 126 0002D021 5d efffffff2d tstl _prt_error ! 127: 127 0002D027 31 09 jeql L236 ! 128: 128 0002D029 # pipe11_print( 2 ); /* print error msg -2 NEGFS*/ ! 129: 129 0002D029 dd 02 pushl $2 ! 130: 130 0002D02B fe 08 ef00000374 callf $8,_pipe11_print ! 131: 131 0002D032 # if( halt_flg ) /* halt on error? */ ! 132: 132 0002D032 L236: ! 133: 133 0002D032 5d efffffff1c tstl _halt_flg ! 134: 134 0002D038 31 09 jeql L238 ! 135: 135 0002D03A # pipe11_halt( 2 ); /* error halt -2 NEGFS */ ! 136: 136 0002D03A dd 02 pushl $2 ! 137: 137 0002D03C fe 08 ef0000046b callf $8,_pipe11_halt ! 138: 138 0002D043 # if( loop_on_err ) { ! 139: 139 0002D043 L238: ! 140: 140 0002D043 5d efffffff0b tstl _loop_on_err ! 141: 141 0002D049 31 0d jeql L240 ! 142: 142 0002D04B # force_loop = TRUE; /* set the force loop flag */ ! 143: 143 0002D04B 0d 01 efffffff02 movl $1,_force_loop ! 144: 144 0002D052 # asm("jmp _pipe11_1_lp1"); /* and loop */ ! 145: 145 0002D052 71 efffffff9e jmp _pipe11_1_lp1 ! 146: 146 0002D058 # } ! 147: 147 0002D058 # } ! 148: 148 0002D058 L240: ! 149: 149 0002D058 # } /* end of FOR loop */ ! 150: 150 0002D058 L235: ! 151: 151 0002D058 L231: ! 152: 152 0002D058 6d effffffef6 incl _index ! 153: 153 0002D05E 13 ff59 jbr L233 ! 154: 154 0002D061 L232: ! 155: 155 0002D061 # } /* end of subtest 1 */ ! 156: 156 0002D061 40 ret#2 ! 157: 157 0002D062 .set L227,0x0 ! 158: 158 0002D062 L229: ! 159: 159 0002D062 13 ff42 jbr L230 ! 160: 160 0002D065 .data ! 161: 161 000005a8 * .text ! 162: 162 0002D065 00 .align 1 ! 163: 163 0002D066 .globl _pipe11_2 ! 164: 164 0002D066 _pipe11_2: ! 165: 165 0002D066 0000 .word L241 ! 166: 166 0002D068 # ! 167: 167 0002D068 # ! 168: 168 0002D068 # ! 169: 169 0002D068 # ! 170: 170 0002D068 # ! 171: 171 0002D068 # /************************************************************************ ! 172: 172 0002D068 # * ! 173: 173 0002D068 # * SUBTEST 2 : 3 NEGFs ! 174: 174 0002D068 # * ! 175: 175 0002D068 # ************************************************************************/ ! 176: 176 0002D068 # pipe11_2() ! 177: 177 0002D068 # { ! 178: 178 0002D068 13 00cf jbr L243 ! 179: 179 0002D06B L244: ! 180: 180 0002D06B # subtest = 2; ! 181: 181 0002D06B 0d 02 effffffee2 movl $2,_subtest ! 182: 182 0002D072 # force_loop = FALSE; ! 183: 183 0002D072 4d effffffedc clrl _force_loop ! 184: 184 0002D078 # for( index = 0; index < max_ldf_1_index; index++ ) ! 185: 185 0002D078 4d effffffed6 clrl _index ! 186: 186 0002D07E L247: ! 187: 187 0002D07E 1d effffffed0 effffffecb cmpl _index,_max_ldf_1_index ! 188: 188 0002D089 91 03 13 00ab jgeq L246 ! 189: 189 0002D08E # { ! 190: 190 0002D08E # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 191: 191 0002D08E 0d effffffec0 50 movl _index,r0 ! 192: 192 0002D095 48 03 50 50 shll $3,r0,r0 ! 193: 193 0002D099 0d e000000000 effffffeb0 movl _ldf_1_data(r0),_sgl_value_1 ! 194: 194 0002D0A4 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 195: 195 0002D0A4 0d effffffeaa 50 movl _index,r0 ! 196: 196 0002D0AB 48 03 50 50 shll $3,r0,r0 ! 197: 197 0002D0AF 0d e000000004 effffffe9a movl _ldf_1_data+4(r0),_sgl_expected ! 198: 198 0002D0BA # if( sgl_expected ) ! 199: 199 0002D0BA 5d effffffe94 tstl _sgl_expected ! 200: 200 0002D0C0 31 0b jeql L248 ! 201: 201 0002D0C2 # sgl_expected ^= 0x80000000; /* negate exptd results */ ! 202: 202 0002D0C2 cc 8f80000000 effffffe87 xorl2 $-2147483648,_sgl_expected ! 203: 203 0002D0CD # /* ! 204: 204 0002D0CD # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 205: 205 0002D0CD # * The force loop flag is set after the first error. ! 206: 206 0002D0CD # */ ! 207: 207 0002D0CD # asm("_pipe11_2_lp1:"); ! 208: 208 0002D0CD L248: ! 209: 209 0002D0CD _pipe11_2_lp1: ! 210: 210 0002D0CD # asm("ldf _sgl_value_1"); /* load the operand */ ! 211: 211 0002D0CD 06 effffffe81 ldf _sgl_value_1 ! 212: 212 0002D0D3 # asm("negf"); /* negate it ( 3 times ) */ ! 213: 213 0002D0D3 b6 negf ! 214: 214 0002D0D4 # asm("negf"); ! 215: 215 0002D0D4 b6 negf ! 216: 216 0002D0D5 # asm("negf"); ! 217: 217 0002D0D5 b6 negf ! 218: 218 0002D0D6 # asm("stf _sgl_st_acc"); /* store the result */ ! 219: 219 0002D0D6 26 effffffe78 stf _sgl_st_acc ! 220: 220 0002D0DC # if( force_loop ) ! 221: 221 0002D0DC 5d effffffe72 tstl _force_loop ! 222: 222 0002D0E2 31 02 jeql L249 ! 223: 223 0002D0E4 # asm("brb _pipe11_2_lp1"); /* loop on an error */ ! 224: 224 0002D0E4 11 e7 brb _pipe11_2_lp1 ! 225: 225 0002D0E6 # /* ! 226: 226 0002D0E6 # * verify the results ! 227: 227 0002D0E6 # */ ! 228: 228 0002D0E6 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 229: 229 0002D0E6 L249: ! 230: 230 0002D0E6 1d effffffe68 effffffe63 cmpl _sgl_st_acc,_sgl_expected ! 231: 231 0002D0F1 31 3d jeql L250 ! 232: 232 0002D0F3 # errcnt++; /* bump the error count */ ! 233: 233 0002D0F3 6d effffffe5b incl _errcnt ! 234: 234 0002D0F9 # if( prt_error ) ! 235: 235 0002D0F9 5d effffffe55 tstl _prt_error ! 236: 236 0002D0FF 31 09 jeql L251 ! 237: 237 0002D101 # pipe11_print( 3 ); /* print error msg -3 NEGFS*/ ! 238: 238 0002D101 dd 03 pushl $3 ! 239: 239 0002D103 fe 08 ef0000029c callf $8,_pipe11_print ! 240: 240 0002D10A # if( halt_flg ) /* halt on error? */ ! 241: 241 0002D10A L251: ! 242: 242 0002D10A 5d effffffe44 tstl _halt_flg ! 243: 243 0002D110 31 09 jeql L252 ! 244: 244 0002D112 # pipe11_halt( 3 ); /* error halt -3 NEGFS */ ! 245: 245 0002D112 dd 03 pushl $3 ! 246: 246 0002D114 fe 08 ef00000393 callf $8,_pipe11_halt ! 247: 247 0002D11B # if( loop_on_err ) { ! 248: 248 0002D11B L252: ! 249: 249 0002D11B 5d effffffe33 tstl _loop_on_err ! 250: 250 0002D121 31 0d jeql L253 ! 251: 251 0002D123 # force_loop = TRUE; /* set the force loop flag */ ! 252: 252 0002D123 0d 01 effffffe2a movl $1,_force_loop ! 253: 253 0002D12A # asm("jmp _pipe11_2_lp1"); /* and loop */ ! 254: 254 0002D12A 71 efffffff9d jmp _pipe11_2_lp1 ! 255: 255 0002D130 # } ! 256: 256 0002D130 # } ! 257: 257 0002D130 L253: ! 258: 258 0002D130 # } /* end of FOR loop */ ! 259: 259 0002D130 L250: ! 260: 260 0002D130 L245: ! 261: 261 0002D130 6d effffffe1e incl _index ! 262: 262 0002D136 13 ff45 jbr L247 ! 263: 263 0002D139 L246: ! 264: 264 0002D139 # } /* end of subtest 2 */ ! 265: 265 0002D139 40 ret#2 ! 266: 266 0002D13A .set L241,0x0 ! 267: 267 0002D13A L243: ! 268: 268 0002D13A 13 ff2e jbr L244 ! 269: 269 0002D13D .data ! 270: 270 000005a8 * .text ! 271: 271 0002D13D 00 .align 1 ! 272: 272 0002D13E .globl _pipe11_3 ! 273: 273 0002D13E _pipe11_3: ! 274: 274 0002D13E 0000 .word L254 ! 275: 275 0002D140 # ! 276: 276 0002D140 # ! 277: 277 0002D140 # ! 278: 278 0002D140 # ! 279: 279 0002D140 # ! 280: 280 0002D140 # /************************************************************************ ! 281: 281 0002D140 # * ! 282: 282 0002D140 # * SUBTEST 3 : 4 NEGFs ! 283: 283 0002D140 # * ! 284: 284 0002D140 # ************************************************************************/ ! 285: 285 0002D140 # pipe11_3() ! 286: 286 0002D140 # { ! 287: 287 0002D140 13 00bd jbr L256 ! 288: 288 0002D143 L257: ! 289: 289 0002D143 # subtest = 3; ! 290: 290 0002D143 0d 03 effffffe0a movl $3,_subtest ! 291: 291 0002D14A # force_loop = FALSE; ! 292: 292 0002D14A 4d effffffe04 clrl _force_loop ! 293: 293 0002D150 # for( index = 0; index < max_ldf_1_index; index++ ) ! 294: 294 0002D150 4d effffffdfe clrl _index ! 295: 295 0002D156 L260: ! 296: 296 0002D156 1d effffffdf8 effffffdf3 cmpl _index,_max_ldf_1_index ! 297: 297 0002D161 91 03 13 0099 jgeq L259 ! 298: 298 0002D166 # { ! 299: 299 0002D166 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 300: 300 0002D166 0d effffffde8 50 movl _index,r0 ! 301: 301 0002D16D 48 03 50 50 shll $3,r0,r0 ! 302: 302 0002D171 0d e000000000 effffffdd8 movl _ldf_1_data(r0),_sgl_value_1 ! 303: 303 0002D17C # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 304: 304 0002D17C 0d effffffdd2 50 movl _index,r0 ! 305: 305 0002D183 48 03 50 50 shll $3,r0,r0 ! 306: 306 0002D187 0d e000000004 effffffdc2 movl _ldf_1_data+4(r0),_sgl_expected ! 307: 307 0002D192 # /* ! 308: 308 0002D192 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 309: 309 0002D192 # * The force loop flag is set after the first error. ! 310: 310 0002D192 # */ ! 311: 311 0002D192 # asm("_pipe11_3_lp1:"); ! 312: 312 0002D192 _pipe11_3_lp1: ! 313: 313 0002D192 # asm("ldf _sgl_value_1"); /* load the operand */ ! 314: 314 0002D192 06 effffffdbc ldf _sgl_value_1 ! 315: 315 0002D198 # asm("negf"); /* negate it ( 4 times ) */ ! 316: 316 0002D198 b6 negf ! 317: 317 0002D199 # asm("negf"); ! 318: 318 0002D199 b6 negf ! 319: 319 0002D19A # asm("negf"); ! 320: 320 0002D19A b6 negf ! 321: 321 0002D19B # asm("negf"); ! 322: 322 0002D19B b6 negf ! 323: 323 0002D19C # asm("stf _sgl_st_acc"); /* store the result */ ! 324: 324 0002D19C 26 effffffdb2 stf _sgl_st_acc ! 325: 325 0002D1A2 # if( force_loop ) ! 326: 326 0002D1A2 5d effffffdac tstl _force_loop ! 327: 327 0002D1A8 31 02 jeql L261 ! 328: 328 0002D1AA # asm("brb _pipe11_3_lp1"); /* loop on an error */ ! 329: 329 0002D1AA 11 e6 brb _pipe11_3_lp1 ! 330: 330 0002D1AC # /* ! 331: 331 0002D1AC # * verify the results ! 332: 332 0002D1AC # */ ! 333: 333 0002D1AC # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 334: 334 0002D1AC L261: ! 335: 335 0002D1AC 1d effffffda2 effffffd9d cmpl _sgl_st_acc,_sgl_expected ! 336: 336 0002D1B7 31 3d jeql L262 ! 337: 337 0002D1B9 # errcnt++; /* bump the error count */ ! 338: 338 0002D1B9 6d effffffd95 incl _errcnt ! 339: 339 0002D1BF # if( prt_error ) ! 340: 340 0002D1BF 5d effffffd8f tstl _prt_error ! 341: 341 0002D1C5 31 09 jeql L263 ! 342: 342 0002D1C7 # pipe11_print( 4 ); /* print error msg -4 NEGFS*/ ! 343: 343 0002D1C7 dd 04 pushl $4 ! 344: 344 0002D1C9 fe 08 ef000001d6 callf $8,_pipe11_print ! 345: 345 0002D1D0 # if( halt_flg ) /* halt on error? */ ! 346: 346 0002D1D0 L263: ! 347: 347 0002D1D0 5d effffffd7e tstl _halt_flg ! 348: 348 0002D1D6 31 09 jeql L264 ! 349: 349 0002D1D8 # pipe11_halt( 4 ); /* error halt -4 NEGFS */ ! 350: 350 0002D1D8 dd 04 pushl $4 ! 351: 351 0002D1DA fe 08 ef000002cd callf $8,_pipe11_halt ! 352: 352 0002D1E1 # if( loop_on_err ) { ! 353: 353 0002D1E1 L264: ! 354: 354 0002D1E1 5d effffffd6d tstl _loop_on_err ! 355: 355 0002D1E7 31 0d jeql L265 ! 356: 356 0002D1E9 # force_loop = TRUE; /* set the force loop flag */ ! 357: 357 0002D1E9 0d 01 effffffd64 movl $1,_force_loop ! 358: 358 0002D1F0 # asm("jmp _pipe11_3_lp1"); /* and loop */ ! 359: 359 0002D1F0 71 efffffff9c jmp _pipe11_3_lp1 ! 360: 360 0002D1F6 # } ! 361: 361 0002D1F6 # } ! 362: 362 0002D1F6 L265: ! 363: 363 0002D1F6 # } /* end of FOR loop */ ! 364: 364 0002D1F6 L262: ! 365: 365 0002D1F6 L258: ! 366: 366 0002D1F6 6d effffffd58 incl _index ! 367: 367 0002D1FC 13 ff57 jbr L260 ! 368: 368 0002D1FF L259: ! 369: 369 0002D1FF # } /* end of subtest 3 */ ! 370: 370 0002D1FF 40 ret#2 ! 371: 371 0002D200 .set L254,0x0 ! 372: 372 0002D200 L256: ! 373: 373 0002D200 13 ff40 jbr L257 ! 374: 374 0002D203 .data ! 375: 375 000005a8 * .text ! 376: 376 0002D203 00 .align 1 ! 377: 377 0002D204 .globl _pipe11_4 ! 378: 378 0002D204 _pipe11_4: ! 379: 379 0002D204 0000 .word L266 ! 380: 380 0002D206 # ! 381: 381 0002D206 # ! 382: 382 0002D206 # ! 383: 383 0002D206 # ! 384: 384 0002D206 # ! 385: 385 0002D206 # ! 386: 386 0002D206 # /************************************************************************ ! 387: 387 0002D206 # * ! 388: 388 0002D206 # * SUBTEST 4 : 5 NEGFs ! 389: 389 0002D206 # * ! 390: 390 0002D206 # ************************************************************************/ ! 391: 391 0002D206 # pipe11_4() ! 392: 392 0002D206 # { ! 393: 393 0002D206 13 00d1 jbr L268 ! 394: 394 0002D209 L269: ! 395: 395 0002D209 # subtest = 4; ! 396: 396 0002D209 0d 04 effffffd44 movl $4,_subtest ! 397: 397 0002D210 # force_loop = FALSE; ! 398: 398 0002D210 4d effffffd3e clrl _force_loop ! 399: 399 0002D216 # for( index = 0; index < max_ldf_1_index; index++ ) ! 400: 400 0002D216 4d effffffd38 clrl _index ! 401: 401 0002D21C L272: ! 402: 402 0002D21C 1d effffffd32 effffffd2d cmpl _index,_max_ldf_1_index ! 403: 403 0002D227 91 03 13 00ad jgeq L271 ! 404: 404 0002D22C # { ! 405: 405 0002D22C # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 406: 406 0002D22C 0d effffffd22 50 movl _index,r0 ! 407: 407 0002D233 48 03 50 50 shll $3,r0,r0 ! 408: 408 0002D237 0d e000000000 effffffd12 movl _ldf_1_data(r0),_sgl_value_1 ! 409: 409 0002D242 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 410: 410 0002D242 0d effffffd0c 50 movl _index,r0 ! 411: 411 0002D249 48 03 50 50 shll $3,r0,r0 ! 412: 412 0002D24D 0d e000000004 effffffcfc movl _ldf_1_data+4(r0),_sgl_expected ! 413: 413 0002D258 # if( sgl_expected ) ! 414: 414 0002D258 5d effffffcf6 tstl _sgl_expected ! 415: 415 0002D25E 31 0b jeql L273 ! 416: 416 0002D260 # sgl_expected ^= 0x80000000; /* negate exptd results */ ! 417: 417 0002D260 cc 8f80000000 effffffce9 xorl2 $-2147483648,_sgl_expected ! 418: 418 0002D26B # /* ! 419: 419 0002D26B # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 420: 420 0002D26B # * The force loop flag is set after the first error. ! 421: 421 0002D26B # */ ! 422: 422 0002D26B # asm("_pipe11_4_lp1:"); ! 423: 423 0002D26B L273: ! 424: 424 0002D26B _pipe11_4_lp1: ! 425: 425 0002D26B # asm("ldf _sgl_value_1"); /* load the operand */ ! 426: 426 0002D26B 06 effffffce3 ldf _sgl_value_1 ! 427: 427 0002D271 # asm("negf"); /* negate it ( 5 times ) */ ! 428: 428 0002D271 b6 negf ! 429: 429 0002D272 # asm("negf"); ! 430: 430 0002D272 b6 negf ! 431: 431 0002D273 # asm("negf"); ! 432: 432 0002D273 b6 negf ! 433: 433 0002D274 # asm("negf"); ! 434: 434 0002D274 b6 negf ! 435: 435 0002D275 # asm("negf"); ! 436: 436 0002D275 b6 negf ! 437: 437 0002D276 # asm("stf _sgl_st_acc"); /* store the result */ ! 438: 438 0002D276 26 effffffcd8 stf _sgl_st_acc ! 439: 439 0002D27C # if( force_loop ) ! 440: 440 0002D27C 5d effffffcd2 tstl _force_loop ! 441: 441 0002D282 31 02 jeql L274 ! 442: 442 0002D284 # asm("brb _pipe11_4_lp1"); /* loop on an error */ ! 443: 443 0002D284 11 e5 brb _pipe11_4_lp1 ! 444: 444 0002D286 # /* ! 445: 445 0002D286 # * verify the results ! 446: 446 0002D286 # */ ! 447: 447 0002D286 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 448: 448 0002D286 L274: ! 449: 449 0002D286 1d effffffcc8 effffffcc3 cmpl _sgl_st_acc,_sgl_expected ! 450: 450 0002D291 31 3d jeql L275 ! 451: 451 0002D293 # errcnt++; /* bump the error count */ ! 452: 452 0002D293 6d effffffcbb incl _errcnt ! 453: 453 0002D299 # if( prt_error ) ! 454: 454 0002D299 5d effffffcb5 tstl _prt_error ! 455: 455 0002D29F 31 09 jeql L276 ! 456: 456 0002D2A1 # pipe11_print( 5 ); /* print error msg -5 NEGFS*/ ! 457: 457 0002D2A1 dd 05 pushl $5 ! 458: 458 0002D2A3 fe 08 ef000000fc callf $8,_pipe11_print ! 459: 459 0002D2AA # if( halt_flg ) /* halt on error? */ ! 460: 460 0002D2AA L276: ! 461: 461 0002D2AA 5d effffffca4 tstl _halt_flg ! 462: 462 0002D2B0 31 09 jeql L277 ! 463: 463 0002D2B2 # pipe11_halt( 5 ); /* error halt -5 NEGFS */ ! 464: 464 0002D2B2 dd 05 pushl $5 ! 465: 465 0002D2B4 fe 08 ef000001f3 callf $8,_pipe11_halt ! 466: 466 0002D2BB # if( loop_on_err ) { ! 467: 467 0002D2BB L277: ! 468: 468 0002D2BB 5d effffffc93 tstl _loop_on_err ! 469: 469 0002D2C1 31 0d jeql L278 ! 470: 470 0002D2C3 # force_loop = TRUE; /* set the force loop flag */ ! 471: 471 0002D2C3 0d 01 effffffc8a movl $1,_force_loop ! 472: 472 0002D2CA # asm("jmp _pipe11_4_lp1"); /* and loop */ ! 473: 473 0002D2CA 71 efffffff9b jmp _pipe11_4_lp1 ! 474: 474 0002D2D0 # } ! 475: 475 0002D2D0 # } ! 476: 476 0002D2D0 L278: ! 477: 477 0002D2D0 # } /* end of FOR loop */ ! 478: 478 0002D2D0 L275: ! 479: 479 0002D2D0 L270: ! 480: 480 0002D2D0 6d effffffc7e incl _index ! 481: 481 0002D2D6 13 ff43 jbr L272 ! 482: 482 0002D2D9 L271: ! 483: 483 0002D2D9 # } /* end of subtest 4 */ ! 484: 484 0002D2D9 40 ret#2 ! 485: 485 0002D2DA .set L266,0x0 ! 486: 486 0002D2DA L268: ! 487: 487 0002D2DA 13 ff2c jbr L269 ! 488: 488 0002D2DD .data ! 489: 489 000005a8 * .text ! 490: 490 0002D2DD 00 .align 1 ! 491: 491 0002D2DE .globl _pipe11_5 ! 492: 492 0002D2DE _pipe11_5: ! 493: 493 0002D2DE 0000 .word L279 ! 494: 494 0002D2E0 # ! 495: 495 0002D2E0 # ! 496: 496 0002D2E0 # ! 497: 497 0002D2E0 # ! 498: 498 0002D2E0 # ! 499: 499 0002D2E0 # /************************************************************************ ! 500: 500 0002D2E0 # * ! 501: 501 0002D2E0 # * SUBTEST 5 : 6 NEGFs ! 502: 502 0002D2E0 # * ! 503: 503 0002D2E0 # ************************************************************************/ ! 504: 504 0002D2E0 # pipe11_5() ! 505: 505 0002D2E0 # { ! 506: 506 0002D2E0 13 00bf jbr L281 ! 507: 507 0002D2E3 L282: ! 508: 508 0002D2E3 # subtest = 5; ! 509: 509 0002D2E3 0d 05 effffffc6a movl $5,_subtest ! 510: 510 0002D2EA # force_loop = FALSE; ! 511: 511 0002D2EA 4d effffffc64 clrl _force_loop ! 512: 512 0002D2F0 # for( index = 0; index < max_ldf_1_index; index++ ) ! 513: 513 0002D2F0 4d effffffc5e clrl _index ! 514: 514 0002D2F6 L285: ! 515: 515 0002D2F6 1d effffffc58 effffffc53 cmpl _index,_max_ldf_1_index ! 516: 516 0002D301 91 03 13 009b jgeq L284 ! 517: 517 0002D306 # { ! 518: 518 0002D306 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 519: 519 0002D306 0d effffffc48 50 movl _index,r0 ! 520: 520 0002D30D 48 03 50 50 shll $3,r0,r0 ! 521: 521 0002D311 0d e000000000 effffffc38 movl _ldf_1_data(r0),_sgl_value_1 ! 522: 522 0002D31C # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 523: 523 0002D31C 0d effffffc32 50 movl _index,r0 ! 524: 524 0002D323 48 03 50 50 shll $3,r0,r0 ! 525: 525 0002D327 0d e000000004 effffffc22 movl _ldf_1_data+4(r0),_sgl_expected ! 526: 526 0002D332 # /* ! 527: 527 0002D332 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 528: 528 0002D332 # * The force loop flag is set after the first error. ! 529: 529 0002D332 # */ ! 530: 530 0002D332 # asm("_pipe11_5_lp1:"); ! 531: 531 0002D332 _pipe11_5_lp1: ! 532: 532 0002D332 # asm("ldf _sgl_value_1"); /* load the operand */ ! 533: 533 0002D332 06 effffffc1c ldf _sgl_value_1 ! 534: 534 0002D338 # asm("negf"); /* negate it ( 6 times ) */ ! 535: 535 0002D338 b6 negf ! 536: 536 0002D339 # asm("negf"); ! 537: 537 0002D339 b6 negf ! 538: 538 0002D33A # asm("negf"); ! 539: 539 0002D33A b6 negf ! 540: 540 0002D33B # asm("negf"); ! 541: 541 0002D33B b6 negf ! 542: 542 0002D33C # asm("negf"); ! 543: 543 0002D33C b6 negf ! 544: 544 0002D33D # asm("negf"); ! 545: 545 0002D33D b6 negf ! 546: 546 0002D33E # asm("stf _sgl_st_acc"); /* store the result */ ! 547: 547 0002D33E 26 effffffc10 stf _sgl_st_acc ! 548: 548 0002D344 # if( force_loop ) ! 549: 549 0002D344 5d effffffc0a tstl _force_loop ! 550: 550 0002D34A 31 02 jeql L286 ! 551: 551 0002D34C # asm("brb _pipe11_5_lp1"); /* loop on an error */ ! 552: 552 0002D34C 11 e4 brb _pipe11_5_lp1 ! 553: 553 0002D34E # /* ! 554: 554 0002D34E # * verify the results ! 555: 555 0002D34E # */ ! 556: 556 0002D34E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 557: 557 0002D34E L286: ! 558: 558 0002D34E 1d effffffc00 effffffbfb cmpl _sgl_st_acc,_sgl_expected ! 559: 559 0002D359 31 3d jeql L287 ! 560: 560 0002D35B # errcnt++; /* bump the error count */ ! 561: 561 0002D35B 6d effffffbf3 incl _errcnt ! 562: 562 0002D361 # if( prt_error ) ! 563: 563 0002D361 5d effffffbed tstl _prt_error ! 564: 564 0002D367 31 09 jeql L288 ! 565: 565 0002D369 # pipe11_print( 6 ); /* print error msg -6 NEGFS*/ ! 566: 566 0002D369 dd 06 pushl $6 ! 567: 567 0002D36B fe 08 ef00000034 callf $8,_pipe11_print ! 568: 568 0002D372 # if( halt_flg ) /* halt on error? */ ! 569: 569 0002D372 L288: ! 570: 570 0002D372 5d effffffbdc tstl _halt_flg ! 571: 571 0002D378 31 09 jeql L289 ! 572: 572 0002D37A # pipe11_halt( 6 ); /* error halt -6 NEGFS */ ! 573: 573 0002D37A dd 06 pushl $6 ! 574: 574 0002D37C fe 08 ef0000012b callf $8,_pipe11_halt ! 575: 575 0002D383 # if( loop_on_err ) { ! 576: 576 0002D383 L289: ! 577: 577 0002D383 5d effffffbcb tstl _loop_on_err ! 578: 578 0002D389 31 0d jeql L290 ! 579: 579 0002D38B # force_loop = TRUE; /* set the force loop flag */ ! 580: 580 0002D38B 0d 01 effffffbc2 movl $1,_force_loop ! 581: 581 0002D392 # asm("jmp _pipe11_5_lp1"); /* and loop */ ! 582: 582 0002D392 71 efffffff9a jmp _pipe11_5_lp1 ! 583: 583 0002D398 # } ! 584: 584 0002D398 # } ! 585: 585 0002D398 L290: ! 586: 586 0002D398 # } /* end of FOR loop */ ! 587: 587 0002D398 L287: ! 588: 588 0002D398 L283: ! 589: 589 0002D398 6d effffffbb6 incl _index ! 590: 590 0002D39E 13 ff55 jbr L285 ! 591: 591 0002D3A1 L284: ! 592: 592 0002D3A1 # } /* end of subtest 5 */ ! 593: 593 0002D3A1 40 ret#2 ! 594: 594 0002D3A2 .set L279,0x0 ! 595: 595 0002D3A2 L281: ! 596: 596 0002D3A2 13 ff3e jbr L282 ! 597: 597 0002D3A5 .data ! 598: 598 000005a8 * .text ! 599: 599 0002D3A5 00 .align 1 ! 600: 600 0002D3A6 .globl _pipe11_print ! 601: 601 0002D3A6 _pipe11_print: ! 602: 602 0002D3A6 0000 .word L291 ! 603: 603 0002D3A8 # ! 604: 604 0002D3A8 # ! 605: 605 0002D3A8 # ! 606: 606 0002D3A8 # ! 607: 607 0002D3A8 # /**************************************************************************** ! 608: 608 0002D3A8 # * ! 609: 609 0002D3A8 # * PRINT AN ERROR MESSAGE ! 610: 610 0002D3A8 # * ! 611: 611 0002D3A8 # * cycle dd PIPELINE 11, subtest dd error ! 612: 612 0002D3A8 # * LDF op, {NEGF}, STF ! 613: 613 0002D3A8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = xxxxxxxx ! 614: 614 0002D3A8 # * expected Acc = xxxxxxxx ! 615: 615 0002D3A8 # ****************************************************************************/ ! 616: 616 0002D3A8 # pipe11_print( nop_count ) ! 617: 617 0002D3A8 # int nop_count; /* # of NEGF instructions */ ! 618: 618 0002D3A8 # { ! 619: 619 0002D3A8 13 0100 jbr L293 ! 620: 620 0002D3AB L294: ! 621: 621 0002D3AB # writes(" \n"); /* start a new print line */ ! 622: 622 0002D3AB .data 1 ! 623: 623 000005b1 * L295: ! 624: 624 000005b1 * 200A00 .ascii " \12\0" ! 625: 625 000005b4 * .text ! 626: 626 0002D3AB dd 8f000005b1 pushl $L295 ! 627: 627 0002D3B1 fe 08 effffffb9c callf $8,_writes ! 628: 628 0002D3B8 # writes("cycle: "); ! 629: 629 0002D3B8 .data 1 ! 630: 630 000005b4 * L296: ! 631: 631 000005b4 * 6379636C653A2000 .ascii "cycle: \0" ! 632: 632 000005bc * .text ! 633: 633 0002D3B8 dd 8f000005b4 pushl $L296 ! 634: 634 0002D3BE fe 08 effffffb8f callf $8,_writes ! 635: 635 0002D3C5 # writed( cycle ); ! 636: 636 0002D3C5 dd effffffb89 pushl _cycle ! 637: 637 0002D3CB fe 08 effffffb82 callf $8,_writed ! 638: 638 0002D3D2 # writes(" (Pipe 11), subtest "); ! 639: 639 0002D3D2 .data 1 ! 640: 640 000005bc * L298: ! 641: 641 000005bc * 20202850697065203131292C2 .ascii " (Pipe 11), subtest \0" ! 642: 0737562746573742000 ! 643: 642 000005d2 * .text ! 644: 643 0002D3D2 dd 8f000005bc pushl $L298 ! 645: 644 0002D3D8 fe 08 effffffb75 callf $8,_writes ! 646: 645 0002D3DF # writed( subtest ); ! 647: 646 0002D3DF dd effffffb6f pushl _subtest ! 648: 647 0002D3E5 fe 08 effffffb68 callf $8,_writed ! 649: 648 0002D3EC # writes(" error\n"); ! 650: 649 0002D3EC .data 1 ! 651: 650 000005d2 * L299: ! 652: 651 000005d2 * 206572726F720A00 .ascii " error\12\0" ! 653: 652 000005da * .text ! 654: 653 0002D3EC dd 8f000005d2 pushl $L299 ! 655: 654 0002D3F2 fe 08 effffffb5b callf $8,_writes ! 656: 655 0002D3F9 # writes(" LDF(op), NEGF"); ! 657: 656 0002D3F9 .data 1 ! 658: 657 000005da * L300: ! 659: 658 000005da * 204C4446286F70292C204E454 .ascii " LDF(op), NEGF\0" ! 660: 74600 ! 661: 659 000005e9 * .text ! 662: 660 0002D3F9 dd 8f000005da pushl $L300 ! 663: 661 0002D3FF fe 08 effffffb4e callf $8,_writes ! 664: 662 0002D406 # while( --nop_count ) ! 665: 663 0002D406 L301: ! 666: 664 0002D406 7d ad04 decl 4(fp) ! 667: 665 0002D409 31 0f jeql L302 ! 668: 666 0002D40B # writes(", NEGF"); ! 669: 667 0002D40B .data 1 ! 670: 668 000005e9 * L303: ! 671: 669 000005e9 * 2C204E45474600 .ascii ", NEGF\0" ! 672: 670 000005f0 * .text ! 673: 671 0002D40B dd 8f000005e9 pushl $L303 ! 674: 672 0002D411 fe 08 effffffb3c callf $8,_writes ! 675: 673 0002D418 11 ec jbr L301 ! 676: 674 0002D41A L302: ! 677: 675 0002D41A # writes(", STF\n"); ! 678: 676 0002D41A .data 1 ! 679: 677 000005f0 * L304: ! 680: 678 000005f0 * 2C205354460A00 .ascii ", STF\12\0" ! 681: 679 000005f7 * .text ! 682: 680 0002D41A dd 8f000005f0 pushl $L304 ! 683: 681 0002D420 fe 08 effffffb2d callf $8,_writes ! 684: 682 0002D427 # writec('\n'); ! 685: 683 0002D427 dd 0a pushl $10 ! 686: 684 0002D429 fe 08 effffffb24 callf $8,_writec ! 687: 685 0002D430 # writes("operand = "); ! 688: 686 0002D430 .data 1 ! 689: 687 000005f7 * L306: ! 690: 688 000005f7 * 6F706572616E64203D2000 .ascii "operand = \0" ! 691: 689 00000602 * .text ! 692: 690 0002D430 dd 8f000005f7 pushl $L306 ! 693: 691 0002D436 fe 08 effffffb17 callf $8,_writes ! 694: 692 0002D43D # write32h( sgl_value_1 ); ! 695: 693 0002D43D dd effffffb11 pushl _sgl_value_1 ! 696: 694 0002D443 fe 08 effffffb0a callf $8,_write32h ! 697: 695 0002D44A # writes(", final Acc = "); ! 698: 696 0002D44A .data 1 ! 699: 697 00000602 * L308: ! 700: 698 00000602 * 2C2020202066696E616C20416 .ascii ", final Acc = \0" ! 701: 363203D2000 ! 702: 699 00000614 * .text ! 703: 700 0002D44A dd 8f00000602 pushl $L308 ! 704: 701 0002D450 fe 08 effffffafd callf $8,_writes ! 705: 702 0002D457 # write32h( sgl_st_acc ); ! 706: 703 0002D457 dd effffffaf7 pushl _sgl_st_acc ! 707: 704 0002D45D fe 08 effffffaf0 callf $8,_write32h ! 708: 705 0002D464 # writes(", data index = "); ! 709: 706 0002D464 .data 1 ! 710: 707 00000614 * L309: ! 711: 708 00000614 * 2C2020206461746120696E646 .ascii ", data index = \0" ! 712: 578203D2000 ! 713: 709 00000626 * .text ! 714: 710 0002D464 dd 8f00000614 pushl $L309 ! 715: 711 0002D46A fe 08 effffffae3 callf $8,_writes ! 716: 712 0002D471 # writed( index ); ! 717: 713 0002D471 dd effffffadd pushl _index ! 718: 714 0002D477 fe 08 effffffad6 callf $8,_writed ! 719: 715 0002D47E # writec('\n'); ! 720: 716 0002D47E dd 0a pushl $10 ! 721: 717 0002D480 fe 08 effffffacd callf $8,_writec ! 722: 718 0002D487 # writes(" expected Acc = "); ! 723: 719 0002D487 .data 1 ! 724: 720 00000626 * L310: ! 725: 721 00000626 * 2020202020202020202020202 .ascii " expected Acc = \0" ! 726: 0202020202020206578706563 ! 727: 74656420416363203D2000 ! 728: 722 0000064a * .text ! 729: 723 0002D487 dd 8f00000626 pushl $L310 ! 730: 724 0002D48D fe 08 effffffac0 callf $8,_writes ! 731: 725 0002D494 # write32h( sgl_expected ); ! 732: 726 0002D494 dd effffffaba pushl _sgl_expected ! 733: 727 0002D49A fe 08 effffffab3 callf $8,_write32h ! 734: 728 0002D4A1 # writec('\n'); ! 735: 729 0002D4A1 dd 0a pushl $10 ! 736: 730 0002D4A3 fe 08 effffffaaa callf $8,_writec ! 737: 731 0002D4AA # } ! 738: 732 0002D4AA 40 ret#2 ! 739: 733 0002D4AB .set L291,0x0 ! 740: 734 0002D4AB L293: ! 741: 735 0002D4AB 13 fefd jbr L294 ! 742: 736 0002D4AE .data ! 743: 737 000005a8 * .text ! 744: 738 0002D4AE .align 1 ! 745: 739 0002D4AE .globl _pipe11_halt ! 746: 740 0002D4AE _pipe11_halt: ! 747: 741 0002D4AE 0000 .word L311 ! 748: 742 0002D4B0 # ! 749: 743 0002D4B0 # ! 750: 744 0002D4B0 # ! 751: 745 0002D4B0 # /**************************************************************************** ! 752: 746 0002D4B0 # * ! 753: 747 0002D4B0 # * SET UP THE REGISTERS AND HALT ! 754: 748 0002D4B0 # * ! 755: 749 0002D4B0 # ****************************************************************************/ ! 756: 750 0002D4B0 # pipe11_halt( nop_count ) ! 757: 751 0002D4B0 # int nop_count; /* # of NEGF instructions */ ! 758: 752 0002D4B0 # { ! 759: 753 0002D4B0 11 45 jbr L313 ! 760: 754 0002D4B2 L314: ! 761: 755 0002D4B2 # sgl_dummy1 = nop_count; ! 762: 756 0002D4B2 0d ad04 effffffa9a movl 4(fp),_sgl_dummy1 ! 763: 757 0002D4BA # asm("movl _test_no,r0"); /* r0 = test number */ ! 764: 758 0002D4BA 0d effffffa94 50 movl _test_no,r0 ! 765: 759 0002D4C1 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 766: 760 0002D4C1 0d effffffa8d 51 movl _subtest,r1 ! 767: 761 0002D4C8 # asm("movl $1,r2"); /* r2 = error code */ ! 768: 762 0002D4C8 0d 01 52 movl $1,r2 ! 769: 763 0002D4CB # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 770: 764 0002D4CB 0d effffffa83 53 movl _cycle,r3 ! 771: 765 0002D4D2 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGFS */ ! 772: 766 0002D4D2 0d effffffa7c 54 movl _sgl_dummy1,r4 ! 773: 767 0002D4D9 # asm("movl _sgl_value_1,r5"); /* r5 = sgl operand */ ! 774: 768 0002D4D9 0d effffffa75 55 movl _sgl_value_1,r5 ! 775: 769 0002D4E0 # asm("movl _sgl_st_acc,r6"); /* r6 = sgl stored */ ! 776: 770 0002D4E0 0d effffffa6e 56 movl _sgl_st_acc,r6 ! 777: 771 0002D4E7 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */ ! 778: 772 0002D4E7 0d effffffa67 57 movl _sgl_expected,r7 ! 779: 773 0002D4EE # asm("movl _index,r8"); /* r8 = data index */ ! 780: 774 0002D4EE 0d effffffa60 58 movl _index,r8 ! 781: 775 0002D4F5 # asm("halt"); /* HALT ... */ ! 782: 776 0002D4F5 00 halt ! 783: 777 0002D4F6 # } ! 784: 778 0002D4F6 40 ret#2 ! 785: 779 0002D4F7 .set L311,0x0 ! 786: 780 0002D4F7 L313: ! 787: 781 0002D4F7 11 b9 jbr L314 ! 788: 782 0002D4F9 .data ! 789: 782 0005A44D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.