![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asparse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / as|
Return to asparse.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / as |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982 Regents of the University of California ! 3: */ ! 4: #ifndef lint ! 5: static char sccsid[] = "@(#)asparse.c 4.17 7/1/83"; ! 6: #endif not lint ! 7: ! 8: #include <stdio.h> ! 9: #include "as.h" ! 10: #include "asscan.h" ! 11: #include "assyms.h" ! 12: #include "asexpr.h" ! 13: ! 14: int lgensym[10]; ! 15: char genref[10]; ! 16: ! 17: long bitfield; ! 18: int bitoff; ! 19: int curlen; /* current length of literals */ ! 20: int printblank; ! 21: ! 22: /* ! 23: * The following three variables are communication between various ! 24: * modules to special case a number of things. They are properly ! 25: * categorized as hacks. ! 26: */ ! 27: extern struct symtab *lastnam;/*last name seen by the lexical analyzer*/ ! 28: int exprisname; /*last factor in an expression was a name*/ ! 29: int droppedLP; /*one is analyzing an expression beginning with*/ ! 30: /*a left parenthesis, which has already been*/ ! 31: /*shifted. (Used to parse (<expr>)(rn)*/ ! 32: ! 33: char yytext[NCPName+2]; /*the lexical image*/ ! 34: int yylval; /*the lexical value; sloppy typing*/ ! 35: u_char yyopcode; /* lexical value for an opcode */ ! 36: Bignum yybignum; /* lexical value for a big number */ ! 37: int num_type; /* type of bignums */ ! 38: /* ! 39: * Expression and argument managers ! 40: */ ! 41: struct exp *xp; /*next free expression slot, used by expr.c*/ ! 42: struct exp explist[NEXP]; /*max of 20 expressions in one opcode*/ ! 43: struct arg arglist[NARG]; /*building up operands in instructions*/ ! 44: /* ! 45: * Sets to accelerate token discrimination ! 46: */ ! 47: char tokensets[(LASTTOKEN) - (FIRSTTOKEN) + 1]; ! 48: ! 49: static char UDotsname[64]; /*name of the assembly source*/ ! 50: ! 51: yyparse() ! 52: { ! 53: reg struct exp *locxp; ! 54: /* ! 55: * loc1xp and ptrloc1xp are used in the ! 56: * expression lookahead ! 57: */ ! 58: struct exp *loc1xp; /*must be non register*/ ! 59: struct exp **ptrloc1xp = & loc1xp; ! 60: struct exp *pval; /*hacking expr:expr*/ ! 61: ! 62: reg struct symtab *np; ! 63: reg int argcnt; ! 64: ! 65: reg inttoktype val; /*what yylex gives*/ ! 66: reg inttoktype auxval; /*saves val*/ ! 67: ! 68: reg struct arg *ap; /*first free argument*/ ! 69: ! 70: reg struct symtab *p; ! 71: reg struct symtab *stpt; ! 72: ! 73: struct strdesc *stringp; /*handles string lists*/ ! 74: ! 75: int regno; /*handles arguments*/ ! 76: int *ptrregno = ®no; ! 77: int sawmul; /*saw * */ ! 78: int sawindex; /*saw [rn]*/ ! 79: int sawsize; ! 80: int seg_type; /*the kind of segment: data or text*/ ! 81: int seg_number; /*the segment number*/ ! 82: int space_value; /*how much .space needs*/ ! 83: int fill_rep; /*how many reps for .fill */ ! 84: int rep_fill; /*the same - temprary */ ! 85: int fill_size; /*how many bytes for .fill */ ! 86: ! 87: int field_width; /*how wide a field is to be*/ ! 88: int field_value; /*the value to stuff in a field*/ ! 89: char *stabname; /*name of stab dealing with*/ ! 90: ptrall stabstart; /*where the stab starts in the buffer*/ ! 91: int reloc_how; /* how to relocate expressions */ ! 92: int incasetable; /* set if in a case table */ ! 93: int j, k; ! 94: char ch; ! 95: int length; /* for printout */ ! 96: union twolong ! 97: { ! 98: long lpart[2]; ! 99: char strpart [8]; ! 100: }fillval; ! 101: ! 102: ! 103: incasetable = 0; ! 104: xp = explist; ! 105: ap = arglist; ! 106: ! 107: val = yylex(); ! 108: ! 109: while (val != PARSEEOF){ /* primary loop */ ! 110: ! 111: while (INTOKSET(val, LINSTBEGIN)){ ! 112: if (val == INT) { ! 113: int i = ((struct exp *)yylval)->e_xvalue; ! 114: shift; ! 115: if (val != COLON){ ! 116: yyerror("Local label %d is not followed by a ':' for a label definition", ! 117: i); ! 118: goto errorfix; ! 119: } ! 120: if (i < 0 || i > 9) { ! 121: yyerror("Local labels are 0-9"); ! 122: goto errorfix; ! 123: } ! 124: (void)sprintf(yytext, "L%d\001%d", i, lgensym[i]); ! 125: lgensym[i]++; ! 126: genref[i] = 0; ! 127: yylval = (int)*lookup(passno == 1); ! 128: val = NAME; ! 129: np = (struct symtab *)yylval; ! 130: goto restlab; ! 131: } ! 132: if (val == NL){ ! 133: lineno++; ! 134: if (liston && (passno == 2) && (! endofsource)) ! 135: { ! 136: /* printing previous line & layout */ ! 137: length = strlen (layout); ! 138: fprintf (listfile, "%*.*s", LHEAD, LHEAD, layout); ! 139: if (length <= LHEAD+LLEN) ! 140: j = LLEN; ! 141: else { /* break line at last blank */ ! 142: j = LHEAD+LLEN; ! 143: while(j>LHEAD && layout[j]!= ' ') ! 144: j--; ! 145: if(j == LHEAD) ! 146: j = LLEN; ! 147: else ! 148: j -= LHEAD; ! 149: } ! 150: k = LHEAD+j; ! 151: fprintf (listfile, "%-*.*s", LLEN, j, &layout[LHEAD]); ! 152: fprintf (listfile, " "); ! 153: do { ! 154: ch = getc (source); ! 155: putc (ch, listfile); ! 156: } while (ch != '\n'); ! 157: while (k < length) ! 158: { ! 159: fprintf (listfile, "%*s", LHEAD, ""); ! 160: /* break line at last blank */ ! 161: if(layout[k] == ' ') ! 162: k++; ! 163: if((j = k+LLEN) >= length) ! 164: j = length; ! 165: else ! 166: while(j>k && layout[j]!= ' ') ! 167: j--; ! 168: if(j == k) ! 169: j = LLEN; ! 170: else ! 171: j -= k; ! 172: fprintf (listfile, "%-*.*s\n", j, j, &layout[k]); ! 173: k += j; ! 174: } ! 175: k = 0; ! 176: while (layout[k] != '\0') ! 177: layout[k++] = '\0'; ! 178: ch = getc (source); ! 179: if (ch == EOF) ! 180: { ! 181: if (ind == ninfiles) ! 182: endofsource = 1; ! 183: else ! 184: { ! 185: source = fopen (innames[ind++], "r"); ! 186: lineno = 1; ! 187: } ! 188: } ! 189: else ! 190: ungetc (ch, source); ! 191: layoutpos = layout; ! 192: sprintf (layoutpos, "%4ld ", lineno); ! 193: layoutpos += 6; ! 194: long_out (dotp->e_xvalue); ! 195: if (dotp->e_xvalue >= datbase) ! 196: sprintf (layoutpos," * "); ! 197: else ! 198: sprintf (layoutpos," "); ! 199: layoutpos += 4; ! 200: } ! 201: shift; ! 202: } else ! 203: if (val == SEMI) ! 204: shift; ! 205: else { /*its a name, so we have a label or def */ ! 206: if (val != NAME){ ! 207: ERROR("Name expected for a label"); ! 208: } ! 209: np = (struct symtab *)yylval; ! 210: shiftover(NAME); ! 211: if (val != COLON) { ! 212: yyerror("\"%s\" is not followed by a ':' for a label definition", ! 213: FETCHNAME(np)); ! 214: goto errorfix; ! 215: } ! 216: restlab: ! 217: shift; ! 218: flushfield(NBPW/4); ! 219: if ((np->s_type&XTYPE)!=XUNDEF) { ! 220: if( (np->s_type&XTYPE)!=dotp->e_xtype ! 221: || np->s_value!=dotp->e_xvalue ! 222: || ( (passno==1) ! 223: &&(np->s_index != dotp->e_xloc) ! 224: ) ! 225: ){ ! 226: #ifndef DEBUG ! 227: if (FETCHNAME(np)[0] != 'L') ! 228: #endif not DEBUG ! 229: { ! 230: if (passno == 1) ! 231: yyerror("%s redefined", ! 232: FETCHNAME(np)); ! 233: else ! 234: yyerror("%s redefined: PHASE ERROR, 1st: %d, 2nd: %d", ! 235: FETCHNAME(np), ! 236: np->s_value, ! 237: dotp->e_xvalue); ! 238: } ! 239: } ! 240: } ! 241: np->s_type &= ~(XTYPE|XFORW); ! 242: np->s_type |= dotp->e_xtype; ! 243: np->s_value = dotp->e_xvalue; ! 244: if (passno == 1){ ! 245: np->s_index = dotp-usedot; ! 246: if (FETCHNAME(np)[0] == 'L'){ ! 247: nlabels++; ! 248: } ! 249: np->s_tag = LABELID; ! 250: } ! 251: } /*end of this being a label*/ ! 252: } /*end of to consuming all labels, NLs and SEMIS */ ! 253: ! 254: xp = explist; ! 255: ap = arglist; ! 256: ! 257: /* ! 258: * process the INSTRUCTION body ! 259: */ ! 260: switch(val){ ! 261: ! 262: default: ! 263: ERROR("Unrecognized instruction or directive"); ! 264: ! 265: case IABORT: ! 266: shift; ! 267: sawabort(); ! 268: /*NOTREACHED*/ ! 269: break; ! 270: ! 271: case PARSEEOF: ! 272: tokptr -= sizeof(bytetoktype); ! 273: *tokptr++ = VOID; ! 274: tokptr[1] = VOID; ! 275: tokptr[2] = PARSEEOF; ! 276: break; ! 277: ! 278: case IFILE: ! 279: shift; ! 280: stringp = (struct strdesc *)yylval; ! 281: shiftover(STRING); ! 282: dotsname = &UDotsname[0]; ! 283: movestr(dotsname, stringp->sd_string, ! 284: min(stringp->sd_strlen, sizeof(UDotsname))); ! 285: break; ! 286: ! 287: case ILINENO: ! 288: shift; /*over the ILINENO*/ ! 289: expr(locxp, val); ! 290: lineno = locxp->e_xvalue; ! 291: break; ! 292: ! 293: case ISET: /* .set <name> , <expr> */ ! 294: shift; ! 295: np = (struct symtab *)yylval; ! 296: shiftover(NAME); ! 297: shiftover(CM); ! 298: expr(locxp, val); ! 299: np->s_type &= (XXTRN|XFORW); ! 300: np->s_type |= locxp->e_xtype&(XTYPE|XFORW); ! 301: np->s_value = locxp->e_xvalue; ! 302: if (passno==1) ! 303: np->s_index = locxp->e_xloc; ! 304: if ((locxp->e_xtype&XTYPE) == XUNDEF) ! 305: yyerror("Illegal set?"); ! 306: break; ! 307: ! 308: case ILSYM: /*.lsym name , expr */ ! 309: shift; ! 310: np = (struct symtab *)yylval; ! 311: shiftover(NAME); ! 312: shiftover(CM); ! 313: expr(locxp, val); ! 314: /* ! 315: * Build the unique occurance of the ! 316: * symbol. ! 317: * The character scanner will have ! 318: * already entered it into the symbol ! 319: * table, but we should remove it ! 320: */ ! 321: if (passno == 1){ ! 322: stpt = (struct symtab *)symalloc(); ! 323: stpt->s_name = np->s_name; ! 324: np->s_tag = OBSOLETE; /*invalidate original */ ! 325: nforgotten++; ! 326: np = stpt; ! 327: if ( (locxp->e_xtype & XTYPE) != XABS) ! 328: yyerror("Illegal second argument to lsym"); ! 329: np->s_value = locxp->e_xvalue; ! 330: np->s_type = XABS; ! 331: np->s_tag = ILSYM; ! 332: } ! 333: break; ! 334: ! 335: case IGLOBAL: /*.globl <name> */ ! 336: shift; ! 337: np = (struct symtab *)yylval; ! 338: shiftover(NAME); ! 339: np->s_type |= XXTRN; ! 340: break; ! 341: ! 342: case IDATA: /*.data [ <expr> ] */ ! 343: case ITEXT: /*.text [ <expr> ] */ ! 344: incasetable = 0; ! 345: seg_type = -val; ! 346: shift; ! 347: if (INTOKSET(val, EBEGOPS+YUKKYEXPRBEG+SAFEEXPRBEG)){ ! 348: expr(locxp, val); ! 349: seg_type = -seg_type; /*now, it is positive*/ ! 350: } ! 351: ! 352: if (seg_type < 0) { /*there wasn't an associated expr*/ ! 353: seg_number = 0; ! 354: seg_type = -seg_type; ! 355: } else { ! 356: if ( ((locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 357: || (seg_number = locxp->e_xvalue) >= NLOC) { ! 358: yyerror("illegal location counter"); ! 359: seg_number = 0; ! 360: } ! 361: } ! 362: if (seg_type == IDATA) ! 363: seg_number += NLOC; ! 364: flushfield(NBPW/4); ! 365: dotp = &usedot[seg_number]; ! 366: if (passno==2) { /* go salt away in pass 2*/ ! 367: txtfil = usefile[seg_number]; ! 368: relfil = rusefile[seg_number]; ! 369: } ! 370: break; ! 371: ! 372: /* ! 373: * Storage filler directives: ! 374: * ! 375: * .byte [<exprlist>] ! 376: * ! 377: * exprlist: empty | exprlist outexpr ! 378: * outexpr: <expr> | <expr> : <expr> ! 379: */ ! 380: case IBYTE: curlen = NBPW/4; goto elist; ! 381: case IWORD: curlen = NBPW/2; goto elist; ! 382: case IINT: curlen = NBPW; goto elist; ! 383: case ILONG: curlen = NBPW; goto elist; ! 384: ! 385: elist: ! 386: seg_type = val; ! 387: shift; ! 388: ! 389: /* ! 390: * Expression List processing ! 391: */ ! 392: if (INTOKSET(val, EBEGOPS+YUKKYEXPRBEG+SAFEEXPRBEG)){ ! 393: do{ ! 394: /* ! 395: * expression list consists of a list of : ! 396: * <expr> ! 397: * <expr> : <expr> ! 398: * (pack expr2 into expr1 bits ! 399: */ ! 400: expr(locxp, val); ! 401: /* ! 402: * now, pointing at the next token ! 403: */ ! 404: /* if (val == COLON){ */ ! 405: /* shiftover(COLON); */ ! 406: /* expr(pval, val); */ ! 407: /* if ((locxp->e_xtype & XTYPE) != XABS) */ ! 408: /* yyerror("Width not absolute"); */ ! 409: /* field_width = locxp->e_xvalue; */ ! 410: /* locxp = pval; */ ! 411: /* if (bitoff + field_width > curlen) */ ! 412: /* flushfield(curlen); */ ! 413: /* if (field_width > curlen) */ ! 414: /* yyerror("Expression crosses field boundary"); */ ! 415: /* } else { */ ! 416: field_width = curlen; ! 417: if (bitoff == 0) printblank = 0; ! 418: else printblank = 1; ! 419: flushfield(curlen); ! 420: if (liston && (passno == 2) && printblank) ! 421: *layoutpos++ = ' '; ! 422: /* } */ ! 423: ! 424: if ((locxp->e_xtype & XTYPE) != XABS) { ! 425: if (bitoff) ! 426: yyerror("Illegal relocation in field"); ! 427: switch(curlen){ ! 428: case NBPW/4: reloc_how = TYPB; break; ! 429: case NBPW/2: reloc_how = TYPW; break; ! 430: case NBPW: reloc_how = TYPL; break; ! 431: } ! 432: if (passno == 1){ ! 433: dotp->e_xvalue += ty_nbyte[reloc_how]; ! 434: } else { ! 435: outrel(locxp, reloc_how); ! 436: if (liston) ! 437: *layoutpos++ = ' '; ! 438: } ! 439: } else { ! 440: /* ! 441: * ! 442: * See if we are doing a case instruction. ! 443: * If so, then see if the branch distance, ! 444: * stored as a word, ! 445: * is going to loose sig bits. ! 446: */ ! 447: if (passno == 2 && incasetable){ ! 448: if ( !(ISWORD(locxp->e_xvalue))) ! 449: yyerror("Case will branch too far"); ! 450: } ! 451: field_value = locxp->e_xvalue & ( (1L << field_width)-1); ! 452: bitfield |= field_value << bitoff; ! 453: bitoff += field_width; ! 454: } ! 455: xp = explist; ! 456: if (auxval = (val == CM)) ! 457: shift; ! 458: } while (auxval); ! 459: } /* there existed an expression at all */ ! 460: ! 461: flushfield(curlen); ! 462: if ( ( curlen == NBPW/4) && bitoff) ! 463: dotp->e_xvalue ++; ! 464: break; ! 465: /*end of case IBYTE, IWORD, ILONG, IINT*/ ! 466: ! 467: case ISPACE: /* .space <expr> */ ! 468: shift; ! 469: expr(locxp, val); ! 470: if ((locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 471: yyerror("Space size not absolute"); ! 472: if (locxp->e_xvalue < 0) ! 473: yyerror("Space size not positive"); ! 474: space_value = locxp->e_xvalue; ! 475: ospace: ! 476: flushfield(NBPW/4); ! 477: { ! 478: static char spacebuf[128]; ! 479: while (space_value > sizeof(spacebuf)){ ! 480: outs(spacebuf, sizeof(spacebuf)); ! 481: space_value -= sizeof(spacebuf); ! 482: } ! 483: outs(spacebuf, space_value); ! 484: } ! 485: if (liston && (passno == 2)) ! 486: sprintf (layoutpos, "****"); ! 487: break; ! 488: ! 489: /* ! 490: * .fill rep, size, value ! 491: * repeat rep times: fill size bytes with (truncated) value ! 492: * size must be between 1 and 8 ! 493: */ ! 494: case IFILL: ! 495: shift; ! 496: expr(locxp, val); ! 497: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 498: yyerror("Fill repetition count not absolute"); ! 499: rep_fill = fill_rep = locxp->e_xvalue; ! 500: shiftover(CM); ! 501: expr(locxp, val); ! 502: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 503: yyerror("Fill size not absolute"); ! 504: fill_size = locxp->e_xvalue; ! 505: if (fill_size <= 0 || fill_size > 8) ! 506: yyerror("Fill count not in in 1..8"); ! 507: shiftover(CM); ! 508: expr(locxp, val); ! 509: if (passno == 2 && (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 510: yyerror("Fill value not absolute"); ! 511: flushfield(NBPW/4); ! 512: dotp->e_xvalue += fill_rep * fill_size; ! 513: if (passno == 1) { ! 514: locxp->e_xvalue += fill_rep * fill_size; ! 515: } else { ! 516: fillval.lpart[0] = locxp->e_yvalue; ! 517: fillval.lpart[1] = locxp->e_xvalue; ! 518: while (fill_rep-- > 0) ! 519: bwrite(&(fillval.strpart[8-fill_size]),fill_size,txtfil); ! 520: if (liston) { ! 521: while (rep_fill-- > 0) ! 522: { ! 523: switch (fill_size) ! 524: { ! 525: case 1: ! 526: byte_out (locxp->e_xvalue); ! 527: *layoutpos++ = ' '; ! 528: break; ! 529: case 2: ! 530: word_out (locxp->e_xvalue); ! 531: *layoutpos++ = ' '; ! 532: break; ! 533: case 3: ! 534: byte_out (locxp->e_xvalue >> 16); ! 535: byte_out (locxp->e_xvalue >> 8); ! 536: byte_out (locxp->e_xvalue); ! 537: *layoutpos++ = ' '; ! 538: break; ! 539: case 4: ! 540: long_out (locxp->e_xvalue); ! 541: *layoutpos++ = ' '; ! 542: break; ! 543: case 5: ! 544: byte_out (locxp->e_yvalue); ! 545: long_out (locxp->e_xvalue); ! 546: *layoutpos++ = ' '; ! 547: break; ! 548: case 6: ! 549: word_out (locxp->e_yvalue); ! 550: long_out (locxp->e_xvalue); ! 551: *layoutpos++ = ' '; ! 552: break; ! 553: case 7: ! 554: byte_out (locxp->e_yvalue >> 16); ! 555: byte_out (locxp->e_yvalue >> 8); ! 556: byte_out (locxp->e_yvalue); ! 557: long_out (locxp->e_xvalue); ! 558: *layoutpos++ = ' '; ! 559: break; ! 560: case 8: ! 561: long_out (locxp->e_yvalue); ! 562: long_out (locxp->e_xvalue); ! 563: *layoutpos++ = ' '; ! 564: break; ! 565: } ! 566: } ! 567: } ! 568: } ! 569: break; ! 570: ! 571: case IASCII: /* .ascii [ <stringlist> ] */ ! 572: case IASCIZ: /* .asciz [ <stringlist> ] */ ! 573: auxval = val; ! 574: shift; ! 575: /* ! 576: * Code to consume a string list ! 577: * ! 578: * stringlist: empty | STRING | stringlist STRING ! 579: */ ! 580: while (val == STRING){ ! 581: int mystrlen; ! 582: flushfield(NBPW/4); ! 583: if (bitoff) ! 584: dotp->e_xvalue++; ! 585: stringp = (struct strdesc *)yylval; ! 586: /* ! 587: * utilize the string scanner cheat; ! 588: * the scanner appended a null byte on the string, ! 589: * but didn't charge it to sd_strlen ! 590: */ ! 591: mystrlen = stringp->sd_strlen; ! 592: mystrlen += (auxval == IASCIZ) ? 1 : 0; ! 593: if (passno == 2){ ! 594: if (stringp->sd_place & STR_CORE){ ! 595: outs(stringp->sd_string, mystrlen); ! 596: if (liston) ! 597: { ! 598: int i; ! 599: for (i = 0;i < mystrlen; i++) ! 600: { ! 601: sprintf (layoutpos, "%02x", ! 602: stringp->sd_string[i]); ! 603: layoutpos += 2; ! 604: } ! 605: } ! 606: } else { ! 607: int i, nread; ! 608: fseek(strfile, stringp->sd_stroff, 0); ! 609: for (i = 0; i < mystrlen;/*VOID*/){ ! 610: nread = fread(yytext, 1, ! 611: min(mystrlen - i, ! 612: sizeof(yytext)), strfile); ! 613: outs(yytext, nread); ! 614: if (liston) ! 615: { ! 616: int k; ! 617: for (k = 0;k < nread; k++) ! 618: { ! 619: sprintf (layoutpos, ! 620: "%02x", yytext[k]); ! 621: layoutpos += 2; ! 622: } ! 623: } ! 624: i += nread; ! 625: } ! 626: } ! 627: } else { ! 628: dotp->e_xvalue += mystrlen; ! 629: } ! 630: shift; /*over the STRING*/ ! 631: if (val == CM) /*could be a split string*/ ! 632: shift; ! 633: } ! 634: break; ! 635: ! 636: case IORG: /* .org <expr> */ ! 637: shift; ! 638: expr(locxp, val); ! 639: ! 640: if ((locxp->e_xtype & XTYPE) == XABS) /* tekmdp */ ! 641: orgwarn++; ! 642: else if ((locxp->e_xtype & ~XXTRN) != dotp->e_xtype) ! 643: yyerror("Illegal expression to set origin"); ! 644: if ((unsigned)locxp->e_xvalue < (unsigned)dotp->e_xvalue) ! 645: { ! 646: ERROR("Backwards 'org'"); ! 647: } ! 648: space_value = locxp->e_xvalue - dotp->e_xvalue; ! 649: goto ospace; ! 650: break; ! 651: ! 652: /* ! 653: * ! 654: * Process stabs. Stabs are created only by the f77 ! 655: * and the C compiler with the -g flag set. ! 656: * We only look at the stab ONCE, during pass 1, and ! 657: * virtually remove the stab from the intermediate file ! 658: * so it isn't seen during pass2. This makes for some ! 659: * hairy processing to handle labels occuring in ! 660: * stab entries, but since most expressions in the ! 661: * stab are integral we save lots of time in the second ! 662: * pass by not looking at the stabs. ! 663: * A stab that is tagged floating will be bumped during ! 664: * the jxxx resolution phase. A stab tagged fixed will ! 665: * not be be bumped. ! 666: * ! 667: * .stab: Old fashioned stabs ! 668: * .stabn: For stabs without names ! 669: * .stabs: For stabs with string names ! 670: * .stabd: For stabs for line numbers or bracketing, ! 671: * without a string name, without ! 672: * a final expression. The value of the ! 673: * final expression is taken to be the current ! 674: * location counter, and is patched by the 2nd pass ! 675: * ! 676: * .stab{<expr>,}*NCPName,<expr>, <expr>, <expr>, <expr> ! 677: * .stabn <expr>, <expr>, <expr>, <expr> ! 678: * .stabs STRING, <expr>, <expr>, <expr>, <expr> ! 679: * .stabd <expr>, <expr>, <expr> # . ! 680: */ ! 681: case ISTAB: ! 682: yyerror(".stab directive no longer supported"); ! 683: goto errorfix; ! 684: ! 685: tailstab: ! 686: expr(locxp, val); ! 687: if (! (locxp->e_xvalue & STABTYPS)){ ! 688: yyerror("Invalid type in %s", stabname); ! 689: goto errorfix; ! 690: } ! 691: stpt->s_ptype = locxp->e_xvalue; ! 692: shiftover(CM); ! 693: expr(locxp, val); ! 694: stpt->s_other = locxp->e_xvalue; ! 695: shiftover(CM); ! 696: expr(locxp, val); ! 697: stpt->s_desc = locxp->e_xvalue; ! 698: shiftover(CM); ! 699: exprisname = 0; ! 700: expr(locxp, val); ! 701: p = locxp->e_xname; ! 702: if (p == NULL) { /*absolute expr to begin with*/ ! 703: stpt->s_value = locxp->e_xvalue; ! 704: stpt->s_index = dotp - usedot; ! 705: if (exprisname){ ! 706: switch(stpt->s_ptype){ ! 707: case N_GSYM: ! 708: case N_FNAME: ! 709: case N_RSYM: ! 710: case N_SSYM: ! 711: case N_LSYM: ! 712: case N_PSYM: ! 713: case N_BCOMM: ! 714: case N_ECOMM: ! 715: case N_LENG: ! 716: stpt->s_tag = STABFIXED; ! 717: break; ! 718: default: ! 719: stpt->s_tag = STABFLOATING; ! 720: break; ! 721: } ! 722: } else ! 723: stpt->s_tag = STABFIXED; ! 724: } ! 725: else { /*really have a name*/ ! 726: stpt->s_dest = locxp->e_xname; ! 727: stpt->s_index = p->s_index; ! 728: stpt->s_type = p->s_type | STABFLAG; ! 729: /* ! 730: * We will assign a more accruate ! 731: * guess of locxp's location when ! 732: * we sort the symbol table ! 733: * The final value of value is ! 734: * given by stabfix() ! 735: */ ! 736: /* ! 737: * For exprs of the form (name + value) one needs to remember locxp->e_xvalue ! 738: * for use in stabfix. The right place to keep this is in stpt->s_value ! 739: * however this gets corrupted at an unknown point. ! 740: * As a bandaid hack the value is preserved in s_desc and s_other (a ! 741: * short and a char). This destroys these two values and will ! 742: * be fixed. May 19 ,1983 Alastair Fyfe ! 743: */ ! 744: if(locxp->e_xvalue) { ! 745: stpt->s_other = (locxp->e_xvalue >> 16); ! 746: stpt->s_desc = (locxp->e_xvalue & 0x0000ffff); ! 747: stpt->s_tag = STABFLOATING; ! 748: } ! 749: } ! 750: /* ! 751: * tokptr now points at one token beyond ! 752: * the current token stored in val and yylval, ! 753: * which are the next tokens after the end of ! 754: * this .stab directive. This next token must ! 755: * be either a SEMI or NL, so is of width just ! 756: * one. Therefore, to point to the next token ! 757: * after the end of this stab, just back up one.. ! 758: */ ! 759: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype)); ! 760: break; /*end of the .stab*/ ! 761: ! 762: case ISTABDOT: ! 763: stabname = ".stabd"; ! 764: stpt = (struct symtab *)yylval; ! 765: /* ! 766: * We clobber everything after the ! 767: * .stabd and its pointer... we MUST ! 768: * be able to get back to this .stabd ! 769: * so that we can resolve its final value ! 770: */ ! 771: stabstart = tokptr; ! 772: shift; /*over the ISTABDOT*/ ! 773: if (passno == 1){ ! 774: expr(locxp, val); ! 775: if (! (locxp->e_xvalue & STABTYPS)){ ! 776: yyerror("Invalid type in .stabd"); ! 777: goto errorfix; ! 778: } ! 779: stpt->s_ptype = locxp->e_xvalue; ! 780: shiftover(CM); ! 781: expr(locxp, val); ! 782: stpt->s_other = locxp->e_xvalue; ! 783: shiftover(CM); ! 784: expr(locxp, val); ! 785: stpt->s_desc = locxp->e_xvalue; ! 786: /* ! 787: * ! 788: * Now, clobber everything but the ! 789: * .stabd pseudo and the pointer ! 790: * to its symbol table entry ! 791: * tokptr points to the next token, ! 792: * build the skip up to this ! 793: */ ! 794: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype)); ! 795: } ! 796: /* ! 797: * pass 1: Assign a good guess for its position ! 798: * (ensures they are sorted into right place)/ ! 799: * pass 2: Fix the actual value ! 800: */ ! 801: stpt->s_value = dotp->e_xvalue; ! 802: stpt->s_index = dotp - usedot; ! 803: stpt->s_tag = STABFLOATING; /*although it has no effect in pass 2*/ ! 804: break; ! 805: ! 806: case ISTABNONE: stabname = ".stabn"; goto shortstab; ! 807: ! 808: case ISTABSTR: stabname = ".stabs"; ! 809: shortstab: ! 810: auxval = val; ! 811: if (passno == 2) goto errorfix; ! 812: stpt = (struct symtab *)yylval; ! 813: stabstart = tokptr; ! 814: (bytetoktype *)stabstart -= sizeof(struct symtab *); ! 815: (bytetoktype *)stabstart -= sizeof(bytetoktype); ! 816: shift; ! 817: if (auxval == ISTABSTR){ ! 818: stringp = (struct strdesc *)yylval; ! 819: shiftover(STRING); ! 820: stpt->s_name = (char *)stringp; ! 821: /* ! 822: * We want the trailing null included in this string. ! 823: * We utilize the cheat the string scanner used, ! 824: * and merely increment the string length ! 825: */ ! 826: stringp->sd_strlen += 1; ! 827: shiftover(CM); ! 828: } else { ! 829: stpt->s_name = (char *)savestr("\0", 0, STR_BOTH); ! 830: } ! 831: goto tailstab; ! 832: break; ! 833: ! 834: case ICOMM: /* .comm <name> , <expr> */ ! 835: case ILCOMM: /* .lcomm <name> , <expr> */ ! 836: auxval = val; ! 837: shift; ! 838: np = (struct symtab *)yylval; ! 839: shiftover(NAME); ! 840: shiftover(CM); ! 841: expr(locxp, val); ! 842: ! 843: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 844: yyerror("comm size not absolute"); ! 845: if (passno == 1 && (np->s_type&XTYPE) != XUNDEF) ! 846: yyerror("Redefinition of %s", FETCHNAME(np)); ! 847: if (passno==1) { ! 848: np->s_value = locxp->e_xvalue; ! 849: if (auxval == ICOMM) ! 850: np->s_type |= XXTRN; ! 851: else { ! 852: np->s_type &= ~XTYPE; ! 853: np->s_type |= XBSS; ! 854: } ! 855: } ! 856: break; ! 857: ! 858: case IALIGN: /* .align <expr> */ ! 859: stpt = (struct symtab *)yylval; ! 860: shift; ! 861: expr(locxp, val); ! 862: jalign(locxp, stpt); ! 863: break; ! 864: ! 865: case INST0: /* instructions w/o arguments*/ ! 866: incasetable = 0; ! 867: insout(yyopcode, (struct arg *)0, 0); ! 868: shift; ! 869: break; ! 870: ! 871: case INSTn: /* instructions with arguments*/ ! 872: case IJXXX: /* UNIX style jump instructions */ ! 873: auxval = val; ! 874: /* ! 875: * Code to process an argument list ! 876: */ ! 877: ap = arglist; ! 878: xp = explist; ! 879: ! 880: shift; /* bring in the first token for the arg list*/ ! 881: ! 882: for (argcnt = 1; argcnt <= 6; argcnt++, ap++){ ! 883: /* ! 884: * code to process an argument proper ! 885: */ ! 886: sawindex = sawmul = sawsize = 0; ! 887: { ! 888: switch(val) { ! 889: ! 890: default: ! 891: disp: ! 892: if( !(INTOKSET(val, ! 893: EBEGOPS ! 894: +YUKKYEXPRBEG ! 895: +SAFEEXPRBEG)) ) { ! 896: ERROR("expression expected"); ! 897: } ! 898: expr(ap->a_xp,val); ! 899: overdisp: ! 900: if ( val == LP || sawsize){ ! 901: shiftover(LP); ! 902: findreg(regno); ! 903: shiftover(RP); ! 904: ap->a_atype = ADISP; ! 905: ap->a_areg1 = regno; ! 906: } else { ! 907: ap->a_atype = AEXP; ! 908: ap->a_areg1 = 0; ! 909: } ! 910: goto index; ! 911: ! 912: case SIZESPEC: ! 913: sizespec: ! 914: sawsize = yylval; ! 915: shift; ! 916: goto disp; ! 917: ! 918: case REG: ! 919: case REGOP: ! 920: findreg(regno); ! 921: ap->a_atype = AREG; ! 922: ap->a_areg1 = regno; ! 923: break; ! 924: ! 925: case MUL: ! 926: sawmul = 1; ! 927: shift; ! 928: if (val == LP) goto base; ! 929: if (val == LITOP) goto imm; ! 930: if (val == SIZESPEC) goto sizespec; ! 931: if (INTOKSET(val, ! 932: EBEGOPS ! 933: +YUKKYEXPRBEG ! 934: +SAFEEXPRBEG)) goto disp; ! 935: ERROR("expression, '(' or '$' expected"); ! 936: break; ! 937: ! 938: case LP: ! 939: base: ! 940: shift; /*consume the LP*/ ! 941: /* ! 942: * hack the ambiguity of ! 943: * movl (expr) (rn), ... ! 944: * note that (expr) could also ! 945: * be (rn) (by special hole in the ! 946: * grammar), which we ensure ! 947: * means register indirection, instead ! 948: * of an expression with value n ! 949: */ ! 950: if (val != REG && val != REGOP){ ! 951: droppedLP = 1; ! 952: val = exprparse(val, &(ap->a_xp)); ! 953: droppedLP = 0; ! 954: goto overdisp; ! 955: } ! 956: findreg(regno); ! 957: shiftover(RP); ! 958: if (val == PLUS){ ! 959: shift; ! 960: ap->a_atype = AINCR; ! 961: if (sawmul && regno != 0xE) ! 962: yyerror ("Autoincrement deferred register must be SP"); ! 963: if (!(sawmul || regno == 0xE)) ! 964: yyerror ("Autoincrement register must be SP"); ! 965: } else ! 966: ap->a_atype = ABASE; ! 967: ap->a_areg1 = regno; ! 968: goto index; ! 969: ! 970: case LITOP: ! 971: imm: ! 972: shift; ! 973: expr(locxp, val); ! 974: ap->a_atype = AIMM; ! 975: ap->a_areg1 = 0; ! 976: ap->a_xp = locxp; ! 977: goto index; ! 978: ! 979: case MP: ! 980: shift; /* -(reg) */ ! 981: findreg(regno); ! 982: if (regno != 0xE) ! 983: yyerror ("Autodecrement register must be SP"); ! 984: shiftover(RP); ! 985: ap->a_atype = ADECR; ! 986: ap->a_areg1 = regno; ! 987: index: /*look for [reg] */ ! 988: if (val == LB){ ! 989: shift; ! 990: findreg(regno); ! 991: shiftover(RB); ! 992: sawindex = 1; ! 993: ap->a_areg2 = regno; ! 994: } ! 995: break; ! 996: ! 997: } /*end of the switch to process an arg*/ ! 998: } /*end of processing an argument*/ ! 999: ! 1000: if (sawmul){ ! 1001: /* ! 1002: * Make a concession for *(%r) ! 1003: * meaning *0(%r) ! 1004: */ ! 1005: if (ap->a_atype == ABASE) { ! 1006: ap->a_atype = ADISP; ! 1007: xp->e_xtype = XABS; ! 1008: xp->e_number = Znumber; ! 1009: xp->e_number.num_tag = TYPL; ! 1010: xp->e_xloc = 0; ! 1011: ap->a_xp = xp++; ! 1012: } ! 1013: ap->a_atype |= ASTAR; ! 1014: sawmul = 0; ! 1015: } ! 1016: if (sawindex){ ! 1017: ap->a_atype |= AINDX; ! 1018: sawindex = 0; ! 1019: } ! 1020: ap->a_dispsize = sawsize == 0 ? d124 : sawsize; ! 1021: if (val != CM) break; ! 1022: shiftover(CM); ! 1023: } /*processing all the arguments*/ ! 1024: ! 1025: if (argcnt > 6){ ! 1026: yyerror("More than 6 arguments"); ! 1027: goto errorfix; ! 1028: } ! 1029: ! 1030: /* ! 1031: * See if this is a case instruction, ! 1032: * so we can set up tests on the following ! 1033: * vector of branch displacements ! 1034: */ ! 1035: if (yyopcode == 0xfc) /* 'casel' instruction */ ! 1036: incasetable++; ! 1037: else ! 1038: incasetable = 0; ! 1039: ! 1040: insout(yyopcode, arglist, ! 1041: auxval == INSTn ? argcnt : - argcnt); ! 1042: break; ! 1043: ! 1044: case IQUAD: num_type = TYPQ; goto bignumlist; ! 1045: case IFFLOAT: num_type = TYPF; goto bignumlist; ! 1046: case IDFLOAT: num_type = TYPD; ! 1047: bignumlist: ! 1048: /* ! 1049: * eat a list of non 32 bit numbers. ! 1050: * IQUAD can, possibly, return ! 1051: * INT's, if the numbers are "small". ! 1052: * ! 1053: * The value of the numbers is coming back ! 1054: * as an expression, NOT in yybignum. ! 1055: */ ! 1056: shift; /* over the opener */ ! 1057: if ((val == BIGNUM) || (val == INT)){ ! 1058: do{ ! 1059: if ((val != BIGNUM) && (val != INT)){ ! 1060: ERROR(ty_float[num_type] ! 1061: ? "floating number expected" ! 1062: : "integer number expected" ); ! 1063: } ! 1064: dotp->e_xvalue += ty_nbyte[num_type]; ! 1065: if (passno == 2){ ! 1066: switch (num_type) { ! 1067: case TYPF: ! 1068: bwrite(&((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong, ! 1069: ty_nbyte[num_type], txtfil); ! 1070: if (liston) ! 1071: { ! 1072: long_out(((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong[0]); ! 1073: *layoutpos++ = ' '; ! 1074: } ! 1075: break; ! 1076: case TYPD: ! 1077: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[0], ! 1078: sizeof (long), txtfil); ! 1079: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[1], ! 1080: sizeof (long), txtfil); ! 1081: if (liston) ! 1082: { ! 1083: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]); ! 1084: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]); ! 1085: *layoutpos++ = ' '; ! 1086: } ! 1087: break; ! 1088: case TYPQ: ! 1089: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1], ! 1090: sizeof (long), txtfil); ! 1091: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0], ! 1092: sizeof (long), txtfil); ! 1093: if (liston) ! 1094: { ! 1095: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]); ! 1096: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]); ! 1097: *layoutpos++ = ' '; ! 1098: } ! 1099: break; ! 1100: } ! 1101: } ! 1102: xp = explist; ! 1103: shift; /* over this number */ ! 1104: if (auxval = (val == CM)) ! 1105: shift; /* over the comma */ ! 1106: } while (auxval); /* as long as there are commas */ ! 1107: } ! 1108: break; ! 1109: /* end of the case for initialized big numbers */ ! 1110: } /*end of the switch for looking at each reserved word*/ ! 1111: ! 1112: continue; ! 1113: ! 1114: errorfix: ! 1115: /* ! 1116: * got here by either requesting to skip to the ! 1117: * end of this statement, or by erroring out and ! 1118: * wanting to apply panic mode recovery ! 1119: */ ! 1120: while ( (val != NL) ! 1121: && (val != SEMI) ! 1122: && (val != PARSEEOF) ! 1123: ){ ! 1124: shift; ! 1125: } ! 1126: if (val == NL) ! 1127: lineno++; ! 1128: shift; ! 1129: ! 1130: } /*end of the loop to read the entire file, line by line*/ ! 1131: ! 1132: } /*end of yyparse*/ ! 1133: ! 1134: /* ! 1135: * Process a register declaration of the form ! 1136: * % <expr> ! 1137: * ! 1138: * Note: ! 1139: * The scanner has already processed funny registers of the form ! 1140: * %dd[+-]*, where dd is a decimal number in the range 00 to 15 (optional ! 1141: * preceding zero digit). If there was any space between the % and ! 1142: * the digit, the scanner wouldn't have recognized it, so we ! 1143: * hack it out here. ! 1144: */ ! 1145: inttoktype funnyreg(val, regnoback) /*what the read head will sit on*/ ! 1146: inttoktype val; /*what the read head is sitting on*/ ! 1147: int *regnoback; /*call by return*/ ! 1148: { ! 1149: reg struct exp *locxp; ! 1150: struct exp *loc1xp; ! 1151: struct exp **ptrloc1xp = & loc1xp; ! 1152: ! 1153: expr(locxp, val); /*and leave the current read head with value*/ ! 1154: if ( (passno == 2) && ! 1155: ( (locxp->e_xtype & XTYPE) != XABS ! 1156: || (locxp->e_xvalue < 0) ! 1157: || (locxp->e_xvalue >= 16) ! 1158: ) ! 1159: ){ ! 1160: yyerror("Illegal register"); ! 1161: return(0); ! 1162: } ! 1163: *regnoback = locxp->e_xvalue; ! 1164: return(val); ! 1165: } ! 1166: /* ! 1167: * Shift over error ! 1168: */ ! 1169: shiftoerror(token) ! 1170: int token; ! 1171: { ! 1172: char *tok_to_name(); ! 1173: yyerror("%s expected", tok_to_name(token)); ! 1174: } ! 1175: ! 1176: /*VARARGS1*/ ! 1177: yyerror(s, a1, a2,a3,a4,a5) ! 1178: char *s; ! 1179: { ! 1180: ! 1181: #define sink stdout ! 1182: ! 1183: if (anyerrs == 0 && anywarnings == 0 && ! silent) ! 1184: fprintf(sink, "Assembler:\n"); ! 1185: anyerrs++; ! 1186: if (silent) ! 1187: return; ! 1188: fprintf(sink, "\"%s\", line %d: ", dotsname, lineno); ! 1189: fprintf(sink, s, a1, a2,a3,a4,a5); ! 1190: fprintf(sink, "\n"); ! 1191: #undef sink ! 1192: } ! 1193: ! 1194: /*VARARGS1*/ ! 1195: yywarning(s, a1, a2,a3,a4,a5) ! 1196: char *s; ! 1197: { ! 1198: #define sink stdout ! 1199: if (anyerrs == 0 && anywarnings == 0 && ! silent) ! 1200: fprintf(sink, "Assembler:\n"); ! 1201: anywarnings++; ! 1202: if (silent) ! 1203: return; ! 1204: fprintf(sink, "\"%s\", line %d: WARNING: ", dotsname, lineno); ! 1205: fprintf(sink, s, a1, a2,a3,a4,a5); ! 1206: fprintf(sink, "\n"); ! 1207: #undef sink ! 1208: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.