![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / gen3|
Return to gen.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / gen3 |
1.1 ! root 1: /* C compiler: VAX subset code generator */ ! 2: ! 3: #include "c.h" ! 4: ! 5: #ifdef DEBUG ! 6: #define debug(x,y) if (x) y ! 7: static void lprint(Node, char *); ! 8: static void nprint(Node); ! 9: static char *rnames(unsigned); ! 10: static int id; ! 11: static Node lhead; ! 12: ! 13: #else ! 14: #define debug(x,y) ! 15: #endif ! 16: ! 17: static int rflag; /* != 0 to trace register allocation */ ! 18: static int framesize; /* size of activation record */ ! 19: static int offset; /* current frame offset */ ! 20: static int argbuildsize; /* size of argument build area */ ! 21: static int argoffset; /* offset from top of stack for next argument */ ! 22: static int nregs = 12; /* number of allocatable registers */ ! 23: static unsigned rmask; /* rmask&(1<<r) == 0 if register r is free */ ! 24: static unsigned usedmask; /* usedmask&(1<<r) == 1 if register r was used */ ! 25: static int reginfo[] = { /* 1<<x if op+x is legal; */ ! 26: 0, /* 0x1000<<x if op+x needs a register */ ! 27: #include "reginfo.h" ! 28: }; ! 29: ! 30: static void genreloads(Node, Node, Symbol); ! 31: static Symbol genspill(Node); ! 32: static void getreg(Node); ! 33: static Node *linearize(Node, Node *, Node); ! 34: static int needsreg(Node); ! 35: static void putreg(Node); ! 36: static void ralloc(Node); ! 37: static void restore(unsigned); ! 38: static void save(unsigned); ! 39: static int spillee(Node, unsigned); ! 40: static void spill(int, unsigned, Node); ! 41: static unsigned uses(Node); ! 42: static int valid(int); ! 43: ! 44: #define typecode(p) (optype(p->op) == U ? I : optype(p->op) == B ? P : optype(p->op)) ! 45: #define sets(p) ((p)->x.rmask<<(p)->x.reg) ! 46: ! 47: /* address - initialize q for addressing expression p+n */ ! 48: static void address(Symbol q, Symbol p, int n) { ! 49: if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) ! 50: q->x.name = stringf("%s%s%d", p->x.name, n >= 0 ? "+" : "", n); ! 51: else { ! 52: q->x.offset = p->x.offset + n; ! 53: q->x.name = stringf("%d(%s)", q->x.offset, ! 54: p->scope == PARAM ? "ap" : "fp"); ! 55: } ! 56: } ! 57: ! 58: /* blockbeg - begin a compound statement */ ! 59: static void blockbeg(Env *e) { ! 60: assert(rmask == (((~0)<<nregs)|1)); ! 61: e->rmask = rmask; ! 62: e->offset = offset; ! 63: } ! 64: ! 65: /* blockend - end a compound statement */ ! 66: static void blockend(Env *e) { ! 67: if (offset > framesize) ! 68: framesize = offset; ! 69: offset = e->offset; ! 70: rmask = e->rmask; ! 71: } ! 72: ! 73: /* defaddress - initialize an address */ ! 74: static void defaddress(Symbol p) { ! 75: print(".long %s\n", p->x.name); ! 76: } ! 77: ! 78: /* defconst - define a constant */ ! 79: static void defconst(int ty, Value v) { ! 80: switch (ty) { ! 81: case C: print(".byte %d\n", v.uc); break; ! 82: case S: print(".word %d\n", v.us); break; ! 83: case I: print(".long %d\n", v.i ); break; ! 84: case U: print(".long 0x%x\n", v.u ); break; ! 85: case P: print(".long 0x%x\n", v.p ); break; ! 86: #ifdef vax ! 87: case F: ! 88: print(".long 0x%x\n", ((unsigned *) &v.f)[0]); ! 89: break; ! 90: case D: ! 91: print(".long 0x%x,0x%x\n", ((unsigned *) &v.d)[0], ! 92: ((unsigned *) &v.d)[1]); ! 93: break; ! 94: #else ! 95: case F: { ! 96: char buf[MAXLINE]; ! 97: sprintf(buf, ".float 0f%.8e\n", v.f); ! 98: outs(buf); ! 99: break; ! 100: } ! 101: case D: { ! 102: char buf[MAXLINE]; ! 103: sprintf(buf, ".double 0d%.18e\n", v.d); ! 104: outs(buf); ! 105: break; ! 106: } ! 107: #endif ! 108: default: assert(0); ! 109: } ! 110: } ! 111: ! 112: /* defstring - emit a string constant */ ! 113: static void defstring(int len, char *s) { ! 114: while (len-- > 0) ! 115: print(".byte %d\n", *s++); ! 116: } ! 117: ! 118: /* defsymbol - initialize p's Xsymbol fields */ ! 119: static void defsymbol(Symbol p) { ! 120: if (p->scope == CONSTANTS) ! 121: p->x.name = p->name; ! 122: else if (p->scope >= LOCAL && p->sclass == STATIC) ! 123: p->x.name = stringf("L%d", genlabel(1)); ! 124: else if (p->generated) ! 125: p->x.name = stringf("L%s", p->name); ! 126: else ! 127: p->x.name = stringf("_%s", p->name); ! 128: } ! 129: ! 130: /* " FDCSIUPVB" */ ! 131: #define suffix(p) ".fdbwllll."[optype((p)->op)] ! 132: #define binary(inst) print("%s%c3 r%d,r%d,r%d\n", inst, suffix(p), \ ! 133: b->x.reg, a->x.reg, r) ! 134: #define unary(inst) print("%s%c r%d,r%d\n", inst, suffix(p), a->x.reg, r) ! 135: #define compare(cp) print("cmp%c r%d,r%d; j%s %s\n", suffix(p), \ ! 136: a->x.reg, b->x.reg, cp, p->syms[0]->x.name) ! 137: ! 138: /* emit - emit the dags on list p */ ! 139: static void emit(Node p) { ! 140: for (; p; p = p->x.next) { ! 141: Node a = p->kids[0], b = p->kids[1]; ! 142: int r = p->x.reg; ! 143: switch (p->op) { ! 144: case BANDU: binary("bic"); break; ! 145: case BORU: binary("bis"); break; ! 146: case BXORU: binary("xor"); break; ! 147: case ADDD: case ADDF: binary("add"); break; ! 148: case ADDI: case ADDP: case ADDU: binary("add"); break; ! 149: case SUBD: case SUBF: binary("sub"); break; ! 150: case SUBI: case SUBP: case SUBU: binary("sub"); break; ! 151: case MULD: case MULF: binary("mul"); break; ! 152: case MULI: case MULU: binary("mul"); break; ! 153: case DIVD: case DIVF: case DIVI: binary("div"); break; ! 154: case DIVU: ! 155: save(p->x.busy&0x3e); ! 156: print("pushl r%d; pushl r%d; calls $2,udiv; movl r0,r%d\n", ! 157: b->x.reg, a->x.reg, r); ! 158: restore(p->x.busy&0x3e); ! 159: break; ! 160: case MODI: ! 161: print("divl3 r%d,r%d,r0; mull2 r%d,r0; subl3 r0,r%d,r%d\n", ! 162: b->x.reg, a->x.reg, b->x.reg, a->x.reg, r); ! 163: break; ! 164: case MODU: ! 165: save(p->x.busy&0x3e); ! 166: print("pushl r%d; pushl r%d; calls $2,urem; movl r0,r%d\n", ! 167: b->x.reg, a->x.reg, r); ! 168: restore(p->x.busy&0x3e); ! 169: break; ! 170: case RSHU: ! 171: print("subl3 r%d,$32,r0; extzv r%d,r0,r%d,r%d\n", ! 172: b->x.reg, b->x.reg, a->x.reg, r); ! 173: break; ! 174: case RSHI: case LSHI: case LSHU: ! 175: print("ashl r%d,r%d,r%d\n", b->x.reg, a->x.reg, r); ! 176: break; ! 177: case INDIRB: ! 178: print("moval (r%d),r%d\n", a->x.reg, r); ! 179: break; ! 180: case INDIRC: case INDIRD: case INDIRF: case INDIRI: ! 181: case INDIRP: case INDIRS: ! 182: print("mov%c (r%d),r%d\n", suffix(p), a->x.reg, r); ! 183: break; ! 184: case BCOMU: unary("mcom" ); break; ! 185: case NEGD: case NEGF: case NEGI: unary("mneg" ); break; ! 186: case CVCI: unary("cvtb" ); break; ! 187: case CVCU: unary("movzb"); break; ! 188: case CVSI: unary("cvtw" ); break; ! 189: case CVSU: unary("movzw"); break; ! 190: case CVDF: case CVDI: unary("cvtd" ); break; ! 191: case CVFD: unary("cvtf" ); break; ! 192: case CVUC: case CVUS: unary("cvtl" ); break; ! 193: case CVIC: case CVIS: case CVID: unary("cvtl" ); break; ! 194: case CVIU: case CVUI: unary("mov" ); break; ! 195: case CVPU: case CVUP: unary("mov" ); break; ! 196: case RETD: case RETF: case RETI: ! 197: print("mov%c r%d,r0; ret\n", suffix(p), a->x.reg); ! 198: break; ! 199: case RETV: ! 200: print("ret\n"); ! 201: break; ! 202: case ADDRGP: case ADDRFP: case ADDRLP: ! 203: print("moval %s,r%d\n", p->syms[0]->x.name, r); ! 204: break; ! 205: case CNSTC: case CNSTI: case CNSTP: ! 206: case CNSTS: case CNSTU: ! 207: print("movl $%s,r%d\n", p->syms[0]->x.name, r); ! 208: break; ! 209: case JUMPV: ! 210: print("jmp (r%d)\n", a->x.reg); ! 211: break; ! 212: case ASGNB: ! 213: save(p->x.busy&0x3f); ! 214: print("movc3 $%s,(r%d),(r%d)\n", p->syms[0]->x.name, ! 215: b->x.reg, a->x.reg); ! 216: restore(p->x.busy&0x3f); ! 217: break; ! 218: case ASGNC: case ASGND: case ASGNF: case ASGNI: case ASGNP: case ASGNS: ! 219: print("mov%c r%d,(r%d)\n", suffix(p), b->x.reg, a->x.reg); ! 220: break; ! 221: case ARGB: ! 222: save(p->x.busy&0x3f); ! 223: print("movc3 $%s,(r%d),%d(sp)\n", p->syms[0]->x.name, ! 224: a->x.reg, p->x.argoffset); ! 225: restore(p->x.busy&0x3f); ! 226: break; ! 227: case ARGD: case ARGF: case ARGI: case ARGP: ! 228: print("mov%c r%d,%d(sp)\n", suffix(p), ! 229: a->x.reg, p->x.argoffset); ! 230: break; ! 231: case CALLB: ! 232: save(p->x.busy&0x3e); ! 233: if (a->x.reg == 1) { ! 234: print("movl r1,r0\n"); ! 235: a->x.reg = 0; ! 236: } ! 237: if (b->x.reg != 1) ! 238: print("movl r%d,r1\n", b->x.reg); ! 239: print("calls $0,(r%d)\n", a->x.reg); ! 240: restore(p->x.busy&0x3e); ! 241: break; ! 242: case CALLD: case CALLF: case CALLI: case CALLV: ! 243: save(p->x.busy&0x3e); ! 244: print("calls $0,(r%d)\n", a->x.reg); ! 245: if (p->op != CALLV) ! 246: print("mov%c r0,r%d\n", suffix(p), r); ! 247: restore(p->x.busy&0x3e); ! 248: break; ! 249: case EQD: case EQF: case EQI: compare("eql" ); break; ! 250: case GED: case GEF: case GEI: compare("geq" ); break; ! 251: case GEU: compare("gequ"); break; ! 252: case GTD: case GTF: case GTI: compare("gtr" ); break; ! 253: case GTU: compare("gtru"); break; ! 254: case LED: case LEF: case LEI: compare("leq" ); break; ! 255: case LEU: compare("lequ"); break; ! 256: case LTD: case LTF: case LTI: compare("lss" ); break; ! 257: case LTU: compare("lssu"); break; ! 258: case NED: case NEF: case NEI: compare("neq" ); break; ! 259: case LABELV: ! 260: print("%s:", p->syms[0]->x.name); ! 261: break; ! 262: default: assert(0); ! 263: } ! 264: } ! 265: } ! 266: ! 267: /* export - announce an exported symbol */ ! 268: static void export(Symbol p) { ! 269: print(".globl %s\n", p->x.name); ! 270: } ! 271: ! 272: /* function - generate code for a function */ ! 273: static void function(Symbol f, Symbol caller[], ! 274: Symbol callee[], int ncalls) { ! 275: int i; ! 276: ! 277: offset = 4; ! 278: for (i = 0; caller[i] && callee[i]; i++) { ! 279: offset = roundup(offset, caller[i]->type->align); ! 280: callee[i]->x.offset = caller[i]->x.offset = offset; ! 281: callee[i]->x.name = caller[i]->x.name = stringf("%d(ap)", offset); ! 282: offset += caller[i]->type->size; ! 283: callee[i]->sclass = AUTO; ! 284: } ! 285: usedmask = argbuildsize = framesize = offset = 0; ! 286: gencode(caller, callee); ! 287: print("%s:.word 0x%x\n", f->x.name, usedmask&~0x3f); ! 288: framesize += 4*nregs + argbuildsize; ! 289: print("subl2 $%d,sp\n", framesize); ! 290: if (isstruct(freturn(f->type))) ! 291: print("movl r1,-4(fp)\n"); ! 292: emitcode(); ! 293: if (glevel > 1) ! 294: print("ret\n"); ! 295: } ! 296: ! 297: /* gen - generate code for the dags on list p */ ! 298: static Node gen(Node p) { ! 299: Node head, *last; ! 300: ! 301: debug(1,id = 0); ! 302: for (last = &head; p; p = p->link) ! 303: last = linearize(p, last, 0); ! 304: debug(rflag,(lhead = head, lprint(head," before ralloc"))); ! 305: for (p = head; p; p = p->x.next) { ! 306: ralloc(p); ! 307: if (p->count == 0 && sets(p)) ! 308: putreg(p); ! 309: } ! 310: debug(rflag,lprint(lhead," after ralloc")); ! 311: return head; ! 312: } ! 313: ! 314: /* getreg - allocate 1 or 2 registers for node p */ ! 315: static void getreg(Node p) { ! 316: int r, m = optype(p->op) == D ? 3 : 1; ! 317: ! 318: for (r = 0; r < nregs; r++) ! 319: if ((rmask&(m<<r)) == 0) { ! 320: p->x.rmask = m; ! 321: p->x.reg = r; ! 322: rmask |= sets(p); ! 323: usedmask |= sets(p); ! 324: debug(rflag,fprint(2,"allocating %s to node #%d\n", rnames(sets(p)), p->x.id)); ! 325: return; ! 326: } ! 327: debug(rflag,lprint(lhead, " before spillee")); ! 328: r = spillee(p, m); ! 329: spill(r, m, p); ! 330: debug(rflag,lprint(lhead, " after spill")); ! 331: assert((rmask&(m<<r)) == 0); ! 332: getreg(p); ! 333: } ! 334: ! 335: /* genreloads - make the nodes after dot use reloads of temp instead of p's register */ ! 336: static void genreloads(Node dot, Node p, Symbol temp) { ! 337: int i; ! 338: Node last; ! 339: ! 340: for (last = dot; dot = dot->x.next; last = dot) ! 341: for (i = 0; i < MAXKIDS; i++) ! 342: if (dot->kids[i] == p) { ! 343: dot->kids[i] = newnode(INDIR + typecode(p), ! 344: newnode(ADDRL+P, 0, 0, temp), 0, 0); ! 345: dot->kids[i]->count = 1; ! 346: p->count--; ! 347: linearize(dot->kids[i], &last->x.next, last->x.next); ! 348: last = dot->kids[i]; ! 349: } ! 350: assert(p->count == 0); ! 351: } ! 352: ! 353: /* genspill - generate code to spill p's register and return the temporary used */ ! 354: static Symbol genspill(Node p) { ! 355: Symbol temp = newtemp(AUTO, typecode(p)); ! 356: Node q = p->x.next; ! 357: ! 358: linearize(newnode(ASGN + typecode(p), ! 359: newnode(ADDRLP, 0, 0, temp), p, 0), ! 360: &p->x.next, p->x.next); ! 361: rmask &= ~1; ! 362: for (p = p->x.next; p != q; p = p->x.next) ! 363: ralloc(p); ! 364: rmask |= 1; ! 365: return temp; ! 366: } ! 367: ! 368: /* global - global id */ ! 369: static void global(Symbol p) { ! 370: switch (p->type->align) { ! 371: case 2: print(".align 1; "); break; ! 372: case 4: print(".align 2; "); break; ! 373: case 8: print(".align 3; "); break; ! 374: } ! 375: print("%s:", p->x.name); ! 376: } ! 377: ! 378: /* import - announce an imported symbol */ ! 379: static void import(Symbol p) { ! 380: } ! 381: ! 382: /* linearize - linearize node list p */ ! 383: static Node *linearize(Node p, Node *last, Node next) { ! 384: if (p && !p->x.visited) { ! 385: last = linearize(p->kids[0], last, 0); ! 386: last = linearize(p->kids[1], last, 0); ! 387: p->x.visited = 1; ! 388: *last = p; ! 389: last = &p->x.next; ! 390: debug(1,if (p->x.id == 0) p->x.id = ++id); ! 391: debug(rflag,{fprint(2,"listing node "); nprint(p);}) ! 392: } ! 393: *last = next; ! 394: return last; ! 395: } ! 396: ! 397: /* local - local variable */ ! 398: static void local(Symbol p) { ! 399: offset = roundup(offset + p->type->size, p->type->align); ! 400: offset = roundup(offset, 4); ! 401: p->x.offset = -offset; ! 402: p->x.name = stringf("%d(fp)", -offset); ! 403: p->sclass = AUTO; ! 404: } ! 405: ! 406: /* needsreg - does p need a register? */ ! 407: static int needsreg(p) Node p; { ! 408: assert(opindex(p->op) > 0 && opindex(p->op) < sizeof reginfo/sizeof reginfo[0]); ! 409: return reginfo[opindex(p->op)]&(0x1000<<optype(p->op)); ! 410: } ! 411: ! 412: /* progbeg - beginning of program */ ! 413: static void progbeg(int argc, char *argv[]) { ! 414: extern int atoi(char *); /* (omit) */ ! 415: while (--argc > 0) ! 416: if (**++argv == '-' && argv[0][1] >= '0' && argv[0][1] <= '9') ! 417: nregs = atoi(*argv + 1); ! 418: else if (strcmp(*argv, "-r") == 0) /* (omit) */ ! 419: rflag++; /* (omit) */ ! 420: rmask = ((~0)<<nregs)|1; ! 421: } ! 422: ! 423: /* progend - end of program */ ! 424: static void progend(void) { ! 425: } ! 426: ! 427: /* putreg - decrement register usage */ ! 428: static void putreg(Node p) { ! 429: if (p && --p->count <= 0) ! 430: { assert(p->x.rmask); ! 431: rmask &= ~sets(p); ! 432: debug(rflag,fprint(2,"deallocating %s from node #%d\n", rnames(sets(p)), p->x.id)); } ! 433: } ! 434: ! 435: /* ralloc - assign a register for p */ ! 436: static void ralloc(Node p) { ! 437: int i; ! 438: ! 439: assert(p); ! 440: assert(p->x.rmask == 0); ! 441: switch (generic(p->op)) { ! 442: case ARG: ! 443: argoffset = roundup(argoffset, p->syms[1]->u.c.v.i); ! 444: p->x.argoffset = argoffset; ! 445: argoffset += p->syms[0]->u.c.v.i; ! 446: if (argoffset > argbuildsize) ! 447: argbuildsize = roundup(argoffset, 4); ! 448: break; ! 449: case CALL: ! 450: argoffset = 0; ! 451: break; ! 452: default:assert(valid(p->op)); ! 453: } ! 454: for (i = 0; i < MAXKIDS; i++) ! 455: putreg(p->kids[i]); ! 456: p->x.busy = rmask; ! 457: if (needsreg(p)) ! 458: getreg(p); ! 459: } ! 460: ! 461: /* restore - restore registers in mask */ ! 462: static void restore(unsigned mask) { ! 463: int i; ! 464: ! 465: for (i = 1; i < nregs; i++) ! 466: if (mask&(1<<i)) ! 467: print("movl %d(fp),r%d\n", ! 468: 4*i - framesize + argbuildsize, i); ! 469: } ! 470: ! 471: /* save - save registers in mask */ ! 472: static void save(unsigned mask) { ! 473: int i; ! 474: ! 475: for (i = 1; i < nregs; i++) ! 476: if (mask&(1<<i)) ! 477: print("movl r%d,%d(fp)\n", i, ! 478: 4*i - framesize + argbuildsize); ! 479: } ! 480: ! 481: /* segment - switch to logical segment s */ ! 482: static void segment(int s) { ! 483: switch (s) { ! 484: case CODE: print(".text\n"); break; ! 485: case LIT: print(".text 1\n"); break; ! 486: case DATA: ! 487: case BSS: print(".data\n"); break; ! 488: default: assert(0); ! 489: } ! 490: } ! 491: ! 492: /* space - initialize n bytes of space */ ! 493: static void space(int n) { ! 494: print(".space %d\n", n); ! 495: } ! 496: ! 497: /* spill - spill all registers that overlap (r,m) */ ! 498: static void spill(int r, unsigned m, Node dot) { ! 499: int i; ! 500: Node p = dot; ! 501: ! 502: while (p = p->x.next) ! 503: for (i = 0; i < MAXKIDS; i++) ! 504: if (p->kids[i] && sets(p->kids[i])&(m<<r)) { ! 505: Symbol temp = genspill(p->kids[i]); ! 506: rmask &= ~sets(p->kids[i]); ! 507: genreloads(dot, p->kids[i], temp); ! 508: } ! 509: } ! 510: ! 511: /* spillee - identify the most-distantly-used register */ ! 512: static int spillee(Node dot, unsigned m) { ! 513: int bestdist = -1, bestreg = 0, dist, r; ! 514: Node q; ! 515: ! 516: debug(rflag,fprint(2,"spillee: dot is node #%d\n", dot->x.id)); ! 517: for (r = 1; r < nregs - (m>>1); r++) { ! 518: dist = 0; ! 519: for (q = dot->x.next; q && !(uses(q)&(m<<r)); q = q->x.next) ! 520: dist++; ! 521: assert(q); /* (omit) */ ! 522: debug(rflag,fprint(2,"r%d used in node #%d at distance %d\n", r, q->x.id, dist)); ! 523: if (dist > bestdist) { ! 524: bestdist = dist; ! 525: bestreg = r; ! 526: } ! 527: } ! 528: debug(rflag,fprint(2,"spilling %s\n",rnames(m<<bestreg))); ! 529: assert(bestreg); /* (omit) */ ! 530: return bestreg; ! 531: } ! 532: ! 533: /* uses - return mask of registers used by node p */ ! 534: static unsigned uses(Node p) { ! 535: int i; ! 536: unsigned m = 0; ! 537: ! 538: for (i = 0; i < MAXKIDS; i++) ! 539: if (p->kids[i]) ! 540: m |= sets(p->kids[i]); ! 541: return m; ! 542: } ! 543: ! 544: /* valid - is operator op a valid operator ? */ ! 545: static int valid(op) { ! 546: return opindex(op) > 0 && opindex(op) < sizeof reginfo/sizeof reginfo[0] ? ! 547: reginfo[opindex(op)]&(1<<optype(op)) : 0; ! 548: } ! 549: ! 550: #ifdef DEBUG ! 551: /* lprint - print the nodelist beginning at p */ ! 552: static void lprint(Node p, char *s) { ! 553: fprint(2, "node list%s:\n", s); ! 554: if (p) { ! 555: char buf[100]; ! 556: sprintf(buf, "%-4s%-8s%-8s%-8s%-7s%-13s%s", ! 557: " #", "op", "kids", "syms", "count", "uses", "sets"); ! 558: fprint(2, "%s\n", buf); ! 559: } ! 560: for ( ; p; p = p->x.next) ! 561: nprint(p); ! 562: } ! 563: ! 564: /* nprint - print a line describing node p */ ! 565: static void nprint(Node p) { ! 566: int i; ! 567: char *kids = "", *syms = "", buf[200]; ! 568: ! 569: if (p->kids[0]) { ! 570: static char buf[100]; ! 571: buf[0] = 0; ! 572: for (i = 0; i < MAXKIDS && p->kids[i]; i++) ! 573: sprintf(buf + strlen(buf), "%3d", p->kids[i]->x.id); ! 574: kids = &buf[1]; ! 575: } ! 576: if (p->syms[0] && p->syms[0]->x.name) { ! 577: static char buf[100]; ! 578: buf[0] = 0; ! 579: for (i = 0; i < MAXSYMS && p->syms[i]; i++) { ! 580: if (p->syms[i]->x.name) ! 581: sprintf(buf + strlen(buf), " %s", p->syms[i]->x.name); ! 582: if (p->syms[i]->u.c.loc) ! 583: sprintf(buf + strlen(buf), "=%s", p->syms[i]->u.c.loc->name); ! 584: } ! 585: syms = &buf[1]; ! 586: } ! 587: sprintf(buf, "%2d. %-8s%-8s%-8s %2d %-13s", ! 588: p->x.id, opname(p->op), kids, syms, p->count, rnames(uses(p))); ! 589: sprintf(buf + strlen(buf), "%s", rnames(sets(p))); ! 590: fprint(2, "%s\n", buf); ! 591: } ! 592: ! 593: /* rnames - return names of registers given by mask m */ ! 594: static char *rnames(unsigned m) { ! 595: static char buf[100]; ! 596: int r; ! 597: ! 598: buf[0] = buf[1] = 0; ! 599: for (r = 0; r < nregs; r++) ! 600: if (m&(1<<r)) ! 601: sprintf(buf + strlen(buf), " r%d", r); ! 602: return &buf[1]; ! 603: } ! 604: #endif ! 605: ! 606: #ifndef V9 ! 607: #include <errno.h> ! 608: #ifndef errno ! 609: extern int errno; ! 610: #endif ! 611: ! 612: /* strtol - interpret str as a base b number; if ptr!=0, *ptr gets updated str */ ! 613: long strtol(str, ptr, b) char *str, **ptr; { ! 614: long n = 0; ! 615: char *s, sign = '+'; ! 616: int d, overflow = 0; ! 617: ! 618: if (ptr) ! 619: *ptr = str; ! 620: if (b < 0 || b == 1 || b > 36) ! 621: return 0; ! 622: while (*str==' '||*str=='\f'||*str=='\n'||*str=='\r'||*str=='\t'||*str=='\v') ! 623: str++; ! 624: if (*str == '-' || *str == '+') ! 625: sign = *str++; ! 626: if (b == 0) ! 627: if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) { ! 628: b = 16; ! 629: str += 2; ! 630: } else if (str[0] == '0') ! 631: b = 8; ! 632: else ! 633: b = 10; ! 634: for (s = str; *str; str++) { ! 635: if (*str >= '0' && *str <= '9') ! 636: d = *str - '0'; ! 637: else if (*str >= 'a' && *str <= 'z' || *str >= 'A' && *str <= 'Z') ! 638: d = (*str&~040) - 'A' + 10; ! 639: else ! 640: break; ! 641: if (d >= b) ! 642: break; ! 643: if (n < (LONG_MIN + d)/b) ! 644: overflow = 1; ! 645: n = b*n - d; ! 646: } ! 647: if (s == str) ! 648: return 0; ! 649: if (ptr) ! 650: *ptr = str; ! 651: if (overflow || (sign == '+' && n == LONG_MIN)) { ! 652: errno = ERANGE; ! 653: return sign == '+' ? LONG_MAX : LONG_MIN; ! 654: } ! 655: return sign == '+' ? -n : n; ! 656: } ! 657: #endif ! 658: ! 659: static Interface naiveVAX = { ! 660: "naiveVAX", ! 661: 1, 1, 0, /* char */ ! 662: 2, 2, 0, /* short */ ! 663: 4, 4, 0, /* int */ ! 664: 4, 4, 1, /* float */ ! 665: 8, 4, 1, /* double */ ! 666: 4, 4, 0, /* T * */ ! 667: 0, 1, 0, /* struct */ ! 668: 1, /* left_to_right */ ! 669: 1, /* little_endian */ ! 670: 0, /* jump_on_return */ ! 671: 0, /* mulops_are_calls */ ! 672: 1, /* compl_band */ ! 673: 0, /* no_argb */ ! 674: 0, /* no_dag */ ! 675: address, ! 676: blockbeg, ! 677: blockend, ! 678: defaddress, ! 679: defconst, ! 680: defstring, ! 681: defsymbol, ! 682: emit, ! 683: export, ! 684: function, ! 685: gen, ! 686: global, ! 687: import, ! 688: local, ! 689: progbeg, ! 690: progend, ! 691: segment, ! 692: space, ! 693: }; ! 694: Interface *interfaces[] = { &naiveVAX, 0 }; ! 695:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.