![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe1.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 pipe1.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 00000c00 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_1 ! 6: 6 00000000 _pipe_1: ! 7: 7 0002603C 0000 .word L215 ! 8: 8 0002603E # ! 9: 9 0002603E # ! 10: 10 0002603E # #include "fpp_defs.h" ! 11: 11 0002603E # ! 12: 12 0002603E # ! 13: 13 0002603E # /***************************************************************************** ! 14: 14 0002603E # * ! 15: 15 0002603E # * PIPELINE TEST #1 MONITOR ! 16: 16 0002603E # * ! 17: 17 0002603E # * This test will do: ! 18: 18 0002603E # * ! 19: 19 0002603E # * LDF(x), SUBF(x), SUBF(x), ADDF(x), ADDF(x), STF ! 20: 20 0002603E # * ! 21: 21 0002603E # * where the x's are the fmacro1 LDF data patterns. ! 22: 22 0002603E # *****************************************************************************/ ! 23: 23 0002603E # pipe_1() ! 24: 24 0002603E # { ! 25: 25 0002603E 13 00a8 jbr L217 ! 26: 26 00026041 L218: ! 27: 27 00026041 # asm(".globl _pipeline_1_t"); ! 28: 28 00026041 .globl _pipeline_1_t ! 29: 29 00026041 # asm("_pipeline_1_t:"); /* entry address */ ! 30: 30 00026041 _pipeline_1_t: ! 31: 31 00026041 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 32: 32 00026041 1d effffffff5 01 cmpl _cycle,$1 ! 33: 33 00026048 21 15 jneq L219 ! 34: 34 0002604A 5d efffffffec tstl _prt_hdrs ! 35: 35 00026050 31 0d jeql L219 ! 36: 36 00026052 # { ! 37: 37 00026052 # writes("\n PIPE_1 "); ! 38: 38 00026052 .data 1 ! 39: 39 00000c00 * L221: ! 40: 40 00000c00 * 0A20504950455F312000 .ascii "\12 PIPE_1 \0" ! 41: 41 00000c0a * .text ! 42: 42 00026052 dd 8f00000c00 pushl $L221 ! 43: 43 00026058 fe 08 efffffffdd callf $8,_writes ! 44: 44 0002605F # } ! 45: 45 0002605F # subtest = 1; ! 46: 46 0002605F L219: ! 47: 47 0002605F 0d 01 efffffffd6 movl $1,_subtest ! 48: 48 00026066 # pipe1_1(); /* data in REGs, no NOPs */ ! 49: 49 00026066 fe 04 ef0000007f callf $4,_pipe1_1 ! 50: 50 0002606D # subtest++; /* increment subtest num */ ! 51: 51 0002606D 6d efffffffc9 incl _subtest ! 52: 52 00026073 # pipe1_2(); /* data in REGs, 1 NOP */ ! 53: 53 00026073 fe 04 ef00000140 callf $4,_pipe1_2 ! 54: 54 0002607A # subtest++; /* increment subtest num */ ! 55: 55 0002607A 6d efffffffbc incl _subtest ! 56: 56 00026080 # pipe1_3(); /* data in REGs, 2 NOPs */ ! 57: 57 00026080 fe 04 ef00000205 callf $4,_pipe1_3 ! 58: 58 00026087 # subtest++; /* increment subtest num */ ! 59: 59 00026087 6d efffffffaf incl _subtest ! 60: 60 0002608D # pipe1_4(); /* data in REGs, 3 NOPs */ ! 61: 61 0002608D fe 04 ef000002d0 callf $4,_pipe1_4 ! 62: 62 00026094 # subtest++; /* increment subtest num */ ! 63: 63 00026094 6d efffffffa2 incl _subtest ! 64: 64 0002609A # pipe1_5(); /* data in CACHE, no NOPs */ ! 65: 65 0002609A fe 04 ef0000039f callf $4,_pipe1_5 ! 66: 66 000260A1 # subtest++; /* increment subtest num */ ! 67: 67 000260A1 6d efffffff95 incl _subtest ! 68: 68 000260A7 # pipe1_6(); /* data in CACHE, 1 NOP */ ! 69: 69 000260A7 fe 04 ef0000046a callf $4,_pipe1_6 ! 70: 70 000260AE # subtest++; /* increment subtest num */ ! 71: 71 000260AE 6d efffffff88 incl _subtest ! 72: 72 000260B4 # pipe1_7(); /* data in CACHE, 2 NOPs */ ! 73: 73 000260B4 fe 04 ef00000539 callf $4,_pipe1_7 ! 74: 74 000260BB # subtest++; /* increment subtest num */ ! 75: 75 000260BB 6d efffffff7b incl _subtest ! 76: 76 000260C1 # pipe1_8(); /* data in CACHE, 3 NOPs */ ! 77: 77 000260C1 fe 04 ef0000060e callf $4,_pipe1_8 ! 78: 78 000260C8 # subtest++; /* increment subtest num */ ! 79: 79 000260C8 6d efffffff6e incl _subtest ! 80: 80 000260CE # pipe1_9(); /* data on STACK, no NOPs */ ! 81: 81 000260CE fe 04 ef000006e7 callf $4,_pipe1_9 ! 82: 82 000260D5 # subtest++; /* increment subtest num */ ! 83: 83 000260D5 6d efffffff61 incl _subtest ! 84: 84 000260DB # pipe1_10(); /* data via FP no NOPs */ ! 85: 85 000260DB fe 04 ef00000858 callf $4,_pipe1_10 ! 86: 86 000260E2 # asm("jmp *return"); /* return to the test monitor */ ! 87: 87 000260E2 71 ffffffff54 jmp *return ! 88: 88 000260E8 # } ! 89: 89 000260E8 40 ret#2 ! 90: 90 000260E9 .set L215,0x0 ! 91: 91 000260E9 L217: ! 92: 92 000260E9 13 ff55 jbr L218 ! 93: 93 000260EC .data ! 94: 94 00000c00 * .text ! 95: 95 000260EC .align 1 ! 96: 96 000260EC .globl _pipe1_1 ! 97: 97 000260EC _pipe1_1: ! 98: 98 000260EC 0000 .word L232 ! 99: 99 000260EE # ! 100: 100 000260EE # ! 101: 101 000260EE # ! 102: 102 000260EE # ! 103: 103 000260EE # ! 104: 104 000260EE # ! 105: 105 000260EE # /************************************************************************ ! 106: 106 000260EE # * ! 107: 107 000260EE # * SUBTEST 1 ! 108: 108 000260EE # * data in registers, no NO-OPs ! 109: 109 000260EE # * ! 110: 110 000260EE # ************************************************************************/ ! 111: 111 000260EE # pipe1_1() ! 112: 112 000260EE # { ! 113: 113 000260EE 13 00c5 jbr L234 ! 114: 114 000260F1 L235: ! 115: 115 000260F1 # force_loop = FALSE; /* clear the force_loop flg */ ! 116: 116 000260F1 4d efffffff45 clrl _force_loop ! 117: 117 000260F7 # index = 0; ! 118: 118 000260F7 4d efffffff3f clrl _index ! 119: 119 000260FD # do ! 120: 120 000260FD L238: ! 121: 121 000260FD # { ! 122: 122 000260FD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 123: 123 000260FD 0d efffffff39 50 movl _index,r0 ! 124: 124 00026104 48 03 50 50 shll $3,r0,r0 ! 125: 125 00026108 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1 ! 126: 126 00026113 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 127: 127 00026113 0d efffffff23 50 movl _index,r0 ! 128: 128 0002611A 48 03 50 50 shll $3,r0,r0 ! 129: 129 0002611E 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected ! 130: 130 00026129 # /* ! 131: 131 00026129 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 132: 132 00026129 # * The force loop flag is set after the first error. ! 133: 133 00026129 # */ ! 134: 134 00026129 # asm("_pipe1_1_lp1:"); ! 135: 135 00026129 _pipe1_1_lp1: ! 136: 136 00026129 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 137: 137 00026129 0d efffffff0d 54 movl _sgl_value_1,r4 ! 138: 138 00026130 # asm("ldf r4"); /* load the operand */ ! 139: 139 00026130 06 54 ldf r4 ! 140: 140 00026132 # asm("subf r4"); /* subtract it (twice ) */ ! 141: 141 00026132 d6 54 subf r4 ! 142: 142 00026134 # asm("subf r4"); ! 143: 143 00026134 d6 54 subf r4 ! 144: 144 00026136 # asm("addf r4"); /* add it back (twice) */ ! 145: 145 00026136 c6 54 addf r4 ! 146: 146 00026138 # asm("addf r4"); ! 147: 147 00026138 c6 54 addf r4 ! 148: 148 0002613A # asm("stf r5"); /* store the result */ ! 149: 149 0002613A 26 55 stf r5 ! 150: 150 0002613C # if ( force_loop ); ! 151: 151 0002613C 5d effffffefa tstl _force_loop ! 152: 152 00026142 31 00 jeql L239 ! 153: 153 00026144 # asm("brb _pipe1_1_lp1");; /* loop on the error */ ! 154: 154 00026144 L239: ! 155: 155 00026144 11 e3 brb _pipe1_1_lp1 ! 156: 156 00026146 # /* ! 157: 157 00026146 # * verify the results ! 158: 158 00026146 # */ ! 159: 159 00026146 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 160: 160 00026146 0d 55 effffffeef movl r5,_sgl_st_acc ! 161: 161 0002614D # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 162: 162 0002614D 1d effffffee9 effffffee4 cmpl _sgl_st_acc,_sgl_expected ! 163: 163 00026158 31 42 jeql L240 ! 164: 164 0002615A # { ! 165: 165 0002615A # errcnt++; /* bump the error count */ ! 166: 166 0002615A 6d effffffedc incl _errcnt ! 167: 167 00026160 # if ( prt_error ) ! 168: 168 00026160 5d effffffed6 tstl _prt_error ! 169: 169 00026166 31 0d jeql L241 ! 170: 170 00026168 # print_pipe1_er("Reg. Data, no NO-OPs"); ! 171: 171 00026168 .data 1 ! 172: 172 00000c0a * L243: ! 173: 173 00000c0a * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0" ! 174: F204E4F2D4F507300 ! 175: 174 00000c1f * .text ! 176: 175 00026168 dd 8f00000c0a pushl $L243 ! 177: 176 0002616E fe 08 ef00000955 callf $8,_print_pipe1_er ! 178: 177 00026175 # if ( halt_flg ) /* halt on error? */ ! 179: 178 00026175 L241: ! 180: 179 00026175 5d effffffec1 tstl _halt_flg ! 181: 180 0002617B 31 0d jeql L244 ! 182: 181 0002617D # pipe1_er_hlt( subtest ); ! 183: 182 0002617D dd effffffeb9 pushl _subtest ! 184: 183 00026183 fe 08 ef00000a4c callf $8,_pipe1_er_hlt ! 185: 184 0002618A # if ( loop_on_err ) { ! 186: 185 0002618A L244: ! 187: 186 0002618A 5d effffffeac tstl _loop_on_err ! 188: 187 00026190 31 0a jeql L246 ! 189: 188 00026192 # force_loop = TRUE; /* set the force loop flag */ ! 190: 189 00026192 0d 01 effffffea3 movl $1,_force_loop ! 191: 190 00026199 # asm("brw _pipe1_1_lp1"); /* and loop */ ! 192: 191 00026199 13 ff8d brw _pipe1_1_lp1 ! 193: 192 0002619C # } ! 194: 193 0002619C # } /* end of compare error */ ! 195: 194 0002619C L246: ! 196: 195 0002619C # } while( index++ < max_ldf_1_index ); ! 197: 196 0002619C L240: ! 198: 197 0002619C L237: ! 199: 198 0002619C 0d effffffe9a 50 movl _index,r0 ! 200: 199 000261A3 6d effffffe93 incl _index ! 201: 200 000261A9 1d 50 effffffe8c cmpl r0,_max_ldf_1_index ! 202: 201 000261B0 81 03 13 ff48 jlss L238 ! 203: 202 000261B5 L236: ! 204: 203 000261B5 # } /* end of subtest 1 */ ! 205: 204 000261B5 40 ret#2 ! 206: 205 000261B6 .set L232,0x0 ! 207: 206 000261B6 L234: ! 208: 207 000261B6 13 ff38 jbr L235 ! 209: 208 000261B9 .data ! 210: 209 00000c00 * .text ! 211: 210 000261B9 00 .align 1 ! 212: 211 000261BA .globl _pipe1_2 ! 213: 212 000261BA _pipe1_2: ! 214: 213 000261BA 0000 .word L247 ! 215: 214 000261BC # ! 216: 215 000261BC # ! 217: 216 000261BC # ! 218: 217 000261BC # ! 219: 218 000261BC # ! 220: 219 000261BC # ! 221: 220 000261BC # /************************************************************************ ! 222: 221 000261BC # * ! 223: 222 000261BC # * SUBTEST 2 ! 224: 223 000261BC # * data in registers, 1 NO-OP ! 225: 224 000261BC # * ! 226: 225 000261BC # ************************************************************************/ ! 227: 226 000261BC # pipe1_2() ! 228: 227 000261BC # { ! 229: 228 000261BC 13 00ca jbr L249 ! 230: 229 000261BF L250: ! 231: 230 000261BF # force_loop = FALSE; /* clear force_loop flag */ ! 232: 231 000261BF 4d effffffe77 clrl _force_loop ! 233: 232 000261C5 # index = 0; ! 234: 233 000261C5 4d effffffe71 clrl _index ! 235: 234 000261CB # do ! 236: 235 000261CB L253: ! 237: 236 000261CB # { ! 238: 237 000261CB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 239: 238 000261CB 0d effffffe6b 50 movl _index,r0 ! 240: 239 000261D2 48 03 50 50 shll $3,r0,r0 ! 241: 240 000261D6 0d e000000000 effffffe5b movl _ldf_1_data(r0),_sgl_value_1 ! 242: 241 000261E1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 243: 242 000261E1 0d effffffe55 50 movl _index,r0 ! 244: 243 000261E8 48 03 50 50 shll $3,r0,r0 ! 245: 244 000261EC 0d e000000004 effffffe45 movl _ldf_1_data+4(r0),_sgl_expected ! 246: 245 000261F7 # /* ! 247: 246 000261F7 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 248: 247 000261F7 # * The force loop flag is set after the first error. ! 249: 248 000261F7 # */ ! 250: 249 000261F7 # asm("_pipe1_2_lp1:"); ! 251: 250 000261F7 _pipe1_2_lp1: ! 252: 251 000261F7 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 253: 252 000261F7 0d effffffe3f 54 movl _sgl_value_1,r4 ! 254: 253 000261FE # asm("ldf r4"); /* load the data operand */ ! 255: 254 000261FE 06 54 ldf r4 ! 256: 255 00026200 # asm("nop"); ! 257: 256 00026200 10 nop ! 258: 257 00026201 # asm("subf r4"); /* subtract the data (2xs) */ ! 259: 258 00026201 d6 54 subf r4 ! 260: 259 00026203 # asm("nop"); ! 261: 260 00026203 10 nop ! 262: 261 00026204 # asm("subf r4"); ! 263: 262 00026204 d6 54 subf r4 ! 264: 263 00026206 # asm("nop"); ! 265: 264 00026206 10 nop ! 266: 265 00026207 # asm("addf r4"); /* add it back (2xs) */ ! 267: 266 00026207 c6 54 addf r4 ! 268: 267 00026209 # asm("nop"); ! 269: 268 00026209 10 nop ! 270: 269 0002620A # asm("addf r4"); ! 271: 270 0002620A c6 54 addf r4 ! 272: 271 0002620C # asm("nop"); ! 273: 272 0002620C 10 nop ! 274: 273 0002620D # asm("stf r5"); /* store the result */ ! 275: 274 0002620D 26 55 stf r5 ! 276: 275 0002620F # if ( force_loop ); ! 277: 276 0002620F 5d effffffe27 tstl _force_loop ! 278: 277 00026215 31 00 jeql L254 ! 279: 278 00026217 # asm("brb _pipe1_2_lp1");; /* loop on the error */ ! 280: 279 00026217 L254: ! 281: 280 00026217 11 de brb _pipe1_2_lp1 ! 282: 281 00026219 # /* ! 283: 282 00026219 # * verify the results ! 284: 283 00026219 # */ ! 285: 284 00026219 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 286: 285 00026219 0d 55 effffffe1c movl r5,_sgl_st_acc ! 287: 286 00026220 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 288: 287 00026220 1d effffffe16 effffffe11 cmpl _sgl_st_acc,_sgl_expected ! 289: 288 0002622B 31 42 jeql L255 ! 290: 289 0002622D # { ! 291: 290 0002622D # errcnt++; /* bump the error count */ ! 292: 291 0002622D 6d effffffe09 incl _errcnt ! 293: 292 00026233 # if ( prt_error ) ! 294: 293 00026233 5d effffffe03 tstl _prt_error ! 295: 294 00026239 31 0d jeql L256 ! 296: 295 0002623B # print_pipe1_er("Reg. Data, 1 NO-OP"); ! 297: 296 0002623B .data 1 ! 298: 297 00000c1f * L257: ! 299: 298 00000c1f * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0" ! 300: 04E4F2D4F5000 ! 301: 299 00000c32 * .text ! 302: 300 0002623B dd 8f00000c1f pushl $L257 ! 303: 301 00026241 fe 08 ef00000882 callf $8,_print_pipe1_er ! 304: 302 00026248 # if ( halt_flg ) /* halt on error? */ ! 305: 303 00026248 L256: ! 306: 304 00026248 5d effffffdee tstl _halt_flg ! 307: 305 0002624E 31 0d jeql L258 ! 308: 306 00026250 # pipe1_er_hlt( subtest ); ! 309: 307 00026250 dd effffffde6 pushl _subtest ! 310: 308 00026256 fe 08 ef00000979 callf $8,_pipe1_er_hlt ! 311: 309 0002625D # if ( loop_on_err ) { ! 312: 310 0002625D L258: ! 313: 311 0002625D 5d effffffdd9 tstl _loop_on_err ! 314: 312 00026263 31 0a jeql L259 ! 315: 313 00026265 # force_loop = TRUE; /* set the force loop flag */ ! 316: 314 00026265 0d 01 effffffdd0 movl $1,_force_loop ! 317: 315 0002626C # asm("brw _pipe1_2_lp1"); /* and loop */ ! 318: 316 0002626C 13 ff88 brw _pipe1_2_lp1 ! 319: 317 0002626F # } ! 320: 318 0002626F # } /* end of compare error */ ! 321: 319 0002626F L259: ! 322: 320 0002626F # } while( index++ < max_ldf_1_index ); ! 323: 321 0002626F L255: ! 324: 322 0002626F L252: ! 325: 323 0002626F 0d effffffdc7 50 movl _index,r0 ! 326: 324 00026276 6d effffffdc0 incl _index ! 327: 325 0002627C 1d 50 effffffdb9 cmpl r0,_max_ldf_1_index ! 328: 326 00026283 81 03 13 ff43 jlss L253 ! 329: 327 00026288 L251: ! 330: 328 00026288 # } /* end of subtest 2 */ ! 331: 329 00026288 40 ret#2 ! 332: 330 00026289 .set L247,0x0 ! 333: 331 00026289 L249: ! 334: 332 00026289 13 ff33 jbr L250 ! 335: 333 0002628C .data ! 336: 334 00000c00 * .text ! 337: 335 0002628C .align 1 ! 338: 336 0002628C .globl _pipe1_3 ! 339: 337 0002628C _pipe1_3: ! 340: 338 0002628C 0000 .word L260 ! 341: 339 0002628E # ! 342: 340 0002628E # ! 343: 341 0002628E # ! 344: 342 0002628E # ! 345: 343 0002628E # ! 346: 344 0002628E # ! 347: 345 0002628E # /************************************************************************ ! 348: 346 0002628E # * ! 349: 347 0002628E # * SUBTEST 3 ! 350: 348 0002628E # * data in registers, 2 NO-OPs ! 351: 349 0002628E # * ! 352: 350 0002628E # ************************************************************************/ ! 353: 351 0002628E # pipe1_3() ! 354: 352 0002628E # { ! 355: 353 0002628E 13 00cf jbr L262 ! 356: 354 00026291 L263: ! 357: 355 00026291 # force_loop = FALSE; /* clear force_loop flag */ ! 358: 356 00026291 4d effffffda5 clrl _force_loop ! 359: 357 00026297 # index = 0; ! 360: 358 00026297 4d effffffd9f clrl _index ! 361: 359 0002629D # do ! 362: 360 0002629D L266: ! 363: 361 0002629D # { ! 364: 362 0002629D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 365: 363 0002629D 0d effffffd99 50 movl _index,r0 ! 366: 364 000262A4 48 03 50 50 shll $3,r0,r0 ! 367: 365 000262A8 0d e000000000 effffffd89 movl _ldf_1_data(r0),_sgl_value_1 ! 368: 366 000262B3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 369: 367 000262B3 0d effffffd83 50 movl _index,r0 ! 370: 368 000262BA 48 03 50 50 shll $3,r0,r0 ! 371: 369 000262BE 0d e000000004 effffffd73 movl _ldf_1_data+4(r0),_sgl_expected ! 372: 370 000262C9 # /* ! 373: 371 000262C9 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 374: 372 000262C9 # * The force loop flag is set after the first error. ! 375: 373 000262C9 # */ ! 376: 374 000262C9 # asm("_pipe1_3_lp1:"); ! 377: 375 000262C9 _pipe1_3_lp1: ! 378: 376 000262C9 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 379: 377 000262C9 0d effffffd6d 54 movl _sgl_value_1,r4 ! 380: 378 000262D0 # asm("ldf r4"); /* loadthe operand */ ! 381: 379 000262D0 06 54 ldf r4 ! 382: 380 000262D2 # asm("nop"); ! 383: 381 000262D2 10 nop ! 384: 382 000262D3 # asm("nop"); ! 385: 383 000262D3 10 nop ! 386: 384 000262D4 # asm("subf r4"); /* subtract the data (2xs) */ ! 387: 385 000262D4 d6 54 subf r4 ! 388: 386 000262D6 # asm("nop"); ! 389: 387 000262D6 10 nop ! 390: 388 000262D7 # asm("nop"); ! 391: 389 000262D7 10 nop ! 392: 390 000262D8 # asm("subf r4"); ! 393: 391 000262D8 d6 54 subf r4 ! 394: 392 000262DA # asm("nop"); ! 395: 393 000262DA 10 nop ! 396: 394 000262DB # asm("nop"); ! 397: 395 000262DB 10 nop ! 398: 396 000262DC # asm("addf r4"); /* add it back (2xs) */ ! 399: 397 000262DC c6 54 addf r4 ! 400: 398 000262DE # asm("nop"); ! 401: 399 000262DE 10 nop ! 402: 400 000262DF # asm("nop"); ! 403: 401 000262DF 10 nop ! 404: 402 000262E0 # asm("addf r4"); ! 405: 403 000262E0 c6 54 addf r4 ! 406: 404 000262E2 # asm("nop"); ! 407: 405 000262E2 10 nop ! 408: 406 000262E3 # asm("nop"); ! 409: 407 000262E3 10 nop ! 410: 408 000262E4 # asm("stf r5"); /* store the result */ ! 411: 409 000262E4 26 55 stf r5 ! 412: 410 000262E6 # if ( force_loop ); ! 413: 411 000262E6 5d effffffd50 tstl _force_loop ! 414: 412 000262EC 31 00 jeql L267 ! 415: 413 000262EE # asm("brb _pipe1_3_lp1");; /* loop on the error */ ! 416: 414 000262EE L267: ! 417: 415 000262EE 11 d9 brb _pipe1_3_lp1 ! 418: 416 000262F0 # /* ! 419: 417 000262F0 # * verify the results ! 420: 418 000262F0 # */ ! 421: 419 000262F0 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 422: 420 000262F0 0d 55 effffffd45 movl r5,_sgl_st_acc ! 423: 421 000262F7 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 424: 422 000262F7 1d effffffd3f effffffd3a cmpl _sgl_st_acc,_sgl_expected ! 425: 423 00026302 31 42 jeql L268 ! 426: 424 00026304 # { ! 427: 425 00026304 # errcnt++; /* bump the error count */ ! 428: 426 00026304 6d effffffd32 incl _errcnt ! 429: 427 0002630A # if ( prt_error ) ! 430: 428 0002630A 5d effffffd2c tstl _prt_error ! 431: 429 00026310 31 0d jeql L269 ! 432: 430 00026312 # print_pipe1_er("Reg. Data, 2 NO-OPs"); ! 433: 431 00026312 .data 1 ! 434: 432 00000c32 * L270: ! 435: 433 00000c32 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0" ! 436: 04E4F2D4F507300 ! 437: 434 00000c46 * .text ! 438: 435 00026312 dd 8f00000c32 pushl $L270 ! 439: 436 00026318 fe 08 ef000007ab callf $8,_print_pipe1_er ! 440: 437 0002631F # if ( halt_flg ) /* halt on error? */ ! 441: 438 0002631F L269: ! 442: 439 0002631F 5d effffffd17 tstl _halt_flg ! 443: 440 00026325 31 0d jeql L271 ! 444: 441 00026327 # pipe1_er_hlt( subtest ); ! 445: 442 00026327 dd effffffd0f pushl _subtest ! 446: 443 0002632D fe 08 ef000008a2 callf $8,_pipe1_er_hlt ! 447: 444 00026334 # if ( loop_on_err ) { ! 448: 445 00026334 L271: ! 449: 446 00026334 5d effffffd02 tstl _loop_on_err ! 450: 447 0002633A 31 0a jeql L272 ! 451: 448 0002633C # force_loop = TRUE; /* set the force loop flag */ ! 452: 449 0002633C 0d 01 effffffcf9 movl $1,_force_loop ! 453: 450 00026343 # asm("brw _pipe1_3_lp1"); /* and loop */ ! 454: 451 00026343 13 ff83 brw _pipe1_3_lp1 ! 455: 452 00026346 # } ! 456: 453 00026346 # } /* end of compare error */ ! 457: 454 00026346 L272: ! 458: 455 00026346 # } while( index++ < max_ldf_1_index ); ! 459: 456 00026346 L268: ! 460: 457 00026346 L265: ! 461: 458 00026346 0d effffffcf0 50 movl _index,r0 ! 462: 459 0002634D 6d effffffce9 incl _index ! 463: 460 00026353 1d 50 effffffce2 cmpl r0,_max_ldf_1_index ! 464: 461 0002635A 81 03 13 ff3e jlss L266 ! 465: 462 0002635F L264: ! 466: 463 0002635F # } /* end of subtest 3 */ ! 467: 464 0002635F 40 ret#2 ! 468: 465 00026360 .set L260,0x0 ! 469: 466 00026360 L262: ! 470: 467 00026360 13 ff2e jbr L263 ! 471: 468 00026363 .data ! 472: 469 00000c00 * .text ! 473: 470 00026363 00 .align 1 ! 474: 471 00026364 .globl _pipe1_4 ! 475: 472 00026364 _pipe1_4: ! 476: 473 00026364 0000 .word L273 ! 477: 474 00026366 # ! 478: 475 00026366 # ! 479: 476 00026366 # ! 480: 477 00026366 # ! 481: 478 00026366 # ! 482: 479 00026366 # ! 483: 480 00026366 # /************************************************************************ ! 484: 481 00026366 # * ! 485: 482 00026366 # * SUBTEST 4 ! 486: 483 00026366 # * data in registers, 3 NO-OPs ! 487: 484 00026366 # * ! 488: 485 00026366 # ************************************************************************/ ! 489: 486 00026366 # pipe1_4() ! 490: 487 00026366 # { ! 491: 488 00026366 13 00d4 jbr L275 ! 492: 489 00026369 L276: ! 493: 490 00026369 # force_loop = FALSE; /* clear force_loop flag */ ! 494: 491 00026369 4d effffffccd clrl _force_loop ! 495: 492 0002636F # index = 0; ! 496: 493 0002636F 4d effffffcc7 clrl _index ! 497: 494 00026375 # do ! 498: 495 00026375 L279: ! 499: 496 00026375 # { ! 500: 497 00026375 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 501: 498 00026375 0d effffffcc1 50 movl _index,r0 ! 502: 499 0002637C 48 03 50 50 shll $3,r0,r0 ! 503: 500 00026380 0d e000000000 effffffcb1 movl _ldf_1_data(r0),_sgl_value_1 ! 504: 501 0002638B # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 505: 502 0002638B 0d effffffcab 50 movl _index,r0 ! 506: 503 00026392 48 03 50 50 shll $3,r0,r0 ! 507: 504 00026396 0d e000000004 effffffc9b movl _ldf_1_data+4(r0),_sgl_expected ! 508: 505 000263A1 # /* ! 509: 506 000263A1 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 510: 507 000263A1 # * The force loop flag is set after the first error. ! 511: 508 000263A1 # */ ! 512: 509 000263A1 # asm("_pipe1_4_lp1:"); ! 513: 510 000263A1 _pipe1_4_lp1: ! 514: 511 000263A1 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 515: 512 000263A1 0d effffffc95 54 movl _sgl_value_1,r4 ! 516: 513 000263A8 # asm("ldf r4"); /* load the operand */ ! 517: 514 000263A8 06 54 ldf r4 ! 518: 515 000263AA # asm("nop"); ! 519: 516 000263AA 10 nop ! 520: 517 000263AB # asm("nop"); ! 521: 518 000263AB 10 nop ! 522: 519 000263AC # asm("nop"); ! 523: 520 000263AC 10 nop ! 524: 521 000263AD # asm("subf r4"); /* subtract the data (2xs) */ ! 525: 522 000263AD d6 54 subf r4 ! 526: 523 000263AF # asm("nop"); ! 527: 524 000263AF 10 nop ! 528: 525 000263B0 # asm("nop"); ! 529: 526 000263B0 10 nop ! 530: 527 000263B1 # asm("nop"); ! 531: 528 000263B1 10 nop ! 532: 529 000263B2 # asm("subf r4"); ! 533: 530 000263B2 d6 54 subf r4 ! 534: 531 000263B4 # asm("nop"); ! 535: 532 000263B4 10 nop ! 536: 533 000263B5 # asm("nop"); ! 537: 534 000263B5 10 nop ! 538: 535 000263B6 # asm("nop"); ! 539: 536 000263B6 10 nop ! 540: 537 000263B7 # asm("addf r4"); /* add it back (2xs) */ ! 541: 538 000263B7 c6 54 addf r4 ! 542: 539 000263B9 # asm("nop"); ! 543: 540 000263B9 10 nop ! 544: 541 000263BA # asm("nop"); ! 545: 542 000263BA 10 nop ! 546: 543 000263BB # asm("nop"); ! 547: 544 000263BB 10 nop ! 548: 545 000263BC # asm("addf r4"); ! 549: 546 000263BC c6 54 addf r4 ! 550: 547 000263BE # asm("nop"); ! 551: 548 000263BE 10 nop ! 552: 549 000263BF # asm("nop"); ! 553: 550 000263BF 10 nop ! 554: 551 000263C0 # asm("nop"); ! 555: 552 000263C0 10 nop ! 556: 553 000263C1 # asm("stf r5"); /* store the result */ ! 557: 554 000263C1 26 55 stf r5 ! 558: 555 000263C3 # if ( force_loop ); ! 559: 556 000263C3 5d effffffc73 tstl _force_loop ! 560: 557 000263C9 31 00 jeql L280 ! 561: 558 000263CB # asm("brb _pipe1_4_lp1");; /* loop on the error */ ! 562: 559 000263CB L280: ! 563: 560 000263CB 11 d4 brb _pipe1_4_lp1 ! 564: 561 000263CD # /* ! 565: 562 000263CD # * verify the results ! 566: 563 000263CD # */ ! 567: 564 000263CD # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 568: 565 000263CD 0d 55 effffffc68 movl r5,_sgl_st_acc ! 569: 566 000263D4 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 570: 567 000263D4 1d effffffc62 effffffc5d cmpl _sgl_st_acc,_sgl_expected ! 571: 568 000263DF 31 42 jeql L281 ! 572: 569 000263E1 # { ! 573: 570 000263E1 # errcnt++; /* bump the error count */ ! 574: 571 000263E1 6d effffffc55 incl _errcnt ! 575: 572 000263E7 # if ( prt_error ) ! 576: 573 000263E7 5d effffffc4f tstl _prt_error ! 577: 574 000263ED 31 0d jeql L282 ! 578: 575 000263EF # print_pipe1_er("Reg. Data, 3 NO-OPs"); ! 579: 576 000263EF .data 1 ! 580: 577 00000c46 * L283: ! 581: 578 00000c46 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0" ! 582: 04E4F2D4F507300 ! 583: 579 00000c5a * .text ! 584: 580 000263EF dd 8f00000c46 pushl $L283 ! 585: 581 000263F5 fe 08 ef000006ce callf $8,_print_pipe1_er ! 586: 582 000263FC # if ( halt_flg ) /* halt on error? */ ! 587: 583 000263FC L282: ! 588: 584 000263FC 5d effffffc3a tstl _halt_flg ! 589: 585 00026402 31 0d jeql L284 ! 590: 586 00026404 # pipe1_er_hlt( subtest ); ! 591: 587 00026404 dd effffffc32 pushl _subtest ! 592: 588 0002640A fe 08 ef000007c5 callf $8,_pipe1_er_hlt ! 593: 589 00026411 # if ( loop_on_err ) { ! 594: 590 00026411 L284: ! 595: 591 00026411 5d effffffc25 tstl _loop_on_err ! 596: 592 00026417 31 0a jeql L285 ! 597: 593 00026419 # force_loop = TRUE; /* set the force loop flag */ ! 598: 594 00026419 0d 01 effffffc1c movl $1,_force_loop ! 599: 595 00026420 # asm("brw _pipe1_4_lp1"); /* and loop */ ! 600: 596 00026420 13 ff7e brw _pipe1_4_lp1 ! 601: 597 00026423 # } ! 602: 598 00026423 # } /* end of compare error */ ! 603: 599 00026423 L285: ! 604: 600 00026423 # } while( index++ < max_ldf_1_index ); ! 605: 601 00026423 L281: ! 606: 602 00026423 L278: ! 607: 603 00026423 0d effffffc13 50 movl _index,r0 ! 608: 604 0002642A 6d effffffc0c incl _index ! 609: 605 00026430 1d 50 effffffc05 cmpl r0,_max_ldf_1_index ! 610: 606 00026437 81 03 13 ff39 jlss L279 ! 611: 607 0002643C L277: ! 612: 608 0002643C # } /* end of subtest 4 */ ! 613: 609 0002643C 40 ret#2 ! 614: 610 0002643D .set L273,0x0 ! 615: 611 0002643D L275: ! 616: 612 0002643D 13 ff29 jbr L276 ! 617: 613 00026440 .data ! 618: 614 00000c00 * .text ! 619: 615 00026440 .align 1 ! 620: 616 00026440 .globl _pipe1_5 ! 621: 617 00026440 _pipe1_5: ! 622: 618 00026440 0000 .word L286 ! 623: 619 00026442 # ! 624: 620 00026442 # ! 625: 621 00026442 # ! 626: 622 00026442 # ! 627: 623 00026442 # ! 628: 624 00026442 # ! 629: 625 00026442 # ! 630: 626 00026442 # /************************************************************************ ! 631: 627 00026442 # * ! 632: 628 00026442 # * SUBTEST 5 ! 633: 629 00026442 # * data in Cache, no NO-OPs ! 634: 630 00026442 # * ! 635: 631 00026442 # ************************************************************************/ ! 636: 632 00026442 # pipe1_5() ! 637: 633 00026442 # { ! 638: 634 00026442 13 00cf jbr L288 ! 639: 635 00026445 L289: ! 640: 636 00026445 # force_loop = FALSE; /* clear force_loop flag */ ! 641: 637 00026445 4d effffffbf1 clrl _force_loop ! 642: 638 0002644B # index = 0; ! 643: 639 0002644B 4d effffffbeb clrl _index ! 644: 640 00026451 # do ! 645: 641 00026451 L292: ! 646: 642 00026451 # { ! 647: 643 00026451 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 648: 644 00026451 0d effffffbe5 50 movl _index,r0 ! 649: 645 00026458 48 03 50 50 shll $3,r0,r0 ! 650: 646 0002645C 0d e000000000 effffffbd5 movl _ldf_1_data(r0),_sgl_value_1 ! 651: 647 00026467 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 652: 648 00026467 0d effffffbcf 50 movl _index,r0 ! 653: 649 0002646E 48 03 50 50 shll $3,r0,r0 ! 654: 650 00026472 0d e000000004 effffffbbf movl _ldf_1_data+4(r0),_sgl_expected ! 655: 651 0002647D # /* ! 656: 652 0002647D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 657: 653 0002647D # * The force loop flag is set after the first error. ! 658: 654 0002647D # */ ! 659: 655 0002647D # asm("_pipe1_5_lp1:"); ! 660: 656 0002647D _pipe1_5_lp1: ! 661: 657 0002647D # asm("ldf _sgl_value_1"); /* load the operand */ ! 662: 658 0002647D 06 effffffbb9 ldf _sgl_value_1 ! 663: 659 00026483 # asm("subf _sgl_value_1"); /* subtract it (twice) */ ! 664: 660 00026483 d6 effffffbb3 subf _sgl_value_1 ! 665: 661 00026489 # asm("subf _sgl_value_1"); ! 666: 662 00026489 d6 effffffbad subf _sgl_value_1 ! 667: 663 0002648F # asm("addf _sgl_value_1"); /* add it back (twice) */ ! 668: 664 0002648F c6 effffffba7 addf _sgl_value_1 ! 669: 665 00026495 # asm("addf _sgl_value_1"); ! 670: 666 00026495 c6 effffffba1 addf _sgl_value_1 ! 671: 667 0002649B # asm("stf _sgl_st_acc"); /* store the result */ ! 672: 668 0002649B 26 effffffb9b stf _sgl_st_acc ! 673: 669 000264A1 # if ( force_loop ); ! 674: 670 000264A1 5d effffffb95 tstl _force_loop ! 675: 671 000264A7 31 00 jeql L293 ! 676: 672 000264A9 # asm("brb _pipe1_5_lp1");; /* loop on the error */ ! 677: 673 000264A9 L293: ! 678: 674 000264A9 11 d2 brb _pipe1_5_lp1 ! 679: 675 000264AB # /* ! 680: 676 000264AB # * verify the results ! 681: 677 000264AB # */ ! 682: 678 000264AB # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 683: 679 000264AB 1d effffffb8b effffffb86 cmpl _sgl_st_acc,_sgl_expected ! 684: 680 000264B6 31 42 jeql L294 ! 685: 681 000264B8 # { ! 686: 682 000264B8 # errcnt++; /* bump the error count */ ! 687: 683 000264B8 6d effffffb7e incl _errcnt ! 688: 684 000264BE # if ( prt_error ) ! 689: 685 000264BE 5d effffffb78 tstl _prt_error ! 690: 686 000264C4 31 0d jeql L295 ! 691: 687 000264C6 # print_pipe1_er("Cache Data, no NO-OPs"); ! 692: 688 000264C6 .data 1 ! 693: 689 00000c5a * L296: ! 694: 690 00000c5a * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0" ! 695: E6F204E4F2D4F507300 ! 696: 691 00000c70 * .text ! 697: 692 000264C6 dd 8f00000c5a pushl $L296 ! 698: 693 000264CC fe 08 ef000005f7 callf $8,_print_pipe1_er ! 699: 694 000264D3 # if ( halt_flg ) /* halt on error? */ ! 700: 695 000264D3 L295: ! 701: 696 000264D3 5d effffffb63 tstl _halt_flg ! 702: 697 000264D9 31 0d jeql L297 ! 703: 698 000264DB # pipe1_er_hlt( subtest ); ! 704: 699 000264DB dd effffffb5b pushl _subtest ! 705: 700 000264E1 fe 08 ef000006ee callf $8,_pipe1_er_hlt ! 706: 701 000264E8 # if ( loop_on_err ) { ! 707: 702 000264E8 L297: ! 708: 703 000264E8 5d effffffb4e tstl _loop_on_err ! 709: 704 000264EE 31 0a jeql L298 ! 710: 705 000264F0 # force_loop = TRUE; /* set the force loop flag */ ! 711: 706 000264F0 0d 01 effffffb45 movl $1,_force_loop ! 712: 707 000264F7 # asm("brw _pipe1_5_lp1"); /* and loop */ ! 713: 708 000264F7 13 ff83 brw _pipe1_5_lp1 ! 714: 709 000264FA # } ! 715: 710 000264FA # } /* end of compare error */ ! 716: 711 000264FA L298: ! 717: 712 000264FA # } while( index++ < max_ldf_1_index ); ! 718: 713 000264FA L294: ! 719: 714 000264FA L291: ! 720: 715 000264FA 0d effffffb3c 50 movl _index,r0 ! 721: 716 00026501 6d effffffb35 incl _index ! 722: 717 00026507 1d 50 effffffb2e cmpl r0,_max_ldf_1_index ! 723: 718 0002650E 81 03 13 ff3e jlss L292 ! 724: 719 00026513 L290: ! 725: 720 00026513 # } /* end of subtest 5 */ ! 726: 721 00026513 40 ret#2 ! 727: 722 00026514 .set L286,0x0 ! 728: 723 00026514 L288: ! 729: 724 00026514 13 ff2e jbr L289 ! 730: 725 00026517 .data ! 731: 726 00000c00 * .text ! 732: 727 00026517 00 .align 1 ! 733: 728 00026518 .globl _pipe1_6 ! 734: 729 00026518 _pipe1_6: ! 735: 730 00026518 0000 .word L299 ! 736: 731 0002651A # ! 737: 732 0002651A # ! 738: 733 0002651A # ! 739: 734 0002651A # ! 740: 735 0002651A # ! 741: 736 0002651A # ! 742: 737 0002651A # /************************************************************************ ! 743: 738 0002651A # * ! 744: 739 0002651A # * SUBTEST 6 ! 745: 740 0002651A # * data in Cache, 1 NO-OP ! 746: 741 0002651A # * ! 747: 742 0002651A # ************************************************************************/ ! 748: 743 0002651A # pipe1_6() ! 749: 744 0002651A # { ! 750: 745 0002651A 13 00d4 jbr L301 ! 751: 746 0002651D L302: ! 752: 747 0002651D # force_loop = FALSE; /* clear force_loop flag */ ! 753: 748 0002651D 4d effffffb19 clrl _force_loop ! 754: 749 00026523 # index = 0; ! 755: 750 00026523 4d effffffb13 clrl _index ! 756: 751 00026529 # do ! 757: 752 00026529 L305: ! 758: 753 00026529 # { ! 759: 754 00026529 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 760: 755 00026529 0d effffffb0d 50 movl _index,r0 ! 761: 756 00026530 48 03 50 50 shll $3,r0,r0 ! 762: 757 00026534 0d e000000000 effffffafd movl _ldf_1_data(r0),_sgl_value_1 ! 763: 758 0002653F # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 764: 759 0002653F 0d effffffaf7 50 movl _index,r0 ! 765: 760 00026546 48 03 50 50 shll $3,r0,r0 ! 766: 761 0002654A 0d e000000004 effffffae7 movl _ldf_1_data+4(r0),_sgl_expected ! 767: 762 00026555 # /* ! 768: 763 00026555 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 769: 764 00026555 # * The force loop flag is set after the first error. ! 770: 765 00026555 # */ ! 771: 766 00026555 # asm("_pipe1_6_lp1:"); ! 772: 767 00026555 _pipe1_6_lp1: ! 773: 768 00026555 # asm("ldf _sgl_value_1"); /* load the operand */ ! 774: 769 00026555 06 effffffae1 ldf _sgl_value_1 ! 775: 770 0002655B # asm("nop"); ! 776: 771 0002655B 10 nop ! 777: 772 0002655C # asm("subf _sgl_value_1"); /* subtract it (twice) */ ! 778: 773 0002655C d6 effffffada subf _sgl_value_1 ! 779: 774 00026562 # asm("nop"); ! 780: 775 00026562 10 nop ! 781: 776 00026563 # asm("subf _sgl_value_1"); ! 782: 777 00026563 d6 effffffad3 subf _sgl_value_1 ! 783: 778 00026569 # asm("nop"); ! 784: 779 00026569 10 nop ! 785: 780 0002656A # asm("addf _sgl_value_1"); /* add it back (twice) */ ! 786: 781 0002656A c6 effffffacc addf _sgl_value_1 ! 787: 782 00026570 # asm("nop"); ! 788: 783 00026570 10 nop ! 789: 784 00026571 # asm("addf _sgl_value_1"); ! 790: 785 00026571 c6 effffffac5 addf _sgl_value_1 ! 791: 786 00026577 # asm("nop"); ! 792: 787 00026577 10 nop ! 793: 788 00026578 # asm("stf _sgl_st_acc"); /* store the result */ ! 794: 789 00026578 26 effffffabe stf _sgl_st_acc ! 795: 790 0002657E # if ( force_loop ); ! 796: 791 0002657E 5d effffffab8 tstl _force_loop ! 797: 792 00026584 31 00 jeql L306 ! 798: 793 00026586 # asm("brb _pipe1_6_lp1");; /* loop on the error */ ! 799: 794 00026586 L306: ! 800: 795 00026586 11 cd brb _pipe1_6_lp1 ! 801: 796 00026588 # /* ! 802: 797 00026588 # * verify the results ! 803: 798 00026588 # */ ! 804: 799 00026588 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 805: 800 00026588 1d effffffaae effffffaa9 cmpl _sgl_st_acc,_sgl_expected ! 806: 801 00026593 31 42 jeql L307 ! 807: 802 00026595 # { ! 808: 803 00026595 # errcnt++; /* bump the error count */ ! 809: 804 00026595 6d effffffaa1 incl _errcnt ! 810: 805 0002659B # if ( prt_error ) ! 811: 806 0002659B 5d effffffa9b tstl _prt_error ! 812: 807 000265A1 31 0d jeql L308 ! 813: 808 000265A3 # print_pipe1_er("Cache Data, 1 NO-OP"); ! 814: 809 000265A3 .data 1 ! 815: 810 00000c70 * L309: ! 816: 811 00000c70 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0" ! 817: 1204E4F2D4F5000 ! 818: 812 00000c84 * .text ! 819: 813 000265A3 dd 8f00000c70 pushl $L309 ! 820: 814 000265A9 fe 08 ef0000051a callf $8,_print_pipe1_er ! 821: 815 000265B0 # if ( halt_flg ) /* halt on error? */ ! 822: 816 000265B0 L308: ! 823: 817 000265B0 5d effffffa86 tstl _halt_flg ! 824: 818 000265B6 31 0d jeql L310 ! 825: 819 000265B8 # pipe1_er_hlt( subtest ); ! 826: 820 000265B8 dd effffffa7e pushl _subtest ! 827: 821 000265BE fe 08 ef00000611 callf $8,_pipe1_er_hlt ! 828: 822 000265C5 # if ( loop_on_err ) { ! 829: 823 000265C5 L310: ! 830: 824 000265C5 5d effffffa71 tstl _loop_on_err ! 831: 825 000265CB 31 0a jeql L311 ! 832: 826 000265CD # force_loop = TRUE; /* set the force loop flag */ ! 833: 827 000265CD 0d 01 effffffa68 movl $1,_force_loop ! 834: 828 000265D4 # asm("brw _pipe1_6_lp1"); /* and loop */ ! 835: 829 000265D4 13 ff7e brw _pipe1_6_lp1 ! 836: 830 000265D7 # } ! 837: 831 000265D7 # } /* end of compare error */ ! 838: 832 000265D7 L311: ! 839: 833 000265D7 # } while( index++ < max_ldf_1_index ); ! 840: 834 000265D7 L307: ! 841: 835 000265D7 L304: ! 842: 836 000265D7 0d effffffa5f 50 movl _index,r0 ! 843: 837 000265DE 6d effffffa58 incl _index ! 844: 838 000265E4 1d 50 effffffa51 cmpl r0,_max_ldf_1_index ! 845: 839 000265EB 81 03 13 ff39 jlss L305 ! 846: 840 000265F0 L303: ! 847: 841 000265F0 # } /* end of subtest 6 */ ! 848: 842 000265F0 40 ret#2 ! 849: 843 000265F1 .set L299,0x0 ! 850: 844 000265F1 L301: ! 851: 845 000265F1 13 ff29 jbr L302 ! 852: 846 000265F4 .data ! 853: 847 00000c00 * .text ! 854: 848 000265F4 .align 1 ! 855: 849 000265F4 .globl _pipe1_7 ! 856: 850 000265F4 _pipe1_7: ! 857: 851 000265F4 0000 .word L312 ! 858: 852 000265F6 # ! 859: 853 000265F6 # ! 860: 854 000265F6 # ! 861: 855 000265F6 # ! 862: 856 000265F6 # ! 863: 857 000265F6 # ! 864: 858 000265F6 # /************************************************************************ ! 865: 859 000265F6 # * ! 866: 860 000265F6 # * SUBTEST 7 ! 867: 861 000265F6 # * data in Cache, 2 NO-OPs ! 868: 862 000265F6 # * ! 869: 863 000265F6 # ************************************************************************/ ! 870: 864 000265F6 # pipe1_7() ! 871: 865 000265F6 # { ! 872: 866 000265F6 13 00d9 jbr L314 ! 873: 867 000265F9 L315: ! 874: 868 000265F9 # force_loop = FALSE; /* clear force_loop flag */ ! 875: 869 000265F9 4d effffffa3d clrl _force_loop ! 876: 870 000265FF # index = 0; ! 877: 871 000265FF 4d effffffa37 clrl _index ! 878: 872 00026605 # do ! 879: 873 00026605 L318: ! 880: 874 00026605 # { ! 881: 875 00026605 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 882: 876 00026605 0d effffffa31 50 movl _index,r0 ! 883: 877 0002660C 48 03 50 50 shll $3,r0,r0 ! 884: 878 00026610 0d e000000000 effffffa21 movl _ldf_1_data(r0),_sgl_value_1 ! 885: 879 0002661B # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 886: 880 0002661B 0d effffffa1b 50 movl _index,r0 ! 887: 881 00026622 48 03 50 50 shll $3,r0,r0 ! 888: 882 00026626 0d e000000004 effffffa0b movl _ldf_1_data+4(r0),_sgl_expected ! 889: 883 00026631 # /* ! 890: 884 00026631 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 891: 885 00026631 # * The force loop flag is set after the first error. ! 892: 886 00026631 # */ ! 893: 887 00026631 # asm("_pipe1_7_lp1:"); ! 894: 888 00026631 _pipe1_7_lp1: ! 895: 889 00026631 # asm("ldf _sgl_value_1"); /* load the operand */ ! 896: 890 00026631 06 effffffa05 ldf _sgl_value_1 ! 897: 891 00026637 # asm("nop"); ! 898: 892 00026637 10 nop ! 899: 893 00026638 # asm("nop"); ! 900: 894 00026638 10 nop ! 901: 895 00026639 # asm("subf _sgl_value_1"); /* subtract it (twice) */ ! 902: 896 00026639 d6 effffff9fd subf _sgl_value_1 ! 903: 897 0002663F # asm("nop"); ! 904: 898 0002663F 10 nop ! 905: 899 00026640 # asm("nop"); ! 906: 900 00026640 10 nop ! 907: 901 00026641 # asm("subf _sgl_value_1"); ! 908: 902 00026641 d6 effffff9f5 subf _sgl_value_1 ! 909: 903 00026647 # asm("nop"); ! 910: 904 00026647 10 nop ! 911: 905 00026648 # asm("nop"); ! 912: 906 00026648 10 nop ! 913: 907 00026649 # asm("addf _sgl_value_1"); /* add it back (twice) */ ! 914: 908 00026649 c6 effffff9ed addf _sgl_value_1 ! 915: 909 0002664F # asm("nop"); ! 916: 910 0002664F 10 nop ! 917: 911 00026650 # asm("nop"); ! 918: 912 00026650 10 nop ! 919: 913 00026651 # asm("addf _sgl_value_1"); ! 920: 914 00026651 c6 effffff9e5 addf _sgl_value_1 ! 921: 915 00026657 # asm("nop"); ! 922: 916 00026657 10 nop ! 923: 917 00026658 # asm("nop"); ! 924: 918 00026658 10 nop ! 925: 919 00026659 # asm("stf _sgl_st_acc"); /* store the result */ ! 926: 920 00026659 26 effffff9dd stf _sgl_st_acc ! 927: 921 0002665F # if ( force_loop ); ! 928: 922 0002665F 5d effffff9d7 tstl _force_loop ! 929: 923 00026665 31 00 jeql L319 ! 930: 924 00026667 # asm("brb _pipe1_7_lp1");; /* loop on the error */ ! 931: 925 00026667 L319: ! 932: 926 00026667 11 c8 brb _pipe1_7_lp1 ! 933: 927 00026669 # /* ! 934: 928 00026669 # * verify the results ! 935: 929 00026669 # */ ! 936: 930 00026669 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 937: 931 00026669 1d effffff9cd effffff9c8 cmpl _sgl_st_acc,_sgl_expected ! 938: 932 00026674 31 42 jeql L320 ! 939: 933 00026676 # { ! 940: 934 00026676 # errcnt++; /* bump the error count */ ! 941: 935 00026676 6d effffff9c0 incl _errcnt ! 942: 936 0002667C # if ( prt_error ) ! 943: 937 0002667C 5d effffff9ba tstl _prt_error ! 944: 938 00026682 31 0d jeql L321 ! 945: 939 00026684 # print_pipe1_er("Cache Data, 2 NO-OPs"); ! 946: 940 00026684 .data 1 ! 947: 941 00000c84 * L322: ! 948: 942 00000c84 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0" ! 949: 2204E4F2D4F507300 ! 950: 943 00000c99 * .text ! 951: 944 00026684 dd 8f00000c84 pushl $L322 ! 952: 945 0002668A fe 08 ef00000439 callf $8,_print_pipe1_er ! 953: 946 00026691 # if ( halt_flg ) /* halt on error? */ ! 954: 947 00026691 L321: ! 955: 948 00026691 5d effffff9a5 tstl _halt_flg ! 956: 949 00026697 31 0d jeql L323 ! 957: 950 00026699 # pipe1_er_hlt( subtest ); ! 958: 951 00026699 dd effffff99d pushl _subtest ! 959: 952 0002669F fe 08 ef00000530 callf $8,_pipe1_er_hlt ! 960: 953 000266A6 # if ( loop_on_err ) { ! 961: 954 000266A6 L323: ! 962: 955 000266A6 5d effffff990 tstl _loop_on_err ! 963: 956 000266AC 31 0a jeql L324 ! 964: 957 000266AE # force_loop = TRUE; /* set the force loop flag */ ! 965: 958 000266AE 0d 01 effffff987 movl $1,_force_loop ! 966: 959 000266B5 # asm("brw _pipe1_7_lp1"); /* and loop */ ! 967: 960 000266B5 13 ff79 brw _pipe1_7_lp1 ! 968: 961 000266B8 # } ! 969: 962 000266B8 # } /* end of compare error */ ! 970: 963 000266B8 L324: ! 971: 964 000266B8 # } while( index++ < max_ldf_1_index ); ! 972: 965 000266B8 L320: ! 973: 966 000266B8 L317: ! 974: 967 000266B8 0d effffff97e 50 movl _index,r0 ! 975: 968 000266BF 6d effffff977 incl _index ! 976: 969 000266C5 1d 50 effffff970 cmpl r0,_max_ldf_1_index ! 977: 970 000266CC 81 03 13 ff34 jlss L318 ! 978: 971 000266D1 L316: ! 979: 972 000266D1 # } /* end of subtest 7 */ ! 980: 973 000266D1 40 ret#2 ! 981: 974 000266D2 .set L312,0x0 ! 982: 975 000266D2 L314: ! 983: 976 000266D2 13 ff24 jbr L315 ! 984: 977 000266D5 .data ! 985: 978 00000c00 * .text ! 986: 979 000266D5 00 .align 1 ! 987: 980 000266D6 .globl _pipe1_8 ! 988: 981 000266D6 _pipe1_8: ! 989: 982 000266D6 0000 .word L325 ! 990: 983 000266D8 # ! 991: 984 000266D8 # ! 992: 985 000266D8 # ! 993: 986 000266D8 # ! 994: 987 000266D8 # ! 995: 988 000266D8 # ! 996: 989 000266D8 # /************************************************************************ ! 997: 990 000266D8 # * ! 998: 991 000266D8 # * SUBTEST 8 ! 999: 992 000266D8 # * data in Cache, 3 NO-OPs ! 1000: 993 000266D8 # * ! 1001: 994 000266D8 # ************************************************************************/ ! 1002: 995 000266D8 # pipe1_8() ! 1003: 996 000266D8 # { ! 1004: 997 000266D8 13 00de jbr L327 ! 1005: 998 000266DB L328: ! 1006: 999 000266DB # force_loop = FALSE; /* clear force_loop flag */ ! 1007: 1000 000266DB 4d effffff95b clrl _force_loop ! 1008: 1001 000266E1 # index = 0; ! 1009: 1002 000266E1 4d effffff955 clrl _index ! 1010: 1003 000266E7 # do ! 1011: 1004 000266E7 L331: ! 1012: 1005 000266E7 # { ! 1013: 1006 000266E7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1014: 1007 000266E7 0d effffff94f 50 movl _index,r0 ! 1015: 1008 000266EE 48 03 50 50 shll $3,r0,r0 ! 1016: 1009 000266F2 0d e000000000 effffff93f movl _ldf_1_data(r0),_sgl_value_1 ! 1017: 1010 000266FD # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1018: 1011 000266FD 0d effffff939 50 movl _index,r0 ! 1019: 1012 00026704 48 03 50 50 shll $3,r0,r0 ! 1020: 1013 00026708 0d e000000004 effffff929 movl _ldf_1_data+4(r0),_sgl_expected ! 1021: 1014 00026713 # /* ! 1022: 1015 00026713 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1023: 1016 00026713 # * The force loop flag is set after the first error. ! 1024: 1017 00026713 # */ ! 1025: 1018 00026713 # asm("_pipe1_8_lp1:"); ! 1026: 1019 00026713 _pipe1_8_lp1: ! 1027: 1020 00026713 # asm("ldf _sgl_value_1"); /* load the operand */ ! 1028: 1021 00026713 06 effffff923 ldf _sgl_value_1 ! 1029: 1022 00026719 # asm("nop"); ! 1030: 1023 00026719 10 nop ! 1031: 1024 0002671A # asm("nop"); ! 1032: 1025 0002671A 10 nop ! 1033: 1026 0002671B # asm("nop"); ! 1034: 1027 0002671B 10 nop ! 1035: 1028 0002671C # asm("subf _sgl_value_1"); /* subtract it (twice) */ ! 1036: 1029 0002671C d6 effffff91a subf _sgl_value_1 ! 1037: 1030 00026722 # asm("nop"); ! 1038: 1031 00026722 10 nop ! 1039: 1032 00026723 # asm("nop"); ! 1040: 1033 00026723 10 nop ! 1041: 1034 00026724 # asm("nop"); ! 1042: 1035 00026724 10 nop ! 1043: 1036 00026725 # asm("subf _sgl_value_1"); ! 1044: 1037 00026725 d6 effffff911 subf _sgl_value_1 ! 1045: 1038 0002672B # asm("nop"); ! 1046: 1039 0002672B 10 nop ! 1047: 1040 0002672C # asm("nop"); ! 1048: 1041 0002672C 10 nop ! 1049: 1042 0002672D # asm("nop"); ! 1050: 1043 0002672D 10 nop ! 1051: 1044 0002672E # asm("addf _sgl_value_1"); /* add it back (twice) */ ! 1052: 1045 0002672E c6 effffff908 addf _sgl_value_1 ! 1053: 1046 00026734 # asm("nop"); ! 1054: 1047 00026734 10 nop ! 1055: 1048 00026735 # asm("nop"); ! 1056: 1049 00026735 10 nop ! 1057: 1050 00026736 # asm("nop"); ! 1058: 1051 00026736 10 nop ! 1059: 1052 00026737 # asm("addf _sgl_value_1"); ! 1060: 1053 00026737 c6 effffff8ff addf _sgl_value_1 ! 1061: 1054 0002673D # asm("nop"); ! 1062: 1055 0002673D 10 nop ! 1063: 1056 0002673E # asm("nop"); ! 1064: 1057 0002673E 10 nop ! 1065: 1058 0002673F # asm("nop"); ! 1066: 1059 0002673F 10 nop ! 1067: 1060 00026740 # asm("stf _sgl_st_acc"); /* store the result */ ! 1068: 1061 00026740 26 effffff8f6 stf _sgl_st_acc ! 1069: 1062 00026746 # if ( force_loop ); ! 1070: 1063 00026746 5d effffff8f0 tstl _force_loop ! 1071: 1064 0002674C 31 00 jeql L332 ! 1072: 1065 0002674E # asm("brb _pipe1_8_lp1");; /* loop on the error */ ! 1073: 1066 0002674E L332: ! 1074: 1067 0002674E 11 c3 brb _pipe1_8_lp1 ! 1075: 1068 00026750 # /* ! 1076: 1069 00026750 # * verify the results ! 1077: 1070 00026750 # */ ! 1078: 1071 00026750 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 1079: 1072 00026750 1d effffff8e6 effffff8e1 cmpl _sgl_st_acc,_sgl_expected ! 1080: 1073 0002675B 31 42 jeql L333 ! 1081: 1074 0002675D # { ! 1082: 1075 0002675D # errcnt++; /* bump the error count */ ! 1083: 1076 0002675D 6d effffff8d9 incl _errcnt ! 1084: 1077 00026763 # if ( prt_error ) ! 1085: 1078 00026763 5d effffff8d3 tstl _prt_error ! 1086: 1079 00026769 31 0d jeql L334 ! 1087: 1080 0002676B # print_pipe1_er("Cache Data, 3 NO-OPs"); ! 1088: 1081 0002676B .data 1 ! 1089: 1082 00000c99 * L335: ! 1090: 1083 00000c99 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0" ! 1091: 3204E4F2D4F507300 ! 1092: 1084 00000cae * .text ! 1093: 1085 0002676B dd 8f00000c99 pushl $L335 ! 1094: 1086 00026771 fe 08 ef00000352 callf $8,_print_pipe1_er ! 1095: 1087 00026778 # if ( halt_flg ) /* halt on error? */ ! 1096: 1088 00026778 L334: ! 1097: 1089 00026778 5d effffff8be tstl _halt_flg ! 1098: 1090 0002677E 31 0d jeql L336 ! 1099: 1091 00026780 # pipe1_er_hlt( subtest ); ! 1100: 1092 00026780 dd effffff8b6 pushl _subtest ! 1101: 1093 00026786 fe 08 ef00000449 callf $8,_pipe1_er_hlt ! 1102: 1094 0002678D # if ( loop_on_err ) { ! 1103: 1095 0002678D L336: ! 1104: 1096 0002678D 5d effffff8a9 tstl _loop_on_err ! 1105: 1097 00026793 31 0a jeql L337 ! 1106: 1098 00026795 # force_loop = TRUE; /* set the force loop flag */ ! 1107: 1099 00026795 0d 01 effffff8a0 movl $1,_force_loop ! 1108: 1100 0002679C # asm("brw _pipe1_8_lp1"); /* and loop */ ! 1109: 1101 0002679C 13 ff74 brw _pipe1_8_lp1 ! 1110: 1102 0002679F # } ! 1111: 1103 0002679F # } /* end of compare error */ ! 1112: 1104 0002679F L337: ! 1113: 1105 0002679F # } while( index++ < max_ldf_1_index ); ! 1114: 1106 0002679F L333: ! 1115: 1107 0002679F L330: ! 1116: 1108 0002679F 0d effffff897 50 movl _index,r0 ! 1117: 1109 000267A6 6d effffff890 incl _index ! 1118: 1110 000267AC 1d 50 effffff889 cmpl r0,_max_ldf_1_index ! 1119: 1111 000267B3 81 03 13 ff2f jlss L331 ! 1120: 1112 000267B8 L329: ! 1121: 1113 000267B8 # } /* end of subtest 8 */ ! 1122: 1114 000267B8 40 ret#2 ! 1123: 1115 000267B9 .set L325,0x0 ! 1124: 1116 000267B9 L327: ! 1125: 1117 000267B9 13 ff1f jbr L328 ! 1126: 1118 000267BC .data ! 1127: 1119 00000c00 * .text ! 1128: 1120 000267BC .align 1 ! 1129: 1121 000267BC .globl _pipe1_9 ! 1130: 1122 000267BC _pipe1_9: ! 1131: 1123 000267BC 0000 .word L338 ! 1132: 1124 000267BE # ! 1133: 1125 000267BE # ! 1134: 1126 000267BE # ! 1135: 1127 000267BE # ! 1136: 1128 000267BE # ! 1137: 1129 000267BE # ! 1138: 1130 000267BE # /***************************************************************************** ! 1139: 1131 000267BE # * ! 1140: 1132 000267BE # * SUBTEST 9 ! 1141: 1133 000267BE # * data on the stack, no NO-OPs ! 1142: 1134 000267BE # * ! 1143: 1135 000267BE # *****************************************************************************/ ! 1144: 1136 000267BE # pipe1_9() ! 1145: 1137 000267BE # { ! 1146: 1138 000267BE 13 0175 jbr L340 ! 1147: 1139 000267C1 L341: ! 1148: 1140 000267C1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1149: 1141 000267C1 ed 6d effffff874 moval (r13),_pre_event_fp ! 1150: 1142 000267C8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1151: 1143 000267C8 ed 6e effffff86d moval (r14),_pre_event_sp ! 1152: 1144 000267CF # force_loop = FALSE; /* clear force_loop flag */ ! 1153: 1145 000267CF 4d effffff867 clrl _force_loop ! 1154: 1146 000267D5 # index = 0; ! 1155: 1147 000267D5 4d effffff861 clrl _index ! 1156: 1148 000267DB # do ! 1157: 1149 000267DB L344: ! 1158: 1150 000267DB # { ! 1159: 1151 000267DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1160: 1152 000267DB 0d effffff85b 50 movl _index,r0 ! 1161: 1153 000267E2 48 03 50 50 shll $3,r0,r0 ! 1162: 1154 000267E6 0d e000000000 effffff84b movl _ldf_1_data(r0),_sgl_value_1 ! 1163: 1155 000267F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1164: 1156 000267F1 0d effffff845 50 movl _index,r0 ! 1165: 1157 000267F8 48 03 50 50 shll $3,r0,r0 ! 1166: 1158 000267FC 0d e000000004 effffff835 movl _ldf_1_data+4(r0),_sgl_expected ! 1167: 1159 00026807 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */ ! 1168: 1160 00026807 ed effffff82f effffff82a moval _pointer_data,_sgl_value_2 ! 1169: 1161 00026812 # /* ! 1170: 1162 00026812 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1171: 1163 00026812 # * The force loop flag is set after the first error. ! 1172: 1164 00026812 # */ ! 1173: 1165 00026812 # asm("_pipe1_9_lp1:"); ! 1174: 1166 00026812 _pipe1_9_lp1: ! 1175: 1167 00026812 # asm("moval _pointer_data,r14"); /* set the stack pointer */ ! 1176: 1168 00026812 ed effffff824 5e moval _pointer_data,r14 ! 1177: 1169 00026819 # asm("movl _sgl_value_1,-(r14)"); /* push the operand 5 times */ ! 1178: 1170 00026819 0d effffff81d 7e movl _sgl_value_1,-(r14) ! 1179: 1171 00026820 # asm("movl _sgl_value_1,-(r14)"); ! 1180: 1172 00026820 0d effffff816 7e movl _sgl_value_1,-(r14) ! 1181: 1173 00026827 # asm("movl _sgl_value_1,-(r14)"); ! 1182: 1174 00026827 0d effffff80f 7e movl _sgl_value_1,-(r14) ! 1183: 1175 0002682E # asm("movl _sgl_value_1,-(r14)"); ! 1184: 1176 0002682E 0d effffff808 7e movl _sgl_value_1,-(r14) ! 1185: 1177 00026835 # asm("movl _sgl_value_1,-(r14)"); ! 1186: 1178 00026835 0d effffff801 7e movl _sgl_value_1,-(r14) ! 1187: 1179 0002683C # /* ! 1188: 1180 0002683C # * now pop the data off the stack ! 1189: 1181 0002683C # */ ! 1190: 1182 0002683C # asm("ldf (r14)+"); /* pop the data & load it */ ! 1191: 1183 0002683C 06 8e ldf (r14)+ ! 1192: 1184 0002683E # asm("subf (r14)+"); /* subtract it (twice) */ ! 1193: 1185 0002683E d6 8e subf (r14)+ ! 1194: 1186 00026840 # asm("subf (r14)+"); ! 1195: 1187 00026840 d6 8e subf (r14)+ ! 1196: 1188 00026842 # asm("addf (r14)+"); /* add it back (twice) */ ! 1197: 1189 00026842 c6 8e addf (r14)+ ! 1198: 1190 00026844 # asm("addf (r14)+"); ! 1199: 1191 00026844 c6 8e addf (r14)+ ! 1200: 1192 00026846 # asm("stf r5"); /* store the result */ ! 1201: 1193 00026846 26 55 stf r5 ! 1202: 1194 00026848 # if ( force_loop ); ! 1203: 1195 00026848 5d effffff7ee tstl _force_loop ! 1204: 1196 0002684E 31 00 jeql L345 ! 1205: 1197 00026850 # asm("brb _pipe1_9_lp1");; /* loop on the error */ ! 1206: 1198 00026850 L345: ! 1207: 1199 00026850 11 c0 brb _pipe1_9_lp1 ! 1208: 1200 00026852 # /* ! 1209: 1201 00026852 # * verify the results ! 1210: 1202 00026852 # */ ! 1211: 1203 00026852 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 1212: 1204 00026852 0d 55 effffff7e3 movl r5,_sgl_st_acc ! 1213: 1205 00026859 # asm("moval (r14),_sgl_value_3"); /* save the stack pointer */ ! 1214: 1206 00026859 ed 6e effffff7dc moval (r14),_sgl_value_3 ! 1215: 1207 00026860 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */ ! 1216: 1208 00026860 # (sgl_value_3 != sgl_value_2) ) /* ... and the final SP */ ! 1217: 1209 00026860 1d effffff7d6 effffff7d1 cmpl _sgl_st_acc,_sgl_expected ! 1218: 1210 0002686B 21 10 jneq L9999 ! 1219: 1211 0002686D 1d effffff7c9 effffff7c4 cmpl _sgl_value_3,_sgl_value_2 ! 1220: 1212 00026878 21 03 13 0091 jeql L346 ! 1221: 1213 0002687D L9999: ! 1222: 1214 0002687D # { ! 1223: 1215 0002687D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1224: 1216 0002687D 0d effffff7b9 5d movl _pre_event_fp,r13 ! 1225: 1217 00026884 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1226: 1218 00026884 0d effffff7b2 5e movl _pre_event_sp,r14 ! 1227: 1219 0002688B # errcnt++; /* bump the error count */ ! 1228: 1220 0002688B 6d effffff7ab incl _errcnt ! 1229: 1221 00026891 # if ( prt_error ) { ! 1230: 1222 00026891 5d effffff7a5 tstl _prt_error ! 1231: 1223 00026897 31 4e jeql L347 ! 1232: 1224 00026899 # print_pipe1_er("POP data from the SP"); ! 1233: 1225 00026899 .data 1 ! 1234: 1226 00000cae * L348: ! 1235: 1227 00000cae * 504F5020646174612066726F6 .ascii "POP data from the SP\0" ! 1236: D2074686520535000 ! 1237: 1228 00000cc3 * .text ! 1238: 1229 00026899 dd 8f00000cae pushl $L348 ! 1239: 1230 0002689F fe 08 ef00000224 callf $8,_print_pipe1_er ! 1240: 1231 000268A6 # writes("final Stack Pointer = "); ! 1241: 1232 000268A6 .data 1 ! 1242: 1233 00000cc3 * L349: ! 1243: 1234 00000cc3 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0" ! 1244: 06F696E746572203D2000 ! 1245: 1235 00000cda * .text ! 1246: 1236 000268A6 dd 8f00000cc3 pushl $L349 ! 1247: 1237 000268AC fe 08 effffff789 callf $8,_writes ! 1248: 1238 000268B3 # write32h( sgl_value_3 ); ! 1249: 1239 000268B3 dd effffff783 pushl _sgl_value_3 ! 1250: 1240 000268B9 fe 08 effffff77c callf $8,_write32h ! 1251: 1241 000268C0 # writes(", expected SP = "); ! 1252: 1242 000268C0 .data 1 ! 1253: 1243 00000cda * L351: ! 1254: 1244 00000cda * 2C20206578706563746564205 .ascii ", expected SP = \0" ! 1255: 350203D2000 ! 1256: 1245 00000cec * .text ! 1257: 1246 000268C0 dd 8f00000cda pushl $L351 ! 1258: 1247 000268C6 fe 08 effffff76f callf $8,_writes ! 1259: 1248 000268CD # write32h( sgl_value_2 ); ! 1260: 1249 000268CD dd effffff769 pushl _sgl_value_2 ! 1261: 1250 000268D3 fe 08 effffff762 callf $8,_write32h ! 1262: 1251 000268DA # writes(" \n"); ! 1263: 1252 000268DA .data 1 ! 1264: 1253 00000cec * L352: ! 1265: 1254 00000cec * 200A00 .ascii " \12\0" ! 1266: 1255 00000cef * .text ! 1267: 1256 000268DA dd 8f00000cec pushl $L352 ! 1268: 1257 000268E0 fe 08 effffff755 callf $8,_writes ! 1269: 1258 000268E7 # } ! 1270: 1259 000268E7 # if ( halt_flg ) /* halt on error? */ ! 1271: 1260 000268E7 L347: ! 1272: 1261 000268E7 5d effffff74f tstl _halt_flg ! 1273: 1262 000268ED 31 0d jeql L353 ! 1274: 1263 000268EF # pipe1_er_hlt( subtest ); ! 1275: 1264 000268EF dd effffff747 pushl _subtest ! 1276: 1265 000268F5 fe 08 ef000002da callf $8,_pipe1_er_hlt ! 1277: 1266 000268FC # if ( loop_on_err ) { ! 1278: 1267 000268FC L353: ! 1279: 1268 000268FC 5d effffff73a tstl _loop_on_err ! 1280: 1269 00026902 31 0a jeql L354 ! 1281: 1270 00026904 # force_loop = TRUE; /* set the force loop flag */ ! 1282: 1271 00026904 0d 01 effffff731 movl $1,_force_loop ! 1283: 1272 0002690B # asm("brw _pipe1_9_lp1"); /* and loop */ ! 1284: 1273 0002690B 13 ff04 brw _pipe1_9_lp1 ! 1285: 1274 0002690E # } ! 1286: 1275 0002690E # } /* end of compare error */ ! 1287: 1276 0002690E L354: ! 1288: 1277 0002690E # } while( index++ < max_ldf_1_index ); ! 1289: 1278 0002690E L346: ! 1290: 1279 0002690E L343: ! 1291: 1280 0002690E 0d effffff728 50 movl _index,r0 ! 1292: 1281 00026915 6d effffff721 incl _index ! 1293: 1282 0002691B 1d 50 effffff71a cmpl r0,_max_ldf_1_index ! 1294: 1283 00026922 81 03 13 feb4 jlss L344 ! 1295: 1284 00026927 L342: ! 1296: 1285 00026927 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1297: 1286 00026927 0d effffff70f 5d movl _pre_event_fp,r13 ! 1298: 1287 0002692E # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1299: 1288 0002692E 0d effffff708 5e movl _pre_event_sp,r14 ! 1300: 1289 00026935 # } /* end of subtest 9 */ ! 1301: 1290 00026935 40 ret#2 ! 1302: 1291 00026936 .set L338,0x0 ! 1303: 1292 00026936 L340: ! 1304: 1293 00026936 13 fe88 jbr L341 ! 1305: 1294 00026939 .data ! 1306: 1295 00000c00 * .text ! 1307: 1296 00026939 00 .align 1 ! 1308: 1297 0002693A .globl _pipe1_10 ! 1309: 1298 0002693A _pipe1_10: ! 1310: 1299 0002693A 0000 .word L355 ! 1311: 1300 0002693C # ! 1312: 1301 0002693C # ! 1313: 1302 0002693C # ! 1314: 1303 0002693C # ! 1315: 1304 0002693C # ! 1316: 1305 0002693C # ! 1317: 1306 0002693C # /****************************************************************************** ! 1318: 1307 0002693C # * ! 1319: 1308 0002693C # * SUBTEST 10 ! 1320: 1309 0002693C # * load 0, add operand 4 times -get data via indexed FRAME pointer ! 1321: 1310 0002693C # * ! 1322: 1311 0002693C # * ADDR INDEX DATA ! 1323: 1312 0002693C # * pointer_data 4 <the STF result goes here> ! 1324: 1313 0002693C # * pointer_data-4 3 <operand data> ! 1325: 1314 0002693C # * pointer_data-16 0 point the frame pointer here ! 1326: 1315 0002693C # * ! 1327: 1316 0002693C # ******************************************************************************/ ! 1328: 1317 0002693C # pipe1_10() ! 1329: 1318 0002693C # { ! 1330: 1319 0002693C 13 0187 jbr L357 ! 1331: 1320 0002693F L358: ! 1332: 1321 0002693F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1333: 1322 0002693F ed 6d effffff6f6 moval (r13),_pre_event_fp ! 1334: 1323 00026946 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1335: 1324 00026946 ed 6e effffff6ef moval (r14),_pre_event_sp ! 1336: 1325 0002694D # force_loop = FALSE; /* clear force_loop flag */ ! 1337: 1326 0002694D 4d effffff6e9 clrl _force_loop ! 1338: 1327 00026953 # index = 0; ! 1339: 1328 00026953 4d effffff6e3 clrl _index ! 1340: 1329 00026959 # do ! 1341: 1330 00026959 L361: ! 1342: 1331 00026959 # { ! 1343: 1332 00026959 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1344: 1333 00026959 0d effffff6dd 50 movl _index,r0 ! 1345: 1334 00026960 48 03 50 50 shll $3,r0,r0 ! 1346: 1335 00026964 0d e000000000 effffff6cd movl _ldf_1_data(r0),_sgl_value_1 ! 1347: 1336 0002696F # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1348: 1337 0002696F 0d effffff6c7 50 movl _index,r0 ! 1349: 1338 00026976 48 03 50 50 shll $3,r0,r0 ! 1350: 1339 0002697A 0d e000000004 effffff6b7 movl _ldf_1_data+4(r0),_sgl_expected ! 1351: 1340 00026985 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */ ! 1352: 1341 00026985 ed effffff6b1 effffff6ac moval _pointer_data,_sgl_value_2 ! 1353: 1342 00026990 # /* ! 1354: 1343 00026990 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1355: 1344 00026990 # * The force loop flag is set after the first error. ! 1356: 1345 00026990 # */ ! 1357: 1346 00026990 # asm("_pipe1_10_lp1:"); ! 1358: 1347 00026990 _pipe1_10_lp1: ! 1359: 1348 00026990 # asm("moval _pointer_data,_sgl_value_2");/* get store data's addr */ ! 1360: 1349 00026990 ed effffff6a6 effffff6a1 moval _pointer_data,_sgl_value_2 ! 1361: 1350 0002699B # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/ ! 1362: 1351 0002699B 2c 04 effffff69a subl2 $4,_sgl_value_2 ! 1363: 1352 000269A2 # asm("movl _sgl_value_1,*_sgl_value_2");/* set the operand data */ ! 1364: 1353 000269A2 0d effffff694 fffffff68f movl _sgl_value_1,*_sgl_value_2 ! 1365: 1354 000269AD # sgl_value_2 -= 12; /* get the FP addr to use */ ! 1366: 1355 000269AD 2c 0c effffff688 subl2 $12,_sgl_value_2 ! 1367: 1356 000269B4 # asm("movl _sgl_value_2,r13"); /* set the FRAME POINTER */ ! 1368: 1357 000269B4 0d effffff682 5d movl _sgl_value_2,r13 ! 1369: 1358 000269BB # asm("movl $3,r5"); /* r5 index = 3 longwords */ ! 1370: 1359 000269BB 0d 03 55 movl $3,r5 ! 1371: 1360 000269BE # asm("movl $4,r6"); /* r6 index = 4 longwords */ ! 1372: 1361 000269BE 0d 04 56 movl $4,r6 ! 1373: 1362 000269C1 # asm("ldf (r13)[r5]"); /* load -indexed by r5 */ ! 1374: 1363 000269C1 06 456d ldf (r13)[r5] ! 1375: 1364 000269C4 # asm("subf (r13)[r5]"); /* subtract it (twice) */ ! 1376: 1365 000269C4 d6 456d subf (r13)[r5] ! 1377: 1366 000269C7 # asm("subf (r13)[r5]"); ! 1378: 1367 000269C7 d6 456d subf (r13)[r5] ! 1379: 1368 000269CA # asm("addf (r13)[r5]"); /* add it back (twice) */ ! 1380: 1369 000269CA c6 456d addf (r13)[r5] ! 1381: 1370 000269CD # asm("addf (r13)[r5]"); ! 1382: 1371 000269CD c6 456d addf (r13)[r5] ! 1383: 1372 000269D0 # asm("stf (r13)[r6]"); /* store -indexed by r6 */ ! 1384: 1373 000269D0 26 466d stf (r13)[r6] ! 1385: 1374 000269D3 # if ( force_loop ); ! 1386: 1375 000269D3 5d effffff663 tstl _force_loop ! 1387: 1376 000269D9 31 00 jeql L362 ! 1388: 1377 000269DB # asm("brw _pipe1_10_lp1");; /* loop on the error */ ! 1389: 1378 000269DB L362: ! 1390: 1379 000269DB 13 ffb2 brw _pipe1_10_lp1 ! 1391: 1380 000269DE # /* ! 1392: 1381 000269DE # * verify the results ! 1393: 1382 000269DE # */ ! 1394: 1383 000269DE # sgl_st_acc = pointer_data; /* move the stored result */ ! 1395: 1384 000269DE 0d effffff658 effffff653 movl _pointer_data,_sgl_st_acc ! 1396: 1385 000269E9 # asm("moval (r13),_sgl_value_3"); /* save the frame pointer */ ! 1397: 1386 000269E9 ed 6d effffff64c moval (r13),_sgl_value_3 ! 1398: 1387 000269F0 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */ ! 1399: 1388 000269F0 # (sgl_value_3 != sgl_value_2) ) /* ... and the final FP */ ! 1400: 1389 000269F0 1d effffff646 effffff641 cmpl _sgl_st_acc,_sgl_expected ! 1401: 1390 000269FB 21 10 jneq L9998 ! 1402: 1391 000269FD 1d effffff639 effffff634 cmpl _sgl_value_3,_sgl_value_2 ! 1403: 1392 00026A08 21 03 13 0091 jeql L363 ! 1404: 1393 00026A0D L9998: ! 1405: 1394 00026A0D # { ! 1406: 1395 00026A0D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1407: 1396 00026A0D 0d effffff629 5d movl _pre_event_fp,r13 ! 1408: 1397 00026A14 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1409: 1398 00026A14 0d effffff622 5e movl _pre_event_sp,r14 ! 1410: 1399 00026A1B # errcnt++; /* bump the error count */ ! 1411: 1400 00026A1B 6d effffff61b incl _errcnt ! 1412: 1401 00026A21 # if ( prt_error ) { ! 1413: 1402 00026A21 5d effffff615 tstl _prt_error ! 1414: 1403 00026A27 31 4e jeql L364 ! 1415: 1404 00026A29 # print_pipe1_er("indexed FP addressing"); ! 1416: 1405 00026A29 .data 1 ! 1417: 1406 00000cef * L365: ! 1418: 1407 00000cef * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1419: 46472657373696E6700 ! 1420: 1408 00000d05 * .text ! 1421: 1409 00026A29 dd 8f00000cef pushl $L365 ! 1422: 1410 00026A2F fe 08 ef00000094 callf $8,_print_pipe1_er ! 1423: 1411 00026A36 # writes("final Frame Pointer = "); ! 1424: 1412 00026A36 .data 1 ! 1425: 1413 00000d05 * L366: ! 1426: 1414 00000d05 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1427: 06F696E746572203D2000 ! 1428: 1415 00000d1c * .text ! 1429: 1416 00026A36 dd 8f00000d05 pushl $L366 ! 1430: 1417 00026A3C fe 08 effffff5f9 callf $8,_writes ! 1431: 1418 00026A43 # writeh( sgl_value_3 ); ! 1432: 1419 00026A43 dd effffff5f3 pushl _sgl_value_3 ! 1433: 1420 00026A49 fe 08 effffff5ec callf $8,_writeh ! 1434: 1421 00026A50 # writes(", expected FP = "); ! 1435: 1422 00026A50 .data 1 ! 1436: 1423 00000d1c * L368: ! 1437: 1424 00000d1c * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1438: 650203D2000 ! 1439: 1425 00000d2e * .text ! 1440: 1426 00026A50 dd 8f00000d1c pushl $L368 ! 1441: 1427 00026A56 fe 08 effffff5df callf $8,_writes ! 1442: 1428 00026A5D # writeh( sgl_value_2 ); ! 1443: 1429 00026A5D dd effffff5d9 pushl _sgl_value_2 ! 1444: 1430 00026A63 fe 08 effffff5d2 callf $8,_writeh ! 1445: 1431 00026A6A # writes(" \n"); ! 1446: 1432 00026A6A .data 1 ! 1447: 1433 00000d2e * L369: ! 1448: 1434 00000d2e * 200A00 .ascii " \12\0" ! 1449: 1435 00000d31 * .text ! 1450: 1436 00026A6A dd 8f00000d2e pushl $L369 ! 1451: 1437 00026A70 fe 08 effffff5c5 callf $8,_writes ! 1452: 1438 00026A77 # } ! 1453: 1439 00026A77 # if ( halt_flg ) /* halt on error? */ ! 1454: 1440 00026A77 L364: ! 1455: 1441 00026A77 5d effffff5bf tstl _halt_flg ! 1456: 1442 00026A7D 31 0d jeql L370 ! 1457: 1443 00026A7F # pipe1_er_hlt( subtest ); ! 1458: 1444 00026A7F dd effffff5b7 pushl _subtest ! 1459: 1445 00026A85 fe 08 ef0000014a callf $8,_pipe1_er_hlt ! 1460: 1446 00026A8C # if ( loop_on_err ) { ! 1461: 1447 00026A8C L370: ! 1462: 1448 00026A8C 5d effffff5aa tstl _loop_on_err ! 1463: 1449 00026A92 31 0a jeql L371 ! 1464: 1450 00026A94 # force_loop = TRUE; /* set the force loop flag */ ! 1465: 1451 00026A94 0d 01 effffff5a1 movl $1,_force_loop ! 1466: 1452 00026A9B # asm("brw _pipe1_10_lp1"); /* and loop */ ! 1467: 1453 00026A9B 13 fef2 brw _pipe1_10_lp1 ! 1468: 1454 00026A9E # } ! 1469: 1455 00026A9E # } /* end of compare error */ ! 1470: 1456 00026A9E L371: ! 1471: 1457 00026A9E # } while( index++ < max_ldf_1_index ); ! 1472: 1458 00026A9E L363: ! 1473: 1459 00026A9E L360: ! 1474: 1460 00026A9E 0d effffff598 50 movl _index,r0 ! 1475: 1461 00026AA5 6d effffff591 incl _index ! 1476: 1462 00026AAB 1d 50 effffff58a cmpl r0,_max_ldf_1_index ! 1477: 1463 00026AB2 81 03 13 fea2 jlss L361 ! 1478: 1464 00026AB7 L359: ! 1479: 1465 00026AB7 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1480: 1466 00026AB7 0d effffff57f 5d movl _pre_event_fp,r13 ! 1481: 1467 00026ABE # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1482: 1468 00026ABE 0d effffff578 5e movl _pre_event_sp,r14 ! 1483: 1469 00026AC5 # } /* end of subtest 10 */ ! 1484: 1470 00026AC5 40 ret#2 ! 1485: 1471 00026AC6 .set L355,0x0 ! 1486: 1472 00026AC6 L357: ! 1487: 1473 00026AC6 13 fe76 jbr L358 ! 1488: 1474 00026AC9 .data ! 1489: 1475 00000c00 * .text ! 1490: 1476 00026AC9 00 .align 1 ! 1491: 1477 00026ACA .globl _print_pipe1_er ! 1492: 1478 00026ACA _print_pipe1_er: ! 1493: 1479 00026ACA 0000 .word L372 ! 1494: 1480 00026ACC # ! 1495: 1481 00026ACC # ! 1496: 1482 00026ACC # ! 1497: 1483 00026ACC # ! 1498: 1484 00026ACC # ! 1499: 1485 00026ACC # /****************************************************************************** ! 1500: 1486 00026ACC # * ! 1501: 1487 00026ACC # * ERROR ROUTINE ! 1502: 1488 00026ACC # * ! 1503: 1489 00026ACC # * print an error in the following form ! 1504: 1490 00026ACC # * ! 1505: 1491 00026ACC # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd ! 1506: 1492 00026ACC # * expected Acc = xxxxxxxx ! 1507: 1493 00026ACC # * ! 1508: 1494 00026ACC # ******************************************************************************/ ! 1509: 1495 00026ACC # print_pipe1_er(msg) ! 1510: 1496 00026ACC # char *msg; ! 1511: 1497 00026ACC # { ! 1512: 1498 00026ACC 13 0103 jbr L374 ! 1513: 1499 00026ACF L375: ! 1514: 1500 00026ACF # writes(" \n"); /* start a new print line */ ! 1515: 1501 00026ACF .data 1 ! 1516: 1502 00000d31 * L376: ! 1517: 1503 00000d31 * 200A00 .ascii " \12\0" ! 1518: 1504 00000d34 * .text ! 1519: 1505 00026ACF dd 8f00000d31 pushl $L376 ! 1520: 1506 00026AD5 fe 08 effffff560 callf $8,_writes ! 1521: 1507 00026ADC # writes("cycle: "); ! 1522: 1508 00026ADC .data 1 ! 1523: 1509 00000d34 * L377: ! 1524: 1510 00000d34 * 6379636C653A2000 .ascii "cycle: \0" ! 1525: 1511 00000d3c * .text ! 1526: 1512 00026ADC dd 8f00000d34 pushl $L377 ! 1527: 1513 00026AE2 fe 08 effffff553 callf $8,_writes ! 1528: 1514 00026AE9 # writed( cycle ); ! 1529: 1515 00026AE9 dd effffff54d pushl _cycle ! 1530: 1516 00026AEF fe 08 effffff546 callf $8,_writed ! 1531: 1517 00026AF6 # writes(" test "); ! 1532: 1518 00026AF6 .data 1 ! 1533: 1519 00000d3c * L379: ! 1534: 1520 00000d3c * 20746573742000 .ascii " test \0" ! 1535: 1521 00000d43 * .text ! 1536: 1522 00026AF6 dd 8f00000d3c pushl $L379 ! 1537: 1523 00026AFC fe 08 effffff539 callf $8,_writes ! 1538: 1524 00026B03 # writed( test_no ); ! 1539: 1525 00026B03 dd effffff533 pushl _test_no ! 1540: 1526 00026B09 fe 08 effffff52c callf $8,_writed ! 1541: 1527 00026B10 # writes(" (Pipe 1), subtest "); ! 1542: 1528 00026B10 .data 1 ! 1543: 1529 00000d43 * L380: ! 1544: 1530 00000d43 * 202028506970652031292C207 .ascii " (Pipe 1), subtest \0" ! 1545: 37562746573742000 ! 1546: 1531 00000d58 * .text ! 1547: 1532 00026B10 dd 8f00000d43 pushl $L380 ! 1548: 1533 00026B16 fe 08 effffff51f callf $8,_writes ! 1549: 1534 00026B1D # writed( subtest ); ! 1550: 1535 00026B1D dd effffff519 pushl _subtest ! 1551: 1536 00026B23 fe 08 effffff512 callf $8,_writed ! 1552: 1537 00026B2A # writes(" error - "); ! 1553: 1538 00026B2A .data 1 ! 1554: 1539 00000d58 * L381: ! 1555: 1540 00000d58 * 206572726F72202D2000 .ascii " error - \0" ! 1556: 1541 00000d62 * .text ! 1557: 1542 00026B2A dd 8f00000d58 pushl $L381 ! 1558: 1543 00026B30 fe 08 effffff505 callf $8,_writes ! 1559: 1544 00026B37 # writes( msg ); ! 1560: 1545 00026B37 dd ad04 pushl 4(fp) ! 1561: 1546 00026B3A fe 08 effffff4fb callf $8,_writes ! 1562: 1547 00026B41 # writec('\n'); ! 1563: 1548 00026B41 dd 0a pushl $10 ! 1564: 1549 00026B43 fe 08 effffff4f2 callf $8,_writec ! 1565: 1550 00026B4A # writes(" LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\n"); ! 1566: 1551 00026B4A .data 1 ! 1567: 1552 00000d62 * L383: ! 1568: 1553 00000d62 * 204C4446286F7031292C20535 .ascii " LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\12\0" ! 1569: 54246286F7031292C20535542 ! 1570: 46286F7031292C20414444462 ! 1571: 86F7031292C2041444446286F ! 1572: 7031292C205354460A00 ! 1573: 1554 00000d9e * .text ! 1574: 1555 00026B4A dd 8f00000d62 pushl $L383 ! 1575: 1556 00026B50 fe 08 effffff4e5 callf $8,_writes ! 1576: 1557 00026B57 # writes("operand = "); ! 1577: 1558 00026B57 .data 1 ! 1578: 1559 00000d9e * L384: ! 1579: 1560 00000d9e * 6F706572616E64203D2000 .ascii "operand = \0" ! 1580: 1561 00000da9 * .text ! 1581: 1562 00026B57 dd 8f00000d9e pushl $L384 ! 1582: 1563 00026B5D fe 08 effffff4d8 callf $8,_writes ! 1583: 1564 00026B64 # write32h( sgl_value_1 ); ! 1584: 1565 00026B64 dd effffff4d2 pushl _sgl_value_1 ! 1585: 1566 00026B6A fe 08 effffff4cb callf $8,_write32h ! 1586: 1567 00026B71 # writes(", final Acc = "); ! 1587: 1568 00026B71 .data 1 ! 1588: 1569 00000da9 * L385: ! 1589: 1570 00000da9 * 2C20202066696E616C2041636 .ascii ", final Acc = \0" ! 1590: 3203D2000 ! 1591: 1571 00000dba * .text ! 1592: 1572 00026B71 dd 8f00000da9 pushl $L385 ! 1593: 1573 00026B77 fe 08 effffff4be callf $8,_writes ! 1594: 1574 00026B7E # write32h( sgl_st_acc ); ! 1595: 1575 00026B7E dd effffff4b8 pushl _sgl_st_acc ! 1596: 1576 00026B84 fe 08 effffff4b1 callf $8,_write32h ! 1597: 1577 00026B8B # writes(", data index = "); ! 1598: 1578 00026B8B .data 1 ! 1599: 1579 00000dba * L386: ! 1600: 1580 00000dba * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1601: 578203D2000 ! 1602: 1581 00000dcc * .text ! 1603: 1582 00026B8B dd 8f00000dba pushl $L386 ! 1604: 1583 00026B91 fe 08 effffff4a4 callf $8,_writes ! 1605: 1584 00026B98 # writed( index ); ! 1606: 1585 00026B98 dd effffff49e pushl _index ! 1607: 1586 00026B9E fe 08 effffff497 callf $8,_writed ! 1608: 1587 00026BA5 # writec('\n'); ! 1609: 1588 00026BA5 dd 0a pushl $10 ! 1610: 1589 00026BA7 fe 08 effffff48e callf $8,_writec ! 1611: 1590 00026BAE # writes(" expected Acc = "); ! 1612: 1591 00026BAE .data 1 ! 1613: 1592 00000dcc * L387: ! 1614: 1593 00000dcc * 2020202020202020202020202 .ascii " expected Acc = \0" ! 1615: 0202020202020657870656374 ! 1616: 656420416363203D2000 ! 1617: 1594 00000def * .text ! 1618: 1595 00026BAE dd 8f00000dcc pushl $L387 ! 1619: 1596 00026BB4 fe 08 effffff481 callf $8,_writes ! 1620: 1597 00026BBB # write32h( sgl_expected ); ! 1621: 1598 00026BBB dd effffff47b pushl _sgl_expected ! 1622: 1599 00026BC1 fe 08 effffff474 callf $8,_write32h ! 1623: 1600 00026BC8 # writec('\n'); ! 1624: 1601 00026BC8 dd 0a pushl $10 ! 1625: 1602 00026BCA fe 08 effffff46b callf $8,_writec ! 1626: 1603 00026BD1 # } ! 1627: 1604 00026BD1 40 ret#2 ! 1628: 1605 00026BD2 .set L372,0x0 ! 1629: 1606 00026BD2 L374: ! 1630: 1607 00026BD2 13 fefa jbr L375 ! 1631: 1608 00026BD5 .data ! 1632: 1609 00000c00 * .text ! 1633: 1610 00026BD5 00 .align 1 ! 1634: 1611 00026BD6 .globl _pipe1_er_hlt ! 1635: 1612 00026BD6 _pipe1_er_hlt: ! 1636: 1613 00026BD6 0000 .word L388 ! 1637: 1614 00026BD8 # ! 1638: 1615 00026BD8 # ! 1639: 1616 00026BD8 # ! 1640: 1617 00026BD8 # ! 1641: 1618 00026BD8 # ! 1642: 1619 00026BD8 # /****************************************************************************** ! 1643: 1620 00026BD8 # * ! 1644: 1621 00026BD8 # * HALT ON ERROR ROUTINE ! 1645: 1622 00026BD8 # * ! 1646: 1623 00026BD8 # * halt with the necessary information saved in the registers ! 1647: 1624 00026BD8 # * ! 1648: 1625 00026BD8 # ******************************************************************************/ ! 1649: 1626 00026BD8 # pipe1_er_hlt( subtest ) ! 1650: 1627 00026BD8 # int subtest; ! 1651: 1628 00026BD8 # { ! 1652: 1629 00026BD8 11 60 jbr L390 ! 1653: 1630 00026BDA L391: ! 1654: 1631 00026BDA # asm("movl _test_no,r0"); /* r0 = test number */ ! 1655: 1632 00026BDA 0d effffff45c 50 movl _test_no,r0 ! 1656: 1633 00026BE1 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1657: 1634 00026BE1 0d effffff455 51 movl _subtest,r1 ! 1658: 1635 00026BE8 # asm("movl $1,r2"); /* r2 = error code */ ! 1659: 1636 00026BE8 0d 01 52 movl $1,r2 ! 1660: 1637 00026BEB # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1661: 1638 00026BEB 0d effffff44b 53 movl _cycle,r3 ! 1662: 1639 00026BF2 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */ ! 1663: 1640 00026BF2 0d effffff444 54 movl _sgl_value_1,r4 ! 1664: 1641 00026BF9 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */ ! 1665: 1642 00026BF9 0d effffff43d 55 movl _sgl_st_acc,r5 ! 1666: 1643 00026C00 # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */ ! 1667: 1644 00026C00 0d effffff436 56 movl _sgl_expected,r6 ! 1668: 1645 00026C07 # asm("movl _index,r7"); /* r7 = data index */ ! 1669: 1646 00026C07 0d effffff42f 57 movl _index,r7 ! 1670: 1647 00026C0E # if( subtest == 9 ) { ! 1671: 1648 00026C0E 1d ad04 09 cmpl 4(fp),$9 ! 1672: 1649 00026C12 21 10 jneq L392 ! 1673: 1650 00026C14 # asm("movl _sgl_value_3,r8"); /* r8 = final SP value */ ! 1674: 1651 00026C14 0d effffff422 58 movl _sgl_value_3,r8 ! 1675: 1652 00026C1B # asm("movl _sgl_value_2,r9"); /* r9 = expected SP value */ ! 1676: 1653 00026C1B 0d effffff41b 59 movl _sgl_value_2,r9 ! 1677: 1654 00026C22 # } else ! 1678: 1655 00026C22 11 14 jbr L393 ! 1679: 1656 00026C24 L392: ! 1680: 1657 00026C24 # if( subtest == 10 ) { ! 1681: 1658 00026C24 1d ad04 0a cmpl 4(fp),$10 ! 1682: 1659 00026C28 21 0e jneq L394 ! 1683: 1660 00026C2A # asm("movl _sgl_value_3,r8"); /* r8 = final FP value */ ! 1684: 1661 00026C2A 0d effffff40c 58 movl _sgl_value_3,r8 ! 1685: 1662 00026C31 # asm("movl _sgl_value_2,r9"); /* r9 = expected FP value */ ! 1686: 1663 00026C31 0d effffff405 59 movl _sgl_value_2,r9 ! 1687: 1664 00026C38 # }; ! 1688: 1665 00026C38 L394: ! 1689: 1666 00026C38 L393: ! 1690: 1667 00026C38 # asm(".globl _pipe1_1_hlt"); ! 1691: 1668 00026C38 .globl _pipe1_1_hlt ! 1692: 1669 00026C38 # asm("_pipe1_1_hlt:"); /* PC after the halt */ ! 1693: 1670 00026C38 _pipe1_1_hlt: ! 1694: 1671 00026C38 # asm("halt"); /* HALT ... */ ! 1695: 1672 00026C38 00 halt ! 1696: 1673 00026C39 # } /* end of halt on error */ ! 1697: 1674 00026C39 40 ret#2 ! 1698: 1675 00026C3A .set L388,0x0 ! 1699: 1676 00026C3A L390: ! 1700: 1677 00026C3A 11 9e jbr L391 ! 1701: 1678 00000c00 * .data ! 1702: 1678 00000c00 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.