![[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] / 43BSDReno / pgrm / as.tahoe|
Return to assyms.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)assyms.c 4.14 8/11/83";
6: #endif not lint
7:
8: #include <stdio.h>
9: #include <ctype.h>
10: #include "as.h"
11: #include "asscan.h"
12: #include "assyms.h"
13:
14: /*
15: * Managers for chunks of symbols allocated from calloc()
16: * We maintain a linked list of such chunks.
17: *
18: */
19: struct allocbox *allochead; /*head of chunk list*/
20: struct allocbox *alloctail; /*tail*/
21: struct allocbox *newbox; /*for creating a new chunk*/
22: struct symtab *nextsym; /*next symbol free*/
23: int symsleft; /*slots left in current chunk*/
24:
25: struct symtab **symptrs;
26: struct symtab **symdelim[NLOC + NLOC +1];
27: struct symtab **symptrub;
28: /*
29: * Managers for the dynamically extendable hash table
30: */
31: struct hashdallop *htab;
32:
33: Iptr itab[NINST]; /*maps opcodes to instructions*/
34: /*
35: * Counts what went into the symbol table, so that the
36: * size of the symbol table can be computed.
37: */
38: int nsyms; /* total number in the symbol table */
39: int njxxx; /* number of jxxx entrys */
40: int nforgotten; /* number of symbols erroneously entered */
41: int nlabels; /* number of label entries */
42:
43: /*
44: * Managers of the symbol literal storage.
45: */
46: struct strpool *strplhead = 0;
47:
48: symtabinit()
49: {
50: allochead = 0;
51: alloctail = 0;
52: nextsym = 0;
53: symsleft = 0;
54: strpoolalloc(); /* get the first strpool storage area */
55: htab = 0;
56: htaballoc(); /* get the first part of the hash table */
57: }
58:
59: /*
60: * Install all known instructions in the symbol table
61: */
62: syminstall()
63: {
64: register Iptr ip;
65: register struct symtab **hp;
66: register char *p1, *p2;
67: register int i;
68:
69: for (i = 0; i < NINST; i++)
70: itab[i] = (Iptr)0xAAAAAAAA;
71:
72: for (ip = (Iptr)instab; FETCHNAME(ip)[0]; ip++) {
73: p1 = FETCHNAME(ip);
74: p2 = yytext;
75: while (*p2++ = *p1++);
76: hp = lookup(0); /* 0 => don't install this*/
77: if (*hp==NULL) {
78: *hp = (struct symtab *)ip;
79: if ( (ip->s_tag!=INSTn)
80: && (ip->s_tag!=INST0)
81: && (ip->s_tag!=0))
82: continue; /* was pseudo-op */
83: itab[ip->i_opcode & 0xFF] = ip;
84: }
85: }
86: } /*end of syminstall*/
87:
88: #define ISLABEL(sp) \
89: ( (!savelabels) \
90: && (sp->s_tag == LABELID) \
91: && (STRPLACE(sp) & STR_CORE) \
92: && (FETCHNAME(sp)[0] == 'L'))
93: /*
94: * Assign final values to symbols,
95: * and overwrite the index field with its relative position in
96: * the symbol table we give to the loader.
97: */
98: extern struct exec hdr;
99:
100: freezesymtab()
101: {
102: register struct symtab *sp;
103: long bs;
104: register int relpos = 0;
105: register struct symtab *ubsp;
106: register struct allocbox *allocwalk;
107:
108: DECLITERATE(allocwalk, sp, ubsp)
109: {
110: if (sp->s_tag >= IGNOREBOUND)
111: continue; /*totally ignore jxxx entries */
112: /*
113: * Ignore stabs, but give them a symbol table index
114: */
115: if (sp->s_type & STABFLAG)
116: goto assignindex;
117: if ((sp->s_type&XTYPE)==XUNDEF)
118: sp->s_type = XXTRN+XUNDEF;
119: else if ((sp->s_type&XTYPE)==XDATA)
120: sp->s_value += usedot[sp->s_index].e_xvalue;
121: else if ((sp->s_type&XTYPE)==XTEXT)
122: sp->s_value += usedot[sp->s_index].e_xvalue;
123: else if ((sp->s_type&XTYPE)==XBSS) {
124: bs = sp->s_value;
125: sp->s_value = hdr.a_bss + datbase;
126: hdr.a_bss += bs;
127: }
128: assignindex:
129: if (!ISLABEL(sp))
130: sp->s_index = relpos++;
131: }
132: }
133:
134: /*
135: * For all of the stabs that had their final value undefined during pass 1
136: * and during pass 2 assign a final value.
137: * We have already given stab entrys a initial approximation
138: * when we constsructed the sorted symbol table.
139: * Iteration order doesn't matter.
140: */
141:
142: stabfix()
143: {
144: register struct symtab *sp, **cosp;
145: register struct symtab *p;
146:
147: SYMITERATE(cosp, sp){
148: if(sp->s_ptype && (sp->s_type & STABFLAG)) {
149: p = sp->s_dest;
150: /*
151: * STABFLOATING indicates that the offset has been saved in s_desc, s_other
152: */
153: if(sp->s_tag == STABFLOATING) {
154: sp->s_value = ( ( ((unsigned char) sp->s_other) << 16) | ( (unsigned short) sp->s_desc ) );
155: sp->s_value = sp->s_value + p->s_value;
156: }
157: else sp->s_value = p->s_value;
158: sp->s_index = p->s_index;
159: sp->s_type = p->s_type;
160:
161:
162: }
163: }
164: }
165:
166: char *Calloc(number, size)
167: int number, size;
168: {
169: register char *newstuff;
170: char *sbrk();
171: newstuff = sbrk(number*size);
172: if ((int)newstuff == -1){
173: yyerror("Ran out of Memory");
174: delexit();
175: }
176: return(newstuff);
177: }
178:
179: char *ClearCalloc(number, size)
180: int number, size;
181: {
182: register char *newstuff; /* r11 */
183: register int length = number * size; /* r10 */
184: #ifdef lint
185: length = length;
186: #endif length
187: newstuff = Calloc(number, size);
188: strncpy (newstuff, "\0", length);
189: return(newstuff);
190: }
191:
192: struct symtab *symalloc()
193: {
194: if (symsleft == 0){
195: newbox = (struct allocbox *)ClearCalloc(1,ALLOCQTY);
196: symsleft = SYMDALLOP;
197: nextsym = &newbox->symslots[0];
198: if (alloctail == 0){
199: allochead = alloctail = newbox;
200: } else {
201: alloctail->nextalloc = newbox;
202: alloctail = newbox;
203: }
204: }
205: --symsleft;
206: ++nsyms;
207: return(nextsym++);
208: }
209:
210: strpoolalloc()
211: {
212: register struct strpool *new;
213:
214: new = (struct strpool *)Calloc(1, sizeof (struct strpool));
215: new->str_nalloc = 0;
216: new->str_next = strplhead;
217: strplhead = new;
218: }
219:
220: symcmp(Pptr, Qptr)
221: struct symtab **Pptr, **Qptr;
222: {
223: register struct symtab *p = *Pptr;
224: register struct symtab *q = *Qptr;
225: if (p->s_index < q->s_index)
226: return(-1);
227: if (p->s_index > q->s_index)
228: return(1);
229: if (p->s_value < q->s_value)
230: return(-1);
231: if (p->s_value > q->s_value)
232: return(1);
233: /*
234: * Force jxxx entries to virtually preceed labels defined
235: * to follow the jxxxx instruction, so that bumping the
236: * jxxx instruction correctly fixes up the following labels
237: */
238: if (p->s_tag >= IGNOREBOUND) /*p points to a jxxx*/
239: return(-1);
240: if (q->s_tag >= IGNOREBOUND)
241: return(1);
242: /*
243: * both are now just plain labels; the relative order doesn't
244: * matter. Both can't be jxxxes, as they would have different
245: * values.
246: */
247: return(0);
248: } /*end of symcmp*/
249:
250: /*
251: * We construct the auxiliary table of pointers, symptrs and
252: * symdelim
253: * We also assign preliminary values to stab entries that did not yet
254: * have an absolute value (because they initially referred to
255: * forward references). We don't worry about .stabds, as they
256: * already have an estimated final value
257: */
258:
259: sortsymtab()
260: {
261: register struct symtab *sp;
262: register struct symtab **cowalk;
263: register struct allocbox *allocwalk;
264: struct symtab *ubsp;
265: int segno;
266: int slotno;
267: int symsin; /*number put into symptrs*/
268:
269: symptrs = (struct symtab **)Calloc(nsyms + 2, sizeof *symptrs);
270: /*
271: * Allocate one word at the beginning of the symptr array
272: * so that backwards scans through the symptr array will
273: * work correctly while scanning through the zeroth segment
274: */
275: *symptrs++ = 0;
276: cowalk = symptrs;
277: symsin = 0;
278: DECLITERATE(allocwalk, sp, ubsp) {
279: if (sp->s_ptype && (sp->s_type &STABFLAG)){
280: sp->s_value = sp->s_dest->s_value;
281: sp->s_index = sp->s_dest->s_index;
282: }
283: if (symsin >= nsyms)
284: yyerror("INTERNAL ERROR: overfilled symbol table indirection table");
285: *cowalk++ = sp;
286: symsin++;
287: }
288: if (symsin != nsyms)
289: yyerror("INTERNAL ERROR: installed %d syms, should have installed %d",
290: symsin, nsyms);
291: symptrub = &symptrs[nsyms ];
292: qsort(symptrs, nsyms, sizeof *symptrs, symcmp);
293: symdelim[0] = symptrs;
294: for (cowalk = symptrs, sp = *cowalk, segno = 0, slotno = 1;
295: segno < NLOC + NLOC;
296: segno++, slotno++){
297: for (; sp && sp->s_index == segno; sp = *++cowalk);
298: symdelim[slotno] = cowalk; /*forms the ub delimeter*/
299: }
300: } /*end of sortsymtab*/
301:
302: #ifdef DEBUG
303: dumpsymtab()
304: {
305: register int segno;
306: register struct symtab *sp, **cosp, *ub;
307: char *tagstring();
308:
309: printf("Symbol Table dump:\n");
310: for (segno = 0; segno < NLOC + NLOC; segno++){
311: printf("Segment number: %d\n", segno);
312: SEGITERATE(segno, 0, 0, cosp, sp, ub, ++){
313: printf("\tSeg: %d \"%s\" value: %d index: %d tag %s\n",
314: segno, sp->s_name ? FETCHNAME(sp) : "(NULL)",
315: sp->s_value, sp->s_index,
316: tagstring(sp->s_tag));
317: printf("\t\ttype: %d jxbump %d jxfear: %d\n",
318: sp->s_type, sp->s_jxbump, sp->s_jxfear);
319: }
320: printf("\n\n");
321: }
322: }
323:
324: static char tagbuff[4];
325:
326: char *tagstring(tag)
327: unsigned char tag;
328: {
329: switch(tag){
330: case JXACTIVE: return("active");
331: case JXNOTYET: return("notyet");
332: case JXALIGN: return("align");
333: case JXQUESTIONABLE: return("jxquestionable");
334: case JXINACTIVE: return("inactive");
335: case JXTUNNEL: return("tunnel");
336: case OBSOLETE: return("obsolete");
337: case IGNOREBOUND: return("ignorebound");
338: case STABFLOATING: return("stabfloating");
339: case STABFIXED: return("stabfixed");
340: case LABELID: return("labelid");
341: case OKTOBUMP: return("oktobump");
342: case ISET: return("iset");
343: case ILSYM: return("ilsym");
344: default: (void)sprintf(tagbuff,"%d", tag);
345: return(tagbuff);
346: }
347: }
348: #endif DEBUG
349:
350: htaballoc()
351: {
352: register struct hashdallop *new;
353: new = (struct hashdallop *)ClearCalloc(1, sizeof (struct hashdallop));
354: if (htab == 0)
355: htab = new;
356: else { /* add AFTER the 1st slot */
357: new->h_next = htab->h_next;
358: htab->h_next = new;
359: }
360: }
361:
362: #define HASHCLOGGED (NHASH / 2)
363:
364: /*
365: * Lookup a symbol stored in extern yytext.
366: * All strings passed in via extern yytext had better have
367: * a trailing null. Strings are placed in yytext for hashing by
368: * syminstall() and by yylex();
369: *
370: * We take pains to avoid function calls; this functdion
371: * is called quite frequently, and the calls overhead
372: * in the vax contributes significantly to the overall
373: * execution speed of as.
374: */
375: struct symtab **lookup(instflg)
376: int instflg; /* 0: don't install */
377: {
378: static int initialprobe;
379: register struct symtab **hp;
380: register char *from;
381: register char *to;
382: register int len;
383: register int nprobes;
384: static struct hashdallop *hdallop;
385: static struct symtab **emptyslot;
386: static struct hashdallop *emptyhd;
387: static struct symtab **hp_ub;
388:
389: emptyslot = 0;
390: for (nprobes = 0, from = yytext;
391: *from;
392: nprobes <<= 2, nprobes += *from++)
393: continue;
394: nprobes += from[-1] << 5;
395: nprobes %= NHASH;
396: if (nprobes < 0)
397: nprobes += NHASH;
398:
399: initialprobe = nprobes;
400: for (hdallop = htab; hdallop != 0; hdallop = hdallop->h_next){
401: for (hp = &(hdallop->h_htab[initialprobe]),
402: nprobes = 1,
403: hp_ub = &(hdallop->h_htab[NHASH]);
404: (*hp) && (nprobes < NHASH);
405: hp += nprobes,
406: hp -= (hp >= hp_ub) ? NHASH:0,
407: nprobes += 2)
408: {
409: from = yytext;
410: to = FETCHNAME(*hp);
411: while (*from && *to)
412: if (*from++ != *to++)
413: goto nextprobe;
414: if (*to == *from) /*assert both are == 0*/
415: return(hp);
416: nextprobe: ;
417: }
418: if (*hp == 0 && emptyslot == 0 &&
419: hdallop->h_nused < HASHCLOGGED) {
420: emptyslot = hp;
421: emptyhd = hdallop;
422: }
423: }
424: if (emptyslot == 0) {
425: htaballoc();
426: hdallop = htab->h_next; /* aren't we smart! */
427: hp = &hdallop->h_htab[initialprobe];
428: } else {
429: hdallop = emptyhd;
430: hp = emptyslot;
431: }
432: if (instflg) {
433: *hp = symalloc();
434: hdallop->h_nused++;
435: for (from = yytext, len = 0; *from++; len++)
436: continue;
437: (*hp)->s_name = (char *)savestr(yytext, len + 1, STR_BOTH);
438: }
439: return(hp);
440: } /*end of lookup*/
441: /*
442: * save a string str with len in the places indicated by place
443: */
444: struct strdesc *savestr(str, len, place)
445: char *str;
446: int len;
447: int place;
448: {
449: reg struct strdesc *res;
450: reg int tlen;
451: /*
452: * Compute the total length of the record to live in core
453: */
454: tlen = sizeof(struct strdesc) - sizeof(res->sd_string);
455: if (place & STR_CORE)
456: tlen += (len + 3) & ~3;
457: /*
458: * See if there is enough space for the record,
459: * and allocate the record.
460: */
461: if (tlen >= (STRPOOLDALLOP - strplhead->str_nalloc))
462: strpoolalloc();
463: res = (struct strdesc *)(strplhead->str_names +
464: strplhead->str_nalloc);
465: /*
466: * Save the string information that is always present
467: */
468: res->sd_stroff = strfilepos;
469: res->sd_strlen = len;
470: res->sd_place = place;
471: /*
472: * Now, save the string itself. If str is null, then
473: * the characters have already been dumped to the file
474: */
475: if ((place & STR_CORE) && str)
476: movestr(res[0].sd_string, str, len);
477: if (place & STR_FILE){
478: if (str){
479: fwrite(str, 1, len, strfile);
480: }
481: strfilepos += len;
482: }
483: /*
484: * Adjust the in core string pool size
485: */
486: strplhead->str_nalloc += tlen;
487: return(res);
488: }
489: /*
490: * The relocation information is saved internally in an array of
491: * lists of relocation buffers. The relocation buffers are
492: * exactly the same size as a token buffer; if we use VM for the
493: * temporary file we reclaim this storage, otherwise we create
494: * them by mallocing.
495: */
496: #define RELBUFLG TOKBUFLG
497: #define NRELOC ((TOKBUFLG - \
498: (sizeof (int) + sizeof (struct relbufdesc *)) \
499: ) / (sizeof (struct relocation_info)))
500:
501: struct relbufdesc{
502: int rel_count;
503: struct relbufdesc *rel_next;
504: struct relocation_info rel_reloc[NRELOC];
505: };
506: extern struct relbufdesc *tok_free;
507: #define rel_free tok_free
508: static struct relbufdesc *rel_temp;
509: struct relocation_info r_can_1PC;
510: struct relocation_info r_can_0PC;
511:
512: initoutrel()
513: {
514: r_can_0PC.r_address = 0;
515: r_can_0PC.r_symbolnum = 0;
516: r_can_0PC.r_pcrel = 0;
517: r_can_0PC.r_length = 0;
518: r_can_0PC.r_extern = 0;
519:
520: r_can_1PC = r_can_0PC;
521: r_can_1PC.r_pcrel = 1;
522: }
523:
524: outrel(xp, reloc_how)
525: register struct exp *xp;
526: int reloc_how; /* TYPB..TYPD + (possibly)RELOC_PCREL */
527: {
528: struct relocation_info reloc;
529: register int x_type_mask;
530: int pcrel;
531:
532: x_type_mask = xp->e_xtype & ~XFORW;
533: pcrel = reloc_how & RELOC_PCREL;
534: reloc_how &= ~RELOC_PCREL;
535:
536: if (bitoff&07)
537: yyerror("Padding error");
538: if (x_type_mask == XUNDEF)
539: yyerror("Undefined reference");
540:
541: if ( (x_type_mask != XABS) || pcrel ) {
542: if (ty_NORELOC[reloc_how])
543: yyerror("Illegal Relocation of floating or large int number.");
544: reloc = pcrel ? r_can_1PC : r_can_0PC;
545: reloc.r_address = dotp->e_xvalue -
546: ( (dotp < &usedot[NLOC] || readonlydata) ? 0 : datbase );
547: reloc.r_length = ty_nlg[reloc_how];
548: switch(x_type_mask){
549: case XXTRN | XUNDEF:
550: reloc.r_symbolnum = xp->e_xname->s_index;
551: reloc.r_extern = 1;
552: break;
553: default:
554: if (readonlydata && (x_type_mask&~XXTRN) == XDATA)
555: x_type_mask = XTEXT | (x_type_mask&XXTRN);
556: reloc.r_symbolnum = x_type_mask;
557: break;
558: }
559: if ( (relfil == 0) || (relfil->rel_count >= NRELOC) ){
560: if (rel_free){
561: rel_temp = rel_free;
562: rel_free = rel_temp->rel_next;
563: } else {
564: rel_temp = (struct relbufdesc *)
565: Calloc(1,sizeof (struct relbufdesc));
566: }
567: rel_temp->rel_count = 0;
568: rel_temp->rel_next = relfil;
569: relfil = rusefile[dotp - &usedot[0]] = rel_temp;
570: }
571: relfil->rel_reloc[relfil->rel_count++] = reloc;
572: }
573: /*
574: * write the unrelocated value to the text file
575: */
576: dotp->e_xvalue += ty_nbyte[reloc_how];
577: if (pcrel)
578: xp->e_xvalue -= dotp->e_xvalue;
579: switch(reloc_how){
580: case TYPQ:
581: bwrite(&(xp->e_number.num_num.numIq_int.Iq_ulong[1]),
582: sizeof (long), txtfil);
583: bwrite(&(xp->e_number.num_num.numIq_int.Iq_ulong[0]),
584: sizeof (long), txtfil);
585: break;
586: case TYPD:
587: bwrite(&(xp->e_number.num_num.numFd_float.Fd_ulong[0]),
588: sizeof (long), txtfil);
589: bwrite(&(xp->e_number.num_num.numFd_float.Fd_ulong[1]),
590: sizeof (long), txtfil);
591: break;
592: case TYPF:
593: bwrite(&(xp->e_number.num_num.numFf_float.Ff_ulong[0]),
594: sizeof (long), txtfil);
595: break;
596:
597: case TYPB:
598: bwrite(((char *)&(xp->e_xvalue))+3, ty_nbyte[reloc_how], txtfil);
599: break;
600: case TYPW:
601: bwrite(((char *)&(xp->e_xvalue))+2, ty_nbyte[reloc_how], txtfil);
602: break;
603: case TYPL:
604: bwrite ((char *)&(xp->e_xvalue), ty_nbyte[reloc_how], txtfil);
605: break;
606: }
607: if (liston && (passno == 2))
608: switch (reloc_how)
609: {
610: case TYPQ:
611: long_out(xp->e_number.num_num.numIq_int.Iq_ulong[1]);
612: long_out(xp->e_number.num_num.numIq_int.Iq_ulong[0]);
613: case TYPD:
614: long_out(xp->e_number.num_num.numIq_int.Iq_ulong[0]);
615: long_out(xp->e_number.num_num.numIq_int.Iq_ulong[1]);
616: break;
617: case TYPF:
618: long_out(xp->e_number.num_num.numFf_float.Ff_ulong[0]);
619: break;
620:
621: case TYPB:
622: byte_out(xp->e_xvalue);
623: break;
624: case TYPW:
625: word_out(xp->e_xvalue);
626: break;
627: case TYPL:
628: long_out(xp->e_xvalue);
629: break;
630: }
631: }
632: /*
633: * Flush out all of the relocation information.
634: * Note that the individual lists of buffers are in
635: * reverse order, so we must reverse them
636: */
637: off_t closeoutrel(relocfile)
638: BFILE *relocfile;
639: {
640: int locindex;
641: u_long Closeoutrel();
642:
643: trsize = 0;
644: for (locindex = 0; locindex < NLOC; locindex++){
645: trsize += Closeoutrel(rusefile[locindex], relocfile);
646: }
647: drsize = 0;
648: for (locindex = 0; locindex < NLOC; locindex++){
649: drsize += Closeoutrel(rusefile[NLOC + locindex], relocfile);
650: }
651: return(trsize + drsize);
652: }
653:
654: u_long Closeoutrel(relfil, relocfile)
655: struct relbufdesc *relfil;
656: BFILE *relocfile;
657: {
658: u_long tail;
659: if (relfil == 0)
660: return(0L);
661: tail = Closeoutrel(relfil->rel_next, relocfile);
662: bwrite((char *)&relfil->rel_reloc[0],
663: relfil->rel_count * sizeof (struct relocation_info),
664: relocfile);
665: return(tail + relfil->rel_count * sizeof (struct relocation_info));
666: }
667:
668: #define NOUTSYMS (nsyms - njxxx - nforgotten - (savelabels ? 0 : nlabels))
669: int sizesymtab()
670: {
671: return (sizeof (struct nlist) * NOUTSYMS);
672: }
673: /*
674: * Write out n symbols to file f, beginning at p
675: * ignoring symbols that are obsolete, jxxx instructions, and
676: * possibly, labels
677: */
678: int symwrite(symfile)
679: BFILE *symfile;
680: {
681: int symsout; /*those actually written*/
682: int symsdesired = NOUTSYMS;
683: reg struct symtab *sp, *ub;
684: char *name; /* temp to save the name */
685: int totalstr;
686: /*
687: * We use sp->s_index to hold the length of the
688: * name; it isn't used for anything else
689: */
690: register struct allocbox *allocwalk;
691:
692: symsout = 0;
693: totalstr = sizeof(totalstr);
694: DECLITERATE(allocwalk, sp, ub) {
695: if (sp->s_tag >= IGNOREBOUND)
696: continue;
697: if (ISLABEL(sp))
698: continue;
699: symsout++;
700: name = sp->s_name; /* save pointer */
701: /*
702: * the length of the symbol table string
703: * always includes the trailing null;
704: * blast the pointer to its a.out value.
705: */
706: if (sp->s_name && (sp->s_index = STRLEN(sp))){
707: sp->s_nmx = totalstr;
708: totalstr += sp->s_index;
709: } else {
710: sp->s_nmx = 0;
711: }
712: if (sp->s_ptype != 0)
713: sp->s_type = sp->s_ptype;
714: else
715: sp->s_type = (sp->s_type & (~XFORW));
716: if (readonlydata && (sp->s_type&~N_EXT) == N_DATA)
717: sp->s_type = N_TEXT | (sp->s_type & N_EXT);
718: bwrite((char *)&sp->s_nm, sizeof (struct nlist), symfile);
719: sp->s_name = name; /* restore pointer */
720: }
721: if (symsout != symsdesired)
722: yyerror("INTERNAL ERROR: Wrote %d symbols, wanted to write %d symbols\n",
723: symsout, symsdesired);
724: /*
725: * Construct the string pool from the symbols that were written,
726: * possibly fetching from the string file if the string
727: * is not core resident.
728: */
729: bwrite(&totalstr, sizeof(totalstr), symfile);
730: symsout = 0;
731: DECLITERATE(allocwalk, sp, ub) {
732: if (sp->s_tag >= IGNOREBOUND)
733: continue;
734: if (ISLABEL(sp))
735: continue;
736: symsout++;
737: if (sp->s_name && STRLEN(sp) > 0){
738: if (STRPLACE(sp) & STR_CORE){
739: bwrite(FETCHNAME(sp), STRLEN(sp), symfile);
740: } else if (STRPLACE(sp) & STR_FILE){
741: char rbuf[2048];
742: int left, nread;
743: fseek(strfile, STROFF(sp), 0);
744: for (left = STRLEN(sp); left > 0; left -= nread){
745: nread = fread(rbuf, sizeof(char),
746: min(sizeof(rbuf), left), strfile);
747: if (nread == 0)
748: break;
749: bwrite(rbuf, nread, symfile);
750: }
751: }
752: }
753: }
754: if (symsout != symsdesired)
755: yyerror("INTERNAL ERROR: Wrote %d strings, wanted %d\n",
756: symsout, symsdesired);
757: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.