![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to assyms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / as|
Return to assyms.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / as |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include <stdio.h>
3: #include "as.h"
4: #include "assyms.h"
5:
6: struct allocbox *allochead;
7: struct allocbox *alloctail;
8: struct symtab *nextsym;
9: struct allocbox *newbox;
10: char *namebuffer;
11: int symsleft;
12:
13: symtabinit()
14: {
15: allochead = 0;
16: alloctail = 0;
17: nextsym = 0;
18: symsleft = 0;
19: }
20:
21: /*
22: * Install all known instructions in the symbol table
23: */
24: syminstall()
25: {
26: register struct instab *ip;
27: register struct symtab **hp;
28: register char *p1, *p2;
29:
30: for (ip=instab; ip->name[0]!=0; ip++) {
31: p1 = ip->name;
32: p2 = yytext;
33: while (*p2++ = *p1++);
34: hp = lookup(0); /* 0 => don't install this*/
35: if (*hp==NULL) {
36: *hp = (struct symtab *)ip;
37: if ( (ip->tag!=INSTn)
38: && (ip->tag!=INST0)
39: && (ip->tag!=0))
40: continue; /* was pseudo-op */
41: itab[ip->opcode & 0xFF] = ip;
42: }
43: }
44: } /*end of syminstall*/
45:
46:
47: /*
48: * Assign final values to symbols,
49: * and overwrite the index field with its relative position in
50: * the symbol table we give to the loader.
51: */
52: extern struct hdr hdr;
53:
54: freezesymtab()
55: {
56: register struct symtab *sp;
57: long bs;
58: register int relpos = 0;
59: #ifdef SORTEDOUTPUT
60: register struct symtab **cosp;
61: #else
62: register struct symtab *ubsp;
63: register struct allocbox *allocwalk;
64: #endif
65:
66: #ifdef SORTEDOUTPUT
67: SYMITERATE(cosp, sp)
68: #else
69: DECLITERATE(allocwalk, sp, ubsp)
70: #endif
71: {
72: if (sp->tag >= IGNOREBOUND)
73: continue; /*totally ignore jxxx entries */
74: /*
75: * Ignore stabs, but give them a symbol table index
76: */
77: if (sp->type & STABFLAG)
78: goto assignindex;
79: if ((sp->type&XTYPE)==XUNDEF)
80: sp->type = XXTRN+XUNDEF;
81: else if ((sp->type&XTYPE)==XDATA)
82: sp->value += usedot[sp->index].xvalue;
83: else if ((sp->type&XTYPE)==XTEXT)
84: sp->value += usedot[sp->index].xvalue;
85: else if ((sp->type&XTYPE)==XBSS) {
86: bs = sp->value;
87: sp->value = hdr.bsize + datbase;
88: hdr.bsize += bs;
89: }
90: assignindex:
91: if ( (sp->name[0] != 'L')
92: || (sp->tag != LABELID)
93: || savelabels
94: ) /*then, we will write it later on*/
95: sp->index = relpos++;
96: }
97: }
98:
99:
100:
101: /*
102: * For all of the stabs that had their final value undefined during pass 1
103: * and during pass 2 assign a final value.
104: * We have already given stab entrys a initial approximation
105: * when we constsructed the sorted symbol table.
106: * Iteration order doesn't matter.
107: */
108: stabfix() {
109: register struct symtab *sp, **cosp;
110: register struct symtab *p;
111:
112: SYMITERATE(cosp, sp){
113: if(sp->ptype && (sp->type & STABFLAG)) {
114: p = sp->dest;
115: sp->value = p->value;
116: sp->index = p->index;
117: sp->type = p->type;
118: #ifdef DSTAB
119: printf("STABFIX: %s (old %s) to %d offsets %d %d\n",
120: sp->name, p->name, sp->value, sp, p);
121: #endif
122: }
123: }
124: }
125:
126: char *Calloc(number, size)
127: int number, size;
128: {
129: register char *newstuff;
130: newstuff = (char *)sbrk(number*size);
131: if ((int)newstuff == -1){
132: yyerror("Ran out of Memory");
133: delexit();
134: }
135: return(newstuff);
136: }
137:
138: struct symtab * symalloc()
139: {
140: if (symsleft == 0){
141: register int *p;
142:
143: newbox = (struct allocbox *)Calloc(1,ALLOCQTY);
144: symsleft = SYMDALLOP;
145: nextsym = &newbox->symslots[0];
146: namebuffer = &newbox->symnames[0];
147: p = (int *)(&newbox->symnames[SYMDALLOP * NCPS]);
148: while ( p > (int *)newbox){
149: *--p = 0;
150: }
151: if (alloctail == 0){
152: allochead = alloctail = newbox;
153: } else {
154: alloctail->nextalloc = newbox;
155: alloctail = newbox;
156: }
157: }
158: --symsleft;
159: ++nsyms;
160: nextsym->name = namebuffer;
161: namebuffer += NCPS;
162: return(nextsym++);
163: }
164:
165: symcmp(pptr, qptr)
166: struct symtab **pptr, **qptr;
167: {
168: register struct symtab *p = *pptr;
169: register struct symtab *q = *qptr;
170: if (p->index < q->index)
171: return(-1);
172: if (p->index > q->index)
173: return(1);
174: if (p->value < q->value)
175: return(-1);
176: if (p->value > q->value)
177: return(1);
178: /*
179: * Force jxxx entries to virtually preceed labels defined
180: * to follow the jxxxx instruction, so that bumping the
181: * jxxx instruction correctly fixes up the following labels
182: */
183: if (p->tag >= IGNOREBOUND) /*p points to a jxxx*/
184: return(-1);
185: if (q->tag >= IGNOREBOUND)
186: return(1);
187: /*
188: * both are now just plain labels; the relative order doesn't
189: * matter. Both can't be jxxxes, as they would have different
190: * values.
191: */
192: return(0);
193: } /*end of symcmp*/
194:
195: /*
196: * We construct the auxiliary table of pointers, symptrs and
197: * symdelim
198: * We also assign preliminary values to stab entries that did not yet
199: * have an absolute value (because they initially referred to
200: * forward references). We don't worry about .stabds, as they
201: * already have an estimated final value
202: */
203:
204: sortsymtab()
205: {
206: register struct symtab *sp;
207: register struct symtab **cowalk;
208: register struct allocbox *allocwalk;
209: struct symtab *ubsp;
210: int segno;
211: int slotno;
212: int symsin; /*number put into symptrs*/
213:
214: symptrs = (struct symtab **)Calloc(nsyms + 2, sizeof *symptrs);
215: /*
216: * Allocate one word at the beginning of the symptr array
217: * so that backwards scans through the symptr array will
218: * work correctly while scanning through the zeroth segment
219: */
220: *symptrs++ = 0;
221: cowalk = symptrs;
222: symsin = 0;
223: DECLITERATE(allocwalk, sp, ubsp) {
224: if (sp->ptype && (sp->type &STABFLAG)){
225: sp->value = sp->dest->value;
226: sp->index = sp->dest->index;
227: }
228: if (symsin >= nsyms)
229: yyerror("INTERNAL ERROR: overfilled symbol table indirection table");
230: *cowalk++ = sp;
231: symsin++;
232: }
233: if (symsin != nsyms)
234: yyerror("INTERNAL ERROR: installed %d syms, should have installed %d",
235: symsin, nsyms);
236: symptrub = &symptrs[nsyms ];
237: qsort(symptrs, nsyms, sizeof *symptrs, symcmp);
238: symdelim[0] = symptrs;
239: for (cowalk = symptrs, sp = *cowalk, segno = 0, slotno = 1;
240: segno < NLOC + NLOC;
241: segno++, slotno++){
242: for (; sp && sp->index == segno; sp = *++cowalk);
243: symdelim[slotno] = cowalk; /*forms the ub delimeter*/
244: }
245: } /*end of sortsymtab*/
246:
247: #ifdef DEBUG
248: dumpsymtab()
249: {
250: register int segno;
251: register struct symtab *sp, **cosp, *ub;
252: char *tagstring();
253:
254: printf("Symbol Table dump:\n");
255: for (segno = 0; segno < NLOC + NLOC; segno++){
256: printf("Segment number: %d\n", segno);
257: SEGITERATE(segno, 0, 0, cosp, sp, ub, ++){
258: printf("\tSeg: %d \"%8.8s\" value: %d index: %d tag %s\n",
259: segno, sp->name, sp->value, sp->index, tagstring(sp->tag));
260: printf("\t\ttype: %d jxbump %d jxfear: %d\n",
261: sp->type, sp->jxbump, sp->jxfear);
262: }
263: printf("\n\n");
264: }
265: }
266:
267: static char tagbuff[4];
268:
269: char *tagstring(tag)
270: unsigned char tag;
271: {
272: switch(tag){
273: case JXACTIVE: return("active");
274: case JXNOTYET: return("notyet");
275: case JXALIGN: return("align");
276: case JXQUESTIONABLE: return("jxquestionable");
277: case JXINACTIVE: return("inactive");
278: case JXTUNNEL: return("tunnel");
279: case OBSOLETE: return("obsolete");
280: case IGNOREBOUND: return("ignorebound");
281: case STABFLOATING: return("stabfloating");
282: case STABFIXED: return("stabfixed");
283: case LABELID: return("labelid");
284: case OKTOBUMP: return("oktobump");
285: case ISET: return("iset");
286: case ILSYM: return("ilsym");
287: default: sprintf(tagbuff,"%d", tag);
288: return(tagbuff);
289: }
290: }
291: #endif
292:
293: #define HASHCLOGGED (NHASH * 3 ) / 4
294:
295: struct symtab **lookup(instflg)
296: int instflg; /* 0: don't install */
297: {
298: register int ihash;
299: register struct symtab **hp;
300: register char *p1, *p2;
301: register int i;
302:
303: #ifdef METRIC
304: nhashed++;
305: #endif
306:
307: /*
308: * All strings passed in in yytext had better have
309: * a trailing null. Strings are placed in yytext for
310: * hashing by syminstall() and yylex()
311: */
312: for (ihash = 0, p1 = yytext ; *p1; ihash <<= 2, ihash += *p1++);
313: ihash += p1[-1] << 5;
314: ihash %= NHASH;
315: if (ihash < 0) ihash += NHASH;
316: hp = &hshtab[ihash];
317: ihash = 1; /*now, it counts the number of times we rehash*/
318: while (*hp) {
319: p1 = yytext;
320: p2 = (*hp)->name;
321: for (i = 0; (i<NCPS) && *p1; i++)
322: if (*p1++ != *p2++)
323: goto no;
324: if (i >= NCPS) /*both symbols are maximal length*/
325: return(hp);
326: if (*p2 == 0) /*assert *p1 == 0*/
327: return(hp);
328: no:
329: #ifdef METRIC
330: nhcollisions++;
331: #endif
332: hp += ihash;
333: ihash += 2;
334: if (hp >= &hshtab[NHASH])
335: hp -= NHASH;
336: }
337: if(++hshused >= HASHCLOGGED) {
338: yyerror("Symbol table overflow");
339: delexit();
340: }
341: if (instflg) {
342: #ifdef METRIC
343: nentered++;
344: #endif
345: *hp = symalloc();
346: p1 = yytext;
347: p2 = (*hp)->name;
348: while (*p2++ = *p1++);
349: }
350: return(hp);
351: } /*end of symlook*/
352:
353: #ifdef vax
354: #define writel(p,n,f) fwrite((long)p, sizeof (long), n, f)
355: #else
356: writel(p,n,f)
357: long *p;
358: FILE *f;
359: {
360: while (n--) {
361: fwrite(&(*p).loword,2,1,f);
362: fwrite(&(*p).hiword,2,1,f);
363: p++;
364: }
365: }
366: #endif
367:
368: int reflen[] = {0,0,1,1,2,2,4,4,8,8};
369:
370: /*
371: * Save the relocation information
372: */
373: outrel(pval,reftype,reltype,xsym)
374: long *pval;
375: register int reftype,reltype;
376: struct symtab *xsym;
377: {
378:
379: /*
380: * reftype: PCREL or not, plus length LEN1, LEN2, LEN4, LEN8
381: * reltype: csect ("segment") number (XTEXT, XDATA, ...) associated with 'val'
382: * xsym: symbol table pointer
383: */
384: long ts;
385: char tc;
386: long tl;
387: short t;
388: if (passno!=2) {
389: dotp->xvalue += reflen[reftype];
390: return;
391: }
392: if (bitoff&07)
393: yyerror("Padding error");
394: reltype &= ~XFORW;
395: if (reltype == XUNDEF)
396: yyerror("Undefined reference");
397: if (reltype != XABS || reftype & PCREL) {
398: /* write the address portion of a relocation datum */
399: if (dotp >= &usedot[NLOC]) {
400: hdr.drsize += sizeof(dotp->xvalue) + 3 + sizeof tc;
401: tl = dotp->xvalue-datbase;
402: writel(&tl,1,relfil);
403: } else {
404: hdr.trsize += sizeof(dotp->xvalue) + 3 + sizeof tc;
405: writel(&dotp->xvalue,1,relfil);
406: }
407: /* write the properties portion of a relocation datum */
408: if (reltype == XXTRN+XUNDEF) {
409: ts = (xsym->index);
410: tc = (XXTRN<<3) | (reftype-LEN1);
411: } else if ((reltype&XTYPE) == XUNDEFO) {
412: ts = (xsym->index);
413: tc = ((XXTRN+2)<<3) | (reftype-LEN1);
414: } else {
415: ts = (reltype);
416: tc = (reftype-LEN1);
417: }
418: fwrite((char *)&ts, 3, 1, relfil);
419: fwrite(&tc, sizeof(tc), 1, relfil);
420: }
421: /* write the raw ("unrelocated") value to the text file */
422: t = reflen[reftype];
423: dotp->xvalue += t;
424: if (reftype & PCREL)
425: *pval -= dotp->xvalue;
426: #ifdef vax
427: fwrite(pval,1,t,txtfil);
428: #else
429: if (t>2) {
430: fwrite(&((*pval).loword),1,2,txtfil);
431: fwrite(&((*pval).hiword),1,t-2,txtfil);
432: } else fwrite(&((*pval).loword),1,t,txtfil);
433: #endif
434: }
435:
436:
437: /*
438: * Write out n symbols to file f, beginning at p
439: * ignoring symbols that are obsolete, jxxx instructions, and
440: * possibly, labels
441: */
442:
443: int sizesymtab()
444: {
445: struct symtab *sp;
446:
447: #define NOUTSYMS (nsyms - njxxx - nforgotten - (savelabels ? 0 : nlabels))
448:
449: return (
450: ( NCPS
451: + sizeof (sp->ptype)
452: + sizeof (sp->other)
453: + sizeof (sp->desc)
454: + sizeof (sp->value)
455: )
456: * NOUTSYMS
457: );
458: }
459:
460: symwrite(f)
461: FILE *f;
462: {
463: int symsout; /*those actually written*/
464: int symsdesired = NOUTSYMS;
465: register struct symtab *sp, *ub;
466: #ifdef SORTEDOUTPUT
467: int segno;
468: register struct symtab **copointer;
469: #else
470: register struct allocbox *allocwalk;
471: #endif
472:
473: #ifdef SORTEDOUTPUT
474: for (segno = 0, symsout = 0; segno < NLOC + NLOC; segno++)
475: SEGITERATE(segno, 0, 0, copointer, sp, ub, ++)
476: #else
477: symsout = 0;
478: DECLITERATE(allocwalk, sp, ub)
479: #endif
480: {
481: if (sp->tag >= IGNOREBOUND)
482: continue;
483: if ((sp->name[0] == 'L') && (sp->tag == LABELID) && !savelabels)
484: continue;
485: symsout++;
486: fwrite(sp->name, NCPS, 1, f);
487: sp->type &= ~XFORW;
488: fwrite((sp->ptype) ? (char *)(&(sp->ptype)) : (char *)(&(sp->type)),
489: sizeof(char), 1, f);
490: /*
491: * WATCH OUT. THIS DEPENDS THAT THE ALLOCATION OF
492: * the four fields ptype, other, desc and value are
493: * contiguous. This may have to be changed!
494: * This is safe (as of 2-Nov-79).
495: */
496: fwrite(&(sp->other),
497: sizeof (sp->other)
498: + sizeof (sp->desc)
499: + sizeof (sp->value), 1, f
500: );
501: #ifdef fooie
502: #ifdef vax
503: fwrite(&(sp->name[0]), sizeof(symtab[0].name), 1, f);
504: fwrite(sp->ptype ? &(sp->ptype) : &(sp->type),
505: sizeof(symtab[0].type), 1, f);
506: fwrite(&(sp->other), sizeof(symtab[0].other), 1, f);
507: fwrite(&(sp->desc), sizeof(symtab[0].desc), 1, f);
508: fwrite(&(sp->value), sizeof(symtab[0].value), 1, f);
509: #else
510: writel(&(p->value), 1, f);
511: #endif
512: #endif
513: }
514: if (symsout != symsdesired)
515: yyerror("INTERNAL ERROR: Wrote %d symbols, wanted to write %d symbols\n",
516: symsout, symsdesired);
517: }
518:
519: Flushfield(n)
520: register int n;
521: {
522: while (n>0) {
523: outb(bitfield);
524: bitfield >>= 8;
525: n -= 8;
526: }
527: bitoff=0;
528: bitfield=0;
529: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.