![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sky.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to sky.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)sky.c 1.1 86/02/03 Copyr 1984 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1984 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "as.h" ! 10: #include "c2.h" ! 11: ! 12: #define SP_REG 15 /* Stack pointer: a7 */ ! 13: #define STATUS_WORD -2 /* Offset to sky status word */ ! 14: #define IDLE 6 /* Idle bit in hibyte of status word */ ! 15: ! 16: #define SP_ADD 0x1001 /* Single add: B1 = A2 + A1 */ ! 17: #define SP_ADDREG 0x104c /* Single add: R0 = R0 + A1 */ ! 18: #define SP_ADDB1 0x1003 /* Single add: B1 = R0 + A1 */ ! 19: ! 20: #define SP_SUB 0x1007 /* Single sub: B1 = A1 - A2 */ ! 21: #define SP_SUBREG1 0x104f /* Single sub: R0 = R0 - A1 */ ! 22: #define SP_SUBREG2 0x1050 /* Single sub: R0 = A1 - R0 */ ! 23: ! 24: #define SP_MUL 0x100b /* Single mul: B1 = A2 * A1 */ ! 25: #define SP_MULREG 0x1052 /* Single mul: R0 = R0 * A1 */ ! 26: #define SP_MULB1 0x100d /* Single mul: B1 = R0 * A1 */ ! 27: ! 28: #define SP_DIV 0x1013 /* Single div: B1 = A2 / A1 */ ! 29: #define SP_DIVREG1 0x1055 /* Single div: R0 = R0 / A1 */ ! 30: #define SP_DIVREG2 0x1056 /* Single div: R0 = A1 / R0 */ ! 31: ! 32: #define SP_LOAD 0x1031 /* Single load: R0 = A1 */ ! 33: #define SP_STORE 0x1037 /* Single store: B1 = R0 */ ! 34: ! 35: #define isskyop(op) (findop(op) != NULL) ! 36: ! 37: /* ! 38: * Struct for each sky operator that can be changed. ! 39: * The code generator produces operations that push two operands ! 40: * to the board and fetch one result. The goal here is to use ! 41: * the on board register as an accumulator. Therefore, one ! 42: * operand will come from register R0 and the result will be ! 43: * left in R0. ! 44: * For some operations (add and mul), one operand can come ! 45: * from register R0 and the result can be fetched from the ! 46: * board. Otherwise (sub and div), a SKY operation to fetch ! 47: * the result must be inserted. ! 48: */ ! 49: struct skyop { ! 50: int op; /* Sky board opcode */ ! 51: int arg_op[2]; /* Opcode if arg "n" in R0 */ ! 52: int fetch; /* Opcode to fetch result from board */ ! 53: }; ! 54: ! 55: /* ! 56: * Info about single precision SKY board operators. ! 57: */ ! 58: struct skyop regops[] = { ! 59: { SP_ADD, SP_ADDREG, SP_ADDREG, SP_ADDB1 }, ! 60: { SP_SUB, SP_SUBREG1, SP_SUBREG2, 0 }, ! 61: { SP_MUL, SP_MULREG, SP_MULREG, SP_MULB1 }, ! 62: { SP_DIV, SP_DIVREG1, SP_DIVREG2, 0 }, ! 63: { 0 }, ! 64: }; ! 65: ! 66: /* ! 67: * Struct for a sky board operation ! 68: */ ! 69: struct skylist { ! 70: NODE *skyload; /* Instruction to load opcode */ ! 71: NODE *arg[2]; /* Args passed to the board */ ! 72: NODE *result; /* Result fetched from the board */ ! 73: NODE *oldresult; /* Result fetched from the board */ ! 74: int oldop; /* Original sky operator */ ! 75: int tstloop; /* Is result preceeded by tst loop */ ! 76: struct skylist *next; /* Linked list */ ! 77: }; ! 78: ! 79: struct oper *newoperand(); ! 80: struct skylist *get_sky(); ! 81: struct skylist *bld_skylist(); ! 82: struct skyop *findop(); ! 83: NODE *newinst(); ! 84: NODE *remove(); ! 85: NODE *delete_tst_loop(); ! 86: static struct sym_bkt *skyname; ! 87: static struct oper skybase; ! 88: ! 89: sky() ! 90: { ! 91: NODE *n; ! 92: register v, regno; ! 93: struct oper *op1; ! 94: struct oper *op2; ! 95: int didchange=0; ! 96: int i, inexact; ! 97: struct oper saveop; ! 98: struct skylist *skylist; ! 99: static struct oper reg = { T_REG, 0, 0, NULL, 0, 0, 0 }; ! 100: static struct oper conz = { T_IMMED, 0, 0, NULL, 0, 0, 0 }; ! 101: ! 102: /* initialize constant table to empty. Find __skybase */ ! 103: forgetall(); ! 104: if (skyname==NULL) skyname = lookup("__skybase"); ! 105: skybase.type_o = T_NORMAL; ! 106: skybase.sym_o = skyname; ! 107: skybase.value_o = 0; ! 108: ! 109: for (n = first.forw; n != &first; n = n->forw){ ! 110: if (n->op == OP_LABEL) { ! 111: /* ! 112: * we really should be doing flow analysis here. ! 113: * lacking that, recognize special case SKY code: ! 114: * 1: tstw a1@(-4) ! 115: * bge 1b ! 116: */ ! 117: if (n->nref == 1 && n->luse == n->forw->forw && ! 118: emptymask( n->forw->rset) && n->forw->forw->op == OP_JUMP) { ! 119: n = n->forw; ! 120: continue; ! 121: } ! 122: /* forget everything */ ! 123: forgetall(); ! 124: continue; ! 125: } ! 126: if (n->nref == 0) { ! 127: continue; ! 128: } ! 129: if (n->op != OP_MOVE) { ! 130: continue; ! 131: } ! 132: op1 = n->ref[0]; ! 133: op2 = n->ref[1]; ! 134: skylist = bld_skylist(&n); ! 135: if (skylist != NULL) { ! 136: rewrite_list(skylist); ! 137: free_list(skylist); ! 138: n = n->back; ! 139: } else if (op1->type_o == T_NORMAL && ! 140: op1->value_o == 0 && ! 141: op1->sym_o == skyname && ! 142: op2->type_o==T_REG) { ! 143: /* move to a register */ ! 144: con_to_reg( op2->value_o, op1, n->subop ); ! 145: } ! 146: } ! 147: } ! 148: ! 149: /* ! 150: * Build a list of sky board operations that ! 151: * can use an accumulator between them. Two operations ! 152: * can use an accumulator if the result of the first operation ! 153: * is the first argument to the second operation. ! 154: */ ! 155: struct skylist * ! 156: bld_skylist(np) ! 157: NODE **np; ! 158: { ! 159: struct skylist *hdr; ! 160: struct skylist *sky; ! 161: struct skylist **bpatch; ! 162: NODE *n; ! 163: ! 164: hdr = NULL; ! 165: n = *np; ! 166: if (is_sky_operation(n)) { ! 167: hdr = get_sky(&n); ! 168: if (hdr == NULL) { ! 169: return(NULL); ! 170: } ! 171: sky = hdr; ! 172: if (result_is_reg(sky)) { ! 173: bpatch = &sky->next; ! 174: while (n->op != OP_LABEL && ! 175: n->op != OP_JUMP && ! 176: n->op != OP_CALL) { ! 177: if (result_killed(n, sky)) { ! 178: break; ! 179: } ! 180: if (n == &first) { ! 181: n = first.back; ! 182: break; ! 183: } ! 184: if (is_sky_operation(n)) { ! 185: sky = get_sky(&n); ! 186: if (sky == NULL) { ! 187: return(NULL); ! 188: } ! 189: *bpatch = sky; ! 190: bpatch = &sky->next; ! 191: if (!result_is_reg(sky)) { ! 192: break; ! 193: } ! 194: } else { ! 195: n = n->forw; ! 196: } ! 197: } ! 198: } ! 199: } ! 200: *np = n; ! 201: return(hdr); ! 202: } ! 203: ! 204: /* ! 205: * Disect a sky board operation. ! 206: * Find the opcode, the two arguments and the result that is fetched ! 207: * off of the board. ! 208: * If it is not a sky board operation return NULL. ! 209: */ ! 210: struct skylist * ! 211: get_sky(np) ! 212: NODE **np; ! 213: { ! 214: NODE *n; ! 215: struct skylist *sky; ! 216: int i; ! 217: ! 218: /* ! 219: * Get the instruction to load an opcode into the sky board ! 220: */ ! 221: n = *np; ! 222: sky = (struct skylist *) calloc(sizeof(*sky), 1); ! 223: sky->skyload = n; ! 224: n = n->forw; ! 225: ! 226: /* ! 227: * Get pointers to the instructions that push arguments ! 228: */ ! 229: for (i = 0; i < 2; i++) { ! 230: if (!move_to_sky(n)) { ! 231: return(NULL); ! 232: } ! 233: sky->arg[i] = n; ! 234: n = n->forw; ! 235: } ! 236: ! 237: /* ! 238: * Get the instruction to fetch the result from the board. ! 239: * It may be preceeded by a test loop. ! 240: */ ! 241: if (n->op == OP_LABEL) { ! 242: for (i = 0; i < 3; i++) { ! 243: n = n->forw; ! 244: } ! 245: sky->tstloop = 1; ! 246: } ! 247: if (!move_from_sky(n)) { ! 248: return(NULL); ! 249: } ! 250: sky->result = n; ! 251: ! 252: n = n->forw; ! 253: sky->next = NULL; ! 254: *np = n; ! 255: return(sky); ! 256: } ! 257: ! 258: /* ! 259: * Is this instruction a movl to the sky board? ! 260: */ ! 261: move_to_sky(n) ! 262: NODE *n; ! 263: { ! 264: struct oper *op2; ! 265: int regno; ! 266: int inexact; ! 267: ! 268: if (n->op == OP_MOVE && n->subop == SUBOP_L) { ! 269: regno = reglookup(&skybase, SUBOP_L, &inexact); ! 270: op2 = n->ref[1]; ! 271: if (op2->type_o == T_DEFER && regno == op2->value_o) { ! 272: return(1); ! 273: } ! 274: } ! 275: return(0); ! 276: } ! 277: ! 278: /* ! 279: * Is this instruction a movl from the sky board? ! 280: */ ! 281: move_from_sky(n) ! 282: NODE *n; ! 283: { ! 284: struct oper *op1; ! 285: int regno; ! 286: int inexact; ! 287: ! 288: if (n->op == OP_MOVE && n->subop == SUBOP_L) { ! 289: regno = reglookup(&skybase, SUBOP_L, &inexact); ! 290: op1 = n->ref[0]; ! 291: if (op1->type_o == T_DEFER && regno == op1->value_o) { ! 292: return(1); ! 293: } ! 294: } ! 295: return(0); ! 296: } ! 297: ! 298: /* ! 299: * See if this instruction stores the result of the sky operation ! 300: * into memory or otherwise kills the result. ! 301: */ ! 302: result_killed(n, sky) ! 303: NODE *n; ! 304: struct skylist *sky; ! 305: { ! 306: struct oper *result; ! 307: struct oper *op1; ! 308: struct oper *op2; ! 309: int i; ! 310: ! 311: /* ! 312: * Is this a movl from the register holding the sky result? ! 313: */ ! 314: result = sky->result->ref[1]; ! 315: if (n->op == OP_MOVE && n->subop == SUBOP_L) { ! 316: op1 = n->ref[0]; ! 317: if (op1->type_o == T_REG && op1->value_o == result->value_o) { ! 318: return(1); ! 319: } ! 320: } ! 321: ! 322: /* ! 323: * Is the destination of this instruction the register holding ! 324: * the sky result? ! 325: */ ! 326: op2 = n->ref[1]; ! 327: if (result->type_o == T_REG && ! 328: op2->type_o == T_REG && ! 329: op2->value_o == result->value_o) { ! 330: return(1); ! 331: } ! 332: return(0); ! 333: } ! 334: ! 335: /* ! 336: * Is the result of this sky operation assigned to a register. ! 337: */ ! 338: result_is_reg(sky) ! 339: struct skylist *sky; ! 340: { ! 341: struct oper *result; ! 342: int i; ! 343: ! 344: result = sky->result->ref[1]; ! 345: if (result->type_o == T_REG) { ! 346: return(1); ! 347: } ! 348: return(0); ! 349: } ! 350: ! 351: /* ! 352: * Is this instuction a movw of an opcode to the sky board? ! 353: */ ! 354: is_sky_operation(n) ! 355: NODE *n; ! 356: { ! 357: struct oper *op1; ! 358: struct oper *op2; ! 359: int regno; ! 360: int inexact; ! 361: ! 362: op1 = n->ref[0]; ! 363: op2 = n->ref[1]; ! 364: if (n->op != OP_MOVE || ! 365: op1->type_o != T_IMMED || ! 366: !isskyop(op1->value_o) || ! 367: op2->type_o != T_DISPL) { ! 368: return(0); ! 369: } ! 370: regno = reglookup(&skybase, SUBOP_L, &inexact); ! 371: if (regno != op2->reg_o || ! 372: op2->value_o != -4) { ! 373: return(0); ! 374: } ! 375: return(1); ! 376: } ! 377: ! 378: /* ! 379: * Rewrite a list of sky operations doing optimizations along the way. ! 380: * Look the for the results of one operation being used as an operand ! 381: * of the next operations. Accumulator operations can be used in ! 382: * this case. ! 383: */ ! 384: rewrite_list(sky) ! 385: struct skylist *sky; ! 386: { ! 387: struct skylist *skyp; ! 388: struct skylist *last_changed; ! 389: NODE *result; ! 390: NODE *arg; ! 391: int first; ! 392: int i; ! 393: ! 394: first = 1; ! 395: last_changed = NULL; ! 396: for (skyp = sky; skyp->next != NULL; skyp = skyp->next) { ! 397: result = skyp->result; ! 398: if (result == NULL) { ! 399: continue; ! 400: } ! 401: for (i = 0; i < 2; i++) { ! 402: arg = skyp->next->arg[i]; ! 403: if (sameops(result->ref[0], arg->ref[1]) && ! 404: sameops(result->ref[1], arg->ref[0])) { ! 405: meter.nskyreg++; ! 406: if (first) { ! 407: insert_reg_load(skyp); ! 408: change_to_reg(skyp, 0); ! 409: } ! 410: change_to_reg(skyp->next, i); ! 411: last_changed = skyp->next; ! 412: first = 0; ! 413: break; ! 414: } ! 415: } ! 416: if (i == 2 && last_changed != NULL) { ! 417: fetch_result(last_changed); ! 418: first = 1; ! 419: last_changed = NULL; ! 420: } ! 421: } ! 422: if (!first && last_changed != NULL) { ! 423: fetch_result(last_changed); ! 424: } ! 425: } ! 426: ! 427: /* ! 428: * Change an operation to use the accumulator and also ! 429: * to leave its result in the accumulator. ! 430: * Remove the instructions that fetch the result from the board. ! 431: * Add a tst loop after the operation to wait for the result ! 432: * to solidify. ! 433: */ ! 434: change_to_reg(sky, argn) ! 435: struct skylist *sky; ! 436: int argn; ! 437: { ! 438: NODE *arg; ! 439: NODE *n; ! 440: struct skyop *skyop; ! 441: struct oper *opcode; ! 442: int op; ! 443: int i; ! 444: ! 445: opcode = sky->skyload->ref[0]; ! 446: op = opcode->value_o; ! 447: sky->oldop = op; ! 448: skyop = findop(op); ! 449: if (skyop == NULL) { ! 450: return; ! 451: } ! 452: opcode->value_o = skyop->arg_op[argn]; ! 453: arg = sky->arg[argn]; ! 454: arg = deletenode(arg); ! 455: if (sky->tstloop) { ! 456: n = sky->result; ! 457: for (i = 0; i < 3; i++) { ! 458: n = n->back; ! 459: } ! 460: delete_tst_loop(n); ! 461: sky->tstloop = 0; ! 462: } ! 463: sky->oldresult = remove(sky->result); ! 464: insert_tst_loop(sky->skyload->forw, sky->skyload->ref[1]); ! 465: } ! 466: ! 467: /* ! 468: * Insert a test loop waiting for the SKY idle bit to turn on. ! 469: * Insert the code: ! 470: * 1: btst #6,skybase(-2) ! 471: * beqs 1b ! 472: */ ! 473: insert_tst_loop(node, skybase) ! 474: NODE *node; ! 475: struct oper *skybase; ! 476: { ! 477: NODE *label; ! 478: NODE *btst; ! 479: NODE *beqs; ! 480: struct sym_bkt *sbp; ! 481: char ltoken[20]; ! 482: extern char *ll_format; ! 483: extern int ll_val[]; ! 484: static struct oper btstbit = { T_IMMED, 0, 0, 0, NULL, NULL, 0, IDLE, 0 }; ! 485: static struct oper labelop = { T_NORMAL, 0, 0, 0, NULL, NULL, 0, 0, 0 }; ! 486: ! 487: sprintf(ltoken, ll_format, '1', ++ll_val[1]); ! 488: sbp = lookup(ltoken); ! 489: sbp->attr_s |= S_LABEL | S_DEC | S_DEF; ! 490: sbp->csect_s = C_TEXT; ! 491: ! 492: label = new(); ! 493: label->op = OP_LABEL; ! 494: label->subop = SUBOP_Z; ! 495: label->nref = 1; ! 496: label->name = sbp; ! 497: ! 498: btst = new(); ! 499: btst->op = OP_OTHER; ! 500: btst->subop = SUBOP_B; ! 501: btst->instr = sopcode("btst"); ! 502: btst->nref = 2; ! 503: btst->ref[0] = newoperand(&btstbit); ! 504: btst->ref[1] = newoperand(skybase); ! 505: btst->ref[1]->value_o = STATUS_WORD; ! 506: ! 507: labelop.sym_o = sbp; ! 508: beqs = new(); ! 509: beqs->op = OP_JUMP; ! 510: beqs->subop = JGE; ! 511: beqs->instr = sopcode("beqs"); ! 512: beqs->nref = 0; ! 513: beqs->ref[0] = newoperand(&labelop); ! 514: beqs->luse = label; ! 515: ! 516: label->forw = btst; ! 517: btst->forw = beqs; ! 518: beqs->back = btst; ! 519: btst->back = label; ! 520: insert(label, node); ! 521: } ! 522: ! 523: /* ! 524: * Remove a node from the list ! 525: */ ! 526: NODE * ! 527: remove(p) ! 528: NODE *p; ! 529: { ! 530: p->back->forw = p->forw; ! 531: p->forw->back = p->back; ! 532: p->back = NULL; ! 533: p->forw = NULL; ! 534: return(p); ! 535: } ! 536: ! 537: /* ! 538: * Find an opcode in the opcode table ! 539: */ ! 540: struct skyop * ! 541: findop(op) ! 542: int op; ! 543: { ! 544: struct skyop *sp; ! 545: ! 546: for (sp = regops; sp->op != 0; sp++) { ! 547: if (sp->op == op) { ! 548: return(sp); ! 549: } ! 550: } ! 551: return(NULL); ! 552: } ! 553: ! 554: /* ! 555: * Insert code to load the sky register with a value. ! 556: * Load it with the first operand of the sky operation ! 557: * passed in here. ! 558: */ ! 559: insert_reg_load(sky) ! 560: struct skylist *sky; ! 561: { ! 562: NODE *p; ! 563: NODE *load; ! 564: NODE *arg; ! 565: ! 566: load = sky->skyload; ! 567: p = newinst(load, load->ref[0], load->ref[1]); ! 568: p->ref[0]->value_o = SP_LOAD; ! 569: insert(p, load->back); ! 570: ! 571: arg = sky->arg[0]; ! 572: p = newinst(arg, arg->ref[0], arg->ref[1]); ! 573: insert(p, load->back); ! 574: } ! 575: ! 576: /* ! 577: * Create a new instruction. ! 578: * Copy the old one passed in and then give it the new arguments. ! 579: */ ! 580: NODE * ! 581: newinst(oldinst, arg1, arg2) ! 582: NODE *oldinst; ! 583: struct oper *arg1; ! 584: struct oper *arg2; ! 585: { ! 586: NODE *p; ! 587: ! 588: p = new(); ! 589: *p = *oldinst; ! 590: p->forw = NULL; ! 591: p->back = NULL; ! 592: p->ref[0] = newoperand(arg1); ! 593: p->ref[1] = newoperand(arg2); ! 594: return(p); ! 595: } ! 596: ! 597: /* ! 598: * Change the code to fetch the result from the sky board. ! 599: * If possible change last operation to use R0 as an operand ! 600: * and generate a fetch'able result. ! 601: * Otherwise, insert additional code to fetch the result. ! 602: */ ! 603: fetch_result(sky) ! 604: struct skylist *sky; ! 605: { ! 606: NODE *n; ! 607: NODE *p; ! 608: NODE *load; ! 609: NODE *result; ! 610: struct skyop *skyop; ! 611: int i; ! 612: ! 613: skyop = findop(sky->oldop); ! 614: if (skyop->fetch != 0) { ! 615: n = sky->skyload->forw; ! 616: n = n->forw; ! 617: if (n->op == OP_LABEL) { ! 618: n = delete_tst_loop(n); ! 619: sky->tstloop = 0; ! 620: } ! 621: sky->skyload->ref[0]->value_o = skyop->fetch; ! 622: insert(sky->oldresult, n); ! 623: } else { ! 624: load = sky->skyload; ! 625: n = load->forw; ! 626: for (i = 0; i < 3; i++) { ! 627: n = n->forw; ! 628: } ! 629: p = newinst(load, load->ref[0], load->ref[1]); ! 630: p->ref[0]->value_o = SP_STORE; ! 631: insert(p, n); ! 632: n = n->forw; ! 633: ! 634: result = sky->oldresult; ! 635: p = newinst(result, result->ref[0], result->ref[1]); ! 636: insert(p, n); ! 637: } ! 638: } ! 639: ! 640: /* ! 641: * Delete a test loop. ! 642: * The actual test and branch may differ here. ! 643: */ ! 644: NODE * ! 645: delete_tst_loop(n) ! 646: NODE *n; ! 647: { ! 648: if (n->op != OP_LABEL) { ! 649: fprintf(stderr, "c2: internal error deleting test loop\n"); ! 650: exit(1); ! 651: } ! 652: n = deletenode(n); /* Label */ ! 653: n = n->forw; ! 654: n = deletenode(n); /* test */ ! 655: n = n->forw; ! 656: n = deletenode(n); /* branch */ ! 657: return(n); ! 658: } ! 659: ! 660: /* ! 661: * Free a list of sky structures ! 662: */ ! 663: free_list(sky) ! 664: struct skylist *sky; ! 665: { ! 666: struct skylist *next; ! 667: struct skylist *skyp; ! 668: ! 669: for (skyp = sky; skyp != NULL; skyp = next) { ! 670: next = skyp->next; ! 671: free(skyp); ! 672: } ! 673: } ! 674: ! 675: /* ! 676: * Look for the sequence: ! 677: * ! 678: * movl skybaseR@,X ! 679: * movl skybaseR@,Y ! 680: * movl X,mem1 ! 681: * movl Y,mem2 ! 682: * ! 683: * Change it to ! 684: * ! 685: * movl skybaseR@,mem1 ! 686: * movl skybaseR@,mem2 ! 687: * ! 688: * This sequence occurs when a double precision value is fetched from ! 689: * the SKY board and is stored into memory. ! 690: */ ! 691: skymove(n) ! 692: NODE *n; ! 693: { ! 694: NODE *n1; ! 695: NODE *n2; ! 696: NODE *n3; ! 697: int reg; ! 698: int reg1; ! 699: ! 700: n1 = n->forw; ! 701: n2 = n1->forw; ! 702: n3 = n2->forw; ! 703: if (skytoreg(n) && skytoreg(n1)) { ! 704: reg = n->ref[1]->value_o; ! 705: reg1 = n1->ref[1]->value_o; ! 706: if (regtomem(n2, reg) && regtomem(n3, reg1)) { ! 707: if (!inmask(reg, n3->forw->rlive ) && ! 708: !inmask(reg1, n3->forw->rlive ) ) { ! 709: n->ref[1] = newoperand(n2->ref[1]); ! 710: n1->ref[1] = newoperand(n3->ref[1]); ! 711: deletenode(n2); ! 712: deletenode(n3); ! 713: meter.ndpsky++; ! 714: return(1); ! 715: } ! 716: } ! 717: } ! 718: return(0); ! 719: } ! 720: ! 721: /* ! 722: * Look for the instruction ! 723: * ! 724: * movl skybaseR@,X ! 725: * ! 726: * which fetches a value from the sky board and puts it in a register. ! 727: * skybaseR is a register containing __skybase and X is a register. ! 728: */ ! 729: static ! 730: skytoreg(n) ! 731: NODE *n; ! 732: { ! 733: struct oper *op1; ! 734: struct oper *op2; ! 735: struct oper *con; ! 736: struct sym_bkt *sym; ! 737: int reg; ! 738: extern struct oper *get_regcon(); ! 739: ! 740: if (n->op != OP_MOVE || n->subop != SUBOP_L) { ! 741: return(0); ! 742: } ! 743: op1 = n->ref[0]; ! 744: op2 = n->ref[1]; ! 745: if (op1->type_o != T_DEFER) { ! 746: return(0); ! 747: } ! 748: reg = op1->value_o; ! 749: sym = get_regcon( reg )->sym_o; ! 750: if (skyname == NULL || sym != skyname) { ! 751: return(0); ! 752: } ! 753: if (op2->type_o != T_REG) { ! 754: return(0); ! 755: } ! 756: return(1); ! 757: } ! 758: ! 759: /* ! 760: * Look for the instruction ! 761: * ! 762: * movl X,mem ! 763: * ! 764: * where X is a register. ! 765: */ ! 766: static ! 767: regtomem(n, reg) ! 768: NODE *n; ! 769: int reg; ! 770: { ! 771: struct oper *op1; ! 772: struct oper *op2; ! 773: ! 774: if (n->op != OP_MOVE || n->subop != SUBOP_L) { ! 775: return(0); ! 776: } ! 777: op1 = n->ref[0]; ! 778: op2 = n->ref[1]; ! 779: if (op1->value_o == reg && op2->type_o != T_REG) { ! 780: return(1); ! 781: } ! 782: return(0); ! 783: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.