![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / c|
Return to dag.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 ! root 1: /* C compiler: dag processing */ ! 2: ! 3: #include "c.h" ! 4: #define NBUCKETS 020 ! 5: ! 6: struct code codehead = { Start }; ! 7: Code codelist = &codehead; /* list of code nodes for current function */ ! 8: int nodecount; /* # of available nodes in hash table */ ! 9: ! 10: static struct dag { /* dags: */ ! 11: struct node node; /* the node itself */ ! 12: struct dag *hlink; /* next dag on hash chain */ ! 13: } *buckets[NBUCKETS]; /* hash table */ ! 14: static Node nodelist; /* node list */ ! 15: dclproto(static struct dag *dagnode,(int, Node, Node, Symbol)); ! 16: dclproto(static void fixup,(Node)); ! 17: dclproto(static int haskid,(Node, Node)); ! 18: dclproto(static Node labelnode,(int)); ! 19: dclproto(static Node list,(Node)); ! 20: dclproto(static void reset,(void)); ! 21: dclproto(static void remove,(Node)); ! 22: dclproto(static void trash,(Node)); ! 23: dclproto(static void typestab,(Symbol, Generic)); ! 24: dclproto(static Node undag,(Node)); ! 25: dclproto(static Node undag1,(Node, Node)); ! 26: ! 27: /* addlocal - add local p to list of locals for the current block */ ! 28: void addlocal(p) Symbol p; { ! 29: if (!p->defined) { ! 30: code(Local)->u.var = p; ! 31: p->defined = 1; ! 32: p->scope = level; ! 33: } ! 34: } ! 35: ! 36: /* btot - map operator op or suffix op into a representative type */ ! 37: Type btot(op) int op; { ! 38: switch (optype(op)) { ! 39: case F: return floattype; ! 40: case D: return doubletype; ! 41: case C: return chartype; ! 42: case S: return shorttype; ! 43: case I: return inttype; ! 44: case U: return unsignedtype; ! 45: case P: return voidptype; ! 46: default: assert(0); ! 47: } ! 48: return 0; ! 49: } ! 50: ! 51: /* code - allocate a code node of kind and append to the code list */ ! 52: Code code(kind) { ! 53: Code cp; ! 54: ! 55: if (kind > Label) { ! 56: for (cp = codelist; cp->kind < Label; ) ! 57: cp = cp->prev; ! 58: if (cp->kind == Jump) ! 59: warning("unreachable code\n"); ! 60: } ! 61: cp = (Code)talloc(sizeof *cp); ! 62: cp->kind = kind; ! 63: cp->prev = codelist; ! 64: cp->next = 0; ! 65: codelist->next = cp; ! 66: return codelist = cp; ! 67: } ! 68: ! 69: /* dagnode - allocate a dag with the given fields */ ! 70: static struct dag *dagnode(op, l, r, sym) Node l, r; Symbol sym; { ! 71: register struct dag *p = (struct dag *) talloc(sizeof *p); ! 72: ! 73: BZERO(p, struct dag); ! 74: p->node.op = op; ! 75: if (p->node.kids[0] = l) ! 76: ++l->count; ! 77: if (p->node.kids[1] = r) ! 78: ++r->count; ! 79: p->node.syms[0] = sym; ! 80: return p; ! 81: } ! 82: ! 83: /* emitcode - emit code for the current function */ ! 84: void emitcode() { ! 85: Code bp, cp; ! 86: Coordinate save; ! 87: ! 88: save = src; ! 89: for (bp = 0, cp = &codehead; errcnt <= 0 && cp; cp = cp->next) ! 90: switch (cp->kind) { ! 91: case Blockbeg: ! 92: cp->u.block.prev = bp; ! 93: bp = cp; ! 94: if (glevel && IR->stabblock) { ! 95: (*IR->stabblock)('{', bp->u.block.level - LOCAL, bp->u.block.locals); ! 96: swtoseg(CODE); ! 97: } ! 98: break; ! 99: case Blockend: ! 100: if (glevel && IR->stabblock) { ! 101: foreach(bp->u.block.identifiers, bp->u.block.level, typestab, (Generic)0); ! 102: foreach(bp->u.block.types, bp->u.block.level, typestab, (Generic)0); ! 103: (*IR->stabblock)('}', bp->u.block.level - LOCAL, bp->u.block.locals); ! 104: swtoseg(CODE); ! 105: } ! 106: bp = bp->u.block.prev; ! 107: break; ! 108: case Local: ! 109: if (glevel && IR->stabsym) { ! 110: (*IR->stabsym)(cp->u.var); ! 111: swtoseg(CODE); ! 112: } ! 113: break; ! 114: case Defpoint: ! 115: src = cp->u.point.src; ! 116: if (glevel && IR->stabline) { ! 117: (*IR->stabline)(&cp->u.point.src); ! 118: swtoseg(CODE); ! 119: } ! 120: break; ! 121: case Jump: ! 122: if (cp->u.node == 0) ! 123: break; ! 124: /* else fall thru */ ! 125: case Gen: case Label: ! 126: (*IR->emit)(cp->u.node); ! 127: break; ! 128: case Switch: { ! 129: int i, k = cp->u.swtch.values[0]; ! 130: for (i = 0; i < cp->u.swtch.size; i++) { ! 131: while (k++ < cp->u.swtch.values[i]) ! 132: (*IR->defaddress)(cp->u.swtch.deflab->u.l.equatedto); ! 133: (*IR->defaddress)(cp->u.swtch.labels[i]->u.l.equatedto); ! 134: } ! 135: break; ! 136: } ! 137: } ! 138: src = save; ! 139: } ! 140: ! 141: /* fixup - re-aim equated labels to the true label */ ! 142: static void fixup(p) Node p; { ! 143: for ( ; p; p = p->link) ! 144: switch (generic(p->op)) { ! 145: case JUMP: ! 146: if (p->kids[0]->op == ADDRG+P) ! 147: p->kids[0]->syms[0] = p->kids[0]->syms[0]->u.l.equatedto; ! 148: break; ! 149: case LABEL: ! 150: case EQ: case GE: case GT: case LE: case LT: case NE: ! 151: assert(p->syms[0]); ! 152: p->syms[0] = p->syms[0]->u.l.equatedto; ! 153: } ! 154: } ! 155: ! 156: /* gencode - generate code for the current function */ ! 157: void gencode(caller, callee) Symbol caller[], callee[]; { ! 158: int i; ! 159: Code bp, cp; ! 160: Symbol p, q; ! 161: Coordinate save; ! 162: ! 163: save = src; ! 164: cp = codehead.next->next; ! 165: codelist = codehead.next; ! 166: for (i = 0; (p = callee[i]) && (q = caller[i]); i++) ! 167: if (p->sclass != q->sclass || p->type != q->type) { ! 168: walk(asgn(p, idnode(q)), 0, 0); ! 169: if (glevel && IR->stabsym) { ! 170: (*IR->stabsym)(p); ! 171: (*IR->stabsym)(q); ! 172: swtoseg(CODE); ! 173: } ! 174: } else if (glevel && IR->stabsym) { ! 175: (*IR->stabsym)(p); ! 176: swtoseg(CODE); ! 177: } ! 178: codelist->next = cp; ! 179: cp->prev = codelist; ! 180: for (bp = 0, cp = &codehead; errcnt <= 0 && cp; cp = cp->next) ! 181: switch (cp->kind) { ! 182: case Start: case Switch: ! 183: break; ! 184: case Defpoint: ! 185: src = cp->u.point.src; ! 186: break; ! 187: case Blockbeg: { ! 188: Symbol *p = cp->u.block.locals; ! 189: cp->u.block.prev = bp; ! 190: bp = cp; ! 191: (*IR->blockbeg)(&bp->u.block.x); ! 192: for ( ; *p; p++) ! 193: if ((*p)->ref || glevel) ! 194: (*IR->local)(*p); ! 195: break; ! 196: } ! 197: case Blockend: ! 198: (*IR->blockend)(&bp->u.block.x); ! 199: bp = bp->u.block.prev; ! 200: break; ! 201: case Local: ! 202: assert(cp->u.var->scope == bp->u.block.level); ! 203: (*IR->local)(cp->u.var); ! 204: break; ! 205: case Address: ! 206: (*IR->address)(cp->u.addr.sym, cp->u.addr.base, cp->u.addr.offset); ! 207: break; ! 208: case Jump: ! 209: if (cp->u.node == 0) ! 210: break; ! 211: /* else fall thru */ ! 212: case Gen: case Label: ! 213: fixup(cp->u.node); ! 214: if (IR->no_dag) ! 215: cp->u.node = undag(cp->u.node); ! 216: cp->u.node = (*IR->gen)(cp->u.node); ! 217: break; ! 218: default:assert(0); ! 219: } ! 220: src = save; ! 221: } ! 222: ! 223: /* haskid - does p appear as an operand in t? */ ! 224: static int haskid(p, t) Node p, t; { ! 225: if (t == 0) ! 226: return 0; ! 227: else if (p == t) ! 228: return 1; ! 229: else ! 230: return haskid(p, t->kids[0]) || haskid(p, t->kids[1]); ! 231: } ! 232: ! 233: /* labelnode - list and return a LABEL node for label lab */ ! 234: static Node labelnode(lab) { ! 235: assert(lab); ! 236: if (islabel(nodelist)) { ! 237: equatelab(findlabel(lab), nodelist->syms[0]); ! 238: return nodelist; ! 239: } ! 240: return list(newnode(LABEL+V, 0, 0, findlabel(lab))); ! 241: } ! 242: ! 243: /* list - list node p unless it's already listed; return p */ ! 244: static Node list(p) Node p; { ! 245: if (p && p->link == 0) { ! 246: if (nodelist) { ! 247: p->link = nodelist->link; ! 248: nodelist->link = p; ! 249: } else ! 250: p->link = p; ! 251: nodelist = p; ! 252: #ifdef DAGCHECK ! 253: { extern void type_checker(Node); type_checker(p); } ! 254: #endif ! 255: } ! 256: return p; ! 257: } ! 258: ! 259: /* listnodes - walk tree tp, building and listing dag nodes in execution order */ ! 260: Node listnodes(tp, tlab, flab) Tree tp; { ! 261: Opcode op; ! 262: Node p, l, r; ! 263: ! 264: if (tp == 0) ! 265: return 0; ! 266: if (tp->node) ! 267: return tp->node; ! 268: op = generic(tp->op); ! 269: switch (op) { ! 270: case AND: ! 271: if (flab) { ! 272: listnodes(tp->kids[0], 0, flab); ! 273: r = listnodes(tp->kids[1], 0, flab); ! 274: } else { ! 275: listnodes(tp->kids[0], 0, flab = genlabel(1)); ! 276: listnodes(tp->kids[1], tlab, 0); ! 277: r = labelnode(flab); ! 278: } ! 279: trash(0); ! 280: return r; ! 281: case NOT: ! 282: return listnodes(tp->kids[0], flab, tlab); ! 283: case OR: ! 284: if (tlab) { ! 285: listnodes(tp->kids[0], tlab, 0); ! 286: r = listnodes(tp->kids[1], tlab, 0); ! 287: } else { ! 288: listnodes(tp->kids[0], tlab = genlabel(1), 0); ! 289: listnodes(tp->kids[1], 0, flab); ! 290: r = labelnode(tlab); ! 291: } ! 292: trash(0); ! 293: return r; ! 294: case COND: { ! 295: Tree q; ! 296: assert(tlab == 0 && flab == 0); ! 297: if (tp->u.sym) ! 298: addlocal(tp->u.sym); ! 299: trash(0); ! 300: listnodes(tp->kids[0], 0, flab = genlabel(2)); ! 301: trash(0); ! 302: if (q = tp->kids[1]) { ! 303: assert(q->op == RIGHT); ! 304: listnodes(q->kids[0], 0, 0); ! 305: if (islabel(nodelist)) { ! 306: equatelab(nodelist->syms[0], findlabel(flab + 1)); ! 307: remove(nodelist); ! 308: } ! 309: trash(0); ! 310: } ! 311: if (q && q->kids[1]) { ! 312: list(jump(flab + 1)); ! 313: labelnode(flab); ! 314: listnodes(q->kids[1], 0, 0); ! 315: if (islabel(nodelist)) { ! 316: equatelab(nodelist->syms[0], findlabel(flab + 1)); ! 317: remove(nodelist); ! 318: } ! 319: } else ! 320: labelnode(flab); ! 321: p = labelnode(flab + 1); ! 322: trash(0); ! 323: if (tp->u.sym) { ! 324: Tree t = idnode(tp->u.sym); ! 325: tp->u.sym->ref = 0; /* undo idnode's setting ref */ ! 326: p = listnodes(t, 0, 0); ! 327: } ! 328: break; ! 329: } ! 330: case CNST: { ! 331: Type ty = unqual(tp->type); ! 332: assert(op == CNST+S || ty->u.sym); ! 333: if (op == CNST+S || ty->u.sym->addressed) ! 334: p = listnodes(cvtconst(tp), tlab, flab); ! 335: else if (tlab == 0 && flab == 0) ! 336: p = node(tp->op, 0, 0, constant(ty, tp->u.v)); ! 337: else { ! 338: assert(ty == inttype); ! 339: if (tlab && tp->u.v.i != 0) ! 340: p = list(jump(tlab)); ! 341: else if (flab && tp->u.v.i == 0) ! 342: p = list(jump(flab)); ! 343: else ! 344: p = 0; ! 345: } ! 346: break; ! 347: } ! 348: case RIGHT: ! 349: if (tp->kids[0] && generic(tp->kids[0]->op) == INDIR ! 350: && tp->kids[1] && generic(tp->kids[1]->op) == ASGN ! 351: && tp->kids[0]->kids[0] == tp->kids[1]->kids[0]) { /* e++ */ ! 352: p = listnodes(tp->kids[0], 0, 0); ! 353: if (nodelist) { ! 354: Node t; ! 355: for (t = nodelist; ; t = t->link) ! 356: if (haskid(p, t->link)) { ! 357: p->link = t->link; ! 358: t->link = p; ! 359: break; ! 360: } else if (t->link == nodelist) { ! 361: list(p); ! 362: break; ! 363: } ! 364: } else ! 365: list(p); ! 366: listnodes(tp->kids[1], 0, 0); ! 367: } else if (tp->kids[1]) { ! 368: if (tp->kids[0] && generic(tp->kids[0]->op) == CNST) ! 369: tp->kids[0] = 0; ! 370: listnodes(tp->kids[0], 0, 0); ! 371: p = listnodes(tp->kids[1], tlab, flab); ! 372: } else ! 373: p = listnodes(tp->kids[0], tlab, flab); ! 374: break; ! 375: case JUMP: ! 376: assert(tlab == 0 && flab == 0); ! 377: assert(tp->u.sym == 0); ! 378: assert(tp->kids[0]); ! 379: l = listnodes(tp->kids[0], 0, 0); ! 380: p = newnode(JUMP+V, l, 0, 0); ! 381: trash(0); ! 382: list(p); ! 383: break; ! 384: case CALL: ! 385: assert(tlab == 0 && flab == 0); ! 386: l = listnodes(tp->kids[0], 0, 0); /* arguments, function name */ ! 387: r = listnodes(tp->kids[1], 0, 0); ! 388: p = newnode(tp->op, l, r, 0); ! 389: p->syms[0] = (Symbol)talloc(sizeof *p->syms[0]); ! 390: BZERO(p->syms[0], struct symbol); ! 391: if (isptr(tp->kids[0]->type) && isfunc(tp->kids[0]->type->type)) ! 392: p->syms[0]->type = tp->kids[0]->type->type; ! 393: else ! 394: p->syms[0]->type = func(voidtype, 0, 1); ! 395: trash(0); ! 396: list(p); ! 397: cfunc->u.f.ncalls++; ! 398: break; ! 399: case ARG: ! 400: assert(tlab == 0 && flab == 0); ! 401: if (IR->left_to_right) ! 402: listnodes(tp->kids[1], 0, 0); ! 403: l = listnodes(tp->kids[0], 0, 0); ! 404: p = newnode(tp->op, l, 0, 0); ! 405: p->syms[0] = intconst(tp->type->size); ! 406: p->syms[1] = intconst(tp->type->align); ! 407: list(p); ! 408: if (!IR->left_to_right) ! 409: listnodes(tp->kids[1], 0, 0); ! 410: return 0; ! 411: case EQ: case NE: case GT: case GE: case LE: case LT: { ! 412: int lab; ! 413: assert(tp->u.sym == 0); ! 414: assert(errcnt || tlab || flab); ! 415: if (lab = flab) { ! 416: assert(tlab == 0); ! 417: switch (op) { ! 418: case EQ: op = NE + optype(tp->op); break; ! 419: case NE: op = EQ + optype(tp->op); break; ! 420: case GT: op = LE + optype(tp->op); break; ! 421: case LT: op = GE + optype(tp->op); break; ! 422: case GE: op = LT + optype(tp->op); break; ! 423: case LE: op = GT + optype(tp->op); break; ! 424: } ! 425: } else if (lab = tlab) ! 426: op = tp->op; ! 427: l = listnodes(tp->kids[0], 0, 0); ! 428: r = listnodes(tp->kids[1], 0, 0); ! 429: p = newnode(op, l, r, findlabel(lab)); ! 430: p->syms[0]->ref++; ! 431: list(p); ! 432: break; ! 433: } ! 434: case ASGN: ! 435: assert(tlab == 0 && flab == 0); ! 436: if (tp->kids[0]->op == FIELD) { ! 437: Tree x = tp->kids[0]->kids[0]; ! 438: Field p = tp->kids[0]->u.field; ! 439: assert(generic(x->op) == INDIR); ! 440: trash(0); ! 441: l = listnodes(lvalue(x), 0, 0); ! 442: if (fieldsize(p) < 8*p->type->size) { ! 443: unsigned int fmask = fieldmask(p); ! 444: unsigned int mask = fmask<<fieldright(p); ! 445: Tree q = tp->kids[1]; ! 446: if (q->op == CNST+I && q->u.v.i == 0 ! 447: || q->op == CNST+U && q->u.v.u == 0) ! 448: q = bitnode(BAND, x, constnode(~mask, unsignedtype)); ! 449: else if (q->op == CNST+I && (q->u.v.i&fmask) == fmask ! 450: || q->op == CNST+U && (q->u.v.u&fmask) == fmask) ! 451: q = bitnode(BOR, x, constnode(mask, unsignedtype)); ! 452: else ! 453: q = bitnode(BOR, ! 454: bitnode(BAND, x, constnode(~mask, unsignedtype)), ! 455: bitnode(BAND, shnode(LSH, cast(q, unsignedtype), ! 456: constnode(fieldright(p), inttype)), ! 457: constnode(mask, unsignedtype))); ! 458: r = listnodes(q, 0, 0); ! 459: } else ! 460: r = listnodes(tp->kids[1], 0, 0); ! 461: } else { ! 462: l = listnodes(tp->kids[0], 0, 0); ! 463: r = listnodes(tp->kids[1], 0, 0); ! 464: } ! 465: trash(isaddrop(tp->kids[0]->op) && !tp->kids[0]->u.sym->computed ? l : 0); ! 466: p = newnode(tp->op, l, r, 0); ! 467: p->syms[0] = intconst(tp->kids[1]->type->size); ! 468: p->syms[1] = intconst(tp->kids[1]->type->align); ! 469: list(p); ! 470: p = listnodes(tp->kids[1], 0, 0); ! 471: break; ! 472: case BAND: ! 473: assert(tlab == 0 && flab == 0); ! 474: l = listnodes(tp->kids[0], 0, 0); ! 475: if (IR->compl_band) ! 476: r = listnodes(cast( ! 477: simplify(BCOM+U, unsignedtype, ! 478: cast(tp->kids[1], unsignedtype), 0), ! 479: tp->kids[1]->type), 0, 0); ! 480: else ! 481: r = listnodes(tp->kids[1], 0, 0); ! 482: p = node(tp->op, l, r, 0); ! 483: break; ! 484: case RSH: ! 485: assert(tlab == 0 && flab == 0); ! 486: l = listnodes(tp->kids[0], 0, 0); ! 487: if (IR->compl_band && tp->op == RSH+I) ! 488: r = listnodes(simplify(NEG+I, inttype, tp->kids[1], 0), 0, 0); ! 489: else ! 490: r = listnodes(tp->kids[1], 0, 0); ! 491: p = node(tp->op, l, r, 0); ! 492: break; ! 493: case ADD: case SUB: case DIV: case MUL: case MOD: ! 494: case BOR: case BXOR: case LSH: ! 495: assert(tlab == 0 && flab == 0); ! 496: l = listnodes(tp->kids[0], 0, 0); ! 497: r = listnodes(tp->kids[1], 0, 0); ! 498: p = node(tp->op, l, r, 0); ! 499: if (IR->mulops_are_calls && ! 500: (p->op == DIV+I || p->op == MOD+I || p->op == MUL+I ! 501: || p->op == DIV+U || p->op == MOD+U || p->op == MUL+U)) ! 502: list(p); ! 503: break; ! 504: case RET: ! 505: assert(tlab == 0 && flab == 0); ! 506: l = listnodes(tp->kids[0], 0, 0); ! 507: p = newnode(tp->op, l, 0, 0); ! 508: list(p); ! 509: break; ! 510: case CVC: case CVD: case CVF: case CVI: ! 511: case CVP: case CVS: case CVU: case NEG: case BCOM: ! 512: assert(tlab == 0 && flab == 0); ! 513: l = listnodes(tp->kids[0], 0, 0); ! 514: p = node(tp->op, l, 0, 0); ! 515: break; ! 516: case INDIR: { ! 517: Type ty = tp->kids[0]->type; ! 518: if (isptr(ty)) ! 519: ty = unqual(ty)->type; ! 520: assert(tlab == 0 && flab == 0); ! 521: l = listnodes(tp->kids[0], 0, 0); ! 522: if (isvolatile(ty) || (isstruct(ty) && unqual(ty)->u.sym->u.s.vfields)) ! 523: p = newnode(tp->op, l, 0, 0); ! 524: else ! 525: p = node(tp->op, l, 0, 0); ! 526: break; ! 527: } ! 528: case FIELD: { ! 529: Tree q; ! 530: assert(tlab == 0 && flab == 0); ! 531: q = shnode(RSH, ! 532: shnode(LSH, tp->kids[0], ! 533: constnode(fieldleft(tp->u.field), inttype)), ! 534: constnode(8*tp->type->size - fieldsize(tp->u.field), inttype)); ! 535: p = listnodes(q, 0, 0); ! 536: break; ! 537: } ! 538: case ADDRL: ! 539: assert(tlab == 0 && flab == 0); ! 540: if (tp->u.sym->temporary) { ! 541: addlocal(tp->u.sym); ! 542: release(tp->u.sym); ! 543: } ! 544: p = node(tp->op, 0, 0, tp->u.sym); ! 545: break; ! 546: case ADDRG: case ADDRF: ! 547: assert(tlab == 0 && flab == 0); ! 548: if (tp->u.sym->scope == LABELS) ! 549: tp->u.sym->ref++; ! 550: p = node(tp->op, 0, 0, tp->u.sym); ! 551: break; ! 552: default:assert(0); ! 553: } ! 554: return tp->node = p; ! 555: } ! 556: ! 557: /* jump - return tree for a jump to lab */ ! 558: Node jump(lab) { ! 559: Symbol p = findlabel(lab); ! 560: ! 561: p->ref++; ! 562: return newnode(JUMP+V, node(ADDRG+P, 0, 0, p), 0, 0); ! 563: } ! 564: ! 565: /* newnode - allocate a node with the given fields */ ! 566: Node newnode(op, l, r, sym) Node l, r; Symbol sym; { ! 567: return &dagnode(op, l, r, sym)->node; ! 568: } ! 569: ! 570: /* node - search for a node with the given fields, or allocate it */ ! 571: Node node(op, l, r, sym) Node l, r; Symbol sym; { ! 572: int i = (opindex(op)^((unsigned)sym>>2))&(NBUCKETS-1); ! 573: register struct dag *p; ! 574: ! 575: for (p = buckets[i]; p; p = p->hlink) ! 576: if (p->node.op == op && p->node.syms[0] == sym ! 577: && p->node.kids[0] == l && p->node.kids[1] == r) ! 578: return &p->node; ! 579: p = dagnode(op, l, r, sym); ! 580: p->hlink = buckets[i]; ! 581: buckets[i] = p; ! 582: ++nodecount; ! 583: return &p->node; ! 584: } ! 585: ! 586: dclproto(static void printdag1,(Node, int, int)); ! 587: dclproto(static void printnode,(Node, int, int)); ! 588: ! 589: /* printdag - print dag p on fd, or the node list if p == 0 */ ! 590: void printdag(p, fd) Node p; { ! 591: printed(0); ! 592: if (p == 0) { ! 593: if (p = nodelist) ! 594: do { ! 595: p = p->link; ! 596: printdag1(p, fd, 0); ! 597: } while (p != nodelist); ! 598: } else if (*printed(nodeid((Tree)p))) ! 599: fprint(fd, "node'%d printed above\n", nodeid((Tree)p)); ! 600: else ! 601: printdag1(p, fd, 0); ! 602: } ! 603: ! 604: /* printdag1 - recursively print dag p */ ! 605: static void printdag1(p, fd, lev) Node p; { ! 606: int id, i; ! 607: ! 608: if (p == 0 || *printed(id = nodeid((Tree)p))) ! 609: return; ! 610: *printed(id) = 1; ! 611: for (i = 0; i < MAXKIDS; i++) ! 612: printdag1(p->kids[i], fd, lev + 1); ! 613: printnode(p, fd, lev); ! 614: } ! 615: ! 616: /* printnode - print fields of dag p */ ! 617: static void printnode(p, fd, lev) Node p; { ! 618: if (p) { ! 619: int i, id = nodeid((Tree)p); ! 620: fprint(fd, "%c%d%s", lev == 0 ? '\'' : '#', id, ! 621: &" "[id < 10 ? 0 : id < 100 ? 1 : 2]); ! 622: fprint(fd, "%s count=%d", opname(p->op), p->count); ! 623: for (i = 0; i < MAXKIDS && p->kids[i]; i++) ! 624: fprint(fd, " #%d", nodeid((Tree)p->kids[i])); ! 625: for (i = 0; i < MAXSYMS && p->syms[i]; i++) ! 626: fprint(fd, " %s", p->syms[i]->name); ! 627: fprint(fd, "\n"); ! 628: } ! 629: } ! 630: ! 631: /* remove - remove node p from the node list */ ! 632: static void remove(p) Node p; { ! 633: if (nodelist) { ! 634: Node q = nodelist; ! 635: for ( ; q->link != p && q->link != nodelist; q = q->link) ! 636: ; ! 637: assert(q->link == p); ! 638: q->link = p->link; ! 639: if (p == nodelist) ! 640: nodelist = q; ! 641: } ! 642: } ! 643: ! 644: /* reset - clear the dag */ ! 645: static void reset() { ! 646: BZERO(buckets, struct dag *[NBUCKETS]); ! 647: nodecount = 0; ! 648: } ! 649: ! 650: /* trash - preclude future links to rvalue of p or all values */ ! 651: static void trash(p) Node p; { ! 652: if (p) { ! 653: register int i; ! 654: register struct dag *q, **r; ! 655: for (i = 0; i < NBUCKETS; i++) ! 656: for (r = &buckets[i]; q = *r; ) ! 657: if (generic(q->node.op) == INDIR && (!isaddrop(q->node.kids[0]->op) ! 658: || q->node.kids[0]->syms[0] == p->syms[0])) { ! 659: *r = q->hlink; ! 660: --nodecount; ! 661: } else ! 662: r = &q->hlink; ! 663: } else if (nodecount > 0) ! 664: reset(); ! 665: } ! 666: ! 667: /* typestab - emit stab entries for p */ ! 668: static void typestab(p, cl) Symbol p; Generic cl; { ! 669: if (!isfunc(p->type) && (p->sclass == EXTERN || p->sclass == STATIC) && IR->stabsym) ! 670: (*IR->stabsym)(p); ! 671: else if ((p->sclass == TYPEDEF || p->sclass == 0) && IR->stabtype) ! 672: (*IR->stabtype)(p); ! 673: } ! 674: ! 675: #define iscall(p) (generic((p)->op) == CALL || IR->mulops_are_calls \ ! 676: && ((p)->op == DIV+I || (p)->op == MOD+I || (p)->op == MUL+I \ ! 677: || (p)->op == DIV+U || (p)->op == MOD+U || (p)->op == MUL+U)) ! 678: ! 679: /* undag - replace multiply-referenced nodes in nodelist by temporaries, return new nodelist */ ! 680: static Node undag(nodelist) Node nodelist; { ! 681: Node p, pred; ! 682: struct node head; ! 683: ! 684: head.link = nodelist; ! 685: for (pred = &head; p = pred->link; ) { ! 686: /* ! 687: * succ is p's successor, ! 688: * pred is p's predecessor, and ! 689: * p->link == pred; ! 690: * undag1(x, p) adds predecessors and maintains p->link == p->link->link. ! 691: */ ! 692: Node succ = p->link; ! 693: p->link = pred; ! 694: if (generic(p->op) == INDIR) { ! 695: assert(p->count >= 1); ! 696: undag1(p, p); ! 697: /* ! 698: * remove p from the node list, ! 699: * setting pred to the last node inserted (if any). ! 700: */ ! 701: pred = p->link; ! 702: pred->link = succ; ! 703: p->link = 0; ! 704: } else if (iscall(p) && p->count >= 1) { ! 705: Node q; ! 706: undag1(p, p); ! 707: /* ! 708: * p->link is p's predecessor, ! 709: * which is the ASGN of p to a temporary. ! 710: */ ! 711: assert(p->link && generic(p->link->op) == ASGN && p->link->kids[1] == p); ! 712: /* ! 713: * remove p from the node list, ! 714: * setting pred to the ASGN node. ! 715: */ ! 716: pred = p->link; ! 717: pred->link = succ; ! 718: /* ! 719: * re-insert p into the node list ! 720: * immediately before its predecessor; ! 721: * this places the CALL node before the ASGN node. ! 722: * / ! 723: for (q = &head; q && q->link != pred; q = q->link) ! 724: ; ! 725: assert(q); ! 726: q->link = p; ! 727: p->link = pred; */ ! 728: p->link = 0; ! 729: } else { ! 730: assert(p->count == 0); ! 731: undag1(p, p); ! 732: /* ! 733: * reestablish p's successor, and ! 734: * advance pred so that pred->link == succ ! 735: */ ! 736: p->link = succ; ! 737: pred = p; ! 738: } ! 739: } ! 740: rmtemps(0, LOCAL); ! 741: return head.link; ! 742: } ! 743: ! 744: /* undag1 - return a reference to the temporary holding value of p, or p */ ! 745: static Node undag1(p, root) Node p, root; { ! 746: Node e; ! 747: ! 748: if (p == 0) ! 749: ; ! 750: else if (p->syms[2]) { ! 751: e = newnode(INDIR + (isunsigned(p->syms[2]->type) ? I : ttob(p->syms[2]->type)), ! 752: newnode(ADDRL+P, 0, 0, p->syms[2]), 0, 0); ! 753: e->count = 1; ! 754: if (--p->count == 1) { ! 755: /* fprint(2, "releasing %s from ", p->syms[2]->name); printnode(p, 2, 1); ! 756: release(p->syms[2]); */ ! 757: p->syms[2] = 0; ! 758: } ! 759: p = e; ! 760: } else if (p->count <= 1 && !iscall(p) ! 761: || p->count == 0 && iscall(p)) { ! 762: p->kids[0] = undag1(p->kids[0], root); ! 763: p->kids[1] = undag1(p->kids[1], root); ! 764: } else if (p->op == ADDRL+P || p->op == ADDRF+P) { ! 765: assert(p != root); ! 766: p = newnode(p->op, 0, 0, p->syms[0]); ! 767: p->count = 1; ! 768: } else if (generic(p->op) == INDIR ! 769: && (p->kids[0]->op == ADDRL+P || p->kids[0]->op == ADDRF+P) ! 770: && p->kids[0]->syms[0]->sclass == REGISTER && p != root) { ! 771: p = newnode(p->op, ! 772: newnode(p->kids[0]->op, 0, 0, p->kids[0]->syms[0]), 0, 0); ! 773: p->count = 1; ! 774: } else if (p->op == INDIR+B) { ! 775: --p->count; ! 776: p = newnode(p->op, p->kids[0], 0, 0); ! 777: p->count = 1; ! 778: p->kids[0] = undag1(p->kids[0], root); ! 779: } else { ! 780: p->syms[2] = temporary(REGISTER, btot(p->op)); ! 781: /* fprint(2, "allocating %s to ", p->syms[2]->name); printnode(p, 2, 1); */ ! 782: if (!p->syms[2]->defined) { ! 783: p->syms[2]->scope = LOCAL; ! 784: p->syms[2]->ref = 1; ! 785: (*IR->local)(p->syms[2]); ! 786: p->syms[2]->defined = 1; ! 787: } ! 788: p->kids[0] = undag1(p->kids[0], root); ! 789: p->kids[1] = undag1(p->kids[1], root); ! 790: e = newnode(ASGN + (isunsigned(p->syms[2]->type) ? I : ttob(p->syms[2]->type)), ! 791: newnode(ADDRL+P, 0, 0, p->syms[2]), p, 0); ! 792: e->syms[0] = intconst(p->syms[2]->type->size); ! 793: e->syms[1] = intconst(p->syms[2]->type->align); ! 794: /* ! 795: * root->link is the root's predecessor; ! 796: * point the root's predecessor to the ASGN, ! 797: * make the ASGN the root's new predecessor, ! 798: * and make root the ASGN's successor. ! 799: */ ! 800: root->link = root->link->link = e; ! 801: e->link = root; ! 802: if (p != root) ! 803: p = undag1(p, root); /* returns reference to the temporary */ ! 804: } ! 805: return p; ! 806: } ! 807: ! 808: /* walk - list tree tp, generate code for current node list, reset node list */ ! 809: void walk(tp, tlab, flab) Tree tp; { ! 810: listnodes(tp, tlab, flab); ! 811: if (nodelist) { ! 812: trash(0); ! 813: code(Gen); ! 814: codelist->u.node = nodelist->link; ! 815: nodelist->link = 0; ! 816: nodelist = 0; ! 817: rmtemps(REGISTER, 0); ! 818: } ! 819: reset(); ! 820: ntree = 0; ! 821: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.