![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / optim|
Return to local.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / optim |
1.1 ! root 1: /* @(#) local.c: 1.5 6/26/84 */ ! 2: ! 3: /* # include <ctype.h> -- optim.h takes care of this */ ! 4: # include "optim.h" ! 5: # include "sgs.h" ! 6: # include "paths.h" ! 7: ! 8: # define ASDATE "" ! 9: # define LINELEN 400 ! 10: ! 11: # define FATAL(S) fatal((S), (char *) 0) ! 12: ! 13: char fixstr[256]; ! 14: char line[LINELEN]; ! 15: char * linptr; /* pointer to current line */ ! 16: int fixlen; ! 17: char * deflab; ! 18: int opn; ! 19: int m; ! 20: int numauto; /* number of bytes of automatic vars. */ ! 21: int numnreg; /* number of registers */ ! 22: boolean indata; ! 23: int lineno = IDVAL; ! 24: int nusel = 0; /* semantically useless instructions */ ! 25: int nspinc = 0; /* useless sp increments */ ! 26: int nmc = 0; /* move followed by compare */ ! 27: int nmal = 0; /* move followed by arithmetic or logical */ ! 28: int nredcmp = 0; /* redundant compares */ ! 29: int nadpsh = 0; /* addw3 or subw3 followed by push */ ! 30: int nadmsh = 0; /* addw3 or subw3 followed by mov */ ! 31: int nadmv = 0; /* replace addw3 or subw3 by mov */ ! 32: extern int ndisc; ! 33: ! 34: #ifdef IMPIL ! 35: zflag = false; /* debug flag for in--line expansion */ ! 36: #endif /* IMPIL */ ! 37: ! 38: # define numops 151 ! 39: ! 40: char *optbl[numops] = { ! 41: "acjl","acjle","acjleu","acjlu", ! 42: "addb2","addb3","addh2","addh3","addw2", ! 43: "addw3","alsw2","alsw3","andb2","andb3", ! 44: "andh2","andh3","andw2","andw3","arsw2", ! 45: "arsw3","atjnzb","atjnzh","atjnzw","bitw", ! 46: "call","cmpb","cmph","cmpw", ! 47: "decpth","decptw","divw2", ! 48: "divw3","extzv","faddd2","faddd3","fadds2", ! 49: "fadds3","fcmpd","fdivd2","fdivd3","fdivs2", ! 50: "fdivs3","fmuld2","fmuld3","fmuls2","fmuls3", ! 51: "fsubd2","fsubd3","fsubs2","fsubs3", ! 52: "incpth","incptw","inctst","insv", ! 53: "jbc","jbs","je","jg","jge", ! 54: "jgeu","jgu","jl","jle","jleu", ! 55: "jlu","jmp","jne","jneg","jnneg", ! 56: "jnpos","jnz","jpos","jsb","jz", ! 57: "llsw2","llsw3","lrsw2","lrsw3","mcomb", ! 58: "mcomh","mcomw","mnegb","mnegh","mnegw", ! 59: "modw2","modw3","movab","movah","movaw", ! 60: "movb","movbbh","movbbw","movbhw","movblb", ! 61: "movblh","movblw","movd","movdd","movds","movdw","movh", ! 62: "movsd","movsw","movtdw","movthb","movtsw", ! 63: "movtwb","movtwh","movw","movwd","movws", ! 64: "movzbh","movzbw","movzhw","mulw2","mulw3", ! 65: "orb2","orb3","orh2","orh3","orw2", ! 66: "orw3","pushaw","pushbb","pushbh", ! 67: "pushd","pushw","pushzb","pushzh","ret","save","subb2", ! 68: "subb3","subh2","subh3","subw2","subw3", ! 69: "switch","switcht", ! 70: "udivw2","udivw3","umodw2","umodw3","umulw2", ! 71: "umulw3","xorb2","xorb3","xorh2","xorh3", ! 72: "xorw2","xorw3" ! 73: }; ! 74: ! 75: FILE *stmpfile; /* Temporary storage for strings which are in the text ! 76: * section. The strings are collected and printed at ! 77: * the end of a function. Requirement for field update */ ! 78: extern char *mktemp(); ! 79: FILE *tmpopen(); ! 80: char tmpname[50]; /* name of file for storing string */ ! 81: FILE *atmpfile; /* Temporary storage for input while scanning for presence of ! 82: * #ASM in function */ ! 83: char atmpname[50]; ! 84: int asmflag = false; /* indicates whether an 'asm' has been encountered */ ! 85: long asmotell; /* location in the output file where the last function ended */ ! 86: int oaflag = false; /* indicates whether -OA flag was entered */ ! 87: boolean instring = false; ! 88: boolean inswitch = false; ! 89: #ifdef IMPIL ! 90: boolean swflag = false; /* switch table appears in function */ ! 91: NODE *lblnode = NULL; /* pointer to last label node */ ! 92: char *pcdecode(); ! 93: #endif /* IMPIL */ ! 94: ! 95: yylex() ! 96: { ! 97: extern char * strchr(); ! 98: ! 99: register char * s; /* temporary string ptr */ ! 100: register char * start; /* another temporary string ptr */ ! 101: register int i; /* temporary int */ ! 102: ! 103: #ifdef IMPIL ! 104: ilinit(); ! 105: #endif /* IMPIL */ ! 106: ! 107: asmopen(); /* open temp file for asm treatment */ ! 108: linptr = NULL; /* start off with no line */ ! 109: ! 110: while (linptr != NULL || ! 111: ((linptr = fgets(line,LINELEN,stdin)) != NULL && putasm(line))) ! 112: { ! 113: switch (*linptr) /* dispatch on first char in line */ ! 114: { ! 115: case '\n': /* ignore new line */ ! 116: break; ! 117: ! 118: case '#': /* check for special comments */ ! 119: s = linptr + 1; /* look at comment only, not # */ ! 120: ! 121: if (strncmp(s,"STRBEG",6) == 0) ! 122: instring = true; /* declare we're in a string */ ! 123: else if (strncmp(s,"STREND",6) == 0) ! 124: instring = false; /* now out of string-ness */ ! 125: else if (strncmp(s,"SWBEG",5) == 0) ! 126: inswitch = swflag = true; /* now in a switch table */ ! 127: else if (strncmp(s,"SWEND",5) == 0) ! 128: inswitch = false; /* out of switch table */ ! 129: else if (strncmp(s,"ASM",3) == 0) ! 130: asmflag = true; /* 'asm' appears in function */ ! 131: #ifdef IMPREGAL ! 132: else if (strncmp(s,"REGAL",5) == 0) ! 133: ratable( line ); /* register allocation opt */ ! 134: #endif /* IMPREGAL */ ! 135: ! 136: break; /* in any case, ignore line further */ ! 137: ! 138: case '.': /* compiler label */ ! 139: default: /* ordinary label */ ! 140: if (indata) /* in data section, just print */ ! 141: { ! 142: printf("%s",linptr); ! 143: break; ! 144: } ! 145: ! 146: /* reach here on labels in text space */ ! 147: ! 148: s = strchr(linptr,':'); /* find : */ ! 149: if (s == NULL) /* error if not found */ ! 150: { FATAL("Bad input format\n"); } ! 151: ! 152: *s++ = '\0'; /* change : to null, skip past */ ! 153: ! 154: /* for N3B (DMERT), switch code and jump tables are in text space, ! 155: ** but SWBEG, SWEND bracket just the table. For m32 and u3b, jump tables are ! 156: ** always in data space. ! 157: ** Write labels found when "inswitch" to special file for N3B only. ! 158: */ ! 159: ! 160: #ifdef N3B ! 161: if (instring || inswitch) /* inside special string or switch... */ ! 162: #else ! 163: if (instring) /* inside special string?... */ ! 164: #endif /* def N3B */ ! 165: { ! 166: putstr(linptr); /* write label to special file */ ! 167: putstr(":\n"); /* put : back in */ ! 168: } ! 169: else /* normal text space label */ ! 170: { ! 171: applbl(linptr,s-linptr); /* append label node */ ! 172: lastnode->uniqid = IDVAL; ! 173: } ! 174: linptr = s; /* continue processing past label */ ! 175: continue; /* next iteration */ ! 176: /* handle more usual case of line beginning with space/tab */ ! 177: case ' ': ! 178: case '\t': ! 179: for (s = linptr; isspace(*s); s++) /* skip white space */ ! 180: ; ! 181: ! 182: switch(*s) /* dispatch on next character */ ! 183: { ! 184: case '\0': /* line of white space */ ! 185: case '#': /* comment */ ! 186: case '\n': /* new line */ ! 187: break; /* ignore */ ! 188: ! 189: case '.': /* start of pseudo-op */ ! 190: pseudo(s); /* do pseudo-ops */ ! 191: break; ! 192: ! 193: default: /* normal instruction */ ! 194: if (indata) /* in data section this is weird case */ ! 195: printf("%s",linptr); /* just write line */ ! 196: else /* normal instruction in text */ ! 197: { ! 198: for (start = s; ! isspace(*s); s++) ! 199: ; /* skip over instruction mnemonic */ ! 200: ! 201: *s++ = '\0'; /* demarcate with null */ ! 202: ! 203: if ((opn = lookup(start)) == OTHER) ! 204: saveop(0,start,s-start,opn); ! 205: /* save funny instruction */ ! 206: else ! 207: saveop(0,optbl[m],0,opn); ! 208: /* save normal inst. (m set by ! 209: ** lookup) ! 210: */ ! 211: for ( ; isspace(*s); s++ ) ! 212: ; /* span white space */ ! 213: opn = 1; /* now save operands */ ! 214: op(s); /* skip intervening spaces/tabs */ ! 215: } ! 216: /* remember program name */ ! 217: #ifdef IMPIL ! 218: if( ntail.back->op == SAVE ) lblnode = ntail.back->back; ! 219: #endif /* IMPIL */ ! 220: break; ! 221: } /* end space/tab case */ ! 222: break; ! 223: } /* end first character switch */ ! 224: ! 225: linptr = NULL; /* indicate we're done with line */ ! 226: } /* end while */ ! 227: return; /* just exit */ ! 228: } ! 229: op (s) ! 230: register char *s; ! 231: { ! 232: register char *t; ! 233: ! 234: while (*s) ! 235: { ! 236: /* scan over leading space/tabs */ ! 237: while (*s == ' ' || *s == '\t') ! 238: s++; ! 239: ! 240: t = s; /* remember effective operand start */ ! 241: while(*s != ',' && *s != '\n') /* find end of operand */ ! 242: s++; ! 243: *s++ = '\0'; ! 244: saveop(opn++, t, s-t, 0); ! 245: if (*t == '.') /* operand is a label */ ! 246: if (inswitch) ! 247: addref(t, s-t); ! 248: } ! 249: lastnode->uniqid = lineno; ! 250: lineno = IDVAL; ! 251: } ! 252: ! 253: ! 254: pseudo (s) ! 255: register char *s; /* points at pseudo-op */ ! 256: { ! 257: void peep(); /* peephole improver */ ! 258: extern int cflag; /* independent part -c flag: ! 259: ** enable/disable common tail ! 260: */ ! 261: register int pop; /* pseudo-op code */ ! 262: char savechar; /* saved char that follows pseudo */ ! 263: char * word = s; /* pointer to beginning of pseudo */ ! 264: ! 265: /* The idea here is to stick in a NUL after the pseudo-op, then replace ! 266: ** the character we clobbered, rather than copy the pseudo-op somewhere else. ! 267: */ ! 268: ! 269: for ( ; ! isspace(*s); s++ ) ! 270: ; /* scan to white space char */ ! 271: savechar = *s; /* mark end of pseudo-op */ ! 272: *s = '\0'; ! 273: ! 274: /* if we're in a data section, we write all pseudo-ops to output, ! 275: ** except for .word's, which we must examine, and .text . ! 276: */ ! 277: ! 278: pop = plookup(word); /* identify pseudo-op */ ! 279: *s = savechar; /* restore saved character */ ! 280: if (indata) { /* check pseudo-op possibilities */ ! 281: if (pop == TEXT) { ! 282: indata = false; /* not in data section anymore */ ! 283: return; ! 284: } ! 285: else if (pop != WORD) { ! 286: printf("%s",linptr); /* output the line */ ! 287: return; ! 288: } ! 289: } ! 290: ! 291: switch (pop) { /* dispatch on pseudo-op in text */ ! 292: case BYTE: ! 293: putstr(linptr); ! 294: break; ! 295: case GLOBL: ! 296: case TV: ! 297: line[(m=length(line))-2] = '\0'; /* remove newline */ ! 298: appfl(line, m-1); ! 299: break; ! 300: case TEXT: ! 301: indata = false; ! 302: break; ! 303: case FIL: ! 304: case BSS: ! 305: printf("%s", line); ! 306: break; ! 307: case LN: ! 308: getln(line); ! 309: break; ! 310: case ALIGN: ! 311: line[(m=length(line))-2] = '\0'; /* remove NL */ ! 312: if (inswitch) { ! 313: #ifdef N3B /* for DMERT, put aligns in switch to special ! 314: ** output file with switch table ! 315: */ ! 316: line[m-2] = '\n'; /* restore new line */ ! 317: putstr(linptr); ! 318: #else ! 319: saveop(0, line+1, m-2, OTHER); ! 320: opn = 1; ! 321: lastnode->uniqid = lineno; ! 322: lineno = IDVAL; ! 323: #endif /* def N3B */ ! 324: } ! 325: else ! 326: appfl(line, m-1); ! 327: break; ! 328: case SET: ! 329: if (*++s == '.' && *++s == 'F') { ! 330: printf("\t.text\n"); ! 331: setauto(line); ! 332: printf("%s", line); ! 333: } ! 334: else if (s--, *s == '.' && *++s == 'R') { ! 335: setnreg(line); ! 336: line[(m=length(line))-2] = '\0'; ! 337: appfl(line,m-1); ! 338: } ! 339: else { ! 340: line[(m=length(line))-2] = '\0'; ! 341: appfl(line, m-1); ! 342: } ! 343: break; ! 344: case DATA: ! 345: printf("%s", line); ! 346: indata = true; ! 347: break; ! 348: case DEF: { ! 349: int found; ! 350: ! 351: line[(m=length(line))-2] = '\0'; /* remove newline */ ! 352: #ifdef IMPIL ! 353: while( isspace( *s ) ) s++; ! 354: if (*s++ == '.' && *s++ == 'e' && ! 355: *s++ == 'f') { /* .ef */ ! 356: appfl( "*", 2 ); ! 357: if( lblnode == NULL ) ! 358: { FATAL( "No label preceeding .bf pseudo op, file may already be optimized\n" ); } ! 359: appfl( lblnode->ops[0], ! 360: length( lblnode->ops[0])); ! 361: } ! 362: s--; ! 363: #endif /* IMPIL */ ! 364: found = 0; ! 365: while (true) { ! 366: while (*s++ != ';'); ! 367: if (*(s += 2) == 'e') /* endef */ ! 368: break; ! 369: /* There are two special cases for ".val". The first is ! 370: ** ".val ." . Since we're going to move the .def line, we need ! 371: ** to replace the '.' with a real label (which we make a hard label) ! 372: ** first. The second special case is ".val .Lxxx" (a local label). ! 373: ** This arises in the compiler from a user-defined label. The ! 374: ** problem here is that if the optimizer discards the local label, ! 375: ** there will be a reference to a non-existent label which will only ! 376: ** show up at link time. To avoid this, we delete (ignore) the whole ! 377: ** line. ! 378: */ ! 379: else if (*s++ == 'v') { /* .val */ ! 380: if (s[3] == '.') ! 381: { ! 382: if (s[4] == ';') /* first case */ ! 383: found = 1; ! 384: else if (s[4] == 'L') ! 385: found = 3; /* second */ ! 386: } ! 387: } ! 388: else if (*s == 'c') /* .scl */ ! 389: if (*(s+3) == '-' && *(s+4) == '1') { ! 390: found = 2; ! 391: break; ! 392: } ! 393: } ! 394: switch(found) ! 395: { ! 396: case 1: /* .val . */ ! 397: deflab = (char *) newlab(); ! 398: deffix(line, deflab); ! 399: appfl(fixstr, fixlen+1); ! 400: fixlbl(deflab); ! 401: applbl(deflab, length(deflab)); ! 402: lastnode->op = HLABEL; ! 403: lastnode-> uniqid = IDVAL; ! 404: break; ! 405: case 2: /* end of function */ ! 406: cflag = -1; /* turn off common tail ! 407: ** merging: improve speed, ! 408: ** not space. ! 409: */ ! 410: if( !asmflag || oaflag ) { ! 411: #ifdef IMPREGAL ! 412: numnreg = raoptim(numnreg, numauto); ! 413: numauto = raautos(numauto); ! 414: #endif /* IMPREGAL */ ! 415: #ifdef IMPIL ! 416: ilmark(); ! 417: #endif /* IMPIL */ ! 418: filter(); ! 419: optim(); ! 420: peep(); /* do peephole improvements */ ! 421: #ifdef IMPIL ! 422: ilstat(numnreg, numauto); ! 423: #endif /* IMPIL */ ! 424: chkauto(); ! 425: } ! 426: prtext(); ! 427: prstr(); ! 428: printf("%s", line); ! 429: printf("\n"); ! 430: asmchk(); ! 431: init(); ! 432: break; ! 433: case 3: /* .val .Lxxx */ ! 434: break; /* ignore line */ ! 435: default: /* other .defs */ ! 436: appfl(line, m-1); ! 437: break; ! 438: } ! 439: } ! 440: break; ! 441: case WORD: ! 442: s++; /* point past tab/nl */ ! 443: ! 444: /* we have to deal with whether .word is within a switch (SWBEG/SWEND) or ! 445: ** not, and whether or not it appears in a data section. ! 446: */ ! 447: ! 448: if (inswitch) { /* always add reference */ ! 449: register char * t = strchr(s,'\n'); ! 450: ! 451: *t = '\0'; /* change NL to null */ ! 452: addref(s,t+1-s); /* add the reference */ ! 453: *t = '\n'; /* restore NL */ ! 454: } ! 455: ! 456: if (indata) /* in data, flush to output */ ! 457: printf("%s",linptr); /* print line */ ! 458: else if (inswitch) /* text (implicit) and switch */ ! 459: putstr(linptr); /* flush to special file */ ! 460: else { /* text, not in switch */ ! 461: saveop(0,".word",6,OTHER); ! 462: opn = 1; /* doing first operand */ ! 463: op(s); ! 464: } ! 465: break; ! 466: ! 467: default: /* all unrecognized text ! 468: ** pseudo-ops ! 469: */ ! 470: if (! (instring || inswitch)) ! 471: printf("%s", linptr); /* flush to output */ ! 472: else ! 473: putstr(linptr); /* in(switch|string): to ! 474: ** special file ! 475: */ ! 476: break; ! 477: } ! 478: } ! 479: ! 480: int ! 481: plookup(s) /* look up pseudo op code */ ! 482: char *s; ! 483: ! 484: { ! 485: /* Note: to improve the linear search speed, these pseudo-ops ! 486: ** are ordered by frequency of occurrence in a sample of C programs. ! 487: */ ! 488: ! 489: static char *pops[numpops] = ! 490: { ! 491: ".word", ".byte", ".set", ".def", ".align", ! 492: ".data", ".text", ".globl", ".ln", ".bss", ! 493: ".file", ".tv" ! 494: }; ! 495: ! 496: static int popcode[numpops] = ! 497: { ! 498: WORD, BYTE, SET, DEF, ALIGN, ! 499: DATA, TEXT, GLOBL, LN, BSS, ! 500: FIL, TV ! 501: }; ! 502: ! 503: register int i; ! 504: ! 505: for (i = 0; i < numpops; i++) ! 506: if (!strcmp(s, pops[i])) ! 507: return(popcode[i]); ! 508: return(POTHER); ! 509: } ! 510: ! 511: ! 512: yyinit(flags) char * flags; { ! 513: ! 514: indata = false; ! 515: for (; *flags != '\0'; flags++) { ! 516: switch( *flags ) { ! 517: case 'V': ! 518: fprintf(stderr,"%s: optimizer - %s %s\n", ! 519: SGSNAME,RELEASE,ASDATE); ! 520: break; ! 521: case 'A': ! 522: oaflag = true; ! 523: break; ! 524: #ifdef IMPIL ! 525: case 'z': ! 526: zflag = true; ! 527: break; ! 528: #endif /* IMPIL */ ! 529: default: ! 530: fprintf(stderr,"Optimizer: invalid flag '%c'\n",*flags); ! 531: } ! 532: } ! 533: } ! 534: ! 535: char * ! 536: yysflgs( p ) char *p; { /* parse flags with sub fields */ ! 537: ! 538: switch( *p ) { ! 539: #ifdef IMPIL ! 540: case 'y': ! 541: p++; /* skip over 'y' to sub option */ ! 542: p = pcdecode( p ); ! 543: return( p ); ! 544: #endif /* IMPIL */ ! 545: default: ! 546: return( p ); ! 547: } ! 548: } ! 549: ! 550: int ! 551: lookup(op) char *op; { /* look up op code ordinal */ ! 552: ! 553: register int f,l,om,x; ! 554: static unsigned char ocode[numops] = { ! 555: ACJL,ACJLE,ACJLEU,ACJLU, ! 556: ADDB2,ADDB3,ADDH2,ADDH3,ADDW2, ! 557: ADDW3,ALSW2,ALSW3,ANDB2,ANDB3, ! 558: ANDH2,ANDH3,ANDW2,ANDW3,ARSW2, ! 559: ARSW3,ATJNZB,ATJNZH,ATJNZW,BITW, ! 560: CALL,CMPB,CMPH,CMPW, ! 561: DECPTH,DECPTW,DIVW2, ! 562: DIVW3,EXTZV,FADDD2,FADDD3,FADDS2, ! 563: FADDS3,FCMPD,FDIVD2,FDIVD3,FDIVS2, ! 564: FDIVS3,FMULD2,FMULD3,FMULS2,FMULS3, ! 565: FSUBD2,FSUBD3,FSUBS2,FSUBS3, ! 566: INCPTH,INCPTW,INCTST,INSV, ! 567: JBC,JBS,JE,JG,JGE, ! 568: JGEU,JGU,JL,JLE,JLEU, ! 569: JLU,JMP,JNE,JNEG,JNNEG, ! 570: JNPOS,JNZ,JPOS,JSB,JZ, ! 571: LLSW2,LLSW3,LRSW2,LRSW3,MCOMB, ! 572: MCOMH,MCOMW,MNEGB,MNEGH,MNEGW, ! 573: MODW2,MODW3,MOVAB,MOVAH,MOVAW, ! 574: MOVB,MOVBBH,MOVBBW,MOVBHW,MOVBLB, ! 575: MOVBLH,MOVBLW,MOVD,MOVDD,MOVDS,MOVDW,MOVH, ! 576: MOVSD,MOVSW,MOVTDW,MOVTHB,MOVTSW, ! 577: MOVTWB,MOVTWH,MOVW,MOVWD,MOVWS, ! 578: MOVZBH,MOVZBW,MOVZHW,MULW2,MULW3, ! 579: ORB2,ORB3,ORH2,ORH3,ORW2, ! 580: ORW3,PUSHAW,PUSHBB,PUSHBH, ! 581: PUSHD,PUSHW,PUSHZB,PUSHZH,RET,SAVE,SUBB2, ! 582: SUBB3,SUBH2,SUBH3,SUBW2,SUBW3, ! 583: SWITCH,SWITCHT, ! 584: UDIVW2,UDIVW3,UMODW2,UMODW3,UMULW2, ! 585: UMULW3,XORB2,XORB3,XORH2,XORH3, ! 586: XORW2,XORW3 ! 587: }; ! 588: ! 589: f = 0; ! 590: l = numops; ! 591: om = 0; ! 592: m = (f+l)/2; ! 593: while (m != om) { ! 594: x = strcmp(op,optbl[m]); ! 595: if (x == 0) ! 596: return((int) ocode[m]); ! 597: else if (x < 0) ! 598: l = m-1; ! 599: else ! 600: f = m+1; ! 601: om = m; ! 602: m = (f+l)/2; ! 603: } ! 604: return(OTHER); ! 605: } ! 606: ! 607: deffix(str,lbl) register char * str, * lbl; { /*change "val .;" to "val ..n;"*/ ! 608: ! 609: register char * nc; ! 610: register boolean scanning; ! 611: ! 612: scanning = true; ! 613: nc = fixstr; ! 614: fixlen = 0; ! 615: while (scanning) ! 616: if (*str == '.' && *(str+1) == ';') { ! 617: str++; ! 618: scanning = false; ! 619: } ! 620: else { ! 621: *nc++ = *str++; ! 622: fixlen++; ! 623: } ! 624: while (*nc++ = *lbl++) ! 625: fixlen++; ! 626: nc--; ! 627: while (*nc++ = *str++) ! 628: fixlen++; ! 629: } ! 630: ! 631: fixlbl(str) register char * str; { /* add colon to end of label */ ! 632: ! 633: while (*str++); ! 634: *--str = ':'; ! 635: *++str = '\0'; ! 636: } ! 637: ! 638: int ! 639: length(str) register char * str; { /* return length of string (including \0) */ ! 640: ! 641: register int l; ! 642: ! 643: l = 1; ! 644: while (*str++) ! 645: l++; ! 646: return (l); ! 647: } ! 648: ! 649: getln(str) register char * str; { /* extract line number */ ! 650: ! 651: while (!isdigit(*str)) ! 652: str++; ! 653: lineno = 0; ! 654: while (isdigit(*str)) { ! 655: lineno = lineno * 10 + *str - '0'; ! 656: str++; ! 657: } ! 658: } ! 659: ! 660: prinst(p) register NODE *p; { /* print instruction */ ! 661: if (p->uniqid != IDVAL) ! 662: printf(" .ln %d\n", p->uniqid); ! 663: #ifdef IMPIL ! 664: if (p->op == CALL ) { ! 665: printf("@ %d %s %s\n", ! 666: numauto + ( int ) p->ops[MAXOPS], p->op1 + 1, p->op2 ); ! 667: p->ops[MAXOPS] = NULL; ! 668: } ! 669: #endif /* IMPIL */ ! 670: switch (p->op) { ! 671: case LABEL: ! 672: printf("%s:\n", p->opcode); ! 673: break; ! 674: case HLABEL: ! 675: printf("%s\n", p->opcode); ! 676: break; ! 677: case MISC: ! 678: printf(" %s\n", p->opcode); ! 679: break; ! 680: case RET: ! 681: if (*(p->op1 + 1) == '-') { ! 682: printf(" RET\n"); ! 683: break; ! 684: } ! 685: default: ! 686: printf(" %s ", p->opcode); ! 687: if (p->op1 != NULL) ! 688: printf("%s", p->op1); ! 689: if (p->op2 != NULL) ! 690: printf(",%s", p->op2); ! 691: if (p->op3 != NULL) ! 692: printf(",%s", p->op3); ! 693: if (p->op4 != NULL) ! 694: printf(",%s", p->op4); ! 695: printf("\n"); ! 696: break; ! 697: } ! 698: } ! 699: ! 700: boolean ! 701: ishlp(p) register NODE *p; { /* return true if a fixed label present */ ! 702: ! 703: for (; (p->op == LABEL || p->op == HLABEL); p=p->forw) ! 704: if (ishl(p)) ! 705: return(true); ! 706: return(false); ! 707: } ! 708: ! 709: FILE * ! 710: tmpopen() { ! 711: strcpy( tmpname, TMPDIR ); ! 712: strcat( tmpname, "/25ccXXXXXX" ); ! 713: return( fopen( mktemp( tmpname ), "w" ) ); ! 714: } ! 715: ! 716: putstr(string) char *string; { ! 717: /* Place string from the text section into a temporary file ! 718: * to be output at the end of the function */ ! 719: ! 720: if( stmpfile == NULL ) ! 721: stmpfile = tmpopen(); ! 722: fprintf(stmpfile,"%s",string); ! 723: } ! 724: ! 725: prstr() { ! 726: /* print the strings stored in stmpfile at the end of the function */ ! 727: ! 728: if( stmpfile != NULL ) { ! 729: register int c; ! 730: ! 731: stmpfile = freopen( tmpname, "r", stmpfile ); ! 732: if( stmpfile != NULL ) ! 733: while( (c=getc(stmpfile)) != EOF ) ! 734: putchar( c ); ! 735: else ! 736: { ! 737: fprintf( stderr, "optimizer error: "); ! 738: fprintf( stderr, "lost temp file\n"); ! 739: } ! 740: (void) fclose( stmpfile ); /* close and delete file */ ! 741: unlink( tmpname ); ! 742: stmpfile = NULL; ! 743: } ! 744: } ! 745: ! 746: /* opens the temp file for storing input while looking for 'asm' */ ! 747: asmopen() { ! 748: strcpy( atmpname, TMPDIR ); ! 749: strcat( atmpname, "/asmXXXXXX" ); ! 750: atmpfile = fopen( mktemp( atmpname ), "w" ); ! 751: asmotell = ftell( stdout ); ! 752: } ! 753: ! 754: /* writes to temp file for 'asm' processing */ ! 755: int ! 756: putasm( line ) ! 757: char *line; ! 758: { ! 759: return( fputs( line, atmpfile ) != EOF ); ! 760: } ! 761: ! 762: /* checks for 'asm' in files and undoes code movement */ ! 763: asmchk() ! 764: { ! 765: register c; ! 766: long endotell; ! 767: extern int vars; ! 768: ! 769: if( asmflag && !oaflag ) { ! 770: if( freopen( atmpname, "r", atmpfile ) != NULL ) { ! 771: endotell = ftell( stdout ); ! 772: fseek( stdout, asmotell, 0 ); /* This is okay as long ! 773: as IMPIL is defined because it ! 774: is not really stdout, it is the file used by ! 775: in-line expansion. That file is still used, ! 776: even when in-line expansion is suppressed. ! 777: If IMPIL is not defined, optim will not work ! 778: correctly to a terminal, but it will work ! 779: correctly to a file. ! 780: This should be fixed. (fbw) */ ! 781: while( ( c = getc( atmpfile ) ) != EOF ) putchar( c ); ! 782: while( ftell( stdout ) < endotell ) printf( "!\n" ); ! 783: } ! 784: else fprintf( stderr, "optimizer error: asm temp file lost\n" ); ! 785: } ! 786: freopen( atmpname, "w", atmpfile ); ! 787: asmotell = ftell( stdout ); ! 788: asmflag = false; ! 789: vars=0; /* reinitialize for global reg allocation */ ! 790: } ! 791: ! 792: putp(p,c) register NODE *p; char *c; { /* insert pointer into jump node */ ! 793: ! 794: if (p->op == CALL) ! 795: p->op2 = c; ! 796: else if (p->op == JBC || p->op == JBS) ! 797: p->op3 = c; ! 798: else if (p->op == RET) { ! 799: p->op1 = NULL; ! 800: p->op2 = c; ! 801: } ! 802: else ! 803: p->op1 = c; ! 804: } ! 805: ! 806: revbr(p) NODE *p; { /* reverse jump in node p */ ! 807: ! 808: switch (p->op) { ! 809: case JZ: p->op = JNZ; p->opcode = "jnz"; break; ! 810: case JNZ: p->op = JZ; p->opcode = "jz"; break; ! 811: case JPOS: p->op = JNPOS; p->opcode = "jnpos"; break; ! 812: case JNPOS: p->op = JPOS; p->opcode = "jpos"; break; ! 813: case JNEG: p->op = JNNEG; p->opcode = "jnneg"; break; ! 814: case JNNEG: p->op = JNEG; p->opcode = "jneg"; break; ! 815: case JE: p->op = JNE; p->opcode = "jne"; break; ! 816: case JNE: p->op = JE; p->opcode = "je"; break; ! 817: case JL: p->op = JGE; p->opcode = "jge"; break; ! 818: case JLE: p->op = JG; p->opcode = "jg"; break; ! 819: case JG: p->op = JLE; p->opcode = "jle"; break; ! 820: case JGE: p->op = JL; p->opcode = "jl"; break; ! 821: case JLU: p->op = JGEU; p->opcode = "jgeu"; break; ! 822: case JLEU: p->op = JGU; p->opcode = "jgu"; break; ! 823: case JGU: p->op = JLEU; p->opcode = "jleu"; break; ! 824: case JGEU: p->op = JLU; p->opcode = "jlu"; break; ! 825: case JBC: p->op = JBS; p->opcode = "jbs"; break; ! 826: case JBS: p->op = JBC; p->opcode = "jbc"; break; ! 827: } ! 828: } ! 829: ! 830: char * ! 831: dst(p) NODE *p; { /* return pointer to dst operand string */ ! 832: ! 833: switch (p->op) { ! 834: case ACJL: case ACJLU: case ACJLEU: case ATJNZB: case ATJNZH: ! 835: case ATJNZW: case INCTST: ! 836: case INCPTH: case INCPTW: case DECPTH: case DECPTW: ! 837: return (p->op1); ! 838: case MCOMB: case MCOMH: case MCOMW: case MOVZBH: case MOVZBW: ! 839: case MOVZHW: case MOVAB: case MOVAH: case MOVAW: case ANDB2: ! 840: case ANDH2: case ANDW2: case ORB2: case ORH2: case ORW2: ! 841: case XORB2: case XORH2: case XORW2: case MOVB: case MOVH: ! 842: case MOVW: case MOVBBH: case MOVBBW: case MOVBHW: case MOVTHB: ! 843: case MOVTWB: case MOVTWH: case MNEGB: case MNEGH: case MNEGW: ! 844: case ADDB2: case ADDH2: case ADDW2: case SUBB2: case SUBH2: ! 845: case SUBW2: case MULW2: case UMULW2: case DIVW2: case UDIVW2: ! 846: case MODW2: case UMODW2: case LLSW2: case LRSW2: case ALSW2: ! 847: case ARSW2: case FADDD2: case FSUBD2: case FMULD2: case FDIVD2: ! 848: case FADDS2: case FSUBS2: case FMULS2: case FDIVS2: ! 849: case MOVWS: case MOVWD: case MOVTSW: case MOVTDW: ! 850: case MOVSW: case MOVDW: case MOVSD: case MOVDS: case MOVDD: ! 851: case MOVD: ! 852: return(p->op2); ! 853: case ANDB3: case ANDH3: case ANDW3: case ORB3: case ORH3: ! 854: case ORW3: case XORB3: case XORH3: case XORW3: case LLSW3: ! 855: case LRSW3: case ADDB3: case ADDH3: case ADDW3: case SUBB3: ! 856: case SUBH3: case SUBW3: case MULW3: case UMULW3: case DIVW3: ! 857: case UDIVW3: case MODW3: case UMODW3: case ALSW3: case ARSW3: ! 858: case FADDD3: case FSUBD3: case FMULD3: case FDIVD3: ! 859: case FADDS3: case FSUBS3: case FMULS3: case FDIVS3: ! 860: return(p->op3); ! 861: case INSV: case EXTZV: ! 862: return(p->op4); ! 863: default: ! 864: return (NULL); ! 865: } ! 866: } ! 867: ! 868: int ! 869: stype(cop) int cop; { /* return implied type of op code */ ! 870: ! 871: switch (cop) { ! 872: case MCOMB: case ANDB2: case ANDB3: case ORB2: case ORB3: ! 873: case XORB2: case XORB3: case MOVB: case MOVTHB: case MOVTWB: ! 874: case MNEGB: case ADDB2: case ADDB3: case SUBB2: case SUBB3: ! 875: case CMPB: ! 876: return (1); ! 877: case MCOMH: case MOVZBH: case ANDH2: case ANDH3: case ORH2: ! 878: case ORH3: case XORH2: case XORH3: case MOVH: case MOVBBH: ! 879: case MOVTWH: case MNEGH: case ADDH2: case ADDH3: case SUBH2: ! 880: case SUBH3: case CMPH: ! 881: return (2); ! 882: default: ! 883: return (4); ! 884: ! 885: case FADDD2: case FSUBD2: case FMULD2: case FDIVD2: ! 886: case FADDD3: case FSUBD3: case FMULD3: case FDIVD3: ! 887: case FCMPD: case MOVSD: case MOVWD: case MOVDD: ! 888: return(8); ! 889: } ! 890: } ! 891: ! 892: boolean ! 893: samereg(cp1,cp2) char *cp1, *cp2; { /* return true if same register */ ! 894: ! 895: if (*cp1 == '%' && *cp1 == *cp2 && *++cp1 == *++cp2 && *++cp1 == *++cp2) ! 896: return(true); ! 897: else ! 898: return(false); ! 899: } ! 900: ! 901: boolean ! 902: usesreg(cp1,cp2) register char *cp1, *cp2; { /*return true if cp2 used in cp1*/ ! 903: ! 904: while(*cp1 != '\0') { ! 905: if (*cp1 == *cp2 && *(cp1+1) == *(cp2+1) && ! 906: *(cp1+2) == *(cp2+2)) ! 907: return(true); ! 908: cp1++; ! 909: } ! 910: return(false); ! 911: } ! 912: ! 913: dstats() { /* print stats on machine dependent optimizations */ ! 914: ! 915: fprintf(stderr,"%d semantically useless instructions(s)\n", nusel); ! 916: fprintf(stderr,"%d useless move(s) before compare(s)\n", nmc); ! 917: fprintf(stderr,"%d merged move-arithmetic/logical(s)\n", nmal); ! 918: fprintf(stderr,"%d useless sp increment(s)\n", nspinc); ! 919: fprintf(stderr,"%d redundant compare(s)\n", nredcmp); ! 920: } ! 921: ! 922: wrapup() { /* print unprocessed text and update statistics file */ ! 923: ! 924: FILE *fopen(), *sp; ! 925: int mc,mal,usel,spinc,redcmp,disc,inst; ! 926: ! 927: if (n0.forw != NULL) { ! 928: printf(" .text\n"); ! 929: filter(); ! 930: prtext(); ! 931: prstr(); ! 932: } ! 933: #ifdef IMPIL ! 934: ilfile(); ! 935: #endif /* IMPIL */ ! 936: ! 937: (void) fclose( atmpfile ); /* close and delete file */ ! 938: unlink( atmpname ); ! 939: ! 940: sp = fopen("/g1/dap/optim/stats/statfile","r"); ! 941: if (sp != NULL) { ! 942: fscanf(sp, "%d %d %d %d %d %d %d", ! 943: &mc,&mal,&usel,&spinc,&redcmp,&disc,&inst); ! 944: fclose(sp); ! 945: mc += nmc; ! 946: mal += nmal; ! 947: usel += nusel; ! 948: spinc += nspinc; ! 949: redcmp += nredcmp; ! 950: disc += ndisc; ! 951: inst += ninst; ! 952: sp = fopen("/g1/dap/optim/stats/statfile","w"); ! 953: if (sp != NULL) { ! 954: fprintf(sp, "%d %d %d %d %d %d %d \n", ! 955: mc,mal,usel,spinc,redcmp,disc,inst); ! 956: fclose(sp); ! 957: } ! 958: } ! 959: } ! 960: ! 961: setauto(str) char *str; { /* set indicator for number of autos */ ! 962: ! 963: while (*str++ != ',') ! 964: ; ! 965: numauto = atoi(str); /* remember # of bytes */ ! 966: return; ! 967: } ! 968: ! 969: setnreg(str) char *str; { /* set indicator for number of registers */ ! 970: ! 971: while (*str++ != ',') ! 972: ; ! 973: numnreg = atoi(str); /* remember number of registers */ ! 974: return; ! 975: } ! 976: chkauto() /* delete sp increment if no autos, or fewer than 15 words */ ! 977: { ! 978: NODE *p; ! 979: ! 980: /* 5.0 UNIX microcode on the 3B20 supports a "save" instruction that ! 981: ** can also allocate temporary space on the stack (up to 15 words). ! 982: ** Standard IS25 "save" does not do the stack allocation. ! 983: */ ! 984: ! 985: #ifndef IMPREGAL ! 986: #ifdef UCODE50 ! 987: if (numauto <= 4*15) /* save handles up to 15 words */ ! 988: #else ! 989: if (numauto == 0) /* if no auto's allocated */ ! 990: #endif /* def UCODE50 */ ! 991: { ! 992: p = n0.forw; ! 993: while (islabel( p )) ! 994: p = p->forw; ! 995: if ( strcmp(p->opcode,"save") == 0 ! 996: && p->forw->op == ADDW2 ! 997: ) /* save followed by addw2 */ ! 998: { ! 999: #ifdef UCODE50 /* must add second operand to save */ ! 1000: p->op2 = getspace(1+2+1); /* for "&dd\0" */ ! 1001: (void) sprintf(p->op2,"&%d",numauto/4); ! 1002: /* append operand with # of autos */ ! 1003: #endif /* def UCODE50 */ ! 1004: p = p->forw; /* point at ADDW2 */ ! 1005: DELNODE( p ); /* delete it */ ! 1006: nspinc++; /* discarded sp increment */ ! 1007: ndisc++; /* discarded instruction */ ! 1008: } ! 1009: } ! 1010: #endif /* der IMPREGAL */ ! 1011: #ifndef IMPIL ! 1012: numauto = 0; /* reset for next routine */ ! 1013: #endif /* IMPIL */ ! 1014: return; ! 1015: } ! 1016: ! 1017: uses(p) NODE *p; { /* set register use bits */ ! 1018: ! 1019: switch (p->op) { ! 1020: case MOVBLB: case MOVBLH: case MOVBLW: ! 1021: return (0x7); ! 1022: case MCOMB: case MCOMH: case MCOMW: case MOVZBH: case MOVZBW: ! 1023: case MOVZHW: case MOVAB: case MOVAH: case MOVAW: case MOVB: ! 1024: case MOVH: case MOVW: case MOVBBH: case MOVBBW: case MOVBHW: ! 1025: case MOVTHB: case MOVTWB: case MOVTWH: case MNEGB: case MNEGH: ! 1026: case MNEGW: ! 1027: case MOVWS: case MOVTSW: case MOVSW: ! 1028: return (scanreg(p->op1,false) | scanreg(p->op2,true) | ! 1029: scanreg(p->op3,false) | scanreg(p->op4,false)); ! 1030: case ANDB3: case ANDH3: case ANDW3: case ORB3: case ORH3: ! 1031: case ORW3: case XORB3: case XORH3: case XORW3: case LLSW3: ! 1032: case LRSW3: case ADDB3: case ADDH3: case ADDW3: case SUBB3: ! 1033: case SUBH3: case SUBW3: case MULW3: case UMULW3: case DIVW3: ! 1034: case UDIVW3: case MODW3: case UMODW3: case ALSW3: case ARSW3: ! 1035: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1036: scanreg(p->op3,true) | scanreg(p->op4,false)); ! 1037: case INSV: case EXTZV: ! 1038: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1039: scanreg(p->op3,false) | scanreg(p->op4,true)); ! 1040: case CALL: ! 1041: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1042: scanreg(p->op3,false) | scanreg(p->op4,false) | ! 1043: ( 1 << 2 )); /* call must preserve %r2; ! 1044: ptr to returned structure */ ! 1045: case RET: ! 1046: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1047: scanreg(p->op3,false) | scanreg(p->op4,false) | ! 1048: RETREG); /* function return values */ ! 1049: case JSB: ! 1050: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1051: scanreg(p->op3,false) | scanreg(p->op4,false) | ! 1052: 1 ); /* cludge for profiler: %r0 is used to pass ! 1053: an argument to _mcount */ ! 1054: case FADDD2: case FSUBD2: case FMULD2: case FDIVD2: ! 1055: case FCMPD: ! 1056: return( dscanreg(p->op1,false) | dscanreg(p->op2,false) | ! 1057: scanreg(p->op3,false) | scanreg(p->op4,false) ); ! 1058: ! 1059: case FADDD3: case FSUBD3: case FMULD3: case FDIVD3: ! 1060: return( dscanreg(p->op1,false) | dscanreg(p->op2,false) | ! 1061: dscanreg(p->op3,true) | scanreg(p->op4,false) ); ! 1062: ! 1063: case MOVWD: case MOVSD: ! 1064: return( scanreg(p->op1,false) | dscanreg(p->op2,true) | ! 1065: scanreg(p->op3,false) | scanreg(p->op4,false) ); ! 1066: ! 1067: case MOVDW: case MOVTDW: case MOVDS: ! 1068: return( dscanreg(p->op1,false) | scanreg(p->op2,true) | ! 1069: scanreg(p->op3,false) | scanreg(p->op4,false) ); ! 1070: ! 1071: case MOVDD: case MOVD: ! 1072: return( dscanreg(p->op1,false) | dscanreg(p->op2,true) | ! 1073: scanreg(p->op3,false) | scanreg(p->op4,false) ); ! 1074: ! 1075: default: ! 1076: return (scanreg(p->op1,false) | scanreg(p->op2,false) | ! 1077: scanreg(p->op3,false) | scanreg(p->op4,false) | ! 1078: ( iscbr( p ) ? CONCODES : 0 ) ); ! 1079: } ! 1080: } ! 1081: ! 1082: scanreg(cp,flag) register char *cp; int flag; { /* determine registers ! 1083: referenced in operand */ ! 1084: ! 1085: int reg,set; ! 1086: ! 1087: if (cp == NULL) ! 1088: return (0); ! 1089: if (flag && *cp == '%') ! 1090: return (0); ! 1091: set = 0; ! 1092: while (*cp != '\0') { ! 1093: if (*cp == '%') { ! 1094: cp++; ! 1095: switch (*cp) { ! 1096: case 'r': ! 1097: cp++; ! 1098: reg = *cp - '0'; ! 1099: break; ! 1100: case 'a': ! 1101: cp++; ! 1102: reg = 9; ! 1103: break; ! 1104: case 'f': ! 1105: cp++; ! 1106: reg = 10; ! 1107: break; ! 1108: case 's': ! 1109: cp++; ! 1110: reg = 11; ! 1111: break; ! 1112: } ! 1113: set = set | 1 << reg; ! 1114: } ! 1115: cp++; ! 1116: } ! 1117: return(set); ! 1118: } ! 1119: ! 1120: /* determine registers used for double operand */ ! 1121: ! 1122: int ! 1123: dscanreg(cp,flag) ! 1124: char * cp; /* operand string */ ! 1125: boolean flag; /* true if register is destination */ ! 1126: { ! 1127: int temp = scanreg(cp,flag); /* do normal scan */ ! 1128: ! 1129: if (*cp == '%') /* if direct register reference... */ ! 1130: temp = 3*temp; /* set bit and its left neighbor (reg+1) */ ! 1131: ! 1132: return(temp); ! 1133: } ! 1134: ! 1135: sets(p) NODE *p; { /* set register destination bits */ ! 1136: ! 1137: char *cp, *dst(); ! 1138: int o; ! 1139: boolean dblflag = false; /* true if register double operand */ ! 1140: ! 1141: switch (o = p->op) { ! 1142: case MOVBLB: case MOVBLH: case MOVBLW: ! 1143: return (0x0007); ! 1144: ! 1145: /* Procedure calls could potentially clobber all of the scratch registers. ! 1146: ** We would like call to "kill" all of them, but we can only be reasonably ! 1147: ** safe by saying it kills those registers in which it returns values. ! 1148: */ ! 1149: ! 1150: case CALL: ! 1151: return(RETREG | CONCODES); ! 1152: ! 1153: /* Register doubles set two registers at a time: r and r+1 */ ! 1154: ! 1155: case FADDD2: case FSUBD2: case FMULD2: case FDIVD2: ! 1156: case FADDD3: case FSUBD3: case FMULD3: case FDIVD3: ! 1157: case MOVWD: case MOVSD: case MOVDD: case MOVD: ! 1158: dblflag = true; ! 1159: ! 1160: default: ! 1161: cp = dst(p); ! 1162: if (cp != NULL) ! 1163: return((dblflag ? 3*setreg(cp) : setreg(cp)) | CONCODES ); ! 1164: /* return reg bit and its left ! 1165: ** neighbor on double ! 1166: */ ! 1167: else ! 1168: return ( ( ( o == RET ) ! 1169: || ( CMPB <= o && o <= ATJNZW ) ! 1170: || ( PUSHAW <= o && o <= PUSHBH ) ) ? CONCODES : 0 ); ! 1171: } ! 1172: } ! 1173: ! 1174: setreg(cp) char *cp; { /* set index of register destination (if one) */ ! 1175: ! 1176: if (*cp == '%') ! 1177: switch (*++cp) { ! 1178: case 'r': ! 1179: cp++; ! 1180: return (1 << (*cp - '0')); ! 1181: case 'a': ! 1182: return (1 << 9); ! 1183: case 'f': ! 1184: return (1 << 10); ! 1185: case 's': ! 1186: return (1 << 11); ! 1187: default: /* unrecognized name */ ! 1188: break; ! 1189: } ! 1190: return(0); /* for non-register or unrecognized */ ! 1191: } ! 1192: ! 1193: boolean ! 1194: isdead(cp,p) char *cp; NODE *p; { /* true iff *cp is dead after p */ ! 1195: ! 1196: int reg; ! 1197: ! 1198: if (*cp != '%') ! 1199: return(false); ! 1200: switch(*++cp) { ! 1201: case 'r': ! 1202: reg = *++cp - '0'; ! 1203: break; ! 1204: case 'a': ! 1205: reg = 9; ! 1206: break; ! 1207: case 'f': ! 1208: reg = 10; ! 1209: break; ! 1210: case 's': ! 1211: reg = 11; ! 1212: break; ! 1213: default: /* unrecognized name */ ! 1214: return(false); ! 1215: } ! 1216: if ((p->nlive & (1 << reg)) == 0) ! 1217: return(true); ! 1218: else ! 1219: return(false); ! 1220: } ! 1221: char * ! 1222: getp(p) NODE *p; { /* return pointer to jump destination operand */ ! 1223: ! 1224: switch (p->op) { ! 1225: case JMP: case JSB: case JZ: case JNZ: ! 1226: case JPOS: case JNPOS: case JNEG: case JNNEG: case JE: ! 1227: case JNE: case JL: case JLE: case JG: case JGE: ! 1228: case JLU: case JLEU: case JGU: case JGEU: ! 1229: return(p->op1); ! 1230: case RET: ! 1231: case SWITCH: ! 1232: case SWITCHT: ! 1233: return(NULL); ! 1234: case JBC: case JBS: ! 1235: return(p->op3); ! 1236: } ! 1237: } ! 1238: ! 1239: char * ! 1240: newlab() { /* generate a new label */ ! 1241: ! 1242: static int lbn = 0; ! 1243: char *c; ! 1244: ! 1245: c = (char *)getspace(lbn < 100 ? 6 : (lbn < 1000 ? 7 : 8)); ! 1246: sprintf(c, "..%d\0", lbn); ! 1247: lbn++; ! 1248: return(c); ! 1249: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.