![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe18.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 pipe18.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 00000464 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _pipe_18 ! 6: 6 00000000 _pipe_18: ! 7: 7 00032A84 0000 .word L215 ! 8: 8 00032A86 # #include "fpp_defs.h" ! 9: 9 00032A86 # ! 10: 10 00032A86 # ! 11: 11 00032A86 # /***************************************************************************** ! 12: 12 00032A86 # * ! 13: 13 00032A86 # * PIPELINE TEST #18 ! 14: 14 00032A86 # * ! 15: 15 00032A86 # * LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD ! 16: 16 00032A86 # * ! 17: 17 00032A86 # * -where the operands are the fmacro1 MULD data patterns. The SUBD operand's ! 18: 18 00032A86 # * address is based on the result of the CVDL. ! 19: 19 00032A86 # * -The load, multiply, and convert will be done twice. The first time will ! 20: 20 00032A86 # * be to get the index and the data to subtract. The data to subtract will ! 21: 21 00032A86 # * be the same as the accumulator so we'll expect a reasult of zero. The ! 22: 22 00032A86 # * data will be stored based on the 1st CVDL result. ! 23: 23 00032A86 # * -If the 2nd CVDL doesn't get done before the SUBD operand is fetched then ! 24: 24 00032A86 # * we won't get a final accumulator of zero. ! 25: 25 00032A86 # * -For size reasons, only the MULD data with a result between -100 and +100 ! 26: 26 00032A86 # * will be used for this test. ! 27: 27 00032A86 # *****************************************************************************/ ! 28: 28 00032A86 # pipe_18() ! 29: 29 00032A86 # { ! 30: 30 00032A86 13 01cc jbr L217 ! 31: 31 00032A89 L218: ! 32: 32 00032A89 # asm(".globl _pipeline_18_t"); ! 33: 33 00032A89 .globl _pipeline_18_t ! 34: 34 00032A89 # asm("_pipeline_18_t:"); ! 35: 35 00032A89 _pipeline_18_t: ! 36: 36 00032A89 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 37: 37 00032A89 1d effffffff5 01 cmpl _cycle,$1 ! 38: 38 00032A90 21 15 jneq L219 ! 39: 39 00032A92 5d efffffffec tstl _prt_hdrs ! 40: 40 00032A98 31 0d jeql L219 ! 41: 41 00032A9A # writes(" PIPE_18"); ! 42: 42 00032A9A .data 1 ! 43: 43 00000464 * L221: ! 44: 44 00000464 * 20504950455F313800 .ascii " PIPE_18\0" ! 45: 45 0000046d * .text ! 46: 46 00032A9A dd 8f00000464 pushl $L221 ! 47: 47 00032AA0 fe 08 efffffffdd callf $8,_writes ! 48: 48 00032AA7 # force_loop = FALSE; /* clear force_loop flag */ ! 49: 49 00032AA7 L219: ! 50: 50 00032AA7 4d efffffffd7 clrl _force_loop ! 51: 51 00032AAD # for( index = 0; index <= max_muld_1_index; index++ ) { ! 52: 52 00032AAD 4d efffffffd1 clrl _index ! 53: 53 00032AB3 L224: ! 54: 54 00032AB3 1d efffffffcb efffffffc6 cmpl _index,_max_muld_1_index ! 55: 55 00032ABE 51 03 13 018b jgtr L223 ! 56: 56 00032AC3 # dbl_value_1 = muld_1_data[index].op_1; /* get the data */ ! 57: 57 00032AC3 5c 18 efffffffba 50 mull3 $24,_index,r0 ! 58: 58 00032ACB 0c 8f00000000 50 addl2 $_muld_1_data,r0 ! 59: 59 00032AD2 0d a004 efffffffae movl 4(r0),_dbl_value_1+4 ! 60: 60 00032ADA 0d 60 efffffffa3 movl (r0),_dbl_value_1 ! 61: 61 00032AE1 # dbl_value_2 = muld_1_data[index].op_2; /* operands */ ! 62: 62 00032AE1 5c 18 efffffff9c 50 mull3 $24,_index,r0 ! 63: 63 00032AE9 0c 8f00000008 50 addl2 $_muld_1_data+8,r0 ! 64: 64 00032AF0 0d a004 efffffff90 movl 4(r0),_dbl_value_2+4 ! 65: 65 00032AF8 0d 60 efffffff85 movl (r0),_dbl_value_2 ! 66: 66 00032AFF # dbl_expected.m = dbl_expected.l = 0; /* result s/b 0 */ ! 67: 67 00032AFF 4d efffffff83 clrl _dbl_expected+4 ! 68: 68 00032B05 0d efffffff7d 50 movl _dbl_expected+4,r0 ! 69: 69 00032B0C 0d 50 efffffff71 movl r0,_dbl_expected ! 70: 70 00032B13 # asm("ldd _dbl_value_1"); ! 71: 71 00032B13 07 efffffff6b ldd _dbl_value_1 ! 72: 72 00032B19 # asm("muld _dbl_value_2"); ! 73: 73 00032B19 e7 efffffff65 muld _dbl_value_2 ! 74: 74 00032B1F # asm("cvdl _index2"); ! 75: 75 00032B1F 87 efffffff5f cvdl _index2 ! 76: 76 00032B25 # asm("nop"); ! 77: 77 00032B25 10 nop ! 78: 78 00032B26 # if( (index2 >= -99) && (index2 <= 99) ) { ! 79: 79 00032B26 1d efffffff58 889d cmpl _index2,$-99 ! 80: 80 00032B2E 81 03 13 0112 jlss L225 ! 81: 81 00032B33 1d efffffff4b 8863 cmpl _index2,$99 ! 82: 82 00032B3B 41 f3 jgtr L225 ! 83: 83 00032B3D # if( index2 ) { ! 84: 84 00032B3D 5d efffffff41 tstl _index2 ! 85: 85 00032B43 31 35 jeql L226 ! 86: 86 00032B45 # sgl_value_5 = 0; /* set a dummy index */ ! 87: 87 00032B45 4d efffffff39 clrl _sgl_value_5 ! 88: 88 00032B4B # adr_dpipe_ops[sgl_value_5].m = 0; ! 89: 89 00032B4B 0d efffffff33 50 movl _sgl_value_5,r0 ! 90: 90 00032B52 48 03 50 50 shll $3,r0,r0 ! 91: 91 00032B56 1c 50 efffffff27 50 addl3 r0,_adr_dpipe_ops,r0 ! 92: 92 00032B5E 4d 60 clrl (r0) ! 93: 93 00032B60 # adr_dpipe_ops[sgl_value_5].l = 0xabadface; ! 94: 94 00032B60 48 03 efffffff1d 50 shll $3,_sgl_value_5,r0 ! 95: 95 00032B68 1c 50 efffffff15 50 addl3 r0,_adr_dpipe_ops,r0 ! 96: 96 00032B70 0d 8fabadface a004 movl $-1414661426,4(r0) ! 97: 97 00032B78 # } else { ! 98: 98 00032B78 11 39 jbr L227 ! 99: 99 00032B7A L226: ! 100: 100 00032B7A # sgl_value_5 = 6; /* set a dummy index */ ! 101: 101 00032B7A 0d 06 efffffff03 movl $6,_sgl_value_5 ! 102: 102 00032B81 # adr_dpipe_ops[sgl_value_5].m = 0xabadbabe; ! 103: 103 00032B81 0d effffffefd 50 movl _sgl_value_5,r0 ! 104: 104 00032B88 48 03 50 50 shll $3,r0,r0 ! 105: 105 00032B8C 1c 50 effffffef1 50 addl3 r0,_adr_dpipe_ops,r0 ! 106: 106 00032B94 0d 8fabadbabe 60 movl $-1414677826,(r0) ! 107: 107 00032B9B # adr_dpipe_ops[sgl_value_5].l = 0xabadface; ! 108: 108 00032B9B 48 03 effffffee2 50 shll $3,_sgl_value_5,r0 ! 109: 109 00032BA3 1c 50 effffffeda 50 addl3 r0,_adr_dpipe_ops,r0 ! 110: 110 00032BAB 0d 8fabadface a004 movl $-1414661426,4(r0) ! 111: 111 00032BB3 # } ! 112: 112 00032BB3 L227: ! 113: 113 00032BB3 # asm("movl _index2,r0"); /* save the index */ ! 114: 114 00032BB3 0d effffffecb 50 movl _index2,r0 ! 115: 115 00032BBA # asm("std _dpipe_ops[r0]"); /* save the Acc's value */ ! 116: 116 00032BBA 27 40effffffec3 std _dpipe_ops[r0] ! 117: 117 00032BC1 # asm("std _dbl_value_3"); /* save this value */ ! 118: 118 00032BC1 27 effffffebd std _dbl_value_3 ! 119: 119 00032BC7 # /* ! 120: 120 00032BC7 # * This is the start of the LOOP ON ERROR section ! 121: 121 00032BC7 # */ ! 122: 122 00032BC7 # asm("_pipe18_1_lp:"); ! 123: 123 00032BC7 _pipe18_1_lp: ! 124: 124 00032BC7 # asm("movl _sgl_value_5,r0"); /* save the bum index */ ! 125: 125 00032BC7 0d effffffeb7 50 movl _sgl_value_5,r0 ! 126: 126 00032BCE # asm("ldd _dbl_value_1"); ! 127: 127 00032BCE 07 effffffeb0 ldd _dbl_value_1 ! 128: 128 00032BD4 # asm("muld _dbl_value_2"); ! 129: 129 00032BD4 e7 effffffeaa muld _dbl_value_2 ! 130: 130 00032BDA # asm("cvdl r0"); /* set up the index to use */ ! 131: 131 00032BDA 87 50 cvdl r0 ! 132: 132 00032BDC # asm("subd _dpipe_ops[r0]"); /* subtract saved value */ ! 133: 133 00032BDC d7 40effffffea1 subd _dpipe_ops[r0] ! 134: 134 00032BE3 # asm("std _dbl_st_acc"); ! 135: 135 00032BE3 27 effffffe9b std _dbl_st_acc ! 136: 136 00032BE9 # asm("movl r0,_sgl_value_6"); /* save the index used */ ! 137: 137 00032BE9 0d 50 effffffe94 movl r0,_sgl_value_6 ! 138: 138 00032BF0 # if( force_loop ) ! 139: 139 00032BF0 5d effffffe8e tstl _force_loop ! 140: 140 00032BF6 31 02 jeql L228 ! 141: 141 00032BF8 # asm("brb _pipe18_1_lp");; /* loop on the error */ ! 142: 142 00032BF8 11 cd brb _pipe18_1_lp ! 143: 143 00032BFA L228: ! 144: 144 00032BFA # /* ! 145: 145 00032BFA # * Verify the results (the accumulator should be = 0) ! 146: 146 00032BFA # */ ! 147: 147 00032BFA # if( (dbl_st_acc.m) || (dbl_st_acc.l) ) { ! 148: 148 00032BFA 5d effffffe84 tstl _dbl_st_acc ! 149: 149 00032C00 21 08 jneq L9999 ! 150: 150 00032C02 5d effffffe80 tstl _dbl_st_acc+4 ! 151: 151 00032C08 31 3b jeql L229 ! 152: 152 00032C0A L9999: ! 153: 153 00032C0A # errcnt++; /* bump the error count */ ! 154: 154 00032C0A 6d effffffe74 incl _errcnt ! 155: 155 00032C10 # if ( prt_error ) ! 156: 156 00032C10 5d effffffe6e tstl _prt_error ! 157: 157 00032C16 31 07 jeql L230 ! 158: 158 00032C18 # pipe18_print(); /* print the error mesage */ ! 159: 159 00032C18 fe 04 ef00000039 callf $4,_pipe18_print ! 160: 160 00032C1F # if ( halt_flg ) ! 161: 161 00032C1F L230: ! 162: 162 00032C1F 5d effffffe5f tstl _halt_flg ! 163: 163 00032C25 31 09 jeql L232 ! 164: 164 00032C27 # pipe18_halt( 1 ); /* halt on the error */ ! 165: 165 00032C27 dd 01 pushl $1 ! 166: 166 00032C29 fe 08 ef000001dc callf $8,_pipe18_halt ! 167: 167 00032C30 # if ( loop_on_err ) { ! 168: 168 00032C30 L232: ! 169: 169 00032C30 5d effffffe4e tstl _loop_on_err ! 170: 170 00032C36 31 0d jeql L234 ! 171: 171 00032C38 # force_loop = TRUE; ! 172: 172 00032C38 0d 01 effffffe45 movl $1,_force_loop ! 173: 173 00032C3F # asm("jmp _pipe18_1_lp");; ! 174: 174 00032C3F 71 efffffff82 jmp _pipe18_1_lp ! 175: 175 00032C45 # } ! 176: 176 00032C45 # } ! 177: 177 00032C45 L234: ! 178: 178 00032C45 # } ! 179: 179 00032C45 L229: ! 180: 180 00032C45 # } ! 181: 181 00032C45 L225: ! 182: 182 00032C45 L222: ! 183: 183 00032C45 6d effffffe39 incl _index ! 184: 184 00032C4B 13 fe65 jbr L224 ! 185: 185 00032C4E L223: ! 186: 186 00032C4E # asm("jmp *return"); /* return to the test monitor */ ! 187: 187 00032C4E 71 fffffffe30 jmp *return ! 188: 188 00032C54 # } ! 189: 189 00032C54 40 ret#2 ! 190: 190 00032C55 .set L215,0x0 ! 191: 191 00032C55 L217: ! 192: 192 00032C55 13 fe31 jbr L218 ! 193: 193 00032C58 .data ! 194: 194 00000464 * .text ! 195: 195 00032C58 .align 1 ! 196: 196 00032C58 .globl _pipe18_print ! 197: 197 00032C58 _pipe18_print: ! 198: 198 00032C58 0000 .word L235 ! 199: 199 00032C5A # ! 200: 200 00032C5A # ! 201: 201 00032C5A # ! 202: 202 00032C5A # ! 203: 203 00032C5A # /* ! 204: 204 00032C5A # ************************************************************************** ! 205: 205 00032C5A # * ! 206: 206 00032C5A # * print an error message of the form ! 207: 207 00032C5A # * ! 208: 208 00032C5A # * cycle: xx Test xx, Error with subtract data based on CVDL value, index = xx ! 209: 209 00032C5A # * test sequence = LDD(op1), MULD(op2), CVDL r0, SUBD operand[r0], STD ! 210: 210 00032C5A # *operand 1 = xxxxxxx xxxxxxx, final Acc = xxxxxxx xxxxxxx, index = xxxxxxx ! 211: 211 00032C5A # *operand 2 = xxxxxxx xxxxxxx, expected Acc = xxxxxxx xxxxxxx ! 212: 212 00032C5A # *operand 3 = xxxxxxx xxxxxxx, CVDL result = xxxxxxx ! 213: 213 00032C5A # * int expected = xxxxxxx ! 214: 214 00032C5A # ************************************************************************** ! 215: 215 00032C5A # */ ! 216: 216 00032C5A # pipe18_print() ! 217: 217 00032C5A # { ! 218: 218 00032C5A 13 01ac jbr L237 ! 219: 219 00032C5D L238: ! 220: 220 00032C5D # writes(" \n"); /* start a new print line */ ! 221: 221 00032C5D .data 1 ! 222: 222 0000046d * L239: ! 223: 223 0000046d * 200A00 .ascii " \12\0" ! 224: 224 00000470 * .text ! 225: 225 00032C5D dd 8f0000046d pushl $L239 ! 226: 226 00032C63 fe 08 effffffe1a callf $8,_writes ! 227: 227 00032C6A # writes("cycle: "); ! 228: 228 00032C6A .data 1 ! 229: 229 00000470 * L240: ! 230: 230 00000470 * 6379636C653A2000 .ascii "cycle: \0" ! 231: 231 00000478 * .text ! 232: 232 00032C6A dd 8f00000470 pushl $L240 ! 233: 233 00032C70 fe 08 effffffe0d callf $8,_writes ! 234: 234 00032C77 # writed( cycle ); ! 235: 235 00032C77 dd effffffe07 pushl _cycle ! 236: 236 00032C7D fe 08 effffffe00 callf $8,_writed ! 237: 237 00032C84 # writes(" Test "); ! 238: 238 00032C84 .data 1 ! 239: 239 00000478 * L242: ! 240: 240 00000478 * 2020546573742000 .ascii " Test \0" ! 241: 241 00000480 * .text ! 242: 242 00032C84 dd 8f00000478 pushl $L242 ! 243: 243 00032C8A fe 08 effffffdf3 callf $8,_writes ! 244: 244 00032C91 # writed( test_no ); ! 245: 245 00032C91 dd effffffded pushl _test_no ! 246: 246 00032C97 fe 08 effffffde6 callf $8,_writed ! 247: 247 00032C9E # writes(" (Pipe 18), error\n"); ! 248: 248 00032C9E .data 1 ! 249: 249 00000480 * L243: ! 250: 250 00000480 * 20202850697065203138292C2 .ascii " (Pipe 18), error\12\0" ! 251: 0206572726F720A00 ! 252: 251 00000495 * .text ! 253: 252 00032C9E dd 8f00000480 pushl $L243 ! 254: 253 00032CA4 fe 08 effffffdd9 callf $8,_writes ! 255: 254 00032CAB # writes(" LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\n"); ! 256: 255 00032CAB .data 1 ! 257: 256 00000495 * L244: ! 258: 257 00000495 * 204C4444286F7031292C204D5 .ascii " LDD(op1), MULD(op2), CVDL(r0), SUBD(op3), STD\12\0" ! 259: 54C44286F7032292C20435644 ! 260: 4C287230292C2053554244286 ! 261: F7033292C205354440A00 ! 262: 258 000004c5 * .text ! 263: 259 00032CAB dd 8f00000495 pushl $L244 ! 264: 260 00032CB1 fe 08 effffffdcc callf $8,_writes ! 265: 261 00032CB8 # writes("operand 1 = "); ! 266: 262 00032CB8 .data 1 ! 267: 263 000004c5 * L245: ! 268: 264 000004c5 * 6F706572616E642031203D200 .ascii "operand 1 = \0" ! 269: 0 ! 270: 265 000004d2 * .text ! 271: 266 00032CB8 dd 8f000004c5 pushl $L245 ! 272: 267 00032CBE fe 08 effffffdbf callf $8,_writes ! 273: 268 00032CC5 # write32h( dbl_value_1.m ); ! 274: 269 00032CC5 dd effffffdb9 pushl _dbl_value_1 ! 275: 270 00032CCB fe 08 effffffdb2 callf $8,_write32h ! 276: 271 00032CD2 # writec(' '); ! 277: 272 00032CD2 dd 20 pushl $32 ! 278: 273 00032CD4 fe 08 effffffda9 callf $8,_writec ! 279: 274 00032CDB # write32h( dbl_value_1.l ); ! 280: 275 00032CDB dd effffffda7 pushl _dbl_value_1+4 ! 281: 276 00032CE1 fe 08 effffffd9c callf $8,_write32h ! 282: 277 00032CE8 # writes(", final Acc = "); ! 283: 278 00032CE8 .data 1 ! 284: 279 000004d2 * L248: ! 285: 280 000004d2 * 2C2020202066696E616C20416 .ascii ", final Acc = \0" ! 286: 363203D2000 ! 287: 281 000004e4 * .text ! 288: 282 00032CE8 dd 8f000004d2 pushl $L248 ! 289: 283 00032CEE fe 08 effffffd8f callf $8,_writes ! 290: 284 00032CF5 # write32h( dbl_st_acc.m ); ! 291: 285 00032CF5 dd effffffd89 pushl _dbl_st_acc ! 292: 286 00032CFB fe 08 effffffd82 callf $8,_write32h ! 293: 287 00032D02 # writec(' '); ! 294: 288 00032D02 dd 20 pushl $32 ! 295: 289 00032D04 fe 08 effffffd79 callf $8,_writec ! 296: 290 00032D0B # write32h( dbl_st_acc.l ); ! 297: 291 00032D0B dd effffffd77 pushl _dbl_st_acc+4 ! 298: 292 00032D11 fe 08 effffffd6c callf $8,_write32h ! 299: 293 00032D18 # writes(", index = "); ! 300: 294 00032D18 .data 1 ! 301: 295 000004e4 * L249: ! 302: 296 000004e4 * 2C2020696E646578203D2000 .ascii ", index = \0" ! 303: 297 000004f0 * .text ! 304: 298 00032D18 dd 8f000004e4 pushl $L249 ! 305: 299 00032D1E fe 08 effffffd5f callf $8,_writes ! 306: 300 00032D25 # writed( index ); ! 307: 301 00032D25 dd effffffd59 pushl _index ! 308: 302 00032D2B fe 08 effffffd52 callf $8,_writed ! 309: 303 00032D32 # writes("\noperand 2 = "); ! 310: 304 00032D32 .data 1 ! 311: 305 000004f0 * L250: ! 312: 306 000004f0 * 0A6F706572616E642032203D2 .ascii "\12operand 2 = \0" ! 313: 000 ! 314: 307 000004fe * .text ! 315: 308 00032D32 dd 8f000004f0 pushl $L250 ! 316: 309 00032D38 fe 08 effffffd45 callf $8,_writes ! 317: 310 00032D3F # write32h( dbl_value_2.m ); ! 318: 311 00032D3F dd effffffd3f pushl _dbl_value_2 ! 319: 312 00032D45 fe 08 effffffd38 callf $8,_write32h ! 320: 313 00032D4C # writec(' '); ! 321: 314 00032D4C dd 20 pushl $32 ! 322: 315 00032D4E fe 08 effffffd2f callf $8,_writec ! 323: 316 00032D55 # write32h( dbl_value_2.l ); ! 324: 317 00032D55 dd effffffd2d pushl _dbl_value_2+4 ! 325: 318 00032D5B fe 08 effffffd22 callf $8,_write32h ! 326: 319 00032D62 # writes(", expected Acc = "); ! 327: 320 00032D62 .data 1 ! 328: 321 000004fe * L251: ! 329: 322 000004fe * 2C20657870656374656420416 .ascii ", expected Acc = \0" ! 330: 363203D2000 ! 331: 323 00000510 * .text ! 332: 324 00032D62 dd 8f000004fe pushl $L251 ! 333: 325 00032D68 fe 08 effffffd15 callf $8,_writes ! 334: 326 00032D6F # write32h( dbl_expected.m ); ! 335: 327 00032D6F dd effffffd0f pushl _dbl_expected ! 336: 328 00032D75 fe 08 effffffd08 callf $8,_write32h ! 337: 329 00032D7C # writec(' '); ! 338: 330 00032D7C dd 20 pushl $32 ! 339: 331 00032D7E fe 08 effffffcff callf $8,_writec ! 340: 332 00032D85 # write32h( dbl_expected.l ); ! 341: 333 00032D85 dd effffffcfd pushl _dbl_expected+4 ! 342: 334 00032D8B fe 08 effffffcf2 callf $8,_write32h ! 343: 335 00032D92 # writes("\noperand 3 = "); ! 344: 336 00032D92 .data 1 ! 345: 337 00000510 * L252: ! 346: 338 00000510 * 0A6F706572616E642033203D2 .ascii "\12operand 3 = \0" ! 347: 000 ! 348: 339 0000051e * .text ! 349: 340 00032D92 dd 8f00000510 pushl $L252 ! 350: 341 00032D98 fe 08 effffffce5 callf $8,_writes ! 351: 342 00032D9F # write32h( dbl_value_3.m ); ! 352: 343 00032D9F dd effffffcdf pushl _dbl_value_3 ! 353: 344 00032DA5 fe 08 effffffcd8 callf $8,_write32h ! 354: 345 00032DAC # writec(' '); ! 355: 346 00032DAC dd 20 pushl $32 ! 356: 347 00032DAE fe 08 effffffccf callf $8,_writec ! 357: 348 00032DB5 # write32h( dbl_value_3.l ); ! 358: 349 00032DB5 dd effffffccd pushl _dbl_value_3+4 ! 359: 350 00032DBB fe 08 effffffcc2 callf $8,_write32h ! 360: 351 00032DC2 # writes(", CVDL result = "); ! 361: 352 00032DC2 .data 1 ! 362: 353 0000051e * L253: ! 363: 354 0000051e * 2C20204356444C20726573756 .ascii ", CVDL result = \0" ! 364: C74203D2000 ! 365: 355 00000530 * .text ! 366: 356 00032DC2 dd 8f0000051e pushl $L253 ! 367: 357 00032DC8 fe 08 effffffcb5 callf $8,_writes ! 368: 358 00032DCF # write32h( sgl_value_6 ); ! 369: 359 00032DCF dd effffffcaf pushl _sgl_value_6 ! 370: 360 00032DD5 fe 08 effffffca8 callf $8,_write32h ! 371: 361 00032DDC # writec('\n'); ! 372: 362 00032DDC dd 0a pushl $10 ! 373: 363 00032DDE fe 08 effffffc9f callf $8,_writec ! 374: 364 00032DE5 # writes(" int expected = "); ! 375: 365 00032DE5 .data 1 ! 376: 366 00000530 * L254: ! 377: 367 00000530 * 2020202020202020202020202 .ascii " int expected = \0" ! 378: 0202020202020202020202020 ! 379: 202020202020696E742065787 ! 380: 06563746564203D2000 ! 381: 368 0000055f * .text ! 382: 369 00032DE5 dd 8f00000530 pushl $L254 ! 383: 370 00032DEB fe 08 effffffc92 callf $8,_writes ! 384: 371 00032DF2 # write32h( index2 ); ! 385: 372 00032DF2 dd effffffc8c pushl _index2 ! 386: 373 00032DF8 fe 08 effffffc85 callf $8,_write32h ! 387: 374 00032DFF # writec('\n'); ! 388: 375 00032DFF dd 0a pushl $10 ! 389: 376 00032E01 fe 08 effffffc7c callf $8,_writec ! 390: 377 00032E08 # } ! 391: 378 00032E08 40 ret#2 ! 392: 379 00032E09 .set L235,0x0 ! 393: 380 00032E09 L237: ! 394: 381 00032E09 13 fe51 jbr L238 ! 395: 382 00032E0C .data ! 396: 383 00000464 * .text ! 397: 384 00032E0C .align 1 ! 398: 385 00032E0C .globl _pipe18_halt ! 399: 386 00032E0C _pipe18_halt: ! 400: 387 00032E0C 0000 .word L255 ! 401: 388 00032E0E # ! 402: 389 00032E0E # ! 403: 390 00032E0E # ! 404: 391 00032E0E # /* ! 405: 392 00032E0E # ************************************************************************** ! 406: 393 00032E0E # * ! 407: 394 00032E0E # * HALT ON AN ERROR ! 408: 395 00032E0E # * ! 409: 396 00032E0E # ************************************************************************** ! 410: 397 00032E0E # */ ! 411: 398 00032E0E # pipe18_halt() ! 412: 399 00032E0E # { ! 413: 400 00032E0E 13 00d1 jbr L257 ! 414: 401 00032E11 L258: ! 415: 402 00032E11 # sgl_value_1 = dbl_value_1.m; ! 416: 403 00032E11 0d effffffc6d effffffc68 movl _dbl_value_1,_sgl_value_1 ! 417: 404 00032E1C # sgl_value_2 = dbl_value_1.l; ! 418: 405 00032E1C 0d effffffc66 effffffc5d movl _dbl_value_1+4,_sgl_value_2 ! 419: 406 00032E27 # sgl_value_3 = dbl_value_2.m; ! 420: 407 00032E27 0d effffffc57 effffffc52 movl _dbl_value_2,_sgl_value_3 ! 421: 408 00032E32 # sgl_value_4 = dbl_value_2.l; ! 422: 409 00032E32 0d effffffc50 effffffc47 movl _dbl_value_2+4,_sgl_value_4 ! 423: 410 00032E3D # asm("movl _test_no,r0"); /* r0 = test number */ ! 424: 411 00032E3D 0d effffffc41 50 movl _test_no,r0 ! 425: 412 00032E44 # asm("movl $1,r1"); /* r1 = subtest number */ ! 426: 413 00032E44 0d 01 51 movl $1,r1 ! 427: 414 00032E47 # asm("movl $1,r2"); /* r2 = error code */ ! 428: 415 00032E47 0d 01 52 movl $1,r2 ! 429: 416 00032E4A # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 430: 417 00032E4A 0d effffffc34 53 movl _cycle,r3 ! 431: 418 00032E51 # asm("movl _sgl_value_1,r4"); /* r4 = MS of dbl operand #1 */ ! 432: 419 00032E51 0d effffffc2d 54 movl _sgl_value_1,r4 ! 433: 420 00032E58 # asm("movl _sgl_value_2,r5"); /* r5 = LS of dbl operand #1 */ ! 434: 421 00032E58 0d effffffc26 55 movl _sgl_value_2,r5 ! 435: 422 00032E5F # asm("movl _sgl_value_3,r6"); /* r6 = MS of dbl operand #2 */ ! 436: 423 00032E5F 0d effffffc1f 56 movl _sgl_value_3,r6 ! 437: 424 00032E66 # asm("movl _sgl_value_4,r7"); /* r7 = LS of dbl operand #2 */ ! 438: 425 00032E66 0d effffffc18 57 movl _sgl_value_4,r7 ! 439: 426 00032E6D # sgl_value_1 = dbl_st_acc.m; ! 440: 427 00032E6D 0d effffffc11 effffffc0c movl _dbl_st_acc,_sgl_value_1 ! 441: 428 00032E78 # sgl_value_2 = dbl_st_acc.l; ! 442: 429 00032E78 0d effffffc0a effffffc01 movl _dbl_st_acc+4,_sgl_value_2 ! 443: 430 00032E83 # sgl_value_3 = dbl_expected.m; ! 444: 431 00032E83 0d effffffbfb effffffbf6 movl _dbl_expected,_sgl_value_3 ! 445: 432 00032E8E # sgl_value_4 = dbl_expected.l; ! 446: 433 00032E8E 0d effffffbf4 effffffbeb movl _dbl_expected+4,_sgl_value_4 ! 447: 434 00032E99 # sgl_value_5 = dbl_value_3.m; ! 448: 435 00032E99 0d effffffbe5 effffffbe0 movl _dbl_value_3,_sgl_value_5 ! 449: 436 00032EA4 # sgl_value_6 = dbl_value_3.l; ! 450: 437 00032EA4 0d effffffbde effffffbd5 movl _dbl_value_3+4,_sgl_value_6 ! 451: 438 00032EAF # asm("movl _sgl_value_5,r8"); /* r8 = MS of dbl operand #3 */ ! 452: 439 00032EAF 0d effffffbcf 58 movl _sgl_value_5,r8 ! 453: 440 00032EB6 # asm("movl _sgl_value_6,r9"); /* r9 = LS of dbl operand #3 */ ! 454: 441 00032EB6 0d effffffbc8 59 movl _sgl_value_6,r9 ! 455: 442 00032EBD # asm("movl _sgl_value_1,r10"); /* r10 = MS of final result */ ! 456: 443 00032EBD 0d effffffbc1 5a movl _sgl_value_1,r10 ! 457: 444 00032EC4 # asm("movl _sgl_value_2,r11"); /* r11 = LS of final result */ ! 458: 445 00032EC4 0d effffffbba 5b movl _sgl_value_2,r11 ! 459: 446 00032ECB # asm("movl _sgl_value_3,r12"); /* r12 = MS of expected result */ ! 460: 447 00032ECB 0d effffffbb3 5c movl _sgl_value_3,r12 ! 461: 448 00032ED2 # asm("movl _sgl_value_4,r13"); /* r13 = LS of expected result */ ! 462: 449 00032ED2 0d effffffbac 5d movl _sgl_value_4,r13 ! 463: 450 00032ED9 # asm("movl _index,r14"); /* r14 = data index */ ! 464: 451 00032ED9 0d effffffba5 5e movl _index,r14 ! 465: 452 00032EE0 # asm("halt"); /* HALT ... */ ! 466: 453 00032EE0 00 halt ! 467: 454 00032EE1 # } ! 468: 455 00032EE1 40 ret#2 ! 469: 456 00032EE2 .set L255,0x0 ! 470: 457 00032EE2 L257: ! 471: 458 00032EE2 13 ff2c jbr L258 ! 472: 459 00032EE5 .data ! 473: 460 00000464 * # ! 474: 460 00000464 * #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.