![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe7.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 pipe7.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 00000de8 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_7 ! 6: 6 00000000 _pipe_7: ! 7: 7 0002AE6C 0000 .word L215 ! 8: 8 0002AE6E # #include "fpp_defs.h" ! 9: 9 0002AE6E # ! 10: 10 0002AE6E # ! 11: 11 0002AE6E # /***************************************************************************** ! 12: 12 0002AE6E # * ! 13: 13 0002AE6E # * MONITOR FOR PIPELINE TEST #7 (The Trans-Siberian Pipeline test) ! 14: 14 0002AE6E # * ! 15: 15 0002AE6E # * This test will do: ! 16: 16 0002AE6E # * ! 17: 17 0002AE6E # * LDF(x), SUBF(x), ADDF(0), SUBF(x), ADDF(x), SUBF(0), ! 18: 18 0002AE6E # * ADDF(x), SUBF(x), ADDF(0), SUBF(0), ADDF(x), STF ! 19: 19 0002AE6E # * ! 20: 20 0002AE6E # * where the x's are the fmacro1 LDF data patterns. This test is an attempt ! 21: 21 0002AE6E # * to fill the instruction Queue. ! 22: 22 0002AE6E # *****************************************************************************/ ! 23: 23 0002AE6E # pipe_7() ! 24: 24 0002AE6E # { ! 25: 25 0002AE6E 13 00a8 jbr L217 ! 26: 26 0002AE71 L218: ! 27: 27 0002AE71 # asm(".globl _pipeline_7_t"); ! 28: 28 0002AE71 .globl _pipeline_7_t ! 29: 29 0002AE71 # asm("_pipeline_7_t:"); /* entry address */ ! 30: 30 0002AE71 _pipeline_7_t: ! 31: 31 0002AE71 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 32: 32 0002AE71 1d effffffff5 01 cmpl _cycle,$1 ! 33: 33 0002AE78 21 15 jneq L219 ! 34: 34 0002AE7A 5d efffffffec tstl _prt_hdrs ! 35: 35 0002AE80 31 0d jeql L219 ! 36: 36 0002AE82 # { ! 37: 37 0002AE82 # writes(" PIPE_7 "); ! 38: 38 0002AE82 .data 1 ! 39: 39 00000de8 * L221: ! 40: 40 00000de8 * 20504950455F372000 .ascii " PIPE_7 \0" ! 41: 41 00000df1 * .text ! 42: 42 0002AE82 dd 8f00000de8 pushl $L221 ! 43: 43 0002AE88 fe 08 efffffffdd callf $8,_writes ! 44: 44 0002AE8F # } ! 45: 45 0002AE8F # subtest = 1; ! 46: 46 0002AE8F L219: ! 47: 47 0002AE8F 0d 01 efffffffd6 movl $1,_subtest ! 48: 48 0002AE96 # pipe7_1(); /* data in REGs, no NOPs */ ! 49: 49 0002AE96 fe 04 ef0000007f callf $4,_pipe7_1 ! 50: 50 0002AE9D # subtest ++; /* increment subtest num */ ! 51: 51 0002AE9D 6d efffffffc9 incl _subtest ! 52: 52 0002AEA3 # pipe7_2(); /* data in REGs, 1 NOP */ ! 53: 53 0002AEA3 fe 04 ef0000015c callf $4,_pipe7_2 ! 54: 54 0002AEAA # subtest ++; /* increment subtest num */ ! 55: 55 0002AEAA 6d efffffffbc incl _subtest ! 56: 56 0002AEB0 # pipe7_3(); /* data in REGs, 2 NOPs */ ! 57: 57 0002AEB0 fe 04 ef00000243 callf $4,_pipe7_3 ! 58: 58 0002AEB7 # subtest ++; /* increment subtest num */ ! 59: 59 0002AEB7 6d efffffffaf incl _subtest ! 60: 60 0002AEBD # pipe7_4(); /* data in REGs, 3 NOPs */ ! 61: 61 0002AEBD fe 04 ef00000336 callf $4,_pipe7_4 ! 62: 62 0002AEC4 # subtest ++; /* increment subtest num */ ! 63: 63 0002AEC4 6d efffffffa2 incl _subtest ! 64: 64 0002AECA # pipe7_5(); /* data in CACHE, no NOPs */ ! 65: 65 0002AECA fe 04 ef00000433 callf $4,_pipe7_5 ! 66: 66 0002AED1 # subtest ++; /* increment subtest num */ ! 67: 67 0002AED1 6d efffffff95 incl _subtest ! 68: 68 0002AED7 # pipe7_6(); /* data in CACHE, 1 NOP */ ! 69: 69 0002AED7 fe 04 ef0000052a callf $4,_pipe7_6 ! 70: 70 0002AEDE # subtest ++; /* increment subtest num */ ! 71: 71 0002AEDE 6d efffffff88 incl _subtest ! 72: 72 0002AEE4 # pipe7_7(); /* data in CACHE, 2 NOPs */ ! 73: 73 0002AEE4 fe 04 ef00000627 callf $4,_pipe7_7 ! 74: 74 0002AEEB # subtest ++; /* increment subtest num */ ! 75: 75 0002AEEB 6d efffffff7b incl _subtest ! 76: 76 0002AEF1 # pipe7_8(); /* data in CACHE, 3 NOPs */ ! 77: 77 0002AEF1 fe 04 ef00000734 callf $4,_pipe7_8 ! 78: 78 0002AEF8 # subtest ++; /* increment subtest num */ ! 79: 79 0002AEF8 6d efffffff6e incl _subtest ! 80: 80 0002AEFE # pipe7_9(); /* data on STACK, no NOPs */ ! 81: 81 0002AEFE fe 04 ef0000084d callf $4,_pipe7_9 ! 82: 82 0002AF05 # subtest ++; /* increment subtest num */ ! 83: 83 0002AF05 6d efffffff61 incl _subtest ! 84: 84 0002AF0B # pipe7_10(); /* data via FP no NOPs */ ! 85: 85 0002AF0B fe 04 ef000009fc callf $4,_pipe7_10 ! 86: 86 0002AF12 # asm("jmp *return"); /* return to the test monitor */ ! 87: 87 0002AF12 71 ffffffff54 jmp *return ! 88: 88 0002AF18 # } ! 89: 89 0002AF18 40 ret#2 ! 90: 90 0002AF19 .set L215,0x0 ! 91: 91 0002AF19 L217: ! 92: 92 0002AF19 13 ff55 jbr L218 ! 93: 93 0002AF1C .data ! 94: 94 00000de8 * .text ! 95: 95 0002AF1C .align 1 ! 96: 96 0002AF1C .globl _pipe7_1 ! 97: 97 0002AF1C _pipe7_1: ! 98: 98 0002AF1C 0000 .word L232 ! 99: 99 0002AF1E # ! 100: 100 0002AF1E # ! 101: 101 0002AF1E # ! 102: 102 0002AF1E # ! 103: 103 0002AF1E # ! 104: 104 0002AF1E # ! 105: 105 0002AF1E # /************************************************************************ ! 106: 106 0002AF1E # * ! 107: 107 0002AF1E # * SUBTEST 1 ! 108: 108 0002AF1E # * data in registers, no NO-OPs ! 109: 109 0002AF1E # * ! 110: 110 0002AF1E # ************************************************************************/ ! 111: 111 0002AF1E # pipe7_1() ! 112: 112 0002AF1E # { ! 113: 113 0002AF1E 13 00e1 jbr L234 ! 114: 114 0002AF21 L235: ! 115: 115 0002AF21 # force_loop = FALSE; /* clear the force_loop flg */ ! 116: 116 0002AF21 4d efffffff45 clrl _force_loop ! 117: 117 0002AF27 # index = 0; ! 118: 118 0002AF27 4d efffffff3f clrl _index ! 119: 119 0002AF2D # do ! 120: 120 0002AF2D L238: ! 121: 121 0002AF2D # { ! 122: 122 0002AF2D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 123: 123 0002AF2D 0d efffffff39 50 movl _index,r0 ! 124: 124 0002AF34 48 03 50 50 shll $3,r0,r0 ! 125: 125 0002AF38 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1 ! 126: 126 0002AF43 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 127: 127 0002AF43 0d efffffff23 50 movl _index,r0 ! 128: 128 0002AF4A 48 03 50 50 shll $3,r0,r0 ! 129: 129 0002AF4E 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected ! 130: 130 0002AF59 # sgl_value_2 = 0; /* set one operand to 0 */ ! 131: 131 0002AF59 4d efffffff0d clrl _sgl_value_2 ! 132: 132 0002AF5F # /* ! 133: 133 0002AF5F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 134: 134 0002AF5F # * The force loop flag is set after the first error. ! 135: 135 0002AF5F # */ ! 136: 136 0002AF5F # asm("_pipe7_1_lp1:"); ! 137: 137 0002AF5F _pipe7_1_lp1: ! 138: 138 0002AF5F # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 139: 139 0002AF5F 0d efffffff07 54 movl _sgl_value_1,r4 ! 140: 140 0002AF66 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */ ! 141: 141 0002AF66 0d efffffff00 53 movl _sgl_value_2,r3 ! 142: 142 0002AF6D # asm("ldf r4"); /* load the ACC (ACC = op) */ ! 143: 143 0002AF6D 06 54 ldf r4 ! 144: 144 0002AF6F # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 145: 145 0002AF6F d6 54 subf r4 ! 146: 146 0002AF71 # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 147: 147 0002AF71 c6 53 addf r3 ! 148: 148 0002AF73 # asm("subf r4"); /* sub. the op. (ACC =-op) */ ! 149: 149 0002AF73 d6 54 subf r4 ! 150: 150 0002AF75 # asm("addf r4"); /* add the op. (ACC = 0 ) */ ! 151: 151 0002AF75 c6 54 addf r4 ! 152: 152 0002AF77 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 153: 153 0002AF77 d6 53 subf r3 ! 154: 154 0002AF79 # asm("addf r4"); /* add the op. (ACC = op) */ ! 155: 155 0002AF79 c6 54 addf r4 ! 156: 156 0002AF7B # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 157: 157 0002AF7B d6 54 subf r4 ! 158: 158 0002AF7D # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 159: 159 0002AF7D c6 53 addf r3 ! 160: 160 0002AF7F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 161: 161 0002AF7F d6 53 subf r3 ! 162: 162 0002AF81 # asm("addf r4"); /* add the op. (ACC = op) */ ! 163: 163 0002AF81 c6 54 addf r4 ! 164: 164 0002AF83 # asm("stf r5"); /* store the ACC (s/b= op) */ ! 165: 165 0002AF83 26 55 stf r5 ! 166: 166 0002AF85 # if( force_loop ) ! 167: 167 0002AF85 5d effffffee1 tstl _force_loop ! 168: 168 0002AF8B 31 02 jeql L239 ! 169: 169 0002AF8D # asm("brb _pipe7_1_lp1");; /* loop on the error */ ! 170: 170 0002AF8D 11 d0 brb _pipe7_1_lp1 ! 171: 171 0002AF8F L239: ! 172: 172 0002AF8F # /* ! 173: 173 0002AF8F # * verify the results ! 174: 174 0002AF8F # */ ! 175: 175 0002AF8F # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 176: 176 0002AF8F 0d 55 effffffed6 movl r5,_sgl_st_acc ! 177: 177 0002AF96 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 178: 178 0002AF96 1d effffffed0 effffffecb cmpl _sgl_st_acc,_sgl_expected ! 179: 179 0002AFA1 31 45 jeql L240 ! 180: 180 0002AFA3 # { ! 181: 181 0002AFA3 # errcnt++; /* bump the error count */ ! 182: 182 0002AFA3 6d effffffec3 incl _errcnt ! 183: 183 0002AFA9 # if ( prt_error ) ! 184: 184 0002AFA9 5d effffffebd tstl _prt_error ! 185: 185 0002AFAF 31 0d jeql L241 ! 186: 186 0002AFB1 # print_pipe7_er("Reg. Data, no NO-OPs"); ! 187: 187 0002AFB1 .data 1 ! 188: 188 00000df1 * L243: ! 189: 189 00000df1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0" ! 190: F204E4F2D4F507300 ! 191: 190 00000e06 * .text ! 192: 191 0002AFB1 dd 8f00000df1 pushl $L243 ! 193: 192 0002AFB7 fe 08 ef00000b0e callf $8,_print_pipe7_er ! 194: 193 0002AFBE # if ( halt_flg ) ! 195: 194 0002AFBE L241: ! 196: 195 0002AFBE 5d effffffea8 tstl _halt_flg ! 197: 196 0002AFC4 31 0d jeql L244 ! 198: 197 0002AFC6 # pipe7_er_hlt( subtest ); ! 199: 198 0002AFC6 dd effffffea0 pushl _subtest ! 200: 199 0002AFCC fe 08 ef00000c11 callf $8,_pipe7_er_hlt ! 201: 200 0002AFD3 # if ( loop_on_err ) { ! 202: 201 0002AFD3 L244: ! 203: 202 0002AFD3 5d effffffe93 tstl _loop_on_err ! 204: 203 0002AFD9 31 0d jeql L246 ! 205: 204 0002AFDB # force_loop = TRUE; /* set the force loop flag */ ! 206: 205 0002AFDB 0d 01 effffffe8a movl $1,_force_loop ! 207: 206 0002AFE2 # asm("jmp _pipe7_1_lp1"); /* and loop */ ! 208: 207 0002AFE2 71 efffffff77 jmp _pipe7_1_lp1 ! 209: 208 0002AFE8 # } ! 210: 209 0002AFE8 # } /* end of compare error */ ! 211: 210 0002AFE8 L246: ! 212: 211 0002AFE8 # } while( index++ < max_ldf_1_index ); ! 213: 212 0002AFE8 L240: ! 214: 213 0002AFE8 L237: ! 215: 214 0002AFE8 0d effffffe7e 50 movl _index,r0 ! 216: 215 0002AFEF 6d effffffe77 incl _index ! 217: 216 0002AFF5 1d 50 effffffe70 cmpl r0,_max_ldf_1_index ! 218: 217 0002AFFC 81 03 13 ff2c jlss L238 ! 219: 218 0002B001 L236: ! 220: 219 0002B001 # } /* end of subtest 1 */ ! 221: 220 0002B001 40 ret#2 ! 222: 221 0002B002 .set L232,0x0 ! 223: 222 0002B002 L234: ! 224: 223 0002B002 13 ff1c jbr L235 ! 225: 224 0002B005 .data ! 226: 225 00000de8 * .text ! 227: 226 0002B005 00 .align 1 ! 228: 227 0002B006 .globl _pipe7_2 ! 229: 228 0002B006 _pipe7_2: ! 230: 229 0002B006 0000 .word L247 ! 231: 230 0002B008 # ! 232: 231 0002B008 # ! 233: 232 0002B008 # ! 234: 233 0002B008 # ! 235: 234 0002B008 # ! 236: 235 0002B008 # ! 237: 236 0002B008 # /************************************************************************ ! 238: 237 0002B008 # * ! 239: 238 0002B008 # * SUBTEST 2 ! 240: 239 0002B008 # * data in registers, 1 NO-OP ! 241: 240 0002B008 # * ! 242: 241 0002B008 # ************************************************************************/ ! 243: 242 0002B008 # pipe7_2() ! 244: 243 0002B008 # { ! 245: 244 0002B008 13 00ec jbr L249 ! 246: 245 0002B00B L250: ! 247: 246 0002B00B # force_loop = FALSE; /* clear force_loop flag */ ! 248: 247 0002B00B 4d effffffe5b clrl _force_loop ! 249: 248 0002B011 # index = 0; ! 250: 249 0002B011 4d effffffe55 clrl _index ! 251: 250 0002B017 # do ! 252: 251 0002B017 L253: ! 253: 252 0002B017 # { ! 254: 253 0002B017 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 255: 254 0002B017 0d effffffe4f 50 movl _index,r0 ! 256: 255 0002B01E 48 03 50 50 shll $3,r0,r0 ! 257: 256 0002B022 0d e000000000 effffffe3f movl _ldf_1_data(r0),_sgl_value_1 ! 258: 257 0002B02D # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 259: 258 0002B02D 0d effffffe39 50 movl _index,r0 ! 260: 259 0002B034 48 03 50 50 shll $3,r0,r0 ! 261: 260 0002B038 0d e000000004 effffffe29 movl _ldf_1_data+4(r0),_sgl_expected ! 262: 261 0002B043 # sgl_value_2 = 0; /* get the '0' operand */ ! 263: 262 0002B043 4d effffffe23 clrl _sgl_value_2 ! 264: 263 0002B049 # /* ! 265: 264 0002B049 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 266: 265 0002B049 # * The force loop flag is set after the first error. ! 267: 266 0002B049 # */ ! 268: 267 0002B049 # asm("_pipe7_2_lp1:"); ! 269: 268 0002B049 _pipe7_2_lp1: ! 270: 269 0002B049 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 271: 270 0002B049 0d effffffe1d 54 movl _sgl_value_1,r4 ! 272: 271 0002B050 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */ ! 273: 272 0002B050 0d effffffe16 53 movl _sgl_value_2,r3 ! 274: 273 0002B057 # asm("ldf r4"); /* load the ACC (ACC = op) */ ! 275: 274 0002B057 06 54 ldf r4 ! 276: 275 0002B059 # asm("nop"); ! 277: 276 0002B059 10 nop ! 278: 277 0002B05A # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 279: 278 0002B05A d6 54 subf r4 ! 280: 279 0002B05C # asm("nop"); ! 281: 280 0002B05C 10 nop ! 282: 281 0002B05D # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 283: 282 0002B05D c6 53 addf r3 ! 284: 283 0002B05F # asm("nop"); ! 285: 284 0002B05F 10 nop ! 286: 285 0002B060 # asm("subf r4"); /* sub. the op. (ACC =-op) */ ! 287: 286 0002B060 d6 54 subf r4 ! 288: 287 0002B062 # asm("nop"); ! 289: 288 0002B062 10 nop ! 290: 289 0002B063 # asm("addf r4"); /* add the op. (ACC = 0 ) */ ! 291: 290 0002B063 c6 54 addf r4 ! 292: 291 0002B065 # asm("nop"); ! 293: 292 0002B065 10 nop ! 294: 293 0002B066 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 295: 294 0002B066 d6 53 subf r3 ! 296: 295 0002B068 # asm("nop"); ! 297: 296 0002B068 10 nop ! 298: 297 0002B069 # asm("addf r4"); /* add the op. (ACC = op) */ ! 299: 298 0002B069 c6 54 addf r4 ! 300: 299 0002B06B # asm("nop"); ! 301: 300 0002B06B 10 nop ! 302: 301 0002B06C # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 303: 302 0002B06C d6 54 subf r4 ! 304: 303 0002B06E # asm("nop"); ! 305: 304 0002B06E 10 nop ! 306: 305 0002B06F # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 307: 306 0002B06F c6 53 addf r3 ! 308: 307 0002B071 # asm("nop"); ! 309: 308 0002B071 10 nop ! 310: 309 0002B072 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 311: 310 0002B072 d6 53 subf r3 ! 312: 311 0002B074 # asm("nop"); ! 313: 312 0002B074 10 nop ! 314: 313 0002B075 # asm("addf r4"); /* add the op. (ACC = op) */ ! 315: 314 0002B075 c6 54 addf r4 ! 316: 315 0002B077 # asm("nop"); ! 317: 316 0002B077 10 nop ! 318: 317 0002B078 # asm("stf r5"); /* store the ACC (s/b= op) */ ! 319: 318 0002B078 26 55 stf r5 ! 320: 319 0002B07A # if( force_loop ) ! 321: 320 0002B07A 5d effffffdec tstl _force_loop ! 322: 321 0002B080 31 02 jeql L254 ! 323: 322 0002B082 # asm("brb _pipe7_2_lp1");; /* loop on the error */ ! 324: 323 0002B082 11 c5 brb _pipe7_2_lp1 ! 325: 324 0002B084 L254: ! 326: 325 0002B084 # /* ! 327: 326 0002B084 # * verify the results ! 328: 327 0002B084 # */ ! 329: 328 0002B084 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 330: 329 0002B084 0d 55 effffffde1 movl r5,_sgl_st_acc ! 331: 330 0002B08B # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 332: 331 0002B08B 1d effffffddb effffffdd6 cmpl _sgl_st_acc,_sgl_expected ! 333: 332 0002B096 31 45 jeql L255 ! 334: 333 0002B098 # { ! 335: 334 0002B098 # errcnt++; /* bump the error count */ ! 336: 335 0002B098 6d effffffdce incl _errcnt ! 337: 336 0002B09E # if ( prt_error ) ! 338: 337 0002B09E 5d effffffdc8 tstl _prt_error ! 339: 338 0002B0A4 31 0d jeql L256 ! 340: 339 0002B0A6 # print_pipe7_er("Reg. Data, 1 NO-OP"); ! 341: 340 0002B0A6 .data 1 ! 342: 341 00000e06 * L257: ! 343: 342 00000e06 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0" ! 344: 04E4F2D4F5000 ! 345: 343 00000e19 * .text ! 346: 344 0002B0A6 dd 8f00000e06 pushl $L257 ! 347: 345 0002B0AC fe 08 ef00000a19 callf $8,_print_pipe7_er ! 348: 346 0002B0B3 # if ( halt_flg ) ! 349: 347 0002B0B3 L256: ! 350: 348 0002B0B3 5d effffffdb3 tstl _halt_flg ! 351: 349 0002B0B9 31 0d jeql L258 ! 352: 350 0002B0BB # pipe7_er_hlt( subtest ); ! 353: 351 0002B0BB dd effffffdab pushl _subtest ! 354: 352 0002B0C1 fe 08 ef00000b1c callf $8,_pipe7_er_hlt ! 355: 353 0002B0C8 # if ( loop_on_err ) { ! 356: 354 0002B0C8 L258: ! 357: 355 0002B0C8 5d effffffd9e tstl _loop_on_err ! 358: 356 0002B0CE 31 0d jeql L259 ! 359: 357 0002B0D0 # force_loop = TRUE; /* set the force loop flag */ ! 360: 358 0002B0D0 0d 01 effffffd95 movl $1,_force_loop ! 361: 359 0002B0D7 # asm("jmp _pipe7_2_lp1"); /* and loop */ ! 362: 360 0002B0D7 71 efffffff6c jmp _pipe7_2_lp1 ! 363: 361 0002B0DD # } ! 364: 362 0002B0DD # } /* end of compare error */ ! 365: 363 0002B0DD L259: ! 366: 364 0002B0DD # } while( index++ < max_ldf_1_index ); ! 367: 365 0002B0DD L255: ! 368: 366 0002B0DD L252: ! 369: 367 0002B0DD 0d effffffd89 50 movl _index,r0 ! 370: 368 0002B0E4 6d effffffd82 incl _index ! 371: 369 0002B0EA 1d 50 effffffd7b cmpl r0,_max_ldf_1_index ! 372: 370 0002B0F1 81 03 13 ff21 jlss L253 ! 373: 371 0002B0F6 L251: ! 374: 372 0002B0F6 # } /* end of subtest 2 */ ! 375: 373 0002B0F6 40 ret#2 ! 376: 374 0002B0F7 .set L247,0x0 ! 377: 375 0002B0F7 L249: ! 378: 376 0002B0F7 13 ff11 jbr L250 ! 379: 377 0002B0FA .data ! 380: 378 00000de8 * .text ! 381: 379 0002B0FA .align 1 ! 382: 380 0002B0FA .globl _pipe7_3 ! 383: 381 0002B0FA _pipe7_3: ! 384: 382 0002B0FA 0000 .word L260 ! 385: 383 0002B0FC # ! 386: 384 0002B0FC # ! 387: 385 0002B0FC # ! 388: 386 0002B0FC # ! 389: 387 0002B0FC # ! 390: 388 0002B0FC # ! 391: 389 0002B0FC # /************************************************************************ ! 392: 390 0002B0FC # * ! 393: 391 0002B0FC # * SUBTEST 3 ! 394: 392 0002B0FC # * data in registers, 2 NO-OPs ! 395: 393 0002B0FC # * ! 396: 394 0002B0FC # ************************************************************************/ ! 397: 395 0002B0FC # pipe7_3() ! 398: 396 0002B0FC # { ! 399: 397 0002B0FC 13 00f7 jbr L262 ! 400: 398 0002B0FF L263: ! 401: 399 0002B0FF # force_loop = FALSE; /* clear force_loop flag */ ! 402: 400 0002B0FF 4d effffffd67 clrl _force_loop ! 403: 401 0002B105 # index = 0; ! 404: 402 0002B105 4d effffffd61 clrl _index ! 405: 403 0002B10B # do ! 406: 404 0002B10B L266: ! 407: 405 0002B10B # { ! 408: 406 0002B10B # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 409: 407 0002B10B 0d effffffd5b 50 movl _index,r0 ! 410: 408 0002B112 48 03 50 50 shll $3,r0,r0 ! 411: 409 0002B116 0d e000000000 effffffd4b movl _ldf_1_data(r0),_sgl_value_1 ! 412: 410 0002B121 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 413: 411 0002B121 0d effffffd45 50 movl _index,r0 ! 414: 412 0002B128 48 03 50 50 shll $3,r0,r0 ! 415: 413 0002B12C 0d e000000004 effffffd35 movl _ldf_1_data+4(r0),_sgl_expected ! 416: 414 0002B137 # sgl_value_2 = 0; /* set the '0' operand */ ! 417: 415 0002B137 4d effffffd2f clrl _sgl_value_2 ! 418: 416 0002B13D # /* ! 419: 417 0002B13D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 420: 418 0002B13D # * The force loop flag is set after the first error. ! 421: 419 0002B13D # */ ! 422: 420 0002B13D # asm("_pipe7_3_lp1:"); ! 423: 421 0002B13D _pipe7_3_lp1: ! 424: 422 0002B13D # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 425: 423 0002B13D 0d effffffd29 54 movl _sgl_value_1,r4 ! 426: 424 0002B144 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */ ! 427: 425 0002B144 0d effffffd22 53 movl _sgl_value_2,r3 ! 428: 426 0002B14B # asm("ldf r4"); /* load the ACC (ACC = op) */ ! 429: 427 0002B14B 06 54 ldf r4 ! 430: 428 0002B14D # asm("nop"); ! 431: 429 0002B14D 10 nop ! 432: 430 0002B14E # asm("nop"); ! 433: 431 0002B14E 10 nop ! 434: 432 0002B14F # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 435: 433 0002B14F d6 54 subf r4 ! 436: 434 0002B151 # asm("nop"); ! 437: 435 0002B151 10 nop ! 438: 436 0002B152 # asm("nop"); ! 439: 437 0002B152 10 nop ! 440: 438 0002B153 # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 441: 439 0002B153 c6 53 addf r3 ! 442: 440 0002B155 # asm("nop"); ! 443: 441 0002B155 10 nop ! 444: 442 0002B156 # asm("nop"); ! 445: 443 0002B156 10 nop ! 446: 444 0002B157 # asm("subf r4"); /* sub. the op. (ACC =-op) */ ! 447: 445 0002B157 d6 54 subf r4 ! 448: 446 0002B159 # asm("nop"); ! 449: 447 0002B159 10 nop ! 450: 448 0002B15A # asm("nop"); ! 451: 449 0002B15A 10 nop ! 452: 450 0002B15B # asm("addf r4"); /* add the op. (ACC = 0 ) */ ! 453: 451 0002B15B c6 54 addf r4 ! 454: 452 0002B15D # asm("nop"); ! 455: 453 0002B15D 10 nop ! 456: 454 0002B15E # asm("nop"); ! 457: 455 0002B15E 10 nop ! 458: 456 0002B15F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 459: 457 0002B15F d6 53 subf r3 ! 460: 458 0002B161 # asm("nop"); ! 461: 459 0002B161 10 nop ! 462: 460 0002B162 # asm("nop"); ! 463: 461 0002B162 10 nop ! 464: 462 0002B163 # asm("addf r4"); /* add the op. (ACC = op) */ ! 465: 463 0002B163 c6 54 addf r4 ! 466: 464 0002B165 # asm("nop"); ! 467: 465 0002B165 10 nop ! 468: 466 0002B166 # asm("nop"); ! 469: 467 0002B166 10 nop ! 470: 468 0002B167 # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 471: 469 0002B167 d6 54 subf r4 ! 472: 470 0002B169 # asm("nop"); ! 473: 471 0002B169 10 nop ! 474: 472 0002B16A # asm("nop"); ! 475: 473 0002B16A 10 nop ! 476: 474 0002B16B # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 477: 475 0002B16B c6 53 addf r3 ! 478: 476 0002B16D # asm("nop"); ! 479: 477 0002B16D 10 nop ! 480: 478 0002B16E # asm("nop"); ! 481: 479 0002B16E 10 nop ! 482: 480 0002B16F # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 483: 481 0002B16F d6 53 subf r3 ! 484: 482 0002B171 # asm("nop"); ! 485: 483 0002B171 10 nop ! 486: 484 0002B172 # asm("nop"); ! 487: 485 0002B172 10 nop ! 488: 486 0002B173 # asm("addf r4"); /* add the op. (ACC = op) */ ! 489: 487 0002B173 c6 54 addf r4 ! 490: 488 0002B175 # asm("nop"); ! 491: 489 0002B175 10 nop ! 492: 490 0002B176 # asm("nop"); ! 493: 491 0002B176 10 nop ! 494: 492 0002B177 # asm("stf r5"); /* store the ACC (s/b= op) */ ! 495: 493 0002B177 26 55 stf r5 ! 496: 494 0002B179 # if( force_loop ) ! 497: 495 0002B179 5d effffffced tstl _force_loop ! 498: 496 0002B17F 31 02 jeql L267 ! 499: 497 0002B181 # asm("brb _pipe7_3_lp1");; /* loop on the error */ ! 500: 498 0002B181 11 ba brb _pipe7_3_lp1 ! 501: 499 0002B183 L267: ! 502: 500 0002B183 # /* ! 503: 501 0002B183 # * verify the results ! 504: 502 0002B183 # */ ! 505: 503 0002B183 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 506: 504 0002B183 0d 55 effffffce2 movl r5,_sgl_st_acc ! 507: 505 0002B18A # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 508: 506 0002B18A 1d effffffcdc effffffcd7 cmpl _sgl_st_acc,_sgl_expected ! 509: 507 0002B195 31 45 jeql L268 ! 510: 508 0002B197 # { ! 511: 509 0002B197 # errcnt++; /* bump the error count */ ! 512: 510 0002B197 6d effffffccf incl _errcnt ! 513: 511 0002B19D # if ( prt_error ) ! 514: 512 0002B19D 5d effffffcc9 tstl _prt_error ! 515: 513 0002B1A3 31 0d jeql L269 ! 516: 514 0002B1A5 # print_pipe7_er("Reg. Data, 2 NO-OPs"); ! 517: 515 0002B1A5 .data 1 ! 518: 516 00000e19 * L270: ! 519: 517 00000e19 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0" ! 520: 04E4F2D4F507300 ! 521: 518 00000e2d * .text ! 522: 519 0002B1A5 dd 8f00000e19 pushl $L270 ! 523: 520 0002B1AB fe 08 ef0000091a callf $8,_print_pipe7_er ! 524: 521 0002B1B2 # if ( halt_flg ) ! 525: 522 0002B1B2 L269: ! 526: 523 0002B1B2 5d effffffcb4 tstl _halt_flg ! 527: 524 0002B1B8 31 0d jeql L271 ! 528: 525 0002B1BA # pipe7_er_hlt( subtest ); ! 529: 526 0002B1BA dd effffffcac pushl _subtest ! 530: 527 0002B1C0 fe 08 ef00000a1d callf $8,_pipe7_er_hlt ! 531: 528 0002B1C7 # if ( loop_on_err ) { ! 532: 529 0002B1C7 L271: ! 533: 530 0002B1C7 5d effffffc9f tstl _loop_on_err ! 534: 531 0002B1CD 31 0d jeql L272 ! 535: 532 0002B1CF # force_loop = TRUE; /* set the force loop flag */ ! 536: 533 0002B1CF 0d 01 effffffc96 movl $1,_force_loop ! 537: 534 0002B1D6 # asm("jmp _pipe7_3_lp1"); /* and loop */ ! 538: 535 0002B1D6 71 efffffff61 jmp _pipe7_3_lp1 ! 539: 536 0002B1DC # } ! 540: 537 0002B1DC # } /* end of compare error */ ! 541: 538 0002B1DC L272: ! 542: 539 0002B1DC # } while( index++ < max_ldf_1_index ); ! 543: 540 0002B1DC L268: ! 544: 541 0002B1DC L265: ! 545: 542 0002B1DC 0d effffffc8a 50 movl _index,r0 ! 546: 543 0002B1E3 6d effffffc83 incl _index ! 547: 544 0002B1E9 1d 50 effffffc7c cmpl r0,_max_ldf_1_index ! 548: 545 0002B1F0 81 03 13 ff16 jlss L266 ! 549: 546 0002B1F5 L264: ! 550: 547 0002B1F5 # } /* end of subtest 3 */ ! 551: 548 0002B1F5 40 ret#2 ! 552: 549 0002B1F6 .set L260,0x0 ! 553: 550 0002B1F6 L262: ! 554: 551 0002B1F6 13 ff06 jbr L263 ! 555: 552 0002B1F9 .data ! 556: 553 00000de8 * .text ! 557: 554 0002B1F9 00 .align 1 ! 558: 555 0002B1FA .globl _pipe7_4 ! 559: 556 0002B1FA _pipe7_4: ! 560: 557 0002B1FA 0000 .word L273 ! 561: 558 0002B1FC # ! 562: 559 0002B1FC # ! 563: 560 0002B1FC # ! 564: 561 0002B1FC # ! 565: 562 0002B1FC # ! 566: 563 0002B1FC # ! 567: 564 0002B1FC # /************************************************************************ ! 568: 565 0002B1FC # * ! 569: 566 0002B1FC # * SUBTEST 4 ! 570: 567 0002B1FC # * data in registers, 3 NO-OPs ! 571: 568 0002B1FC # * ! 572: 569 0002B1FC # ************************************************************************/ ! 573: 570 0002B1FC # pipe7_4() ! 574: 571 0002B1FC # { ! 575: 572 0002B1FC 13 0102 jbr L275 ! 576: 573 0002B1FF L276: ! 577: 574 0002B1FF # force_loop = FALSE; /* clear force_loop flag */ ! 578: 575 0002B1FF 4d effffffc67 clrl _force_loop ! 579: 576 0002B205 # index = 0; ! 580: 577 0002B205 4d effffffc61 clrl _index ! 581: 578 0002B20B # do ! 582: 579 0002B20B L279: ! 583: 580 0002B20B # { ! 584: 581 0002B20B # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 585: 582 0002B20B 0d effffffc5b 50 movl _index,r0 ! 586: 583 0002B212 48 03 50 50 shll $3,r0,r0 ! 587: 584 0002B216 0d e000000000 effffffc4b movl _ldf_1_data(r0),_sgl_value_1 ! 588: 585 0002B221 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 589: 586 0002B221 0d effffffc45 50 movl _index,r0 ! 590: 587 0002B228 48 03 50 50 shll $3,r0,r0 ! 591: 588 0002B22C 0d e000000004 effffffc35 movl _ldf_1_data+4(r0),_sgl_expected ! 592: 589 0002B237 # sgl_value_2 = 0; /* set the '0' operand */ ! 593: 590 0002B237 4d effffffc2f clrl _sgl_value_2 ! 594: 591 0002B23D # /* ! 595: 592 0002B23D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 596: 593 0002B23D # * The force loop flag is set after the first error. ! 597: 594 0002B23D # */ ! 598: 595 0002B23D # asm("_pipe7_4_lp1:"); ! 599: 596 0002B23D _pipe7_4_lp1: ! 600: 597 0002B23D # asm("movl _sgl_value_1,r4"); /* move the data to r4 */ ! 601: 598 0002B23D 0d effffffc29 54 movl _sgl_value_1,r4 ! 602: 599 0002B244 # asm("movl _sgl_value_2,r3"); /* move the '0' to r3 */ ! 603: 600 0002B244 0d effffffc22 53 movl _sgl_value_2,r3 ! 604: 601 0002B24B # asm("ldf r4"); /* load the ACC (ACC = op) */ ! 605: 602 0002B24B 06 54 ldf r4 ! 606: 603 0002B24D # asm("nop"); ! 607: 604 0002B24D 10 nop ! 608: 605 0002B24E # asm("nop"); ! 609: 606 0002B24E 10 nop ! 610: 607 0002B24F # asm("nop"); ! 611: 608 0002B24F 10 nop ! 612: 609 0002B250 # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 613: 610 0002B250 d6 54 subf r4 ! 614: 611 0002B252 # asm("nop"); ! 615: 612 0002B252 10 nop ! 616: 613 0002B253 # asm("nop"); ! 617: 614 0002B253 10 nop ! 618: 615 0002B254 # asm("nop"); ! 619: 616 0002B254 10 nop ! 620: 617 0002B255 # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 621: 618 0002B255 c6 53 addf r3 ! 622: 619 0002B257 # asm("nop"); ! 623: 620 0002B257 10 nop ! 624: 621 0002B258 # asm("nop"); ! 625: 622 0002B258 10 nop ! 626: 623 0002B259 # asm("nop"); ! 627: 624 0002B259 10 nop ! 628: 625 0002B25A # asm("subf r4"); /* sub. the op. (ACC =-op) */ ! 629: 626 0002B25A d6 54 subf r4 ! 630: 627 0002B25C # asm("nop"); ! 631: 628 0002B25C 10 nop ! 632: 629 0002B25D # asm("nop"); ! 633: 630 0002B25D 10 nop ! 634: 631 0002B25E # asm("nop"); ! 635: 632 0002B25E 10 nop ! 636: 633 0002B25F # asm("addf r4"); /* add the op. (ACC = 0 ) */ ! 637: 634 0002B25F c6 54 addf r4 ! 638: 635 0002B261 # asm("nop"); ! 639: 636 0002B261 10 nop ! 640: 637 0002B262 # asm("nop"); ! 641: 638 0002B262 10 nop ! 642: 639 0002B263 # asm("nop"); ! 643: 640 0002B263 10 nop ! 644: 641 0002B264 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 645: 642 0002B264 d6 53 subf r3 ! 646: 643 0002B266 # asm("nop"); ! 647: 644 0002B266 10 nop ! 648: 645 0002B267 # asm("nop"); ! 649: 646 0002B267 10 nop ! 650: 647 0002B268 # asm("nop"); ! 651: 648 0002B268 10 nop ! 652: 649 0002B269 # asm("addf r4"); /* add the op. (ACC = op) */ ! 653: 650 0002B269 c6 54 addf r4 ! 654: 651 0002B26B # asm("nop"); ! 655: 652 0002B26B 10 nop ! 656: 653 0002B26C # asm("nop"); ! 657: 654 0002B26C 10 nop ! 658: 655 0002B26D # asm("nop"); ! 659: 656 0002B26D 10 nop ! 660: 657 0002B26E # asm("subf r4"); /* sub. the op. (ACC = 0 ) */ ! 661: 658 0002B26E d6 54 subf r4 ! 662: 659 0002B270 # asm("nop"); ! 663: 660 0002B270 10 nop ! 664: 661 0002B271 # asm("nop"); ! 665: 662 0002B271 10 nop ! 666: 663 0002B272 # asm("nop"); ! 667: 664 0002B272 10 nop ! 668: 665 0002B273 # asm("addf r3"); /* add a '0' (ACC = 0 ) */ ! 669: 666 0002B273 c6 53 addf r3 ! 670: 667 0002B275 # asm("nop"); ! 671: 668 0002B275 10 nop ! 672: 669 0002B276 # asm("nop"); ! 673: 670 0002B276 10 nop ! 674: 671 0002B277 # asm("nop"); ! 675: 672 0002B277 10 nop ! 676: 673 0002B278 # asm("subf r3"); /* sub. a '0' (ACC = 0 ) */ ! 677: 674 0002B278 d6 53 subf r3 ! 678: 675 0002B27A # asm("nop"); ! 679: 676 0002B27A 10 nop ! 680: 677 0002B27B # asm("nop"); ! 681: 678 0002B27B 10 nop ! 682: 679 0002B27C # asm("nop"); ! 683: 680 0002B27C 10 nop ! 684: 681 0002B27D # asm("addf r4"); /* add the op. (ACC = op) */ ! 685: 682 0002B27D c6 54 addf r4 ! 686: 683 0002B27F # asm("nop"); ! 687: 684 0002B27F 10 nop ! 688: 685 0002B280 # asm("nop"); ! 689: 686 0002B280 10 nop ! 690: 687 0002B281 # asm("nop"); ! 691: 688 0002B281 10 nop ! 692: 689 0002B282 # asm("stf r5"); /* store the ACC (s/b= op) */ ! 693: 690 0002B282 26 55 stf r5 ! 694: 691 0002B284 # if( force_loop ) ! 695: 692 0002B284 5d effffffbe2 tstl _force_loop ! 696: 693 0002B28A 31 02 jeql L280 ! 697: 694 0002B28C # asm("brb _pipe7_4_lp1");; /* loop on the error */ ! 698: 695 0002B28C 11 af brb _pipe7_4_lp1 ! 699: 696 0002B28E L280: ! 700: 697 0002B28E # /* ! 701: 698 0002B28E # * verify the results ! 702: 699 0002B28E # */ ! 703: 700 0002B28E # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 704: 701 0002B28E 0d 55 effffffbd7 movl r5,_sgl_st_acc ! 705: 702 0002B295 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 706: 703 0002B295 1d effffffbd1 effffffbcc cmpl _sgl_st_acc,_sgl_expected ! 707: 704 0002B2A0 31 45 jeql L281 ! 708: 705 0002B2A2 # { ! 709: 706 0002B2A2 # errcnt++; /* bump the error count */ ! 710: 707 0002B2A2 6d effffffbc4 incl _errcnt ! 711: 708 0002B2A8 # if ( prt_error ) ! 712: 709 0002B2A8 5d effffffbbe tstl _prt_error ! 713: 710 0002B2AE 31 0d jeql L282 ! 714: 711 0002B2B0 # print_pipe7_er("Reg. Data, 3 NO-OPs"); ! 715: 712 0002B2B0 .data 1 ! 716: 713 00000e2d * L283: ! 717: 714 00000e2d * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0" ! 718: 04E4F2D4F507300 ! 719: 715 00000e41 * .text ! 720: 716 0002B2B0 dd 8f00000e2d pushl $L283 ! 721: 717 0002B2B6 fe 08 ef0000080f callf $8,_print_pipe7_er ! 722: 718 0002B2BD # if ( halt_flg ) ! 723: 719 0002B2BD L282: ! 724: 720 0002B2BD 5d effffffba9 tstl _halt_flg ! 725: 721 0002B2C3 31 0d jeql L284 ! 726: 722 0002B2C5 # pipe7_er_hlt( subtest ); ! 727: 723 0002B2C5 dd effffffba1 pushl _subtest ! 728: 724 0002B2CB fe 08 ef00000912 callf $8,_pipe7_er_hlt ! 729: 725 0002B2D2 # if ( loop_on_err ) { ! 730: 726 0002B2D2 L284: ! 731: 727 0002B2D2 5d effffffb94 tstl _loop_on_err ! 732: 728 0002B2D8 31 0d jeql L285 ! 733: 729 0002B2DA # force_loop = TRUE; /* set the force loop flag */ ! 734: 730 0002B2DA 0d 01 effffffb8b movl $1,_force_loop ! 735: 731 0002B2E1 # asm("jmp _pipe7_4_lp1"); /* and loop */ ! 736: 732 0002B2E1 71 efffffff56 jmp _pipe7_4_lp1 ! 737: 733 0002B2E7 # } ! 738: 734 0002B2E7 # } /* end of compare error */ ! 739: 735 0002B2E7 L285: ! 740: 736 0002B2E7 # } while( index++ < max_ldf_1_index ); ! 741: 737 0002B2E7 L281: ! 742: 738 0002B2E7 L278: ! 743: 739 0002B2E7 0d effffffb7f 50 movl _index,r0 ! 744: 740 0002B2EE 6d effffffb78 incl _index ! 745: 741 0002B2F4 1d 50 effffffb71 cmpl r0,_max_ldf_1_index ! 746: 742 0002B2FB 81 03 13 ff0b jlss L279 ! 747: 743 0002B300 L277: ! 748: 744 0002B300 # } /* end of subtest 4 */ ! 749: 745 0002B300 40 ret#2 ! 750: 746 0002B301 .set L273,0x0 ! 751: 747 0002B301 L275: ! 752: 748 0002B301 13 fefb jbr L276 ! 753: 749 0002B304 .data ! 754: 750 00000de8 * .text ! 755: 751 0002B304 .align 1 ! 756: 752 0002B304 .globl _pipe7_5 ! 757: 753 0002B304 _pipe7_5: ! 758: 754 0002B304 0000 .word L286 ! 759: 755 0002B306 # ! 760: 756 0002B306 # ! 761: 757 0002B306 # ! 762: 758 0002B306 # ! 763: 759 0002B306 # ! 764: 760 0002B306 # ! 765: 761 0002B306 # ! 766: 762 0002B306 # /************************************************************************ ! 767: 763 0002B306 # * ! 768: 764 0002B306 # * SUBTEST 5 ! 769: 765 0002B306 # * data in Cache, no NO-OPs ! 770: 766 0002B306 # * ! 771: 767 0002B306 # ************************************************************************/ ! 772: 768 0002B306 # pipe7_5() ! 773: 769 0002B306 # { ! 774: 770 0002B306 13 00fc jbr L288 ! 775: 771 0002B309 L289: ! 776: 772 0002B309 # force_loop = FALSE; /* clear force_loop flag */ ! 777: 773 0002B309 4d effffffb5d clrl _force_loop ! 778: 774 0002B30F # index = 0; ! 779: 775 0002B30F 4d effffffb57 clrl _index ! 780: 776 0002B315 # do ! 781: 777 0002B315 L292: ! 782: 778 0002B315 # { ! 783: 779 0002B315 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 784: 780 0002B315 0d effffffb51 50 movl _index,r0 ! 785: 781 0002B31C 48 03 50 50 shll $3,r0,r0 ! 786: 782 0002B320 0d e000000000 effffffb41 movl _ldf_1_data(r0),_sgl_value_1 ! 787: 783 0002B32B # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 788: 784 0002B32B 0d effffffb3b 50 movl _index,r0 ! 789: 785 0002B332 48 03 50 50 shll $3,r0,r0 ! 790: 786 0002B336 0d e000000004 effffffb2b movl _ldf_1_data+4(r0),_sgl_expected ! 791: 787 0002B341 # sgl_value_2 = 0; /* set the '0' operand */ ! 792: 788 0002B341 4d effffffb25 clrl _sgl_value_2 ! 793: 789 0002B347 # /* ! 794: 790 0002B347 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 795: 791 0002B347 # * The force loop flag is set after the first error. ! 796: 792 0002B347 # */ ! 797: 793 0002B347 # asm("_pipe7_5_lp1:"); ! 798: 794 0002B347 _pipe7_5_lp1: ! 799: 795 0002B347 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */ ! 800: 796 0002B347 06 effffffb1f ldf _sgl_value_1 ! 801: 797 0002B34D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 802: 798 0002B34D d6 effffffb19 subf _sgl_value_1 ! 803: 799 0002B353 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 804: 800 0002B353 c6 effffffb13 addf _sgl_value_2 ! 805: 801 0002B359 # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */ ! 806: 802 0002B359 d6 effffffb0d subf _sgl_value_1 ! 807: 803 0002B35F # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */ ! 808: 804 0002B35F c6 effffffb07 addf _sgl_value_1 ! 809: 805 0002B365 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 810: 806 0002B365 d6 effffffb01 subf _sgl_value_2 ! 811: 807 0002B36B # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 812: 808 0002B36B c6 effffffafb addf _sgl_value_1 ! 813: 809 0002B371 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 814: 810 0002B371 d6 effffffaf5 subf _sgl_value_1 ! 815: 811 0002B377 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 816: 812 0002B377 c6 effffffaef addf _sgl_value_2 ! 817: 813 0002B37D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 818: 814 0002B37D d6 effffffae9 subf _sgl_value_2 ! 819: 815 0002B383 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 820: 816 0002B383 c6 effffffae3 addf _sgl_value_1 ! 821: 817 0002B389 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */ ! 822: 818 0002B389 26 effffffadd stf _sgl_st_acc ! 823: 819 0002B38F # if( force_loop ) ! 824: 820 0002B38F 5d effffffad7 tstl _force_loop ! 825: 821 0002B395 31 02 jeql L293 ! 826: 822 0002B397 # asm("brb _pipe7_5_lp1");; /* loop on the error */ ! 827: 823 0002B397 11 ae brb _pipe7_5_lp1 ! 828: 824 0002B399 L293: ! 829: 825 0002B399 # /* ! 830: 826 0002B399 # * verify the results ! 831: 827 0002B399 # */ ! 832: 828 0002B399 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 833: 829 0002B399 1d effffffacd effffffac8 cmpl _sgl_st_acc,_sgl_expected ! 834: 830 0002B3A4 31 45 jeql L294 ! 835: 831 0002B3A6 # { ! 836: 832 0002B3A6 # errcnt++; /* bump the error count */ ! 837: 833 0002B3A6 6d effffffac0 incl _errcnt ! 838: 834 0002B3AC # if ( prt_error ) ! 839: 835 0002B3AC 5d effffffaba tstl _prt_error ! 840: 836 0002B3B2 31 0d jeql L295 ! 841: 837 0002B3B4 # print_pipe7_er("Cache Data, no NO-OPs"); ! 842: 838 0002B3B4 .data 1 ! 843: 839 00000e41 * L296: ! 844: 840 00000e41 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0" ! 845: E6F204E4F2D4F507300 ! 846: 841 00000e57 * .text ! 847: 842 0002B3B4 dd 8f00000e41 pushl $L296 ! 848: 843 0002B3BA fe 08 ef0000070b callf $8,_print_pipe7_er ! 849: 844 0002B3C1 # if ( halt_flg ) ! 850: 845 0002B3C1 L295: ! 851: 846 0002B3C1 5d effffffaa5 tstl _halt_flg ! 852: 847 0002B3C7 31 0d jeql L297 ! 853: 848 0002B3C9 # pipe7_er_hlt( subtest ); ! 854: 849 0002B3C9 dd effffffa9d pushl _subtest ! 855: 850 0002B3CF fe 08 ef0000080e callf $8,_pipe7_er_hlt ! 856: 851 0002B3D6 # if ( loop_on_err ) { ! 857: 852 0002B3D6 L297: ! 858: 853 0002B3D6 5d effffffa90 tstl _loop_on_err ! 859: 854 0002B3DC 31 0d jeql L298 ! 860: 855 0002B3DE # force_loop = TRUE; /* set the force loop flag */ ! 861: 856 0002B3DE 0d 01 effffffa87 movl $1,_force_loop ! 862: 857 0002B3E5 # asm("jmp _pipe7_5_lp1"); /* and loop */ ! 863: 858 0002B3E5 71 efffffff5c jmp _pipe7_5_lp1 ! 864: 859 0002B3EB # } ! 865: 860 0002B3EB # } /* end of compare error */ ! 866: 861 0002B3EB L298: ! 867: 862 0002B3EB # } while( index++ < max_ldf_1_index ); ! 868: 863 0002B3EB L294: ! 869: 864 0002B3EB L291: ! 870: 865 0002B3EB 0d effffffa7b 50 movl _index,r0 ! 871: 866 0002B3F2 6d effffffa74 incl _index ! 872: 867 0002B3F8 1d 50 effffffa6d cmpl r0,_max_ldf_1_index ! 873: 868 0002B3FF 81 03 13 ff11 jlss L292 ! 874: 869 0002B404 L290: ! 875: 870 0002B404 # } /* end of subtest 5 */ ! 876: 871 0002B404 40 ret#2 ! 877: 872 0002B405 .set L286,0x0 ! 878: 873 0002B405 L288: ! 879: 874 0002B405 13 ff01 jbr L289 ! 880: 875 0002B408 .data ! 881: 876 00000de8 * .text ! 882: 877 0002B408 .align 1 ! 883: 878 0002B408 .globl _pipe7_6 ! 884: 879 0002B408 _pipe7_6: ! 885: 880 0002B408 0000 .word L299 ! 886: 881 0002B40A # ! 887: 882 0002B40A # ! 888: 883 0002B40A # ! 889: 884 0002B40A # ! 890: 885 0002B40A # ! 891: 886 0002B40A # ! 892: 887 0002B40A # /************************************************************************ ! 893: 888 0002B40A # * ! 894: 889 0002B40A # * SUBTEST 6 ! 895: 890 0002B40A # * data in Cache, 1 NO-OP ! 896: 891 0002B40A # * ! 897: 892 0002B40A # ************************************************************************/ ! 898: 893 0002B40A # pipe7_6() ! 899: 894 0002B40A # { ! 900: 895 0002B40A 13 0101 jbr L301 ! 901: 896 0002B40D L302: ! 902: 897 0002B40D # force_loop = FALSE; /* clear force_loop flag */ ! 903: 898 0002B40D 4d effffffa59 clrl _force_loop ! 904: 899 0002B413 # index = 0; ! 905: 900 0002B413 4d effffffa53 clrl _index ! 906: 901 0002B419 # do ! 907: 902 0002B419 L305: ! 908: 903 0002B419 # { ! 909: 904 0002B419 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 910: 905 0002B419 0d effffffa4d 50 movl _index,r0 ! 911: 906 0002B420 48 03 50 50 shll $3,r0,r0 ! 912: 907 0002B424 0d e000000000 effffffa3d movl _ldf_1_data(r0),_sgl_value_1 ! 913: 908 0002B42F # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 914: 909 0002B42F 0d effffffa37 50 movl _index,r0 ! 915: 910 0002B436 48 03 50 50 shll $3,r0,r0 ! 916: 911 0002B43A 0d e000000004 effffffa27 movl _ldf_1_data+4(r0),_sgl_expected ! 917: 912 0002B445 # /* ! 918: 913 0002B445 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 919: 914 0002B445 # * The force loop flag is set after the first error. ! 920: 915 0002B445 # */ ! 921: 916 0002B445 # asm("_pipe7_6_lp1:"); ! 922: 917 0002B445 _pipe7_6_lp1: ! 923: 918 0002B445 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */ ! 924: 919 0002B445 06 effffffa21 ldf _sgl_value_1 ! 925: 920 0002B44B # asm("nop"); ! 926: 921 0002B44B 10 nop ! 927: 922 0002B44C # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 928: 923 0002B44C d6 effffffa1a subf _sgl_value_1 ! 929: 924 0002B452 # asm("nop"); ! 930: 925 0002B452 10 nop ! 931: 926 0002B453 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 932: 927 0002B453 c6 effffffa13 addf _sgl_value_2 ! 933: 928 0002B459 # asm("nop"); ! 934: 929 0002B459 10 nop ! 935: 930 0002B45A # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */ ! 936: 931 0002B45A d6 effffffa0c subf _sgl_value_1 ! 937: 932 0002B460 # asm("nop"); ! 938: 933 0002B460 10 nop ! 939: 934 0002B461 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */ ! 940: 935 0002B461 c6 effffffa05 addf _sgl_value_1 ! 941: 936 0002B467 # asm("nop"); ! 942: 937 0002B467 10 nop ! 943: 938 0002B468 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 944: 939 0002B468 d6 effffff9fe subf _sgl_value_2 ! 945: 940 0002B46E # asm("nop"); ! 946: 941 0002B46E 10 nop ! 947: 942 0002B46F # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 948: 943 0002B46F c6 effffff9f7 addf _sgl_value_1 ! 949: 944 0002B475 # asm("nop"); ! 950: 945 0002B475 10 nop ! 951: 946 0002B476 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 952: 947 0002B476 d6 effffff9f0 subf _sgl_value_1 ! 953: 948 0002B47C # asm("nop"); ! 954: 949 0002B47C 10 nop ! 955: 950 0002B47D # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 956: 951 0002B47D c6 effffff9e9 addf _sgl_value_2 ! 957: 952 0002B483 # asm("nop"); ! 958: 953 0002B483 10 nop ! 959: 954 0002B484 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 960: 955 0002B484 d6 effffff9e2 subf _sgl_value_2 ! 961: 956 0002B48A # asm("nop"); ! 962: 957 0002B48A 10 nop ! 963: 958 0002B48B # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 964: 959 0002B48B c6 effffff9db addf _sgl_value_1 ! 965: 960 0002B491 # asm("nop"); ! 966: 961 0002B491 10 nop ! 967: 962 0002B492 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */ ! 968: 963 0002B492 26 effffff9d4 stf _sgl_st_acc ! 969: 964 0002B498 # if( force_loop ) ! 970: 965 0002B498 5d effffff9ce tstl _force_loop ! 971: 966 0002B49E 31 02 jeql L306 ! 972: 967 0002B4A0 # asm("brb _pipe7_6_lp1");; /* loop on the error */ ! 973: 968 0002B4A0 11 a3 brb _pipe7_6_lp1 ! 974: 969 0002B4A2 L306: ! 975: 970 0002B4A2 # /* ! 976: 971 0002B4A2 # * verify the results ! 977: 972 0002B4A2 # */ ! 978: 973 0002B4A2 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 979: 974 0002B4A2 1d effffff9c4 effffff9bf cmpl _sgl_st_acc,_sgl_expected ! 980: 975 0002B4AD 31 45 jeql L307 ! 981: 976 0002B4AF # { ! 982: 977 0002B4AF # errcnt++; /* bump the error count */ ! 983: 978 0002B4AF 6d effffff9b7 incl _errcnt ! 984: 979 0002B4B5 # if ( prt_error ) ! 985: 980 0002B4B5 5d effffff9b1 tstl _prt_error ! 986: 981 0002B4BB 31 0d jeql L308 ! 987: 982 0002B4BD # print_pipe7_er("Cache Data, 1 NO-OP"); ! 988: 983 0002B4BD .data 1 ! 989: 984 00000e57 * L309: ! 990: 985 00000e57 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0" ! 991: 1204E4F2D4F5000 ! 992: 986 00000e6b * .text ! 993: 987 0002B4BD dd 8f00000e57 pushl $L309 ! 994: 988 0002B4C3 fe 08 ef00000602 callf $8,_print_pipe7_er ! 995: 989 0002B4CA # if ( halt_flg ) ! 996: 990 0002B4CA L308: ! 997: 991 0002B4CA 5d effffff99c tstl _halt_flg ! 998: 992 0002B4D0 31 0d jeql L310 ! 999: 993 0002B4D2 # pipe7_er_hlt( subtest ); ! 1000: 994 0002B4D2 dd effffff994 pushl _subtest ! 1001: 995 0002B4D8 fe 08 ef00000705 callf $8,_pipe7_er_hlt ! 1002: 996 0002B4DF # if ( loop_on_err ) { ! 1003: 997 0002B4DF L310: ! 1004: 998 0002B4DF 5d effffff987 tstl _loop_on_err ! 1005: 999 0002B4E5 31 0d jeql L311 ! 1006: 1000 0002B4E7 # force_loop = TRUE; /* set the force loop flag */ ! 1007: 1001 0002B4E7 0d 01 effffff97e movl $1,_force_loop ! 1008: 1002 0002B4EE # asm("jmp _pipe7_6_lp1"); /* and loop */ ! 1009: 1003 0002B4EE 71 efffffff51 jmp _pipe7_6_lp1 ! 1010: 1004 0002B4F4 # } ! 1011: 1005 0002B4F4 # } /* end of compare error */ ! 1012: 1006 0002B4F4 L311: ! 1013: 1007 0002B4F4 # } while( index++ < max_ldf_1_index ); ! 1014: 1008 0002B4F4 L307: ! 1015: 1009 0002B4F4 L304: ! 1016: 1010 0002B4F4 0d effffff972 50 movl _index,r0 ! 1017: 1011 0002B4FB 6d effffff96b incl _index ! 1018: 1012 0002B501 1d 50 effffff964 cmpl r0,_max_ldf_1_index ! 1019: 1013 0002B508 81 03 13 ff0c jlss L305 ! 1020: 1014 0002B50D L303: ! 1021: 1015 0002B50D # } /* end of subtest 6 */ ! 1022: 1016 0002B50D 40 ret#2 ! 1023: 1017 0002B50E .set L299,0x0 ! 1024: 1018 0002B50E L301: ! 1025: 1019 0002B50E 13 fefc jbr L302 ! 1026: 1020 0002B511 .data ! 1027: 1021 00000de8 * .text ! 1028: 1022 0002B511 00 .align 1 ! 1029: 1023 0002B512 .globl _pipe7_7 ! 1030: 1024 0002B512 _pipe7_7: ! 1031: 1025 0002B512 0000 .word L312 ! 1032: 1026 0002B514 # ! 1033: 1027 0002B514 # ! 1034: 1028 0002B514 # ! 1035: 1029 0002B514 # ! 1036: 1030 0002B514 # ! 1037: 1031 0002B514 # ! 1038: 1032 0002B514 # /************************************************************************ ! 1039: 1033 0002B514 # * ! 1040: 1034 0002B514 # * SUBTEST 7 ! 1041: 1035 0002B514 # * data in Cache, 2 NO-OPs ! 1042: 1036 0002B514 # * ! 1043: 1037 0002B514 # ************************************************************************/ ! 1044: 1038 0002B514 # pipe7_7() ! 1045: 1039 0002B514 # { ! 1046: 1040 0002B514 13 0112 jbr L314 ! 1047: 1041 0002B517 L315: ! 1048: 1042 0002B517 # force_loop = FALSE; /* clear force_loop flag */ ! 1049: 1043 0002B517 4d effffff94f clrl _force_loop ! 1050: 1044 0002B51D # index = 0; ! 1051: 1045 0002B51D 4d effffff949 clrl _index ! 1052: 1046 0002B523 # do ! 1053: 1047 0002B523 L318: ! 1054: 1048 0002B523 # { ! 1055: 1049 0002B523 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1056: 1050 0002B523 0d effffff943 50 movl _index,r0 ! 1057: 1051 0002B52A 48 03 50 50 shll $3,r0,r0 ! 1058: 1052 0002B52E 0d e000000000 effffff933 movl _ldf_1_data(r0),_sgl_value_1 ! 1059: 1053 0002B539 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1060: 1054 0002B539 0d effffff92d 50 movl _index,r0 ! 1061: 1055 0002B540 48 03 50 50 shll $3,r0,r0 ! 1062: 1056 0002B544 0d e000000004 effffff91d movl _ldf_1_data+4(r0),_sgl_expected ! 1063: 1057 0002B54F # sgl_value_2 = 0; /* set the '0' operand */ ! 1064: 1058 0002B54F 4d effffff917 clrl _sgl_value_2 ! 1065: 1059 0002B555 # /* ! 1066: 1060 0002B555 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1067: 1061 0002B555 # * The force loop flag is set after the first error. ! 1068: 1062 0002B555 # */ ! 1069: 1063 0002B555 # asm("_pipe7_7_lp1:"); ! 1070: 1064 0002B555 _pipe7_7_lp1: ! 1071: 1065 0002B555 # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */ ! 1072: 1066 0002B555 06 effffff911 ldf _sgl_value_1 ! 1073: 1067 0002B55B # asm("nop"); ! 1074: 1068 0002B55B 10 nop ! 1075: 1069 0002B55C # asm("nop"); ! 1076: 1070 0002B55C 10 nop ! 1077: 1071 0002B55D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 1078: 1072 0002B55D d6 effffff909 subf _sgl_value_1 ! 1079: 1073 0002B563 # asm("nop"); ! 1080: 1074 0002B563 10 nop ! 1081: 1075 0002B564 # asm("nop"); ! 1082: 1076 0002B564 10 nop ! 1083: 1077 0002B565 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 1084: 1078 0002B565 c6 effffff901 addf _sgl_value_2 ! 1085: 1079 0002B56B # asm("nop"); ! 1086: 1080 0002B56B 10 nop ! 1087: 1081 0002B56C # asm("nop"); ! 1088: 1082 0002B56C 10 nop ! 1089: 1083 0002B56D # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */ ! 1090: 1084 0002B56D d6 effffff8f9 subf _sgl_value_1 ! 1091: 1085 0002B573 # asm("nop"); ! 1092: 1086 0002B573 10 nop ! 1093: 1087 0002B574 # asm("nop"); ! 1094: 1088 0002B574 10 nop ! 1095: 1089 0002B575 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */ ! 1096: 1090 0002B575 c6 effffff8f1 addf _sgl_value_1 ! 1097: 1091 0002B57B # asm("nop"); ! 1098: 1092 0002B57B 10 nop ! 1099: 1093 0002B57C # asm("nop"); ! 1100: 1094 0002B57C 10 nop ! 1101: 1095 0002B57D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 1102: 1096 0002B57D d6 effffff8e9 subf _sgl_value_2 ! 1103: 1097 0002B583 # asm("nop"); ! 1104: 1098 0002B583 10 nop ! 1105: 1099 0002B584 # asm("nop"); ! 1106: 1100 0002B584 10 nop ! 1107: 1101 0002B585 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 1108: 1102 0002B585 c6 effffff8e1 addf _sgl_value_1 ! 1109: 1103 0002B58B # asm("nop"); ! 1110: 1104 0002B58B 10 nop ! 1111: 1105 0002B58C # asm("nop"); ! 1112: 1106 0002B58C 10 nop ! 1113: 1107 0002B58D # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 1114: 1108 0002B58D d6 effffff8d9 subf _sgl_value_1 ! 1115: 1109 0002B593 # asm("nop"); ! 1116: 1110 0002B593 10 nop ! 1117: 1111 0002B594 # asm("nop"); ! 1118: 1112 0002B594 10 nop ! 1119: 1113 0002B595 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 1120: 1114 0002B595 c6 effffff8d1 addf _sgl_value_2 ! 1121: 1115 0002B59B # asm("nop"); ! 1122: 1116 0002B59B 10 nop ! 1123: 1117 0002B59C # asm("nop"); ! 1124: 1118 0002B59C 10 nop ! 1125: 1119 0002B59D # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 1126: 1120 0002B59D d6 effffff8c9 subf _sgl_value_2 ! 1127: 1121 0002B5A3 # asm("nop"); ! 1128: 1122 0002B5A3 10 nop ! 1129: 1123 0002B5A4 # asm("nop"); ! 1130: 1124 0002B5A4 10 nop ! 1131: 1125 0002B5A5 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 1132: 1126 0002B5A5 c6 effffff8c1 addf _sgl_value_1 ! 1133: 1127 0002B5AB # asm("nop"); ! 1134: 1128 0002B5AB 10 nop ! 1135: 1129 0002B5AC # asm("nop"); ! 1136: 1130 0002B5AC 10 nop ! 1137: 1131 0002B5AD # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */ ! 1138: 1132 0002B5AD 26 effffff8b9 stf _sgl_st_acc ! 1139: 1133 0002B5B3 # if( force_loop ) ! 1140: 1134 0002B5B3 5d effffff8b3 tstl _force_loop ! 1141: 1135 0002B5B9 31 02 jeql L319 ! 1142: 1136 0002B5BB # asm("brb _pipe7_7_lp1");; /* loop on the error */ ! 1143: 1137 0002B5BB 11 98 brb _pipe7_7_lp1 ! 1144: 1138 0002B5BD L319: ! 1145: 1139 0002B5BD # /* ! 1146: 1140 0002B5BD # * verify the results ! 1147: 1141 0002B5BD # */ ! 1148: 1142 0002B5BD # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 1149: 1143 0002B5BD 1d effffff8a9 effffff8a4 cmpl _sgl_st_acc,_sgl_expected ! 1150: 1144 0002B5C8 31 45 jeql L320 ! 1151: 1145 0002B5CA # { ! 1152: 1146 0002B5CA # errcnt++; /* bump the error count */ ! 1153: 1147 0002B5CA 6d effffff89c incl _errcnt ! 1154: 1148 0002B5D0 # if ( prt_error ) ! 1155: 1149 0002B5D0 5d effffff896 tstl _prt_error ! 1156: 1150 0002B5D6 31 0d jeql L321 ! 1157: 1151 0002B5D8 # print_pipe7_er("Cache Data, 2 NO-OPs"); ! 1158: 1152 0002B5D8 .data 1 ! 1159: 1153 00000e6b * L322: ! 1160: 1154 00000e6b * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0" ! 1161: 2204E4F2D4F507300 ! 1162: 1155 00000e80 * .text ! 1163: 1156 0002B5D8 dd 8f00000e6b pushl $L322 ! 1164: 1157 0002B5DE fe 08 ef000004e7 callf $8,_print_pipe7_er ! 1165: 1158 0002B5E5 # if ( halt_flg ) ! 1166: 1159 0002B5E5 L321: ! 1167: 1160 0002B5E5 5d effffff881 tstl _halt_flg ! 1168: 1161 0002B5EB 31 0d jeql L323 ! 1169: 1162 0002B5ED # pipe7_er_hlt( subtest ); ! 1170: 1163 0002B5ED dd effffff879 pushl _subtest ! 1171: 1164 0002B5F3 fe 08 ef000005ea callf $8,_pipe7_er_hlt ! 1172: 1165 0002B5FA # if ( loop_on_err ) { ! 1173: 1166 0002B5FA L323: ! 1174: 1167 0002B5FA 5d effffff86c tstl _loop_on_err ! 1175: 1168 0002B600 31 0d jeql L324 ! 1176: 1169 0002B602 # force_loop = TRUE; /* set the force loop flag */ ! 1177: 1170 0002B602 0d 01 effffff863 movl $1,_force_loop ! 1178: 1171 0002B609 # asm("jmp _pipe7_7_lp1"); /* and loop */ ! 1179: 1172 0002B609 71 efffffff46 jmp _pipe7_7_lp1 ! 1180: 1173 0002B60F # } ! 1181: 1174 0002B60F # } /* end of compare error */ ! 1182: 1175 0002B60F L324: ! 1183: 1176 0002B60F # } while( index++ < max_ldf_1_index ); ! 1184: 1177 0002B60F L320: ! 1185: 1178 0002B60F L317: ! 1186: 1179 0002B60F 0d effffff857 50 movl _index,r0 ! 1187: 1180 0002B616 6d effffff850 incl _index ! 1188: 1181 0002B61C 1d 50 effffff849 cmpl r0,_max_ldf_1_index ! 1189: 1182 0002B623 81 03 13 fefb jlss L318 ! 1190: 1183 0002B628 L316: ! 1191: 1184 0002B628 # } /* end of subtest 7 */ ! 1192: 1185 0002B628 40 ret#2 ! 1193: 1186 0002B629 .set L312,0x0 ! 1194: 1187 0002B629 L314: ! 1195: 1188 0002B629 13 feeb jbr L315 ! 1196: 1189 0002B62C .data ! 1197: 1190 00000de8 * .text ! 1198: 1191 0002B62C .align 1 ! 1199: 1192 0002B62C .globl _pipe7_8 ! 1200: 1193 0002B62C _pipe7_8: ! 1201: 1194 0002B62C 0000 .word L325 ! 1202: 1195 0002B62E # ! 1203: 1196 0002B62E # ! 1204: 1197 0002B62E # ! 1205: 1198 0002B62E # ! 1206: 1199 0002B62E # ! 1207: 1200 0002B62E # ! 1208: 1201 0002B62E # /************************************************************************ ! 1209: 1202 0002B62E # * ! 1210: 1203 0002B62E # * SUBTEST 8 ! 1211: 1204 0002B62E # * data in Cache, 3 NO-OPs ! 1212: 1205 0002B62E # * ! 1213: 1206 0002B62E # ************************************************************************/ ! 1214: 1207 0002B62E # pipe7_8() ! 1215: 1208 0002B62E # { ! 1216: 1209 0002B62E 13 011d jbr L327 ! 1217: 1210 0002B631 L328: ! 1218: 1211 0002B631 # force_loop = FALSE; /* clear force_loop flag */ ! 1219: 1212 0002B631 4d effffff835 clrl _force_loop ! 1220: 1213 0002B637 # index = 0; ! 1221: 1214 0002B637 4d effffff82f clrl _index ! 1222: 1215 0002B63D # do ! 1223: 1216 0002B63D L331: ! 1224: 1217 0002B63D # { ! 1225: 1218 0002B63D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1226: 1219 0002B63D 0d effffff829 50 movl _index,r0 ! 1227: 1220 0002B644 48 03 50 50 shll $3,r0,r0 ! 1228: 1221 0002B648 0d e000000000 effffff819 movl _ldf_1_data(r0),_sgl_value_1 ! 1229: 1222 0002B653 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1230: 1223 0002B653 0d effffff813 50 movl _index,r0 ! 1231: 1224 0002B65A 48 03 50 50 shll $3,r0,r0 ! 1232: 1225 0002B65E 0d e000000004 effffff803 movl _ldf_1_data+4(r0),_sgl_expected ! 1233: 1226 0002B669 # sgl_value_2 = 0; /* set the '0' operand */ ! 1234: 1227 0002B669 4d effffff7fd clrl _sgl_value_2 ! 1235: 1228 0002B66F # /* ! 1236: 1229 0002B66F # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1237: 1230 0002B66F # * The force loop flag is set after the first error. ! 1238: 1231 0002B66F # */ ! 1239: 1232 0002B66F # asm("_pipe7_8_lp1:"); ! 1240: 1233 0002B66F _pipe7_8_lp1: ! 1241: 1234 0002B66F # asm("ldf _sgl_value_1"); /* load the ACC (ACC = op) */ ! 1242: 1235 0002B66F 06 effffff7f7 ldf _sgl_value_1 ! 1243: 1236 0002B675 # asm("nop"); ! 1244: 1237 0002B675 10 nop ! 1245: 1238 0002B676 # asm("nop"); ! 1246: 1239 0002B676 10 nop ! 1247: 1240 0002B677 # asm("nop"); ! 1248: 1241 0002B677 10 nop ! 1249: 1242 0002B678 # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 1250: 1243 0002B678 d6 effffff7ee subf _sgl_value_1 ! 1251: 1244 0002B67E # asm("nop"); ! 1252: 1245 0002B67E 10 nop ! 1253: 1246 0002B67F # asm("nop"); ! 1254: 1247 0002B67F 10 nop ! 1255: 1248 0002B680 # asm("nop"); ! 1256: 1249 0002B680 10 nop ! 1257: 1250 0002B681 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 1258: 1251 0002B681 c6 effffff7e5 addf _sgl_value_2 ! 1259: 1252 0002B687 # asm("nop"); ! 1260: 1253 0002B687 10 nop ! 1261: 1254 0002B688 # asm("nop"); ! 1262: 1255 0002B688 10 nop ! 1263: 1256 0002B689 # asm("nop"); ! 1264: 1257 0002B689 10 nop ! 1265: 1258 0002B68A # asm("subf _sgl_value_1"); /* sub. the op. (ACC =-op) */ ! 1266: 1259 0002B68A d6 effffff7dc subf _sgl_value_1 ! 1267: 1260 0002B690 # asm("nop"); ! 1268: 1261 0002B690 10 nop ! 1269: 1262 0002B691 # asm("nop"); ! 1270: 1263 0002B691 10 nop ! 1271: 1264 0002B692 # asm("nop"); ! 1272: 1265 0002B692 10 nop ! 1273: 1266 0002B693 # asm("addf _sgl_value_1"); /* add the op. (ACC = 0 ) */ ! 1274: 1267 0002B693 c6 effffff7d3 addf _sgl_value_1 ! 1275: 1268 0002B699 # asm("nop"); ! 1276: 1269 0002B699 10 nop ! 1277: 1270 0002B69A # asm("nop"); ! 1278: 1271 0002B69A 10 nop ! 1279: 1272 0002B69B # asm("nop"); ! 1280: 1273 0002B69B 10 nop ! 1281: 1274 0002B69C # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 1282: 1275 0002B69C d6 effffff7ca subf _sgl_value_2 ! 1283: 1276 0002B6A2 # asm("nop"); ! 1284: 1277 0002B6A2 10 nop ! 1285: 1278 0002B6A3 # asm("nop"); ! 1286: 1279 0002B6A3 10 nop ! 1287: 1280 0002B6A4 # asm("nop"); ! 1288: 1281 0002B6A4 10 nop ! 1289: 1282 0002B6A5 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 1290: 1283 0002B6A5 c6 effffff7c1 addf _sgl_value_1 ! 1291: 1284 0002B6AB # asm("nop"); ! 1292: 1285 0002B6AB 10 nop ! 1293: 1286 0002B6AC # asm("nop"); ! 1294: 1287 0002B6AC 10 nop ! 1295: 1288 0002B6AD # asm("nop"); ! 1296: 1289 0002B6AD 10 nop ! 1297: 1290 0002B6AE # asm("subf _sgl_value_1"); /* sub. the op. (ACC = 0 ) */ ! 1298: 1291 0002B6AE d6 effffff7b8 subf _sgl_value_1 ! 1299: 1292 0002B6B4 # asm("nop"); ! 1300: 1293 0002B6B4 10 nop ! 1301: 1294 0002B6B5 # asm("nop"); ! 1302: 1295 0002B6B5 10 nop ! 1303: 1296 0002B6B6 # asm("nop"); ! 1304: 1297 0002B6B6 10 nop ! 1305: 1298 0002B6B7 # asm("addf _sgl_value_2"); /* add a '0' (ACC = 0 ) */ ! 1306: 1299 0002B6B7 c6 effffff7af addf _sgl_value_2 ! 1307: 1300 0002B6BD # asm("nop"); ! 1308: 1301 0002B6BD 10 nop ! 1309: 1302 0002B6BE # asm("nop"); ! 1310: 1303 0002B6BE 10 nop ! 1311: 1304 0002B6BF # asm("nop"); ! 1312: 1305 0002B6BF 10 nop ! 1313: 1306 0002B6C0 # asm("subf _sgl_value_2"); /* sub. a '0' (ACC = 0 ) */ ! 1314: 1307 0002B6C0 d6 effffff7a6 subf _sgl_value_2 ! 1315: 1308 0002B6C6 # asm("nop"); ! 1316: 1309 0002B6C6 10 nop ! 1317: 1310 0002B6C7 # asm("nop"); ! 1318: 1311 0002B6C7 10 nop ! 1319: 1312 0002B6C8 # asm("nop"); ! 1320: 1313 0002B6C8 10 nop ! 1321: 1314 0002B6C9 # asm("addf _sgl_value_1"); /* add the op. (ACC = op) */ ! 1322: 1315 0002B6C9 c6 effffff79d addf _sgl_value_1 ! 1323: 1316 0002B6CF # asm("nop"); ! 1324: 1317 0002B6CF 10 nop ! 1325: 1318 0002B6D0 # asm("nop"); ! 1326: 1319 0002B6D0 10 nop ! 1327: 1320 0002B6D1 # asm("nop"); ! 1328: 1321 0002B6D1 10 nop ! 1329: 1322 0002B6D2 # asm("stf _sgl_st_acc"); /* store the ACC (s/b= op) */ ! 1330: 1323 0002B6D2 26 effffff794 stf _sgl_st_acc ! 1331: 1324 0002B6D8 # if( force_loop ) ! 1332: 1325 0002B6D8 5d effffff78e tstl _force_loop ! 1333: 1326 0002B6DE 31 02 jeql L332 ! 1334: 1327 0002B6E0 # asm("brb _pipe7_8_lp1");; /* loop on the error */ ! 1335: 1328 0002B6E0 11 8d brb _pipe7_8_lp1 ! 1336: 1329 0002B6E2 L332: ! 1337: 1330 0002B6E2 # /* ! 1338: 1331 0002B6E2 # * verify the results ! 1339: 1332 0002B6E2 # */ ! 1340: 1333 0002B6E2 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */ ! 1341: 1334 0002B6E2 1d effffff784 effffff77f cmpl _sgl_st_acc,_sgl_expected ! 1342: 1335 0002B6ED 31 45 jeql L333 ! 1343: 1336 0002B6EF # { ! 1344: 1337 0002B6EF # errcnt++; /* bump the error count */ ! 1345: 1338 0002B6EF 6d effffff777 incl _errcnt ! 1346: 1339 0002B6F5 # if ( prt_error ) ! 1347: 1340 0002B6F5 5d effffff771 tstl _prt_error ! 1348: 1341 0002B6FB 31 0d jeql L334 ! 1349: 1342 0002B6FD # print_pipe7_er("Cache Data, 3 NO-OPs"); ! 1350: 1343 0002B6FD .data 1 ! 1351: 1344 00000e80 * L335: ! 1352: 1345 00000e80 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0" ! 1353: 3204E4F2D4F507300 ! 1354: 1346 00000e95 * .text ! 1355: 1347 0002B6FD dd 8f00000e80 pushl $L335 ! 1356: 1348 0002B703 fe 08 ef000003c2 callf $8,_print_pipe7_er ! 1357: 1349 0002B70A # if ( halt_flg ) ! 1358: 1350 0002B70A L334: ! 1359: 1351 0002B70A 5d effffff75c tstl _halt_flg ! 1360: 1352 0002B710 31 0d jeql L336 ! 1361: 1353 0002B712 # pipe7_er_hlt( subtest ); ! 1362: 1354 0002B712 dd effffff754 pushl _subtest ! 1363: 1355 0002B718 fe 08 ef000004c5 callf $8,_pipe7_er_hlt ! 1364: 1356 0002B71F # if ( loop_on_err ) { ! 1365: 1357 0002B71F L336: ! 1366: 1358 0002B71F 5d effffff747 tstl _loop_on_err ! 1367: 1359 0002B725 31 0d jeql L337 ! 1368: 1360 0002B727 # force_loop = TRUE; /* set the force loop flag */ ! 1369: 1361 0002B727 0d 01 effffff73e movl $1,_force_loop ! 1370: 1362 0002B72E # asm("jmp _pipe7_8_lp1"); /* and loop */ ! 1371: 1363 0002B72E 71 efffffff3b jmp _pipe7_8_lp1 ! 1372: 1364 0002B734 # } ! 1373: 1365 0002B734 # } /* end of compare error */ ! 1374: 1366 0002B734 L337: ! 1375: 1367 0002B734 # } while( index++ < max_ldf_1_index ); ! 1376: 1368 0002B734 L333: ! 1377: 1369 0002B734 L330: ! 1378: 1370 0002B734 0d effffff732 50 movl _index,r0 ! 1379: 1371 0002B73B 6d effffff72b incl _index ! 1380: 1372 0002B741 1d 50 effffff724 cmpl r0,_max_ldf_1_index ! 1381: 1373 0002B748 81 03 13 fef0 jlss L331 ! 1382: 1374 0002B74D L329: ! 1383: 1375 0002B74D # } /* end of subtest 8 */ ! 1384: 1376 0002B74D 40 ret#2 ! 1385: 1377 0002B74E .set L325,0x0 ! 1386: 1378 0002B74E L327: ! 1387: 1379 0002B74E 13 fee0 jbr L328 ! 1388: 1380 0002B751 .data ! 1389: 1381 00000de8 * .text ! 1390: 1382 0002B751 00 .align 1 ! 1391: 1383 0002B752 .globl _pipe7_9 ! 1392: 1384 0002B752 _pipe7_9: ! 1393: 1385 0002B752 0000 .word L338 ! 1394: 1386 0002B754 # ! 1395: 1387 0002B754 # ! 1396: 1388 0002B754 # ! 1397: 1389 0002B754 # ! 1398: 1390 0002B754 # ! 1399: 1391 0002B754 # ! 1400: 1392 0002B754 # /***************************************************************************** ! 1401: 1393 0002B754 # * ! 1402: 1394 0002B754 # * SUBTEST 9 ! 1403: 1395 0002B754 # * data on the stack, no NO-OPs ! 1404: 1396 0002B754 # * ! 1405: 1397 0002B754 # *****************************************************************************/ ! 1406: 1398 0002B754 # pipe7_9() ! 1407: 1399 0002B754 # { ! 1408: 1400 0002B754 13 01b4 jbr L340 ! 1409: 1401 0002B757 L341: ! 1410: 1402 0002B757 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1411: 1403 0002B757 ed 6d effffff70e moval (r13),_pre_event_fp ! 1412: 1404 0002B75E # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1413: 1405 0002B75E ed 6e effffff707 moval (r14),_pre_event_sp ! 1414: 1406 0002B765 # force_loop = FALSE; /* clear force_loop flag */ ! 1415: 1407 0002B765 4d effffff701 clrl _force_loop ! 1416: 1408 0002B76B # index = 0; ! 1417: 1409 0002B76B 4d effffff6fb clrl _index ! 1418: 1410 0002B771 # do ! 1419: 1411 0002B771 L344: ! 1420: 1412 0002B771 # { ! 1421: 1413 0002B771 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1422: 1414 0002B771 0d effffff6f5 50 movl _index,r0 ! 1423: 1415 0002B778 48 03 50 50 shll $3,r0,r0 ! 1424: 1416 0002B77C 0d e000000000 effffff6e5 movl _ldf_1_data(r0),_sgl_value_1 ! 1425: 1417 0002B787 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1426: 1418 0002B787 0d effffff6df 50 movl _index,r0 ! 1427: 1419 0002B78E 48 03 50 50 shll $3,r0,r0 ! 1428: 1420 0002B792 0d e000000004 effffff6cf movl _ldf_1_data+4(r0),_sgl_expected ! 1429: 1421 0002B79D # sgl_value_4 = 0; /* set the '0' operand */ ! 1430: 1422 0002B79D 4d effffff6c9 clrl _sgl_value_4 ! 1431: 1423 0002B7A3 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */ ! 1432: 1424 0002B7A3 ed effffff6c3 effffff6be moval _pointer_data,_sgl_value_2 ! 1433: 1425 0002B7AE # /* ! 1434: 1426 0002B7AE # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1435: 1427 0002B7AE # * The force loop flag is set after the first error. ! 1436: 1428 0002B7AE # */ ! 1437: 1429 0002B7AE # asm("_pipe7_9_lp1:"); ! 1438: 1430 0002B7AE _pipe7_9_lp1: ! 1439: 1431 0002B7AE # asm("moval _pointer_data,r14"); /* set the stack pointer */ ! 1440: 1432 0002B7AE ed effffff6b8 5e moval _pointer_data,r14 ! 1441: 1433 0002B7B5 # asm("movl _sgl_value_1,-(r14)"); /* push operand to add */ ! 1442: 1434 0002B7B5 0d effffff6b1 7e movl _sgl_value_1,-(r14) ! 1443: 1435 0002B7BC # asm("movl _sgl_value_4,-(r14)"); /* '0' to subtract */ ! 1444: 1436 0002B7BC 0d effffff6aa 7e movl _sgl_value_4,-(r14) ! 1445: 1437 0002B7C3 # asm("movl _sgl_value_4,-(r14)"); /* '0' to add */ ! 1446: 1438 0002B7C3 0d effffff6a3 7e movl _sgl_value_4,-(r14) ! 1447: 1439 0002B7CA # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */ ! 1448: 1440 0002B7CA 0d effffff69c 7e movl _sgl_value_1,-(r14) ! 1449: 1441 0002B7D1 # asm("movl _sgl_value_1,-(r14)"); /* op. to add */ ! 1450: 1442 0002B7D1 0d effffff695 7e movl _sgl_value_1,-(r14) ! 1451: 1443 0002B7D8 # asm("movl _sgl_value_4,-(r14)"); /* '0' to subtract */ ! 1452: 1444 0002B7D8 0d effffff68e 7e movl _sgl_value_4,-(r14) ! 1453: 1445 0002B7DF # asm("movl _sgl_value_1,-(r14)"); /* op. to add */ ! 1454: 1446 0002B7DF 0d effffff687 7e movl _sgl_value_1,-(r14) ! 1455: 1447 0002B7E6 # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */ ! 1456: 1448 0002B7E6 0d effffff680 7e movl _sgl_value_1,-(r14) ! 1457: 1449 0002B7ED # asm("movl _sgl_value_4,-(r14)"); /* '0' to add */ ! 1458: 1450 0002B7ED 0d effffff679 7e movl _sgl_value_4,-(r14) ! 1459: 1451 0002B7F4 # asm("movl _sgl_value_1,-(r14)"); /* op. to subtract */ ! 1460: 1452 0002B7F4 0d effffff672 7e movl _sgl_value_1,-(r14) ! 1461: 1453 0002B7FB # asm("movl _sgl_value_1,-(r14)"); /* op. to load */ ! 1462: 1454 0002B7FB 0d effffff66b 7e movl _sgl_value_1,-(r14) ! 1463: 1455 0002B802 # /* ! 1464: 1456 0002B802 # * now pop the data off the stack ! 1465: 1457 0002B802 # */ ! 1466: 1458 0002B802 # asm("ldf (r14)+"); /* pop the data & load it */ ! 1467: 1459 0002B802 06 8e ldf (r14)+ ! 1468: 1460 0002B804 # asm("subf (r14)+"); /* sub. the op. (ACC = 0 ) */ ! 1469: 1461 0002B804 d6 8e subf (r14)+ ! 1470: 1462 0002B806 # asm("addf (r14)+"); /* add a '0' (ACC = 0 ) */ ! 1471: 1463 0002B806 c6 8e addf (r14)+ ! 1472: 1464 0002B808 # asm("subf (r14)+"); /* sub. the op. (ACC =-op) */ ! 1473: 1465 0002B808 d6 8e subf (r14)+ ! 1474: 1466 0002B80A # asm("addf (r14)+"); /* add the op. (ACC = 0 ) */ ! 1475: 1467 0002B80A c6 8e addf (r14)+ ! 1476: 1468 0002B80C # asm("subf (r14)+"); /* sub. a '0' (ACC = 0 ) */ ! 1477: 1469 0002B80C d6 8e subf (r14)+ ! 1478: 1470 0002B80E # asm("addf (r14)+"); /* add the op. (ACC = op) */ ! 1479: 1471 0002B80E c6 8e addf (r14)+ ! 1480: 1472 0002B810 # asm("subf (r14)+"); /* sub. the op. (ACC = 0 ) */ ! 1481: 1473 0002B810 d6 8e subf (r14)+ ! 1482: 1474 0002B812 # asm("addf (r14)+"); /* add a '0' (ACC = 0 ) */ ! 1483: 1475 0002B812 c6 8e addf (r14)+ ! 1484: 1476 0002B814 # asm("subf (r14)+"); /* sub. a '0' (ACC = 0 ) */ ! 1485: 1477 0002B814 d6 8e subf (r14)+ ! 1486: 1478 0002B816 # asm("addf (r14)+"); /* add the op. (ACC = op) */ ! 1487: 1479 0002B816 c6 8e addf (r14)+ ! 1488: 1480 0002B818 # asm("stf r5"); /* store the ACC (s/b= op) */ ! 1489: 1481 0002B818 26 55 stf r5 ! 1490: 1482 0002B81A # if( force_loop ) ! 1491: 1483 0002B81A 5d effffff64c tstl _force_loop ! 1492: 1484 0002B820 31 02 jeql L345 ! 1493: 1485 0002B822 # asm("brb _pipe7_9_lp1");; /* loop on the error */ ! 1494: 1486 0002B822 11 8a brb _pipe7_9_lp1 ! 1495: 1487 0002B824 L345: ! 1496: 1488 0002B824 # /* ! 1497: 1489 0002B824 # * verify the results ! 1498: 1490 0002B824 # */ ! 1499: 1491 0002B824 # asm("movl r5,_sgl_st_acc"); /* get the result */ ! 1500: 1492 0002B824 0d 55 effffff641 movl r5,_sgl_st_acc ! 1501: 1493 0002B82B # asm("moval (r14),_sgl_value_3"); /* save the stack pointer */ ! 1502: 1494 0002B82B ed 6e effffff63a moval (r14),_sgl_value_3 ! 1503: 1495 0002B832 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */ ! 1504: 1496 0002B832 # (sgl_value_3 != sgl_value_2) ) /* ... and the final SP */ ! 1505: 1497 0002B832 1d effffff634 effffff62f cmpl _sgl_st_acc,_sgl_expected ! 1506: 1498 0002B83D 21 10 jneq L9999 ! 1507: 1499 0002B83F 1d effffff627 effffff622 cmpl _sgl_value_3,_sgl_value_2 ! 1508: 1500 0002B84A 21 03 13 0094 jeql L346 ! 1509: 1501 0002B84F L9999: ! 1510: 1502 0002B84F # { ! 1511: 1503 0002B84F # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1512: 1504 0002B84F 0d effffff617 5d movl _pre_event_fp,r13 ! 1513: 1505 0002B856 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1514: 1506 0002B856 0d effffff610 5e movl _pre_event_sp,r14 ! 1515: 1507 0002B85D # errcnt++; /* bump the error count */ ! 1516: 1508 0002B85D 6d effffff609 incl _errcnt ! 1517: 1509 0002B863 # if ( prt_error ) { ! 1518: 1510 0002B863 5d effffff603 tstl _prt_error ! 1519: 1511 0002B869 31 4e jeql L347 ! 1520: 1512 0002B86B # print_pipe7_er("POP data from the STACK"); ! 1521: 1513 0002B86B .data 1 ! 1522: 1514 00000e95 * L348: ! 1523: 1515 00000e95 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0" ! 1524: D2074686520535441434B00 ! 1525: 1516 00000ead * .text ! 1526: 1517 0002B86B dd 8f00000e95 pushl $L348 ! 1527: 1518 0002B871 fe 08 ef00000254 callf $8,_print_pipe7_er ! 1528: 1519 0002B878 # writes("final Stack Pointer = "); ! 1529: 1520 0002B878 .data 1 ! 1530: 1521 00000ead * L349: ! 1531: 1522 00000ead * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0" ! 1532: 06F696E746572203D2000 ! 1533: 1523 00000ec4 * .text ! 1534: 1524 0002B878 dd 8f00000ead pushl $L349 ! 1535: 1525 0002B87E fe 08 effffff5e7 callf $8,_writes ! 1536: 1526 0002B885 # write32h( sgl_value_5 ); ! 1537: 1527 0002B885 dd effffff5e1 pushl _sgl_value_5 ! 1538: 1528 0002B88B fe 08 effffff5da callf $8,_write32h ! 1539: 1529 0002B892 # writes(", expected SP = "); ! 1540: 1530 0002B892 .data 1 ! 1541: 1531 00000ec4 * L351: ! 1542: 1532 00000ec4 * 2C20206578706563746564205 .ascii ", expected SP = \0" ! 1543: 350203D2000 ! 1544: 1533 00000ed6 * .text ! 1545: 1534 0002B892 dd 8f00000ec4 pushl $L351 ! 1546: 1535 0002B898 fe 08 effffff5cd callf $8,_writes ! 1547: 1536 0002B89F # write32h( sgl_value_4 ); ! 1548: 1537 0002B89F dd effffff5c7 pushl _sgl_value_4 ! 1549: 1538 0002B8A5 fe 08 effffff5c0 callf $8,_write32h ! 1550: 1539 0002B8AC # writes("\n"); ! 1551: 1540 0002B8AC .data 1 ! 1552: 1541 00000ed6 * L352: ! 1553: 1542 00000ed6 * 0A00 .ascii "\12\0" ! 1554: 1543 00000ed8 * .text ! 1555: 1544 0002B8AC dd 8f00000ed6 pushl $L352 ! 1556: 1545 0002B8B2 fe 08 effffff5b3 callf $8,_writes ! 1557: 1546 0002B8B9 # } ! 1558: 1547 0002B8B9 # if ( halt_flg ) /* halt on error? */ ! 1559: 1548 0002B8B9 L347: ! 1560: 1549 0002B8B9 5d effffff5ad tstl _halt_flg ! 1561: 1550 0002B8BF 31 0d jeql L353 ! 1562: 1551 0002B8C1 # pipe7_er_hlt( subtest ); ! 1563: 1552 0002B8C1 dd effffff5a5 pushl _subtest ! 1564: 1553 0002B8C7 fe 08 ef00000316 callf $8,_pipe7_er_hlt ! 1565: 1554 0002B8CE # if ( loop_on_err ) { ! 1566: 1555 0002B8CE L353: ! 1567: 1556 0002B8CE 5d effffff598 tstl _loop_on_err ! 1568: 1557 0002B8D4 31 0d jeql L354 ! 1569: 1558 0002B8D6 # force_loop = TRUE; /* set the force loop flag */ ! 1570: 1559 0002B8D6 0d 01 effffff58f movl $1,_force_loop ! 1571: 1560 0002B8DD # asm("jmp _pipe7_9_lp1"); /* and loop */ ! 1572: 1561 0002B8DD 71 effffffecb jmp _pipe7_9_lp1 ! 1573: 1562 0002B8E3 # } ! 1574: 1563 0002B8E3 # } /* end of compare error */ ! 1575: 1564 0002B8E3 L354: ! 1576: 1565 0002B8E3 # } while( index++ < max_ldf_1_index ); ! 1577: 1566 0002B8E3 L346: ! 1578: 1567 0002B8E3 L343: ! 1579: 1568 0002B8E3 0d effffff583 50 movl _index,r0 ! 1580: 1569 0002B8EA 6d effffff57c incl _index ! 1581: 1570 0002B8F0 1d 50 effffff575 cmpl r0,_max_ldf_1_index ! 1582: 1571 0002B8F7 81 03 13 fe75 jlss L344 ! 1583: 1572 0002B8FC L342: ! 1584: 1573 0002B8FC # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1585: 1574 0002B8FC 0d effffff56a 5d movl _pre_event_fp,r13 ! 1586: 1575 0002B903 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1587: 1576 0002B903 0d effffff563 5e movl _pre_event_sp,r14 ! 1588: 1577 0002B90A # } /* end of subtest 9 */ ! 1589: 1578 0002B90A 40 ret#2 ! 1590: 1579 0002B90B .set L338,0x0 ! 1591: 1580 0002B90B L340: ! 1592: 1581 0002B90B 13 fe49 jbr L341 ! 1593: 1582 0002B90E .data ! 1594: 1583 00000de8 * .text ! 1595: 1584 0002B90E .align 1 ! 1596: 1585 0002B90E .globl _pipe7_10 ! 1597: 1586 0002B90E _pipe7_10: ! 1598: 1587 0002B90E 0000 .word L355 ! 1599: 1588 0002B910 # ! 1600: 1589 0002B910 # ! 1601: 1590 0002B910 # ! 1602: 1591 0002B910 # ! 1603: 1592 0002B910 # ! 1604: 1593 0002B910 # ! 1605: 1594 0002B910 # /****************************************************************************** ! 1606: 1595 0002B910 # * ! 1607: 1596 0002B910 # * SUBTEST 10 ! 1608: 1597 0002B910 # * load 0, add operand 4 times -get data via indexed FRAME pointer ! 1609: 1598 0002B910 # * ! 1610: 1599 0002B910 # * ADDR INDEX DATA ! 1611: 1600 0002B910 # * pointer_data 4 <the STF result goes here> ! 1612: 1601 0002B910 # * pointer_data-4 3 <operand data> ! 1613: 1602 0002B910 # * pointer_data-8 2 <'0' data> ! 1614: 1603 0002B910 # * pointer_data-16 0 point the frame pointer here ! 1615: 1604 0002B910 # * ! 1616: 1605 0002B910 # ******************************************************************************/ ! 1617: 1606 0002B910 # pipe7_10() ! 1618: 1607 0002B910 # { ! 1619: 1608 0002B910 13 01b6 jbr L357 ! 1620: 1609 0002B913 L358: ! 1621: 1610 0002B913 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */ ! 1622: 1611 0002B913 ed 6d effffff552 moval (r13),_pre_event_fp ! 1623: 1612 0002B91A # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */ ! 1624: 1613 0002B91A ed 6e effffff54b moval (r14),_pre_event_sp ! 1625: 1614 0002B921 # force_loop = FALSE; /* clear force_loop flag */ ! 1626: 1615 0002B921 4d effffff545 clrl _force_loop ! 1627: 1616 0002B927 # index = 0; ! 1628: 1617 0002B927 4d effffff53f clrl _index ! 1629: 1618 0002B92D # do ! 1630: 1619 0002B92D L361: ! 1631: 1620 0002B92D # { ! 1632: 1621 0002B92D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */ ! 1633: 1622 0002B92D 0d effffff539 50 movl _index,r0 ! 1634: 1623 0002B934 48 03 50 50 shll $3,r0,r0 ! 1635: 1624 0002B938 0d e000000000 effffff529 movl _ldf_1_data(r0),_sgl_value_1 ! 1636: 1625 0002B943 # sgl_expected = ldf_1_data[index].exp; /* get expected results */ ! 1637: 1626 0002B943 0d effffff523 50 movl _index,r0 ! 1638: 1627 0002B94A 48 03 50 50 shll $3,r0,r0 ! 1639: 1628 0002B94E 0d e000000004 effffff513 movl _ldf_1_data+4(r0),_sgl_expected ! 1640: 1629 0002B959 # sgl_value_4 = 0; /* set the '0' operand */ ! 1641: 1630 0002B959 4d effffff50d clrl _sgl_value_4 ! 1642: 1631 0002B95F # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */ ! 1643: 1632 0002B95F ed effffff507 effffff502 moval _pointer_data,_sgl_value_2 ! 1644: 1633 0002B96A # /* ! 1645: 1634 0002B96A # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1646: 1635 0002B96A # * The force loop flag is set after the first error. ! 1647: 1636 0002B96A # */ ! 1648: 1637 0002B96A # asm("_pipe7_10_lp1:"); ! 1649: 1638 0002B96A _pipe7_10_lp1: ! 1650: 1639 0002B96A # asm("moval _pointer_data,_sgl_value_2");/* get store data's addr */ ! 1651: 1640 0002B96A ed effffff4fc effffff4f7 moval _pointer_data,_sgl_value_2 ! 1652: 1641 0002B975 # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/ ! 1653: 1642 0002B975 2c 04 effffff4f0 subl2 $4,_sgl_value_2 ! 1654: 1643 0002B97C # asm("movl _sgl_value_1,*_sgl_value_2");/* set the operand data */ ! 1655: 1644 0002B97C 0d effffff4ea fffffff4e5 movl _sgl_value_1,*_sgl_value_2 ! 1656: 1645 0002B987 # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/ ! 1657: 1646 0002B987 2c 04 effffff4de subl2 $4,_sgl_value_2 ! 1658: 1647 0002B98E # asm("movl _sgl_value_4,*_sgl_value_2");/* set the '0' data */ ! 1659: 1648 0002B98E 0d effffff4d8 fffffff4d3 movl _sgl_value_4,*_sgl_value_2 ! 1660: 1649 0002B999 # sgl_value_2 -= 8; /* get the FP addr to use */ ! 1661: 1650 0002B999 2c 08 effffff4cc subl2 $8,_sgl_value_2 ! 1662: 1651 0002B9A0 # asm("movl _sgl_value_2,r13"); /* set the FRAME POINTER */ ! 1663: 1652 0002B9A0 0d effffff4c6 5d movl _sgl_value_2,r13 ! 1664: 1653 0002B9A7 # asm("movl $2,r2"); /* r2 index = 2 longwords */ ! 1665: 1654 0002B9A7 0d 02 52 movl $2,r2 ! 1666: 1655 0002B9AA # asm("movl $3,r5"); /* r5 index = 3 longwords */ ! 1667: 1656 0002B9AA 0d 03 55 movl $3,r5 ! 1668: 1657 0002B9AD # asm("movl $4,r6"); /* r6 index = 4 longwords */ ! 1669: 1658 0002B9AD 0d 04 56 movl $4,r6 ! 1670: 1659 0002B9B0 # asm("ldf (r13)[r5]"); /* load the operand via SP */ ! 1671: 1660 0002B9B0 06 456d ldf (r13)[r5] ! 1672: 1661 0002B9B3 # asm("subf (r13)[r5]"); /* sub. the op. (ACC = 0 ) */ ! 1673: 1662 0002B9B3 d6 456d subf (r13)[r5] ! 1674: 1663 0002B9B6 # asm("addf (r13)[r2]"); /* add a '0' (ACC = 0 ) */ ! 1675: 1664 0002B9B6 c6 426d addf (r13)[r2] ! 1676: 1665 0002B9B9 # asm("subf (r13)[r5]"); /* sub. the op. (ACC =-op) */ ! 1677: 1666 0002B9B9 d6 456d subf (r13)[r5] ! 1678: 1667 0002B9BC # asm("addf (r13)[r5]"); /* add the op. (ACC = 0 ) */ ! 1679: 1668 0002B9BC c6 456d addf (r13)[r5] ! 1680: 1669 0002B9BF # asm("subf (r13)[r2]"); /* sub. a '0' (ACC = 0 ) */ ! 1681: 1670 0002B9BF d6 426d subf (r13)[r2] ! 1682: 1671 0002B9C2 # asm("addf (r13)[r5]"); /* add the op. (ACC = op) */ ! 1683: 1672 0002B9C2 c6 456d addf (r13)[r5] ! 1684: 1673 0002B9C5 # asm("subf (r13)[r5]"); /* sub. the op. (ACC = 0 ) */ ! 1685: 1674 0002B9C5 d6 456d subf (r13)[r5] ! 1686: 1675 0002B9C8 # asm("addf (r13)[r2]"); /* add a '0' (ACC = 0 ) */ ! 1687: 1676 0002B9C8 c6 426d addf (r13)[r2] ! 1688: 1677 0002B9CB # asm("subf (r13)[r2]"); /* sub. a '0' (ACC = 0 ) */ ! 1689: 1678 0002B9CB d6 426d subf (r13)[r2] ! 1690: 1679 0002B9CE # asm("addf (r13)[r5]"); /* add the op. (ACC = op) */ ! 1691: 1680 0002B9CE c6 456d addf (r13)[r5] ! 1692: 1681 0002B9D1 # asm("stf (r13)[r6]"); /* store -indexed by r6 */ ! 1693: 1682 0002B9D1 26 466d stf (r13)[r6] ! 1694: 1683 0002B9D4 # if( force_loop ) ! 1695: 1684 0002B9D4 5d effffff492 tstl _force_loop ! 1696: 1685 0002B9DA 31 02 jeql L362 ! 1697: 1686 0002B9DC # asm("brb _pipe7_10_lp1");; /* loop on the error */ ! 1698: 1687 0002B9DC 11 8c brb _pipe7_10_lp1 ! 1699: 1688 0002B9DE L362: ! 1700: 1689 0002B9DE # /* ! 1701: 1690 0002B9DE # * verify the results ! 1702: 1691 0002B9DE # */ ! 1703: 1692 0002B9DE # sgl_st_acc = pointer_data; /* move the stored result */ ! 1704: 1693 0002B9DE 0d effffff488 effffff483 movl _pointer_data,_sgl_st_acc ! 1705: 1694 0002B9E9 # asm("moval (r13),_sgl_value_3"); /* save the frame pointer */ ! 1706: 1695 0002B9E9 ed 6d effffff47c moval (r13),_sgl_value_3 ! 1707: 1696 0002B9F0 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */ ! 1708: 1697 0002B9F0 # (sgl_value_3 != sgl_value_2) ) /* ... and the final FP */ ! 1709: 1698 0002B9F0 1d effffff476 effffff471 cmpl _sgl_st_acc,_sgl_expected ! 1710: 1699 0002B9FB 21 10 jneq L9998 ! 1711: 1700 0002B9FD 1d effffff469 effffff464 cmpl _sgl_value_3,_sgl_value_2 ! 1712: 1701 0002BA08 21 03 13 0094 jeql L363 ! 1713: 1702 0002BA0D L9998: ! 1714: 1703 0002BA0D # { ! 1715: 1704 0002BA0D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */ ! 1716: 1705 0002BA0D 0d effffff459 5d movl _pre_event_fp,r13 ! 1717: 1706 0002BA14 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */ ! 1718: 1707 0002BA14 0d effffff452 5e movl _pre_event_sp,r14 ! 1719: 1708 0002BA1B # errcnt++; /* bump the error count */ ! 1720: 1709 0002BA1B 6d effffff44b incl _errcnt ! 1721: 1710 0002BA21 # if ( prt_error ) { ! 1722: 1711 0002BA21 5d effffff445 tstl _prt_error ! 1723: 1712 0002BA27 31 4e jeql L364 ! 1724: 1713 0002BA29 # print_pipe7_er("indexed FP addressing"); ! 1725: 1714 0002BA29 .data 1 ! 1726: 1715 00000ed8 * L365: ! 1727: 1716 00000ed8 * 696E646578656420465020616 .ascii "indexed FP addressing\0" ! 1728: 46472657373696E6700 ! 1729: 1717 00000eee * .text ! 1730: 1718 0002BA29 dd 8f00000ed8 pushl $L365 ! 1731: 1719 0002BA2F fe 08 ef00000096 callf $8,_print_pipe7_er ! 1732: 1720 0002BA36 # writes("final Frame Pointer = "); ! 1733: 1721 0002BA36 .data 1 ! 1734: 1722 00000eee * L366: ! 1735: 1723 00000eee * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0" ! 1736: 06F696E746572203D2000 ! 1737: 1724 00000f05 * .text ! 1738: 1725 0002BA36 dd 8f00000eee pushl $L366 ! 1739: 1726 0002BA3C fe 08 effffff429 callf $8,_writes ! 1740: 1727 0002BA43 # writeh( sgl_value_5 ); ! 1741: 1728 0002BA43 dd effffff423 pushl _sgl_value_5 ! 1742: 1729 0002BA49 fe 08 effffff41c callf $8,_writeh ! 1743: 1730 0002BA50 # writes(", expected FP = "); ! 1744: 1731 0002BA50 .data 1 ! 1745: 1732 00000f05 * L368: ! 1746: 1733 00000f05 * 2C20206578706563746564204 .ascii ", expected FP = \0" ! 1747: 650203D2000 ! 1748: 1734 00000f17 * .text ! 1749: 1735 0002BA50 dd 8f00000f05 pushl $L368 ! 1750: 1736 0002BA56 fe 08 effffff40f callf $8,_writes ! 1751: 1737 0002BA5D # writeh( sgl_value_4 ); ! 1752: 1738 0002BA5D dd effffff409 pushl _sgl_value_4 ! 1753: 1739 0002BA63 fe 08 effffff402 callf $8,_writeh ! 1754: 1740 0002BA6A # writes("\n"); ! 1755: 1741 0002BA6A .data 1 ! 1756: 1742 00000f17 * L369: ! 1757: 1743 00000f17 * 0A00 .ascii "\12\0" ! 1758: 1744 00000f19 * .text ! 1759: 1745 0002BA6A dd 8f00000f17 pushl $L369 ! 1760: 1746 0002BA70 fe 08 effffff3f5 callf $8,_writes ! 1761: 1747 0002BA77 # } ! 1762: 1748 0002BA77 # if ( halt_flg ) /* halt on error? */ ! 1763: 1749 0002BA77 L364: ! 1764: 1750 0002BA77 5d effffff3ef tstl _halt_flg ! 1765: 1751 0002BA7D 31 0d jeql L370 ! 1766: 1752 0002BA7F # pipe7_er_hlt( subtest ); ! 1767: 1753 0002BA7F dd effffff3e7 pushl _subtest ! 1768: 1754 0002BA85 fe 08 ef00000158 callf $8,_pipe7_er_hlt ! 1769: 1755 0002BA8C # if ( loop_on_err ) { ! 1770: 1756 0002BA8C L370: ! 1771: 1757 0002BA8C 5d effffff3da tstl _loop_on_err ! 1772: 1758 0002BA92 31 0d jeql L371 ! 1773: 1759 0002BA94 # force_loop = TRUE; /* set the force loop flag */ ! 1774: 1760 0002BA94 0d 01 effffff3d1 movl $1,_force_loop ! 1775: 1761 0002BA9B # asm("jmp _pipe7_10_lp1"); /* and loop */ ! 1776: 1762 0002BA9B 71 effffffec9 jmp _pipe7_10_lp1 ! 1777: 1763 0002BAA1 # } ! 1778: 1764 0002BAA1 # } /* end of compare error */ ! 1779: 1765 0002BAA1 L371: ! 1780: 1766 0002BAA1 # } while( index++ < max_ldf_1_index ); ! 1781: 1767 0002BAA1 L363: ! 1782: 1768 0002BAA1 L360: ! 1783: 1769 0002BAA1 0d effffff3c5 50 movl _index,r0 ! 1784: 1770 0002BAA8 6d effffff3be incl _index ! 1785: 1771 0002BAAE 1d 50 effffff3b7 cmpl r0,_max_ldf_1_index ! 1786: 1772 0002BAB5 81 03 13 fe73 jlss L361 ! 1787: 1773 0002BABA L359: ! 1788: 1774 0002BABA # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */ ! 1789: 1775 0002BABA 0d effffff3ac 5d movl _pre_event_fp,r13 ! 1790: 1776 0002BAC1 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */ ! 1791: 1777 0002BAC1 0d effffff3a5 5e movl _pre_event_sp,r14 ! 1792: 1778 0002BAC8 # } /* end of subtest 10 */ ! 1793: 1779 0002BAC8 40 ret#2 ! 1794: 1780 0002BAC9 .set L355,0x0 ! 1795: 1781 0002BAC9 L357: ! 1796: 1782 0002BAC9 13 fe47 jbr L358 ! 1797: 1783 0002BACC .data ! 1798: 1784 00000de8 * .text ! 1799: 1785 0002BACC .align 1 ! 1800: 1786 0002BACC .globl _print_pipe7_er ! 1801: 1787 0002BACC _print_pipe7_er: ! 1802: 1788 0002BACC 0000 .word L372 ! 1803: 1789 0002BACE # ! 1804: 1790 0002BACE # ! 1805: 1791 0002BACE # /****************************************************************************** ! 1806: 1792 0002BACE # * ! 1807: 1793 0002BACE # * ERROR ROUTINE ! 1808: 1794 0002BACE # * ! 1809: 1795 0002BACE # * print an error in the following form ! 1810: 1796 0002BACE # * ! 1811: 1797 0002BACE # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd ! 1812: 1798 0002BACE # * expected Acc = xxxxxxxx ! 1813: 1799 0002BACE # * ! 1814: 1800 0002BACE # ******************************************************************************/ ! 1815: 1801 0002BACE # print_pipe7_er(msg) ! 1816: 1802 0002BACE # char *msg; ! 1817: 1803 0002BACE # { ! 1818: 1804 0002BACE 13 0110 jbr L374 ! 1819: 1805 0002BAD1 L375: ! 1820: 1806 0002BAD1 # writes("\n"); /* start a new print line */ ! 1821: 1807 0002BAD1 .data 1 ! 1822: 1808 00000f19 * L376: ! 1823: 1809 00000f19 * 0A00 .ascii "\12\0" ! 1824: 1810 00000f1b * .text ! 1825: 1811 0002BAD1 dd 8f00000f19 pushl $L376 ! 1826: 1812 0002BAD7 fe 08 effffff38e callf $8,_writes ! 1827: 1813 0002BADE # writes("cycle: "); ! 1828: 1814 0002BADE .data 1 ! 1829: 1815 00000f1b * L377: ! 1830: 1816 00000f1b * 6379636C653A2000 .ascii "cycle: \0" ! 1831: 1817 00000f23 * .text ! 1832: 1818 0002BADE dd 8f00000f1b pushl $L377 ! 1833: 1819 0002BAE4 fe 08 effffff381 callf $8,_writes ! 1834: 1820 0002BAEB # writed( cycle ); ! 1835: 1821 0002BAEB dd effffff37b pushl _cycle ! 1836: 1822 0002BAF1 fe 08 effffff374 callf $8,_writed ! 1837: 1823 0002BAF8 # writes(" test "); ! 1838: 1824 0002BAF8 .data 1 ! 1839: 1825 00000f23 * L379: ! 1840: 1826 00000f23 * 20746573742000 .ascii " test \0" ! 1841: 1827 00000f2a * .text ! 1842: 1828 0002BAF8 dd 8f00000f23 pushl $L379 ! 1843: 1829 0002BAFE fe 08 effffff367 callf $8,_writes ! 1844: 1830 0002BB05 # writed( test_no ); ! 1845: 1831 0002BB05 dd effffff361 pushl _test_no ! 1846: 1832 0002BB0B fe 08 effffff35a callf $8,_writed ! 1847: 1833 0002BB12 # writes(" (Pipe 7), subtest "); ! 1848: 1834 0002BB12 .data 1 ! 1849: 1835 00000f2a * L380: ! 1850: 1836 00000f2a * 202028506970652037292C207 .ascii " (Pipe 7), subtest \0" ! 1851: 37562746573742000 ! 1852: 1837 00000f3f * .text ! 1853: 1838 0002BB12 dd 8f00000f2a pushl $L380 ! 1854: 1839 0002BB18 fe 08 effffff34d callf $8,_writes ! 1855: 1840 0002BB1F # writed( subtest ); ! 1856: 1841 0002BB1F dd effffff347 pushl _subtest ! 1857: 1842 0002BB25 fe 08 effffff340 callf $8,_writed ! 1858: 1843 0002BB2C # writes(" error - "); ! 1859: 1844 0002BB2C .data 1 ! 1860: 1845 00000f3f * L381: ! 1861: 1846 00000f3f * 206572726F72202D2000 .ascii " error - \0" ! 1862: 1847 00000f49 * .text ! 1863: 1848 0002BB2C dd 8f00000f3f pushl $L381 ! 1864: 1849 0002BB32 fe 08 effffff333 callf $8,_writes ! 1865: 1850 0002BB39 # writes( msg ); ! 1866: 1851 0002BB39 dd ad04 pushl 4(fp) ! 1867: 1852 0002BB3C fe 08 effffff329 callf $8,_writes ! 1868: 1853 0002BB43 # writec('\n'); ! 1869: 1854 0002BB43 dd 0a pushl $10 ! 1870: 1855 0002BB45 fe 08 effffff320 callf $8,_writec ! 1871: 1856 0002BB4C # writes( ! 1872: 1857 0002BB4C # "LDF(op), SUBF(op), ADDF(0.0), SUBF(op), ADDF(op), SUBF(0.0),\n"); ! 1873: 1858 0002BB4C .data 1 ! 1874: 1859 00000f49 * L383: ! 1875: 1860 00000f49 * 4C4446286F70292C205355424 .ascii "LDF(op), SUBF(op), ADDF(0.0), SUBF(op), ADDF(op), SUBF(0.0),\12\0" ! 1876: 6286F70292C20414444462830 ! 1877: 2E30292C2053554246286F702 ! 1878: 92C202041444446286F70292C ! 1879: 20205355424628302E30292C0 ! 1880: A00 ! 1881: 1861 00000f89 * .text ! 1882: 1862 0002BB4C dd 8f00000f49 pushl $L383 ! 1883: 1863 0002BB52 fe 08 effffff313 callf $8,_writes ! 1884: 1864 0002BB59 # writes( ! 1885: 1865 0002BB59 # " ADDF(op), SUBF(op), ADDF(0.0), SUBF(0.0), ADDF(op), STF\n"); ! 1886: 1866 0002BB59 .data 1 ! 1887: 1867 00000f89 * L384: ! 1888: 1868 00000f89 * 2020202020202020204144444 .ascii " ADDF(op), SUBF(op), ADDF(0.0), SUBF(0.0), ADDF(op), S" ! 1889: 6286F70292C2053554246286F ! 1890: 70292C20204144444628302E3 ! 1891: 0292C205355424628302E3029 ! 1892: 2C2041444446286F70292C202 ! 1893: 053 ! 1894: 1869 00000fc9 * 54460A00 .ascii "TF\12\0" ! 1895: 1870 00000fcd * .text ! 1896: 1871 0002BB59 dd 8f00000f89 pushl $L384 ! 1897: 1872 0002BB5F fe 08 effffff306 callf $8,_writes ! 1898: 1873 0002BB66 # writes("operand = "); ! 1899: 1874 0002BB66 .data 1 ! 1900: 1875 00000fcd * L385: ! 1901: 1876 00000fcd * 6F706572616E64203D2000 .ascii "operand = \0" ! 1902: 1877 00000fd8 * .text ! 1903: 1878 0002BB66 dd 8f00000fcd pushl $L385 ! 1904: 1879 0002BB6C fe 08 effffff2f9 callf $8,_writes ! 1905: 1880 0002BB73 # write32h( sgl_value_1 ); ! 1906: 1881 0002BB73 dd effffff2f3 pushl _sgl_value_1 ! 1907: 1882 0002BB79 fe 08 effffff2ec callf $8,_write32h ! 1908: 1883 0002BB80 # writes(", final Acc = "); ! 1909: 1884 0002BB80 .data 1 ! 1910: 1885 00000fd8 * L386: ! 1911: 1886 00000fd8 * 2C20202066696E616C2041636 .ascii ", final Acc = \0" ! 1912: 3203D2000 ! 1913: 1887 00000fe9 * .text ! 1914: 1888 0002BB80 dd 8f00000fd8 pushl $L386 ! 1915: 1889 0002BB86 fe 08 effffff2df callf $8,_writes ! 1916: 1890 0002BB8D # write32h( sgl_st_acc ); ! 1917: 1891 0002BB8D dd effffff2d9 pushl _sgl_st_acc ! 1918: 1892 0002BB93 fe 08 effffff2d2 callf $8,_write32h ! 1919: 1893 0002BB9A # writes(", data index = "); ! 1920: 1894 0002BB9A .data 1 ! 1921: 1895 00000fe9 * L387: ! 1922: 1896 00000fe9 * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1923: 578203D2000 ! 1924: 1897 00000ffb * .text ! 1925: 1898 0002BB9A dd 8f00000fe9 pushl $L387 ! 1926: 1899 0002BBA0 fe 08 effffff2c5 callf $8,_writes ! 1927: 1900 0002BBA7 # writed( index ); ! 1928: 1901 0002BBA7 dd effffff2bf pushl _index ! 1929: 1902 0002BBAD fe 08 effffff2b8 callf $8,_writed ! 1930: 1903 0002BBB4 # writec('\n'); ! 1931: 1904 0002BBB4 dd 0a pushl $10 ! 1932: 1905 0002BBB6 fe 08 effffff2af callf $8,_writec ! 1933: 1906 0002BBBD # writes(" expected Acc = "); ! 1934: 1907 0002BBBD .data 1 ! 1935: 1908 00000ffb * L388: ! 1936: 1909 00000ffb * 2020202020202020202020202 .ascii " expected Acc = \0" ! 1937: 0202020202020657870656374 ! 1938: 656420416363203D2000 ! 1939: 1910 0000101e * .text ! 1940: 1911 0002BBBD dd 8f00000ffb pushl $L388 ! 1941: 1912 0002BBC3 fe 08 effffff2a2 callf $8,_writes ! 1942: 1913 0002BBCA # write32h( sgl_expected ); ! 1943: 1914 0002BBCA dd effffff29c pushl _sgl_expected ! 1944: 1915 0002BBD0 fe 08 effffff295 callf $8,_write32h ! 1945: 1916 0002BBD7 # writec('\n'); ! 1946: 1917 0002BBD7 dd 0a pushl $10 ! 1947: 1918 0002BBD9 fe 08 effffff28c callf $8,_writec ! 1948: 1919 0002BBE0 # } ! 1949: 1920 0002BBE0 40 ret#2 ! 1950: 1921 0002BBE1 .set L372,0x0 ! 1951: 1922 0002BBE1 L374: ! 1952: 1923 0002BBE1 13 feed jbr L375 ! 1953: 1924 0002BBE4 .data ! 1954: 1925 00000de8 * .text ! 1955: 1926 0002BBE4 .align 1 ! 1956: 1927 0002BBE4 .globl _pipe7_er_hlt ! 1957: 1928 0002BBE4 _pipe7_er_hlt: ! 1958: 1929 0002BBE4 0000 .word L389 ! 1959: 1930 0002BBE6 # ! 1960: 1931 0002BBE6 # ! 1961: 1932 0002BBE6 # ! 1962: 1933 0002BBE6 # ! 1963: 1934 0002BBE6 # ! 1964: 1935 0002BBE6 # /****************************************************************************** ! 1965: 1936 0002BBE6 # * ! 1966: 1937 0002BBE6 # * HALT ON ERROR ROUTINE ! 1967: 1938 0002BBE6 # * ! 1968: 1939 0002BBE6 # * halt with the necessary information saved in the registers ! 1969: 1940 0002BBE6 # * ! 1970: 1941 0002BBE6 # ******************************************************************************/ ! 1971: 1942 0002BBE6 # pipe7_er_hlt( subtest ) ! 1972: 1943 0002BBE6 # int subtest; ! 1973: 1944 0002BBE6 # { ! 1974: 1945 0002BBE6 11 67 jbr L391 ! 1975: 1946 0002BBE8 L392: ! 1976: 1947 0002BBE8 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1977: 1948 0002BBE8 0d effffff27e 50 movl _test_no,r0 ! 1978: 1949 0002BBEF # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1979: 1950 0002BBEF 0d effffff277 51 movl _subtest,r1 ! 1980: 1951 0002BBF6 # asm("movl $1,r2"); /* r2 = error code */ ! 1981: 1952 0002BBF6 0d 01 52 movl $1,r2 ! 1982: 1953 0002BBF9 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1983: 1954 0002BBF9 0d effffff26d 53 movl _cycle,r3 ! 1984: 1955 0002BC00 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */ ! 1985: 1956 0002BC00 0d effffff266 54 movl _sgl_value_1,r4 ! 1986: 1957 0002BC07 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */ ! 1987: 1958 0002BC07 0d effffff25f 55 movl _sgl_st_acc,r5 ! 1988: 1959 0002BC0E # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */ ! 1989: 1960 0002BC0E 0d effffff258 56 movl _sgl_expected,r6 ! 1990: 1961 0002BC15 # asm("movl _index,r7"); /* r7 = data index */ ! 1991: 1962 0002BC15 0d effffff251 57 movl _index,r7 ! 1992: 1963 0002BC1C # asm("movl _sgl_value_2,r8"); /* r8 = floating zero */ ! 1993: 1964 0002BC1C 0d effffff24a 58 movl _sgl_value_2,r8 ! 1994: 1965 0002BC23 # if( subtest == 9 ) { ! 1995: 1966 0002BC23 1d ad04 09 cmpl 4(fp),$9 ! 1996: 1967 0002BC27 21 10 jneq L393 ! 1997: 1968 0002BC29 # asm("movl _sgl_value_3,r9"); /* r9 = final SP value */ ! 1998: 1969 0002BC29 0d effffff23d 59 movl _sgl_value_3,r9 ! 1999: 1970 0002BC30 # asm("movl _sgl_value_2,r10"); /* r10 = expected SP value */ ! 2000: 1971 0002BC30 0d effffff236 5a movl _sgl_value_2,r10 ! 2001: 1972 0002BC37 # } else ! 2002: 1973 0002BC37 11 14 jbr L394 ! 2003: 1974 0002BC39 L393: ! 2004: 1975 0002BC39 # if( subtest == 10 ) { ! 2005: 1976 0002BC39 1d ad04 0a cmpl 4(fp),$10 ! 2006: 1977 0002BC3D 21 0e jneq L395 ! 2007: 1978 0002BC3F # asm("movl _sgl_value_3,r9"); /* r9 = final FP value */ ! 2008: 1979 0002BC3F 0d effffff227 59 movl _sgl_value_3,r9 ! 2009: 1980 0002BC46 # asm("movl _sgl_value_2,r10"); /* r10 = expected FP value */ ! 2010: 1981 0002BC46 0d effffff220 5a movl _sgl_value_2,r10 ! 2011: 1982 0002BC4D # }; ! 2012: 1983 0002BC4D L395: ! 2013: 1984 0002BC4D L394: ! 2014: 1985 0002BC4D # asm(".globl _pipe7_1_hlt"); ! 2015: 1986 0002BC4D .globl _pipe7_1_hlt ! 2016: 1987 0002BC4D # asm("_pipe7_1_hlt:"); /* PC after the halt */ ! 2017: 1988 0002BC4D _pipe7_1_hlt: ! 2018: 1989 0002BC4D # asm("halt"); /* HALT ... */ ! 2019: 1990 0002BC4D 00 halt ! 2020: 1991 0002BC4E # } /* end of halt on error */ ! 2021: 1992 0002BC4E 40 ret#2 ! 2022: 1993 0002BC4F .set L389,0x0 ! 2023: 1994 0002BC4F L391: ! 2024: 1995 0002BC4F 11 97 jbr L392 ! 2025: 1996 0002BC51 .data ! 2026: 1996 00056ABD .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.