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