![[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] / 43BSDTahoe / lib / old_compiler / as / as.tahoe|
Return to asparse.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)asparse.c 4.17 7/1/83";
6: #endif not lint
7:
8: #include <stdio.h>
9: #include "as.h"
10: #include "asscan.h"
11: #include "assyms.h"
12: #include "asexpr.h"
13:
14: int lgensym[10];
15: char genref[10];
16:
17: long bitfield;
18: int bitoff;
19: int curlen; /* current length of literals */
20: int printblank;
21:
22: /*
23: * The following three variables are communication between various
24: * modules to special case a number of things. They are properly
25: * categorized as hacks.
26: */
27: extern struct symtab *lastnam;/*last name seen by the lexical analyzer*/
28: int exprisname; /*last factor in an expression was a name*/
29: int droppedLP; /*one is analyzing an expression beginning with*/
30: /*a left parenthesis, which has already been*/
31: /*shifted. (Used to parse (<expr>)(rn)*/
32:
33: char yytext[NCPName+2]; /*the lexical image*/
34: int yylval; /*the lexical value; sloppy typing*/
35: u_char yyopcode; /* lexical value for an opcode */
36: Bignum yybignum; /* lexical value for a big number */
37: int num_type; /* type of bignums */
38: /*
39: * Expression and argument managers
40: */
41: struct exp *xp; /*next free expression slot, used by expr.c*/
42: struct exp explist[NEXP]; /*max of 20 expressions in one opcode*/
43: struct arg arglist[NARG]; /*building up operands in instructions*/
44: /*
45: * Sets to accelerate token discrimination
46: */
47: char tokensets[(LASTTOKEN) - (FIRSTTOKEN) + 1];
48:
49: static char UDotsname[64]; /*name of the assembly source*/
50:
51: yyparse()
52: {
53: reg struct exp *locxp;
54: /*
55: * loc1xp and ptrloc1xp are used in the
56: * expression lookahead
57: */
58: struct exp *loc1xp; /*must be non register*/
59: struct exp **ptrloc1xp = & loc1xp;
60: struct exp *pval; /*hacking expr:expr*/
61:
62: reg struct symtab *np;
63: reg int argcnt;
64:
65: reg inttoktype val; /*what yylex gives*/
66: reg inttoktype auxval; /*saves val*/
67:
68: reg struct arg *ap; /*first free argument*/
69:
70: reg struct symtab *p;
71: reg struct symtab *stpt;
72:
73: struct strdesc *stringp; /*handles string lists*/
74:
75: int regno; /*handles arguments*/
76: int *ptrregno = ®no;
77: int sawmul; /*saw * */
78: int sawindex; /*saw [rn]*/
79: int sawsize;
80: int seg_type; /*the kind of segment: data or text*/
81: int seg_number; /*the segment number*/
82: int space_value; /*how much .space needs*/
83: int fill_rep; /*how many reps for .fill */
84: int rep_fill; /*the same - temprary */
85: int fill_size; /*how many bytes for .fill */
86:
87: int field_width; /*how wide a field is to be*/
88: int field_value; /*the value to stuff in a field*/
89: char *stabname; /*name of stab dealing with*/
90: ptrall stabstart; /*where the stab starts in the buffer*/
91: int reloc_how; /* how to relocate expressions */
92: int incasetable; /* set if in a case table */
93: int j, k;
94: char ch;
95: int length; /* for printout */
96: union twolong
97: {
98: long lpart[2];
99: char strpart [8];
100: }fillval;
101:
102:
103: incasetable = 0;
104: xp = explist;
105: ap = arglist;
106:
107: val = yylex();
108:
109: while (val != PARSEEOF){ /* primary loop */
110:
111: while (INTOKSET(val, LINSTBEGIN)){
112: if (val == INT) {
113: int i = ((struct exp *)yylval)->e_xvalue;
114: shift;
115: if (val != COLON){
116: yyerror("Local label %d is not followed by a ':' for a label definition",
117: i);
118: goto errorfix;
119: }
120: if (i < 0 || i > 9) {
121: yyerror("Local labels are 0-9");
122: goto errorfix;
123: }
124: (void)sprintf(yytext, "L%d\001%d", i, lgensym[i]);
125: lgensym[i]++;
126: genref[i] = 0;
127: yylval = (int)*lookup(passno == 1);
128: val = NAME;
129: np = (struct symtab *)yylval;
130: goto restlab;
131: }
132: if (val == NL){
133: lineno++;
134: if (liston && (passno == 2) && (! endofsource))
135: {
136: /* printing previous line & layout */
137: length = strlen (layout);
138: fprintf (listfile, "%*.*s", LHEAD, LHEAD, layout);
139: if (length <= LHEAD+LLEN)
140: j = LLEN;
141: else { /* break line at last blank */
142: j = LHEAD+LLEN;
143: while(j>LHEAD && layout[j]!= ' ')
144: j--;
145: if(j == LHEAD)
146: j = LLEN;
147: else
148: j -= LHEAD;
149: }
150: k = LHEAD+j;
151: fprintf (listfile, "%-*.*s", LLEN, j, &layout[LHEAD]);
152: fprintf (listfile, " ");
153: do {
154: ch = getc (source);
155: putc (ch, listfile);
156: } while (ch != '\n');
157: while (k < length)
158: {
159: fprintf (listfile, "%*s", LHEAD, "");
160: /* break line at last blank */
161: if(layout[k] == ' ')
162: k++;
163: if((j = k+LLEN) >= length)
164: j = length;
165: else
166: while(j>k && layout[j]!= ' ')
167: j--;
168: if(j == k)
169: j = LLEN;
170: else
171: j -= k;
172: fprintf (listfile, "%-*.*s\n", j, j, &layout[k]);
173: k += j;
174: }
175: k = 0;
176: while (layout[k] != '\0')
177: layout[k++] = '\0';
178: ch = getc (source);
179: if (ch == EOF)
180: {
181: if (ind == ninfiles)
182: endofsource = 1;
183: else
184: {
185: source = fopen (innames[ind++], "r");
186: lineno = 1;
187: }
188: }
189: else
190: ungetc (ch, source);
191: layoutpos = layout;
192: (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: switch(stpt->s_ptype){
707: case N_LCSYM:
708: stpt->s_dest = (struct symtab *)exprisname;
709: stpt->s_type |= STABFLAG;
710: case N_GSYM:
711: case N_FNAME:
712: case N_RSYM:
713: case N_SSYM:
714: case N_LSYM:
715: case N_PSYM:
716: case N_BCOMM:
717: case N_ECOMM:
718: case N_LENG:
719: stpt->s_tag = STABFIXED;
720: break;
721: default:
722: stpt->s_tag = STABFLOATING;
723: break;
724: }
725: } else
726: stpt->s_tag = STABFIXED;
727: }
728: else { /*really have a name*/
729: stpt->s_dest = locxp->e_xname;
730: stpt->s_index = p->s_index;
731: stpt->s_type = p->s_type | STABFLAG;
732: /*
733: * We will assign a more accruate
734: * guess of locxp's location when
735: * we sort the symbol table
736: * The final value of value is
737: * given by stabfix()
738: */
739: /*
740: * For exprs of the form (name + value) one needs to remember locxp->e_xvalue
741: * for use in stabfix. The right place to keep this is in stpt->s_value
742: * however this gets corrupted at an unknown point.
743: * As a bandaid hack the value is preserved in s_desc and s_other (a
744: * short and a char). This destroys these two values and will
745: * be fixed. May 19 ,1983 Alastair Fyfe
746: */
747: if(locxp->e_xvalue) {
748: stpt->s_other = (locxp->e_xvalue >> 16);
749: stpt->s_desc = (locxp->e_xvalue & 0x0000ffff);
750: stpt->s_tag = STABFLOATING;
751: }
752: }
753: /*
754: * tokptr now points at one token beyond
755: * the current token stored in val and yylval,
756: * which are the next tokens after the end of
757: * this .stab directive. This next token must
758: * be either a SEMI or NL, so is of width just
759: * one. Therefore, to point to the next token
760: * after the end of this stab, just back up one..
761: */
762: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype));
763: break; /*end of the .stab*/
764:
765: case ISTABDOT:
766: stabname = ".stabd";
767: stpt = (struct symtab *)yylval;
768: /*
769: * We clobber everything after the
770: * .stabd and its pointer... we MUST
771: * be able to get back to this .stabd
772: * so that we can resolve its final value
773: */
774: stabstart = tokptr;
775: shift; /*over the ISTABDOT*/
776: if (passno == 1){
777: expr(locxp, val);
778: if (! (locxp->e_xvalue & STABTYPS)){
779: yyerror("Invalid type in .stabd");
780: goto errorfix;
781: }
782: stpt->s_ptype = locxp->e_xvalue;
783: shiftover(CM);
784: expr(locxp, val);
785: stpt->s_other = locxp->e_xvalue;
786: shiftover(CM);
787: expr(locxp, val);
788: stpt->s_desc = locxp->e_xvalue;
789: /*
790: *
791: * Now, clobber everything but the
792: * .stabd pseudo and the pointer
793: * to its symbol table entry
794: * tokptr points to the next token,
795: * build the skip up to this
796: */
797: buildskip(stabstart, (bytetoktype *)tokptr - sizeof(bytetoktype));
798: }
799: /*
800: * pass 1: Assign a good guess for its position
801: * (ensures they are sorted into right place)/
802: * pass 2: Fix the actual value
803: */
804: stpt->s_value = dotp->e_xvalue;
805: stpt->s_index = dotp - usedot;
806: stpt->s_tag = STABFLOATING; /*although it has no effect in pass 2*/
807: break;
808:
809: case ISTABNONE: stabname = ".stabn"; goto shortstab;
810:
811: case ISTABSTR: stabname = ".stabs";
812: shortstab:
813: auxval = val;
814: if (passno == 2) goto errorfix;
815: stpt = (struct symtab *)yylval;
816: stabstart = tokptr;
817: (bytetoktype *)stabstart -= sizeof(struct symtab *);
818: (bytetoktype *)stabstart -= sizeof(bytetoktype);
819: shift;
820: if (auxval == ISTABSTR){
821: stringp = (struct strdesc *)yylval;
822: shiftover(STRING);
823: stpt->s_name = (char *)stringp;
824: /*
825: * We want the trailing null included in this string.
826: * We utilize the cheat the string scanner used,
827: * and merely increment the string length
828: */
829: stringp->sd_strlen += 1;
830: shiftover(CM);
831: } else {
832: stpt->s_name = (char *)savestr("\0", 0, STR_BOTH);
833: }
834: goto tailstab;
835: break;
836:
837: case ICOMM: /* .comm <name> , <expr> */
838: case ILCOMM: /* .lcomm <name> , <expr> */
839: auxval = val;
840: shift;
841: np = (struct symtab *)yylval;
842: shiftover(NAME);
843: shiftover(CM);
844: expr(locxp, val);
845:
846: if ( (locxp->e_xtype & XTYPE) != XABS) /* tekmdp */
847: yyerror("comm size not absolute");
848: if (passno == 1 && (np->s_type&XTYPE) != XUNDEF)
849: yyerror("Redefinition of %s", FETCHNAME(np));
850: if (passno==1) {
851: np->s_value = locxp->e_xvalue;
852: if (auxval == ICOMM)
853: np->s_type |= XXTRN;
854: else {
855: np->s_type &= ~XTYPE;
856: np->s_type |= XBSS;
857: }
858: }
859: break;
860:
861: case IALIGN: /* .align <expr> */
862: stpt = (struct symtab *)yylval;
863: shift;
864: expr(locxp, val);
865: if ((dotp->e_xtype & XTYPE) == XDATA)
866: djalign(locxp, stpt);
867: else
868: jalign(locxp, stpt);
869: break;
870:
871: case INST0: /* instructions w/o arguments*/
872: incasetable = 0;
873: insout(yyopcode, (struct arg *)0, 0);
874: shift;
875: break;
876:
877: case INSTn: /* instructions with arguments*/
878: case IJXXX: /* UNIX style jump instructions */
879: auxval = val;
880: /*
881: * Code to process an argument list
882: */
883: ap = arglist;
884: xp = explist;
885:
886: shift; /* bring in the first token for the arg list*/
887:
888: for (argcnt = 1; argcnt <= 6; argcnt++, ap++){
889: /*
890: * code to process an argument proper
891: */
892: sawindex = sawmul = sawsize = 0;
893: {
894: switch(val) {
895:
896: default:
897: disp:
898: if( !(INTOKSET(val,
899: EBEGOPS
900: +YUKKYEXPRBEG
901: +SAFEEXPRBEG)) ) {
902: ERROR("expression expected");
903: }
904: expr(ap->a_xp,val);
905: overdisp:
906: if ( val == LP || sawsize){
907: shiftover(LP);
908: findreg(regno);
909: shiftover(RP);
910: ap->a_atype = ADISP;
911: ap->a_areg1 = regno;
912: } else {
913: ap->a_atype = AEXP;
914: ap->a_areg1 = 0;
915: }
916: goto index;
917:
918: case SIZESPEC:
919: sizespec:
920: sawsize = yylval;
921: shift;
922: goto disp;
923:
924: case REG:
925: case REGOP:
926: findreg(regno);
927: ap->a_atype = AREG;
928: ap->a_areg1 = regno;
929: break;
930:
931: case MUL:
932: sawmul = 1;
933: shift;
934: if (val == LP) goto base;
935: if (val == LITOP) goto imm;
936: if (val == SIZESPEC) goto sizespec;
937: if (INTOKSET(val,
938: EBEGOPS
939: +YUKKYEXPRBEG
940: +SAFEEXPRBEG)) goto disp;
941: ERROR("expression, '(' or '$' expected");
942: break;
943:
944: case LP:
945: base:
946: shift; /*consume the LP*/
947: /*
948: * hack the ambiguity of
949: * movl (expr) (rn), ...
950: * note that (expr) could also
951: * be (rn) (by special hole in the
952: * grammar), which we ensure
953: * means register indirection, instead
954: * of an expression with value n
955: */
956: if (val != REG && val != REGOP){
957: droppedLP = 1;
958: val = exprparse(val, &(ap->a_xp));
959: droppedLP = 0;
960: goto overdisp;
961: }
962: findreg(regno);
963: shiftover(RP);
964: if (val == PLUS){
965: shift;
966: ap->a_atype = AINCR;
967: if (sawmul && regno != 0xE)
968: yyerror ("Autoincrement deferred register must be SP");
969: if (!(sawmul || regno == 0xE))
970: yyerror ("Autoincrement register must be SP");
971: } else
972: ap->a_atype = ABASE;
973: ap->a_areg1 = regno;
974: goto index;
975:
976: case LITOP:
977: imm:
978: shift;
979: expr(locxp, val);
980: ap->a_atype = AIMM;
981: ap->a_areg1 = 0;
982: ap->a_xp = locxp;
983: goto index;
984:
985: case MP:
986: shift; /* -(reg) */
987: findreg(regno);
988: if (regno != 0xE)
989: yyerror ("Autodecrement register must be SP");
990: shiftover(RP);
991: ap->a_atype = ADECR;
992: ap->a_areg1 = regno;
993: index: /*look for [reg] */
994: if (val == LB){
995: shift;
996: findreg(regno);
997: shiftover(RB);
998: sawindex = 1;
999: ap->a_areg2 = regno;
1000: }
1001: break;
1002:
1003: } /*end of the switch to process an arg*/
1004: } /*end of processing an argument*/
1005:
1006: if (sawmul){
1007: /*
1008: * Make a concession for *(%r)
1009: * meaning *0(%r)
1010: */
1011: if (ap->a_atype == ABASE) {
1012: ap->a_atype = ADISP;
1013: xp->e_xtype = XABS;
1014: xp->e_number = Znumber;
1015: xp->e_number.num_tag = TYPL;
1016: xp->e_xloc = 0;
1017: ap->a_xp = xp++;
1018: }
1019: ap->a_atype |= ASTAR;
1020: sawmul = 0;
1021: }
1022: if (sawindex){
1023: ap->a_atype |= AINDX;
1024: sawindex = 0;
1025: }
1026: ap->a_dispsize = sawsize == 0 ? d124 : sawsize;
1027: if (val != CM) break;
1028: shiftover(CM);
1029: } /*processing all the arguments*/
1030:
1031: if (argcnt > 6){
1032: yyerror("More than 6 arguments");
1033: goto errorfix;
1034: }
1035:
1036: /*
1037: * See if this is a case instruction,
1038: * so we can set up tests on the following
1039: * vector of branch displacements
1040: */
1041: if (yyopcode == 0xfc) /* 'casel' instruction */
1042: incasetable++;
1043: else
1044: incasetable = 0;
1045:
1046: insout(yyopcode, arglist,
1047: auxval == INSTn ? argcnt : - argcnt);
1048: break;
1049:
1050: case IQUAD: num_type = TYPQ; goto bignumlist;
1051: case IFFLOAT: num_type = TYPF; goto bignumlist;
1052: case IDFLOAT: num_type = TYPD;
1053: bignumlist:
1054: /*
1055: * eat a list of non 32 bit numbers.
1056: * IQUAD can, possibly, return
1057: * INT's, if the numbers are "small".
1058: *
1059: * The value of the numbers is coming back
1060: * as an expression, NOT in yybignum.
1061: */
1062: shift; /* over the opener */
1063: if ((val == BIGNUM) || (val == INT)){
1064: do{
1065: if ((val != BIGNUM) && (val != INT)){
1066: ERROR(ty_float[num_type]
1067: ? "floating number expected"
1068: : "integer number expected" );
1069: }
1070: dotp->e_xvalue += ty_nbyte[num_type];
1071: if (passno == 2){
1072: switch (num_type) {
1073: case TYPF:
1074: bwrite(&((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong,
1075: ty_nbyte[num_type], txtfil);
1076: if (liston)
1077: {
1078: long_out(((struct exp *)yylval)->e_number.num_num.numFf_float.Ff_ulong[0]);
1079: *layoutpos++ = ' ';
1080: }
1081: break;
1082: case TYPD:
1083: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[0],
1084: sizeof (long), txtfil);
1085: bwrite(&((struct exp *)yylval)->e_number.num_num.numFd_float.Fd_ulong[1],
1086: sizeof (long), txtfil);
1087: if (liston)
1088: {
1089: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]);
1090: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]);
1091: *layoutpos++ = ' ';
1092: }
1093: break;
1094: case TYPQ:
1095: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1],
1096: sizeof (long), txtfil);
1097: bwrite(&((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0],
1098: sizeof (long), txtfil);
1099: if (liston)
1100: {
1101: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[1]);
1102: long_out(((struct exp *)yylval)->e_number.num_num.numIq_int.Iq_ulong[0]);
1103: *layoutpos++ = ' ';
1104: }
1105: break;
1106: }
1107: }
1108: xp = explist;
1109: shift; /* over this number */
1110: if (auxval = (val == CM))
1111: shift; /* over the comma */
1112: } while (auxval); /* as long as there are commas */
1113: }
1114: break;
1115: /* end of the case for initialized big numbers */
1116: } /*end of the switch for looking at each reserved word*/
1117:
1118: continue;
1119:
1120: errorfix:
1121: /*
1122: * got here by either requesting to skip to the
1123: * end of this statement, or by erroring out and
1124: * wanting to apply panic mode recovery
1125: */
1126: while ( (val != NL)
1127: && (val != SEMI)
1128: && (val != PARSEEOF)
1129: ){
1130: shift;
1131: }
1132: if (val == NL)
1133: lineno++;
1134: shift;
1135:
1136: } /*end of the loop to read the entire file, line by line*/
1137:
1138: } /*end of yyparse*/
1139:
1140: /*
1141: * Process a register declaration of the form
1142: * % <expr>
1143: *
1144: * Note:
1145: * The scanner has already processed funny registers of the form
1146: * %dd[+-]*, where dd is a decimal number in the range 00 to 15 (optional
1147: * preceding zero digit). If there was any space between the % and
1148: * the digit, the scanner wouldn't have recognized it, so we
1149: * hack it out here.
1150: */
1151: inttoktype funnyreg(val, regnoback) /*what the read head will sit on*/
1152: inttoktype val; /*what the read head is sitting on*/
1153: int *regnoback; /*call by return*/
1154: {
1155: reg struct exp *locxp;
1156: struct exp *loc1xp;
1157: struct exp **ptrloc1xp = & loc1xp;
1158:
1159: expr(locxp, val); /*and leave the current read head with value*/
1160: if ( (passno == 2) &&
1161: ( (locxp->e_xtype & XTYPE) != XABS
1162: || (locxp->e_xvalue < 0)
1163: || (locxp->e_xvalue >= 16)
1164: )
1165: ){
1166: yyerror("Illegal register");
1167: return(0);
1168: }
1169: *regnoback = locxp->e_xvalue;
1170: return(val);
1171: }
1172: /*
1173: * Shift over error
1174: */
1175: shiftoerror(token)
1176: int token;
1177: {
1178: char *tok_to_name();
1179: yyerror("%s expected", tok_to_name(token));
1180: }
1181:
1182: /*VARARGS1*/
1183: yyerror(s, a1, a2,a3,a4,a5)
1184: char *s;
1185: {
1186:
1187: #define sink stdout
1188:
1189: if (anyerrs == 0 && anywarnings == 0 && ! silent)
1190: fprintf(sink, "Assembler:\n");
1191: anyerrs++;
1192: if (silent)
1193: return;
1194: fprintf(sink, "\"%s\", line %d: ", dotsname, lineno);
1195: fprintf(sink, s, a1, a2,a3,a4,a5);
1196: fprintf(sink, "\n");
1197: #undef sink
1198: }
1199:
1200: /*VARARGS1*/
1201: yywarning(s, a1, a2,a3,a4,a5)
1202: char *s;
1203: {
1204: #define sink stdout
1205: if (anyerrs == 0 && anywarnings == 0 && ! silent)
1206: fprintf(sink, "Assembler:\n");
1207: anywarnings++;
1208: if (silent)
1209: return;
1210: fprintf(sink, "\"%s\", line %d: WARNING: ", dotsname, lineno);
1211: fprintf(sink, s, a1, a2,a3,a4,a5);
1212: fprintf(sink, "\n");
1213: #undef sink
1214: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.