![[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] / 43BSD / bin / as|
Return to asparse.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / as |
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.2 (Berkeley) 6/19/85";
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_GSYM:
544: case N_FNAME:
545: case N_RSYM:
546: case N_SSYM:
547: case N_LSYM:
548: case N_PSYM:
549: case N_BCOMM:
550: case N_ECOMM:
551: case N_LENG:
552: stpt->s_tag = STABFIXED;
553: break;
554: default:
555: stpt->s_tag = STABFLOATING;
556: break;
557: }
558: } else
559: stpt->s_tag = STABFIXED;
560: }
561: else { /*really have a name*/
562: stpt->s_dest = locxp->e_xname;
563: stpt->s_index = p->s_index;
564: stpt->s_type = p->s_type | STABFLAG;
565: /*
566: * We will assign a more accruate
567: * guess of locxp's location when
568: * we sort the symbol table
569: * The final value of value is
570: * given by stabfix()
571: */
572: /*
573: * For exprs of the form (name + value) one needs to remember locxp->e_xvalue
574: * for use in stabfix. The right place to keep this is in stpt->s_value
575: * however this gets corrupted at an unknown point.
576: * As a bandaid hack the value is preserved in s_desc and s_other (a
577: * short and a char). This destroys these two values and will
578: * be fixed. May 19 ,1983 Alastair Fyfe
579: */
580: if(locxp->e_xvalue) {
581: stpt->s_other = (locxp->e_xvalue >> 16);
582: stpt->s_desc = (locxp->e_xvalue & 0x0000ffff);
583: stpt->s_tag = STABFLOATING;
584: }
585: }
586: /*
587: * tokptr now points at one token beyond
588: * the current token stored in val and yylval,
589: * which are the next tokens after the end of
590: * this .stab directive. This next token must
591: * be either a SEMI or NL, so is of width just
592: * one. Therefore, to point to the next token
593: * after the end of this stab, just back up one..
594: */
595: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype));
596: break; /*end of the .stab*/
597:
598: case ISTABDOT:
599: stabname = ".stabd";
600: stpt = (struct symtab *)yylval;
601: /*
602: * We clobber everything after the
603: * .stabd and its pointer... we MUST
604: * be able to get back to this .stabd
605: * so that we can resolve its final value
606: */
607: stabstart = tokptr;
608: shift; /*over the ISTABDOT*/
609: if (passno == 1){
610: expr(locxp, val);
611: if (! (locxp->e_xvalue & STABTYPS)){
612: yyerror("Invalid type in .stabd");
613: goto errorfix;
614: }
615: stpt->s_ptype = locxp->e_xvalue;
616: shiftover(CM);
617: expr(locxp, val);
618: stpt->s_other = locxp->e_xvalue;
619: shiftover(CM);
620: expr(locxp, val);
621: stpt->s_desc = locxp->e_xvalue;
622: /*
623: *
624: * Now, clobber everything but the
625: * .stabd pseudo and the pointer
626: * to its symbol table entry
627: * tokptr points to the next token,
628: * build the skip up to this
629: */
630: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype));
631: }
632: /*
633: * pass 1: Assign a good guess for its position
634: * (ensures they are sorted into right place)/
635: * pass 2: Fix the actual value
636: */
637: stpt->s_value = dotp->e_xvalue;
638: stpt->s_index = dotp - usedot;
639: stpt->s_tag = STABFLOATING; /*although it has no effect in pass 2*/
640: break;
641:
642: case ISTABNONE: stabname = ".stabn"; goto shortstab;
643:
644: case ISTABSTR: stabname = ".stabs";
645: shortstab:
646: auxval = val;
647: if (passno == 2) goto errorfix;
648: stpt = (struct symtab *)yylval;
649: stabstart = tokptr;
650: (bytetoktype *)stabstart -= sizeof(struct symtab *);
651: (bytetoktype *)stabstart -= sizeof(bytetoktype);
652: shift;
653: if (auxval == ISTABSTR){
654: stringp = (struct strdesc *)yylval;
655: shiftover(STRING);
656: stpt->s_name = (char *)stringp;
657: /*
658: * We want the trailing null included in this string.
659: * We utilize the cheat the string scanner used,
660: * and merely increment the string length
661: */
662: stringp->sd_strlen += 1;
663: shiftover(CM);
664: } else {
665: stpt->s_name = (char *)savestr("\0", 0, STR_BOTH);
666: }
667: goto tailstab;
668: break;
669:
670: case ICOMM: /* .comm <name> , <expr> */
671: case ILCOMM: /* .lcomm <name> , <expr> */
672: auxval = val;
673: shift;
674: np = (struct symtab *)yylval;
675: shiftover(NAME);
676: shiftover(CM);
677: expr(locxp, val);
678:
679: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */
680: yyerror("comm size not absolute");
681: if (passno == 1 && (np->s_type&XTYPE) != XUNDEF)
682: yyerror("Redefinition of %s", FETCHNAME(np));
683: if (passno==1) {
684: np->s_value = locxp->e_xvalue;
685: if (auxval == ICOMM)
686: np->s_type |= XXTRN;
687: else {
688: np->s_type &= ~XTYPE;
689: np->s_type |= XBSS;
690: }
691: }
692: break;
693:
694: case IALIGN: /* .align <expr> */
695: stpt = (struct symtab *)yylval;
696: shift;
697: expr(locxp, val);
698: jalign(locxp, stpt);
699: break;
700:
701: case INST0: /* instructions w/o arguments*/
702: incasetable = 0;
703: insout(yyopcode, (struct arg *)0, 0);
704: shift;
705: break;
706:
707: case INSTn: /* instructions with arguments*/
708: case IJXXX: /* UNIX style jump instructions */
709: auxval = val;
710: /*
711: * Code to process an argument list
712: */
713: ap = arglist;
714: xp = explist;
715:
716: shift; /* bring in the first token for the arg list*/
717:
718: for (argcnt = 1; argcnt <= 6; argcnt++, ap++){
719: /*
720: * code to process an argument proper
721: */
722: sawindex = sawmul = sawsize = 0;
723: {
724: switch(val) {
725:
726: default:
727: disp:
728: if( !(INTOKSET(val,
729: EBEGOPS
730: +YUKKYEXPRBEG
731: +SAFEEXPRBEG)) ) {
732: ERROR("expression expected");
733: }
734: expr(ap->a_xp,val);
735: overdisp:
736: if ( val == LP || sawsize){
737: shiftover(LP);
738: findreg(regno);
739: shiftover(RP);
740: ap->a_atype = ADISP;
741: ap->a_areg1 = regno;
742: } else {
743: ap->a_atype = AEXP;
744: ap->a_areg1 = 0;
745: }
746: goto index;
747:
748: case SIZESPEC:
749: sizespec:
750: sawsize = yylval;
751: shift;
752: goto disp;
753:
754: case REG:
755: case REGOP:
756: findreg(regno);
757: ap->a_atype = AREG;
758: ap->a_areg1 = regno;
759: break;
760:
761: case MUL:
762: sawmul = 1;
763: shift;
764: if (val == LP) goto base;
765: if (val == LITOP) goto imm;
766: if (val == SIZESPEC) goto sizespec;
767: if (INTOKSET(val,
768: EBEGOPS
769: +YUKKYEXPRBEG
770: +SAFEEXPRBEG)) goto disp;
771: ERROR("expression, '(' or '$' expected");
772: break;
773:
774: case LP:
775: base:
776: shift; /*consume the LP*/
777: /*
778: * hack the ambiguity of
779: * movl (expr) (rn), ...
780: * note that (expr) could also
781: * be (rn) (by special hole in the
782: * grammar), which we ensure
783: * means register indirection, instead
784: * of an expression with value n
785: */
786: if (val != REG && val != REGOP){
787: droppedLP = 1;
788: val = exprparse(val, &(ap->a_xp));
789: droppedLP = 0;
790: goto overdisp;
791: }
792: findreg(regno);
793: shiftover(RP);
794: if (val == PLUS){
795: shift;
796: ap->a_atype = AINCR;
797: } else
798: ap->a_atype = ABASE;
799: ap->a_areg1 = regno;
800: goto index;
801:
802: case LITOP:
803: imm:
804: shift;
805: expr(locxp, val);
806: ap->a_atype = AIMM;
807: ap->a_areg1 = 0;
808: ap->a_xp = locxp;
809: goto index;
810:
811: case MP:
812: shift; /* -(reg) */
813: findreg(regno);
814: shiftover(RP);
815: ap->a_atype = ADECR;
816: ap->a_areg1 = regno;
817: index: /*look for [reg] */
818: if (val == LB){
819: shift;
820: findreg(regno);
821: shiftover(RB);
822: sawindex = 1;
823: ap->a_areg2 = regno;
824: }
825: break;
826:
827: } /*end of the switch to process an arg*/
828: } /*end of processing an argument*/
829:
830: if (sawmul){
831: /*
832: * Make a concession for *(%r)
833: * meaning *0(%r)
834: */
835: if (ap->a_atype == ABASE) {
836: ap->a_atype = ADISP;
837: xp->e_xtype = XABS;
838: xp->e_number = Znumber;
839: xp->e_number.num_tag = TYPL;
840: xp->e_xloc = 0;
841: ap->a_xp = xp++;
842: }
843: ap->a_atype |= ASTAR;
844: sawmul = 0;
845: }
846: if (sawindex){
847: ap->a_atype |= AINDX;
848: sawindex = 0;
849: }
850: ap->a_dispsize = sawsize == 0 ? d124 : sawsize;
851: if (val != CM) break;
852: shiftover(CM);
853: } /*processing all the arguments*/
854:
855: if (argcnt > 6){
856: yyerror("More than 6 arguments");
857: goto errorfix;
858: }
859:
860: /*
861: * See if this is a case instruction,
862: * so we can set up tests on the following
863: * vector of branch displacements
864: */
865: if (yyopcode.Op_eopcode == CORE){
866: switch(yyopcode.Op_popcode){
867: case 0x8f: /* caseb */
868: case 0xaf: /* casew */
869: case 0xcf: /* casel */
870: incasetable++;
871: break;
872: default:
873: incasetable = 0;
874: break;
875: }
876: }
877:
878: insout(yyopcode, arglist,
879: auxval == INSTn ? argcnt : - argcnt);
880: break;
881:
882: case IQUAD: toconv = TYPQ; goto bignumlist;
883: case IOCTA: toconv = TYPO; goto bignumlist;
884:
885: case IFFLOAT: toconv = TYPF; goto bignumlist;
886: case IDFLOAT: toconv = TYPD; goto bignumlist;
887: case IGFLOAT: toconv = TYPG; goto bignumlist;
888: case IHFLOAT: toconv = TYPH; goto bignumlist;
889: bignumlist:
890: /*
891: * eat a list of non 32 bit numbers.
892: * IQUAD and IOCTA can, possibly, return
893: * INT's, if the numbers are "small".
894: *
895: * The value of the numbers is coming back
896: * as an expression, NOT in yybignum.
897: */
898: shift; /* over the opener */
899: if ((val == BIGNUM) || (val == INT)){
900: do{
901: if ((val != BIGNUM) && (val != INT)){
902: ERROR(ty_float[toconv]
903: ? "floating number expected"
904: : "integer number expected" );
905: }
906: dotp->e_xvalue += ty_nbyte[toconv];
907: if (passno == 2){
908: bignumwrite(
909: ((struct exp *)yylval)->e_number,
910: toconv);
911: }
912: xp = explist;
913: shift; /* over this number */
914: if (auxval = (val == CM))
915: shift; /* over the comma */
916: } while (auxval); /* as long as there are commas */
917: }
918: break;
919: /* end of the case for initialized big numbers */
920: } /*end of the switch for looking at each reserved word*/
921:
922: continue;
923:
924: errorfix:
925: /*
926: * got here by either requesting to skip to the
927: * end of this statement, or by erroring out and
928: * wanting to apply panic mode recovery
929: */
930: while ( (val != NL)
931: && (val != SEMI)
932: && (val != PARSEEOF)
933: ){
934: shift;
935: }
936: if (val == NL)
937: lineno++;
938: shift;
939:
940: } /*end of the loop to read the entire file, line by line*/
941:
942: } /*end of yyparse*/
943:
944: /*
945: * Process a register declaration of the form
946: * % <expr>
947: *
948: * Note:
949: * The scanner has already processed funny registers of the form
950: * %dd[+-]*, where dd is a decimal number in the range 00 to 15 (optional
951: * preceding zero digit). If there was any space between the % and
952: * the digit, the scanner wouldn't have recognized it, so we
953: * hack it out here.
954: */
955: inttoktype funnyreg(val, regnoback) /*what the read head will sit on*/
956: inttoktype val; /*what the read head is sitting on*/
957: int *regnoback; /*call by return*/
958: {
959: reg struct exp *locxp;
960: struct exp *loc1xp;
961: struct exp **ptrloc1xp = & loc1xp;
962:
963: expr(locxp, val); /*and leave the current read head with value*/
964: if ( (passno == 2) &&
965: ( (locxp->e_xtype & XTYPE) != XABS
966: || (locxp->e_xvalue < 0)
967: || (locxp->e_xvalue >= 16)
968: )
969: ){
970: yyerror("Illegal register");
971: return(0);
972: }
973: *regnoback = locxp->e_xvalue;
974: return(val);
975: }
976: /*
977: * Shift over error
978: */
979: shiftoerror(token)
980: int token;
981: {
982: char *tok_to_name();
983: yyerror("%s expected", tok_to_name(token));
984: }
985:
986: /*VARARGS1*/
987: yyerror(s, a1, a2,a3,a4,a5)
988: char *s;
989: {
990:
991: #define sink stdout
992:
993: if (anyerrs == 0 && anywarnings == 0 && ! silent)
994: fprintf(sink, "Assembler:\n");
995: anyerrs++;
996: if (silent)
997: return;
998: fprintf(sink, "\"%s\", line %d: ", dotsname, lineno);
999: fprintf(sink, s, a1, a2,a3,a4,a5);
1000: fprintf(sink, "\n");
1001: #undef sink
1002: }
1003:
1004: /*VARARGS1*/
1005: yywarning(s, a1, a2,a3,a4,a5)
1006: char *s;
1007: {
1008: #define sink stdout
1009: if (anyerrs == 0 && anywarnings == 0 && ! silent)
1010: fprintf(sink, "Assembler:\n");
1011: anywarnings++;
1012: if (silent)
1013: return;
1014: fprintf(sink, "\"%s\", line %d: WARNING: ", dotsname, lineno);
1015: fprintf(sink, s, a1, a2,a3,a4,a5);
1016: fprintf(sink, "\n");
1017: #undef sink
1018: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.