![[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 [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe|
Return to asparse.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982 Regents of the University of California ! 3: */ ! 4: #ifndef lint ! 5: static char sccsid[] = "$W$ (Berkeley) 5/31/88"; ! 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: (void)sprintf (layoutpos, "%4ld ", lineno); ! 193: layoutpos += 6; ! 194: long_out (dotp->e_xvalue); ! 195: if (dotp->e_xvalue >= datbase) ! 196: (void)sprintf (layoutpos," * "); ! 197: else ! 198: (void)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: (void)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: (void)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: (void)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: stpt->s_type = locxp->e_xtype; ! 707: switch(stpt->s_ptype){ ! 708: case N_LCSYM: ! 709: stpt->s_dest = (struct symtab *)exprisname; ! 710: stpt->s_type |= STABFLAG; ! 711: case N_GSYM: ! 712: case N_FNAME: ! 713: case N_RSYM: ! 714: case N_SSYM: ! 715: case N_LSYM: ! 716: case N_PSYM: ! 717: case N_BCOMM: ! 718: case N_ECOMM: ! 719: case N_LENG: ! 720: stpt->s_tag = STABFIXED; ! 721: break; ! 722: default: ! 723: stpt->s_tag = STABFLOATING; ! 724: break; ! 725: } ! 726: } else ! 727: stpt->s_tag = STABFIXED; ! 728: } ! 729: else { /*really have a name*/ ! 730: stpt->s_dest = locxp->e_xname; ! 731: stpt->s_index = p->s_index; ! 732: stpt->s_type = p->s_type | STABFLAG; ! 733: /* ! 734: * We will assign a more accruate ! 735: * guess of locxp's location when ! 736: * we sort the symbol table ! 737: * The final value of value is ! 738: * given by stabfix() ! 739: */ ! 740: /* ! 741: * For exprs of the form (name + value) one needs to remember locxp->e_xvalue ! 742: * for use in stabfix. The right place to keep this is in stpt->s_value ! 743: * however this gets corrupted at an unknown point. ! 744: * As a bandaid hack the value is preserved in s_desc and s_other (a ! 745: * short and a char). This destroys these two values and will ! 746: * be fixed. May 19 ,1983 Alastair Fyfe ! 747: */ ! 748: if(locxp->e_xvalue) { ! 749: stpt->s_other = (locxp->e_xvalue >> 16); ! 750: stpt->s_desc = (locxp->e_xvalue & 0x0000ffff); ! 751: stpt->s_tag = STABFLOATING; ! 752: } ! 753: } ! 754: /* ! 755: * tokptr now points at one token beyond ! 756: * the current token stored in val and yylval, ! 757: * which are the next tokens after the end of ! 758: * this .stab directive. This next token must ! 759: * be either a SEMI or NL, so is of width just ! 760: * one. Therefore, to point to the next token ! 761: * after the end of this stab, just back up one.. ! 762: */ ! 763: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype)); ! 764: break; /*end of the .stab*/ ! 765: ! 766: case ISTABDOT: ! 767: stabname = ".stabd"; ! 768: stpt = (struct symtab *)yylval; ! 769: /* ! 770: * We clobber everything after the ! 771: * .stabd and its pointer... we MUST ! 772: * be able to get back to this .stabd ! 773: * so that we can resolve its final value ! 774: */ ! 775: stabstart = tokptr; ! 776: shift; /*over the ISTABDOT*/ ! 777: if (passno == 1){ ! 778: expr(locxp, val); ! 779: if (! (locxp->e_xvalue & STABTYPS)){ ! 780: yyerror("Invalid type in .stabd"); ! 781: goto errorfix; ! 782: } ! 783: stpt->s_ptype = locxp->e_xvalue; ! 784: shiftover(CM); ! 785: expr(locxp, val); ! 786: stpt->s_other = locxp->e_xvalue; ! 787: shiftover(CM); ! 788: expr(locxp, val); ! 789: stpt->s_desc = locxp->e_xvalue; ! 790: /* ! 791: * ! 792: * Now, clobber everything but the ! 793: * .stabd pseudo and the pointer ! 794: * to its symbol table entry ! 795: * tokptr points to the next token, ! 796: * build the skip up to this ! 797: */ ! 798: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype)); ! 799: } ! 800: /* ! 801: * pass 1: Assign a good guess for its position ! 802: * (ensures they are sorted into right place)/ ! 803: * pass 2: Fix the actual value ! 804: */ ! 805: stpt->s_value = dotp->e_xvalue; ! 806: stpt->s_index = dotp - usedot; ! 807: stpt->s_tag = STABFLOATING; /*although it has no effect in pass 2*/ ! 808: break; ! 809: ! 810: case ISTABNONE: stabname = ".stabn"; goto shortstab; ! 811: ! 812: case ISTABSTR: stabname = ".stabs"; ! 813: shortstab: ! 814: auxval = val; ! 815: if (passno == 2) goto errorfix; ! 816: stpt = (struct symtab *)yylval; ! 817: stabstart = tokptr; ! 818: (bytetoktype *)stabstart -= sizeof(struct symtab *); ! 819: (bytetoktype *)stabstart -= sizeof(bytetoktype); ! 820: shift; ! 821: if (auxval == ISTABSTR){ ! 822: stringp = (struct strdesc *)yylval; ! 823: shiftover(STRING); ! 824: stpt->s_name = (char *)stringp; ! 825: /* ! 826: * We want the trailing null included in this string. ! 827: * We utilize the cheat the string scanner used, ! 828: * and merely increment the string length ! 829: */ ! 830: stringp->sd_strlen += 1; ! 831: shiftover(CM); ! 832: } else { ! 833: stpt->s_name = (char *)savestr("\0", 0, STR_BOTH); ! 834: } ! 835: goto tailstab; ! 836: break; ! 837: ! 838: case ICOMM: /* .comm <name> , <expr> */ ! 839: case ILCOMM: /* .lcomm <name> , <expr> */ ! 840: auxval = val; ! 841: shift; ! 842: np = (struct symtab *)yylval; ! 843: shiftover(NAME); ! 844: shiftover(CM); ! 845: expr(locxp, val); ! 846: ! 847: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */ ! 848: yyerror("comm size not absolute"); ! 849: if (passno == 1 && (np->s_type&XTYPE) != XUNDEF) ! 850: yyerror("Redefinition of %s", FETCHNAME(np)); ! 851: if (passno==1) { ! 852: np->s_value = locxp->e_xvalue; ! 853: if (auxval == ICOMM) ! 854: np->s_type |= XXTRN; ! 855: else { ! 856: np->s_type &= ~XTYPE; ! 857: np->s_type |= XBSS; ! 858: } ! 859: } ! 860: break; ! 861: ! 862: case IALIGN: /* .align <expr> */ ! 863: stpt = (struct symtab *)yylval; ! 864: shift; ! 865: expr(locxp, val); ! 866: if ((dotp->e_xtype & XTYPE) == XDATA) ! 867: djalign(locxp, stpt); ! 868: else ! 869: jalign(locxp, stpt); ! 870: break; ! 871: ! 872: case INST0: /* instructions w/o arguments*/ ! 873: incasetable = 0; ! 874: insout(yyopcode, (struct arg *)0, 0); ! 875: shift; ! 876: break; ! 877: ! 878: case INSTn: /* instructions with arguments*/ ! 879: case IJXXX: /* UNIX style jump instructions */ ! 880: auxval = val; ! 881: /* ! 882: * Code to process an argument list ! 883: */ ! 884: ap = arglist; ! 885: xp = explist; ! 886: ! 887: shift; /* bring in the first token for the arg list*/ ! 888: ! 889: for (argcnt = 1; argcnt <= 6; argcnt++, ap++){ ! 890: /* ! 891: * code to process an argument proper ! 892: */ ! 893: sawindex = sawmul = sawsize = 0; ! 894: { ! 895: switch(val) { ! 896: ! 897: default: ! 898: disp: ! 899: if( !(INTOKSET(val, ! 900: EBEGOPS ! 901: +YUKKYEXPRBEG ! 902: +SAFEEXPRBEG)) ) { ! 903: ERROR("expression expected"); ! 904: } ! 905: expr(ap->a_xp,val); ! 906: overdisp: ! 907: if ( val == LP || sawsize){ ! 908: shiftover(LP); ! 909: findreg(regno); ! 910: shiftover(RP); ! 911: ap->a_atype = ADISP; ! 912: ap->a_areg1 = regno; ! 913: } else { ! 914: ap->a_atype = AEXP; ! 915: ap->a_areg1 = 0; ! 916: } ! 917: goto index; ! 918: ! 919: case SIZESPEC: ! 920: sizespec: ! 921: sawsize = yylval; ! 922: shift; ! 923: goto disp; ! 924: ! 925: case REG: ! 926: case REGOP: ! 927: findreg(regno); ! 928: ap->a_atype = AREG; ! 929: ap->a_areg1 = regno; ! 930: break; ! 931: ! 932: case MUL: ! 933: sawmul = 1; ! 934: shift; ! 935: if (val == LP) goto base; ! 936: if (val == LITOP) goto imm; ! 937: if (val == SIZESPEC) goto sizespec; ! 938: if (INTOKSET(val, ! 939: EBEGOPS ! 940: +YUKKYEXPRBEG ! 941: +SAFEEXPRBEG)) goto disp; ! 942: ERROR("expression, '(' or '$' expected"); ! 943: break; ! 944: ! 945: case LP: ! 946: base: ! 947: shift; /*consume the LP*/ ! 948: /* ! 949: * hack the ambiguity of ! 950: * movl (expr) (rn), ... ! 951: * note that (expr) could also ! 952: * be (rn) (by special hole in the ! 953: * grammar), which we ensure ! 954: * means register indirection, instead ! 955: * of an expression with value n ! 956: */ ! 957: if (val != REG && val != REGOP){ ! 958: droppedLP = 1; ! 959: val = exprparse(val, &(ap->a_xp)); ! 960: droppedLP = 0; ! 961: goto overdisp; ! 962: } ! 963: findreg(regno); ! 964: shiftover(RP); ! 965: if (val == PLUS){ ! 966: shift; ! 967: ap->a_atype = AINCR; ! 968: if (sawmul && regno != 0xE) ! 969: yyerror ("Autoincrement deferred register must be SP"); ! 970: if (!(sawmul || regno == 0xE)) ! 971: yyerror ("Autoincrement register must be SP"); ! 972: } else ! 973: ap->a_atype = ABASE; ! 974: ap->a_areg1 = regno; ! 975: goto index; ! 976: ! 977: case LITOP: ! 978: imm: ! 979: shift; ! 980: expr(locxp, val); ! 981: ap->a_atype = AIMM; ! 982: ap->a_areg1 = 0; ! 983: ap->a_xp = locxp; ! 984: goto index; ! 985: ! 986: case MP: ! 987: shift; /* -(reg) */ ! 988: findreg(regno); ! 989: if (regno != 0xE) ! 990: yyerror ("Autodecrement register must be SP"); ! 991: shiftover(RP); ! 992: ap->a_atype = ADECR; ! 993: ap->a_areg1 = regno; ! 994: index: /*look for [reg] */ ! 995: if (val == LB){ ! 996: shift; ! 997: findreg(regno); ! 998: shiftover(RB); ! 999: sawindex = 1; ! 1000: ap->a_areg2 = regno; ! 1001: } ! 1002: break; ! 1003: ! 1004: } /*end of the switch to process an arg*/ ! 1005: } /*end of processing an argument*/ ! 1006: ! 1007: if (sawmul){ ! 1008: /* ! 1009: * Make a concession for *(%r) ! 1010: * meaning *0(%r) ! 1011: */ ! 1012: if (ap->a_atype == ABASE) { ! 1013: ap->a_atype = ADISP; ! 1014: xp->e_xtype = XABS; ! 1015: xp->e_number = Znumber; ! 1016: xp->e_number.num_tag = TYPL; ! 1017: xp->e_xloc = 0; ! 1018: ap->a_xp = xp++; ! 1019: } ! 1020: ap->a_atype |= ASTAR; ! 1021: sawmul = 0; ! 1022: } ! 1023: if (sawindex){ ! 1024: ap->a_atype |= AINDX; ! 1025: sawindex = 0; ! 1026: } ! 1027: ap->a_dispsize = sawsize == 0 ? d124 : sawsize; ! 1028: if (val != CM) break; ! 1029: shiftover(CM); ! 1030: } /*processing all the arguments*/ ! 1031: ! 1032: if (argcnt > 6){ ! 1033: yyerror("More than 6 arguments"); ! 1034: goto errorfix; ! 1035: } ! 1036: ! 1037: /* ! 1038: * See if this is a case instruction, ! 1039: * so we can set up tests on the following ! 1040: * vector of branch displacements ! 1041: */ ! 1042: if (yyopcode == 0xfc) /* 'casel' instruction */ ! 1043: incasetable++; ! 1044: else ! 1045: incasetable = 0; ! 1046: ! 1047: insout(yyopcode, arglist, ! 1048: auxval == INSTn ? argcnt : - argcnt); ! 1049: break; ! 1050: ! 1051: case IQUAD: num_type = TYPQ; goto bignumlist; ! 1052: case IFFLOAT: num_type = TYPF; goto bignumlist; ! 1053: case IDFLOAT: num_type = TYPD; ! 1054: bignumlist: ! 1055: /* ! 1056: * eat a list of non 32 bit numbers. ! 1057: * IQUAD can, possibly, return ! 1058: * INT's, if the numbers are "small". ! 1059: * ! 1060: * The value of the numbers is coming back ! 1061: * as an expression, NOT in yybignum. ! 1062: */ ! 1063: shift; /* over the opener */ ! 1064: if ((val == BIGNUM) || (val == INT)){ ! 1065: do{ ! 1066: if ((val != BIGNUM) && (val != INT)){ ! 1067: ERROR(ty_float[num_type] ! 1068: ? "floating number expected" ! 1069: : "integer number expected" ); ! 1070: } ! 1071: dotp->e_xvalue += ty_nbyte[num_type]; ! 1072: if (passno == 2){ ! 1073: switch (num_type) { ! 1074: case TYPF: ! 1075: bwrite(((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong, ! 1076: ty_nbyte[num_type], txtfil); ! 1077: if (liston) ! 1078: { ! 1079: long_out(((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong[0]); ! 1080: *layoutpos++ = ' '; ! 1081: } ! 1082: break; ! 1083: case TYPD: ! 1084: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[0], ! 1085: sizeof (long), txtfil); ! 1086: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[1], ! 1087: sizeof (long), txtfil); ! 1088: if (liston) ! 1089: { ! 1090: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]); ! 1091: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]); ! 1092: *layoutpos++ = ' '; ! 1093: } ! 1094: break; ! 1095: case TYPQ: ! 1096: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1], ! 1097: sizeof (long), txtfil); ! 1098: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0], ! 1099: sizeof (long), txtfil); ! 1100: if (liston) ! 1101: { ! 1102: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]); ! 1103: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]); ! 1104: *layoutpos++ = ' '; ! 1105: } ! 1106: break; ! 1107: } ! 1108: } ! 1109: xp = explist; ! 1110: shift; /* over this number */ ! 1111: if (auxval = (val == CM)) ! 1112: shift; /* over the comma */ ! 1113: } while (auxval); /* as long as there are commas */ ! 1114: } ! 1115: break; ! 1116: /* end of the case for initialized big numbers */ ! 1117: } /*end of the switch for looking at each reserved word*/ ! 1118: ! 1119: continue; ! 1120: ! 1121: errorfix: ! 1122: /* ! 1123: * got here by either requesting to skip to the ! 1124: * end of this statement, or by erroring out and ! 1125: * wanting to apply panic mode recovery ! 1126: */ ! 1127: while ( (val != NL) ! 1128: && (val != SEMI) ! 1129: && (val != PARSEEOF) ! 1130: ){ ! 1131: shift; ! 1132: } ! 1133: if (val == NL) ! 1134: lineno++; ! 1135: shift; ! 1136: ! 1137: } /*end of the loop to read the entire file, line by line*/ ! 1138: ! 1139: } /*end of yyparse*/ ! 1140: ! 1141: /* ! 1142: * Process a register declaration of the form ! 1143: * % <expr> ! 1144: * ! 1145: * Note: ! 1146: * The scanner has already processed funny registers of the form ! 1147: * %dd[+-]*, where dd is a decimal number in the range 00 to 15 (optional ! 1148: * preceding zero digit). If there was any space between the % and ! 1149: * the digit, the scanner wouldn't have recognized it, so we ! 1150: * hack it out here. ! 1151: */ ! 1152: inttoktype funnyreg(val, regnoback) /*what the read head will sit on*/ ! 1153: inttoktype val; /*what the read head is sitting on*/ ! 1154: int *regnoback; /*call by return*/ ! 1155: { ! 1156: reg struct exp *locxp; ! 1157: struct exp *loc1xp; ! 1158: struct exp **ptrloc1xp = & loc1xp; ! 1159: ! 1160: expr(locxp, val); /*and leave the current read head with value*/ ! 1161: if ( (passno == 2) && ! 1162: ( (locxp->e_xtype & XTYPE) != XABS ! 1163: || (locxp->e_xvalue < 0) ! 1164: || (locxp->e_xvalue >= 16) ! 1165: ) ! 1166: ){ ! 1167: yyerror("Illegal register"); ! 1168: return(0); ! 1169: } ! 1170: *regnoback = locxp->e_xvalue; ! 1171: return(val); ! 1172: } ! 1173: /* ! 1174: * Shift over error ! 1175: */ ! 1176: shiftoerror(token) ! 1177: int token; ! 1178: { ! 1179: char *tok_to_name(); ! 1180: yyerror("%s expected", tok_to_name(token)); ! 1181: } ! 1182: ! 1183: /*VARARGS1*/ ! 1184: yyerror(s, a1, a2,a3,a4,a5) ! 1185: char *s; ! 1186: { ! 1187: ! 1188: #define sink stdout ! 1189: ! 1190: if (anyerrs == 0 && anywarnings == 0 && ! silent) ! 1191: fprintf(sink, "Assembler:\n"); ! 1192: anyerrs++; ! 1193: if (silent) ! 1194: return; ! 1195: fprintf(sink, "\"%s\", line %d: ", dotsname, lineno); ! 1196: fprintf(sink, s, a1, a2,a3,a4,a5); ! 1197: fprintf(sink, "\n"); ! 1198: #undef sink ! 1199: } ! 1200: ! 1201: /*VARARGS1*/ ! 1202: yywarning(s, a1, a2,a3,a4,a5) ! 1203: char *s; ! 1204: { ! 1205: #define sink stdout ! 1206: if (anyerrs == 0 && anywarnings == 0 && ! silent) ! 1207: fprintf(sink, "Assembler:\n"); ! 1208: anywarnings++; ! 1209: if (silent) ! 1210: return; ! 1211: fprintf(sink, "\"%s\", line %d: WARNING: ", dotsname, lineno); ! 1212: fprintf(sink, s, a1, a2,a3,a4,a5); ! 1213: fprintf(sink, "\n"); ! 1214: #undef sink ! 1215: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.