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