![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to syms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / ld|
Return to syms.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 root 1: static char ID[] = "@(#) syms.c: 1.18 10/5/83";
2: #include "system.h"
3: #include <stdio.h>
4: #include <fatal.h>
5: #include <signal.h>
6: #if !NOSDP
7: #include "sdp1.h"
8: #include "sdpsrc/hd/define2.h"
9: #include "sdpsrc/hd/define4.h"
10: #include "sdpsrc/hd/struct.h"
11: #endif
12: #include "structs.h"
13: #include "paths.h"
14: #include "extrns.h"
15: #if TRVEC
16: #include "tv.h"
17: #include "ldtv.h"
18: #endif
19: #include "sgsmacros.h"
20: #include "instr.h"
21: #include "ldmacros.h"
22:
23:
24:
25: /*
26: * ***** NOTICE ***** NOTICE ***** NOTICE *******
27: * *
28: * This version of syms.c is designed to *
29: * permit multiple aux entries per symbol *
30: * *
31: * This version of syms.c uses a one-way *
32: * circular list to link all symbols that *
33: * hash to the same hashtab[] entry *
34: * *
35: * ***** NOTICE ***** NOTICE ***** NOTICE *******
36: */
37:
38: #if NOSDP && !UNIX
39: #define HASHSIZE 1021
40: #else
41: #define HASHSIZE 521
42: #endif
43: /*
44: * VAX cc bug KLUDGE
45: */
46: #define abs(x) (x < 0 ? -x : x)
47:
48: ITEMID hashtab[HASHSIZE];
49:
50: #if NOSDP
51: #if UNIX
52: #define MAXEXTRA 100
53: #define XSMTBSZ 100
54: #define XAXTBSZ 50
55: #define MYSMTBSZ 200
56: #define MYAXTBSZ 100
57: #else
58: #if AR16WR
59: #define MAXEXTRA 20
60: #define XSMTBSZ 80
61: #define XAXTBSZ 40
62: #define MYSMTBSZ 400
63: #define MYAXTBSZ 200
64: #endif
65: #if AR32W
66: #define MAXEXTRA 100
67: #define XSMTBSZ 800
68: #define XAXTBSZ 400
69: #define MYSMTBSZ 4000
70: #define MYAXTBSZ 2000
71: #endif
72: #if AR32WR
73: #define MAXEXTRA 10
74: #define XSMTBSZ 400
75: #define XAXTBSZ 200
76: #define MYSMTBSZ 2000
77: #define MYAXTBSZ 1000
78: #endif
79: #endif
80: int xsymcnt = 0;
81: int xauxcnt = 0;
82: SYMTAB *xsymptr[MAXEXTRA];
83: AUXTAB *xauxptr[MAXEXTRA];
84: SYMTAB mysymtab[MYSMTBSZ+1];
85: AUXTAB myauxtab[MYAXTBSZ+1];
86: #else
87: extern HEADER global_frames[MAXATTACH];
88: static char sdpname[sizeof(TMPDIR)+20] = "";
89: static char auxname[sizeof(TMPDIR)+20] = "";
90:
91: static int sdp_called = 0; /* indicates when syminit() has been called */
92: static int aux_called = 0; /* indicates when auxinit() has been called */
93: /*eject*/
94: syminit()
95: {
96:
97: /*
98: * Initialize the Software Demand Paging System
99: */
100:
101: if( sdp_called )
102: lderror(2,0,NULL,"Attempt to re-initialize SDP symbol space");
103:
104: sprintf( sdpname, "%s/%s", TMPDIR, "ldXXXXXX" );
105: mktemp( sdpname );
106:
107: sdp_called++;
108:
109: if( sdpinit(sdpname, CREATE, SYMSPACE) != SYMSPACE )
110: lderror(2,0,NULL,"Failed to initialize SDP symbol space");
111: else
112: sdp_called++;
113:
114: auxinit(); /* initialize aux entry space */
115: }
116:
117:
118:
119: symfini()
120: {
121: char buf[sizeof(sdpname)*2 + 20];
122:
123: /*
124: * Ignore BREAK, HANGUP, and QUIT signals, to insure that the cleanup
125: * is done
126: */
127:
128: signal(SIGINT, SIG_IGN);
129: signal(SIGQUIT, SIG_IGN);
130:
131: if( sdp_called == 2 ) {
132: sdp_called--;
133: if( sdpterm(SYMSPACE) < 0 )
134: lderror(2,0,NULL,"Failed to close SDP symbol space");
135: }
136:
137: if( sdp_called != 1 )
138: return;
139: sdp_called--;
140:
141: #if TS || RT
142: sprintf(buf, "rm -r %s", sdpname);
143: #else
144: sprintf(buf, "rm -r %s; rmdir %s", sdpname, sdpname);
145: #endif
146:
147: if( fork() == 0 ) {
148: execl("/bin/sh", "sh", "-c", buf, 0);
149: lderror(0,0,NULL, "Execl(%s) failed", buf);
150: _exit(127);
151: }
152:
153: auxfini(); /* close aux entry space */
154: }
155: /*eject*/
156: #endif
157: hash(name)
158: register char *name;
159: {
160:
161: /*
162: * Compute hash value for a symbol name
163: */
164:
165: register unsigned hashval;
166: register int tmp; /* VAX CC BUG KLUDGE */
167:
168: hashval = 0;
169: while (*name)
170: hashval = hashval * 10 + *name++; /*used to be 13*/
171:
172: /*
173: * Because of a bug in the current VAX compiler, the following
174: * line has temporarily been replaced by the KLUDGE following
175: * this comment. The define of abs() is also added above
176: *
177: * return( (int) (hashval % HASHSIZE) );
178: */
179:
180: tmp = (int) hashval;
181: tmp = abs(tmp);
182: return ( tmp % HASHSIZE );
183: }
184: /*eject*/
185: SYMTAB *
186: findsym(name)
187: char *name;
188: {
189:
190: /*
191: * Return a pointer to the ld symbol table entry for a symbol.
192: *
193: * NULL indicates that the symbol does not exist
194: */
195:
196: register SYMTAB *p; /* ld symbol table entry */
197: register int chain; /* size of a collision chain */
198: int hashval; /* hashtab[] index for the sym */
199: register ITEMID acid, /* SDP id for ld symbol entry */
200: base; /* head of collision chain */
201:
202:
203: /*
204: * All symbols that hash to the same value are connected in a one-way,
205: * circular linked list. The most recently referenced symbol on
206: * the chain is considered the head of the chain, and its id is
207: * stored in the hash table
208: *
209: * Get the head of the collision chain, and walk down it looking for
210: * a match
211: */
212:
213: hashval = hash(name);
214: if( (acid = hashtab[hashval]) == 0 )
215: return( NULL );
216: base = acid;
217: chain = 1;
218:
219: do {
220: char sym_space[9];
221: char *sym_name;
222: #if NOSDP
223: p = getsym(acid);
224: #else
225: p = (SYMTAB *) lock(acid, MISPARTITION, RNLY);
226: #endif
227: if (p->smnamelength == 9)
228: {
229: strncpy( sym_space, p->sment.n_name, 8 );
230: sym_space[8] = '\0';
231: sym_name = sym_space;
232: }
233: #if FLEXNAMES
234: else if (p->smnamelength > 9)
235: sym_name = p->sment.n_nptr;
236: #endif
237: else
238: sym_name = p->sment.n_name;
239:
240: if (equal( sym_name, name, p->smnamelength ))
241: {
242: maxchain = max(maxchain,chain);
243: nwalks += (chain - 1);
244: hashtab[hashval] = acid;
245: return( p );
246: }
247: #if !NOSDP
248: unlock(acid, RNLY);
249: #endif
250:
251: acid = p->smchainid;
252: chain++;
253:
254: }
255: while( acid != base );
256:
257: nfwalks += (chain - 1);
258:
259: return( NULL ); /* not found */
260: }
261: /*eject*/
262: AUXTAB *
263: findaux(sym, ndx)
264: SYMTAB *sym;
265: int ndx;
266: {
267:
268: /*
269: * Return a pointer to the ndx'th aux entry for the ld symbol table
270: * entry given by sym
271: *
272: * NULL indicates that no such aux entry exists
273: */
274:
275: register AUXTAB *a; /* pointer to a symbol aux entry*/
276: ITEMID acid; /* SDP id for ld aux entry */
277:
278: #if DEBUG
279: if( dflag > 15 )
280: fprintf( stderr, "\nfindaux %s ", SYMNAME( sym->sment ));
281: #endif
282:
283: /*
284: * All aux entries belonging to a symbol are linked together in a
285: * one-way linked list. The entries are ordered by aux-entry
286: * number: the first aux entry is the head of the list; it is
287: * linked to the 2'nd aux entry, which is linked to the 3'rd, etc
288: *
289: * Get the head of the aux entry list, and walk down it looking for
290: * the specified aux entry
291: */
292:
293: acid = sym->smauxid;
294:
295: while( acid != 0 ) {
296:
297: #if NOSDP
298: a = getaux(acid);
299: #else
300: a = (AUXTAB *) lock(acid, MISPARTITION, RNLY);
301: #endif
302:
303: if( a->axord == ndx )
304: return( a );
305: #if !NOSDP
306: unlock(acid, RNLY);
307: #endif
308:
309: acid = a->axchainid;
310:
311: }
312:
313: return( NULL ); /* not found */
314: }
315: /*eject*/
316: SYMTAB *
317: makesym(sym, filp)
318: register SYMENT *sym;
319: INFILE *filp;
320: {
321:
322: /*
323: * Given a (new) *.o symbol table entry, add it to the ld
324: * symbol table
325: *
326: * A ld symbol table entry is built and initialized. Appropriate
327: * entries are made in the hash table and in the SDP address space
328: *
329: * The address of the ld symbol table entry is returned
330: */
331:
332: register SYMTAB *p; /* pointer to a ld symbol entry */
333: register ITEMID acid; /* SDP id of a ld symbol entry */
334: int hashval; /* index into hash table for sym*/
335: int auxcnt;
336: char *name;
337:
338: name = PTRNAME( sym );
339: if( (p = findsym(name)) == NULL ) {
340: /*
341: * Case 1: The symbol is not in the ld symbol table.
342: * Add a new entry, making it the head of the
343: * collision chain
344: * Update the hash table
345: */
346: #if NOSDP
347: if (numldsyms >= MYSMTBSZ + (xsymcnt * XSMTBSZ)) {
348: if (xsymcnt >= MAXEXTRA)
349: lderror(2,0,"internal error: ","symbol table overflow");
350: xsymptr[xsymcnt++] = (SYMTAB *) myalloc(XSMTBSZ * SYMSIZ);
351: }
352: acid = ++numldsyms;
353: p = getsym(acid);
354: #else
355: numldsyms++;
356: acid = allocate(SYMSIZ, SYMSPACE, MISPARTITION);
357: p = (SYMTAB *) lock(acid, MISPARTITION, WRTN);
358: zero( p, SYMSIZ );
359: #endif
360: p->sment = *sym;
361: p->smnamelength = strlen( name ) + 1;
362: #if FLEXNAMES
363: if ((sym->n_zeroes == 0L) && ((filp == NULL)
364: || (filp && (filp->flstrings == NULL))))
365: p->sment.n_nptr = savefn(sym->n_nptr);
366: #endif
367: p->sment.n_numaux = 0;
368: p->smmyacid = acid;
369:
370: hashval = hash(name);
371: if( hashtab[hashval] > 0 ) {
372: SYMTAB *p2;
373: #if NOSDP
374: p2 = getsym(hashtab[hashval]);
375: #else
376: p2 = (SYMTAB *) lock(hashtab[hashval], HITPARTITION, WRTN);
377: #endif
378: p->smchainid = p2->smchainid;
379: p2->smchainid = acid;
380: #if !NOSDP
381: unlock(hashtab[hashval], WRTN);
382: #endif
383: ncolisns++;
384: }
385: else
386: p->smchainid = acid;
387:
388: hashtab[hashval] = acid;
389: return( p );
390: }
391:
392: /*
393: * Case 2: The symbol is already in the symbol table
394: * Update the existing entry
395: */
396:
397: if( sym->n_scnum != 0 ) {
398: /*
399: * The makesym() argument 'sym' is the defining entry
400: * for the symbol
401: */
402: if( p->sment.n_scnum == 0 ) {
403:
404: /*
405: * The existing ld symbol table entry
406: * was from a reference
407: *
408: * Merge the information from the function
409: * argument and the ld symbol table
410: *
411: * The ld symbol table entry may have a ld-
412: * generated aux entry. If so, carry this
413: * entry over.
414: */
415: #if COMMON
416: if (Mflag && p->sment.n_value > 0)
417: lderror(0,0,NULL, "Symbol %s in %s is multiply defined.",
418: name,curfilnm );
419: #endif
420: p->sment.n_value = sym->n_value;
421: p->sment.n_scnum = sym->n_scnum;
422: p->sment.n_type = sym->n_type;
423: p->sment.n_sclass = sym->n_sclass;
424: }
425: else if( p->sment.n_scnum != -1 )
426: lderror(1,0,NULL, "Symbol %s in %s is multiply defined. First defined in %s",
427: name, curfilnm, p->smscnptr->isfilptr->flname );
428: }
429:
430: #if COMMON
431: else if (sym->n_value > 0) /* & sym->n_scnum == 0 => common sym */
432: {
433: if (Mflag && (p->sment.n_scnum != 0 ||
434: (p->sment.n_scnum == 0 && p->sment.n_value > 0)))
435: lderror(0, 0, NULL, "Symbol %s in %s is multiply defined.",
436: name, curfilnm);
437:
438: /* set value for .common symbol */
439:
440: if ( p->sment.n_scnum == N_UNDEF )
441: {
442: if ( !tflag && ( p->sment.n_value > 0 )
443: && ( p->sment.n_value != sym->n_value ))
444: {
445: lderror(0, 0, NULL,
446: "Multiply defined symbol %s, in %s, has more than one size",
447: PTRNAME(sym), curfilnm);
448: }
449:
450: p->sment.n_value = /* max of old & new val */
451: (p->sment.n_value > sym->n_value) ?
452: p->sment.n_value : sym->n_value;
453:
454: if (sym->n_type != T_NULL && p->sment.n_type == T_NULL)
455: p->sment.n_type = sym->n_type;
456: }
457: }
458: #endif
459: return( p );
460: }
461: /*eject*/
462: AUXTAB *
463: makeaux(sym, aux, ndx)
464: register SYMTAB *sym; /* symbol table entry to which the aux entry belongs */
465: register AUXENT *aux; /* new aux entry */
466: int ndx; /* number of aux entries already added to entry */
467: {
468:
469: /*
470: * Given a (*.o) aux entry, add it to an existing ld symbol
471: * table entry
472: *
473: * The address of the ld aux entry is returned
474: */
475:
476: register AUXTAB *a;
477: register int tvndx;
478: ITEMID acid;
479:
480: #if DEBUG
481: if( dflag > 15 )
482: fprintf( stderr, "\nmakeaux %s ", SYMNAME( sym->sment ) );
483: else if( dflag > 2 )
484: fprintf(stderr, "makeaux: %s (%d) : %08lx %04x %04x %08lx %08lx %04x\n",
485: SYMNAME(sym->sment), ndx,
486: aux->x_sym.x_tagndx, aux->x_sym.x_misc.x_lnsz.x_lnno,
487: aux->x_sym.x_misc.x_lnsz.x_size,
488: aux->x_sym.x_fcnary.x_fcn.x_lnnoptr,
489: aux->x_sym.x_fcnary.x_fcn.x_endndx,
490: aux->x_sym.x_tvndx);
491: #endif
492:
493: /*
494: * Add the new aux entry to the symbol table entry
495: */
496:
497: if( (acid = sym->smauxid) == 0 ) {
498: /*
499: * Add the first aux entry for a symbol
500: */
501: if( ndx != 0 )
502: lderror(1,0,NULL,"Making aux entry %d for symbol %s out of sequence",
503: ndx+1, SYMNAME( sym->sment ));
504: #if NOSDP
505: if (numldaux >= MYAXTBSZ + (xauxcnt * XAXTBSZ)) {
506: if (xauxcnt >= MAXEXTRA)
507: lderror(2,0,"internal error: ","aux table overflow");
508: xauxptr[xauxcnt++] = (AUXTAB *) myalloc(XAXTBSZ * AUXSIZ);
509: }
510: acid = ++numldaux;
511: a = getaux(acid);
512: #else
513: numldaux++;
514: acid = allocate(AUXSIZ, AUXSPACE, MISPARTITION);
515: a = (AUXTAB *) lock(acid, MISPARTITION, WRTN);
516:
517: zero( a, AUXSIZ );
518: #endif
519: a->axent = *aux;
520: a->axord = 1;
521: a->axmyacid = acid;
522: a->axchainid = 0;
523:
524: sym->sment.n_numaux++;
525: sym->smauxid = acid;
526:
527: return( a );
528: }
529:
530: #if NOSDP
531: a = getaux(acid);
532: #else
533: a = (AUXTAB *) lock(acid, MISPARTITION, WRTN);
534: #endif
535:
536:
537: if( ndx == 0 ) {
538: /*
539: * The symbol table entry already has a aux entry.
540: *
541: * This occurs when ld generates an aux entry for
542: * the symbol, to contain a tv slot index.
543: *
544: * Merge this ld-entry with the entry obtained from
545: * the input file
546: *
547: * Two cases: due to a tv ref in an earlier
548: * input file, the aux entry in the symbol
549: * table is a dummy one and should be
550: * overwritten except for the tvndx.
551: *
552: * (2) we are doing subsystem linking and
553: * we are getting dummy and real auxents
554: * in an unknown order. in this case
555: * we have to test to see which one is
556: * the dummy and either overwrite it
557: * or throw it away. We have this info
558: * in psymtab() and should be an arg
559: * to makeaux(). However a KLUDGE is
560: * to see which one is all 0's except
561: * for the tvndx and call that one the
562: * dummy. This should be cleaned up
563: * and made reasonable later.
564: */
565:
566: /* if incoming is not dummy */
567: if ( ! ( (aux->x_sym.x_tagndx == 0L) &&
568: (aux->x_sym.x_misc.x_fsize == 0L) &&
569: (aux->x_sym.x_fcnary.x_fcn.x_lnnoptr == 0L) &&
570: (aux->x_sym.x_fcnary.x_fcn.x_endndx == 0L) ) ) {
571: tvndx = a->axent.x_sym.x_tvndx;
572: a->axent = *aux;
573: if (tvndx != N_TV)
574: a->axent.x_sym.x_tvndx = tvndx;
575: }
576:
577: return( a );
578: }
579:
580: /*
581: * Step down the chain of aux entries, to the correct position for the
582: * new entry
583: */
584:
585: while( a->axord != ndx ) {
586: #if NOSDP
587: acid = a->axchainid;
588: a = getaux(acid);
589: #else
590: unlock(acid, RNLY);
591: acid = a->axchainid;
592: a = (AUXTAB *) lock(acid, MISPARTITION, RNLY);
593: #endif
594: }
595:
596: if( a->axchainid != 0 ) {
597: /*
598: * Overwriting an existing aux entry (but not the first aux
599: * entry). Warn the user
600: */
601: lderror(0,0,NULL,"Overwriting aux entry %d of symbol %s",
602: ndx+1, SYMNAME( sym->sment ));
603:
604: #if NOSDP
605: acid = a->axchainid;
606: a = getaux(acid);
607: #else
608: unlock(acid, RNLY);
609: acid = a->axchainid;
610: a = (AUXTAB *) lock(acid, MISPARTITION, WRTN);
611: #endif
612:
613: a->axent = *aux;
614:
615: return( a );
616: }
617: else {
618: /*
619: * Add the new aux entry at the end of the list
620: */
621: #if NOSDP
622: if (numldaux >= MYAXTBSZ + (xauxcnt * XAXTBSZ)) {
623: if (xauxcnt >= MAXEXTRA)
624: lderror(2,0,"internal error: ","aux table overflow");
625: xauxptr[xauxcnt++] = (AUXTAB *) myalloc(XAXTBSZ * AUXSIZ);
626: }
627: acid = a->axchainid = ++numldsyms;
628: a = getaux(acid);
629: #else
630: numldaux++;
631: a->axchainid = allocate(AUXSIZ, AUXSPACE, MISPARTITION);
632: unlock(acid, WRTN);
633: acid = a->axchainid;
634: a = (AUXTAB *) lock(acid, MISPARTITION, WRTN);
635:
636: zero( a, AUXSIZ );
637: #endif
638: a->axent = *aux;
639: a->axord = ndx + 1;
640: a->axmyacid = acid;
641: a->axchainid = 0;
642:
643: sym->sment.n_numaux++;
644:
645: return( a );
646: }
647: }
648:
649: ITEMID
650: putsym(sym, changed)
651: SYMTAB *sym;
652: int changed;
653: {
654:
655: /*
656: * Return a ld symbol table entry to the SDP empire ("unlock")
657: * Return the SDP access ID
658: */
659:
660: #if DEBUG
661: if( dflag > 15 )
662: fprintf( stderr, "\n putsym %s ", SYMNAME( sym->sment ));
663: #endif
664:
665: #if !NOSDP
666: unlock(sym->smmyacid, (changed ? WRTN : RNLY));
667: #endif
668: return( sym->smmyacid );
669: }
670:
671:
672: ITEMID
673: putaux(aux, changed)
674: AUXTAB *aux;
675: int changed;
676: {
677:
678: /*
679: * Return an auxiliary entry to the SDP empire ("unlock")
680: *
681: * Return the SDP access ID
682: */
683:
684: #if DEBUG
685: if( dflag > 15 )
686: fprintf( stderr, "\n putaux %8lx ", aux->axmyacid );
687: #endif
688:
689: #if !NOSDP
690: unlock(aux->axmyacid, (changed ? WRTN : RNLY));
691: #endif
692: return( aux->axmyacid );
693: }
694:
695:
696:
697: SYMTAB *
698: getsym(acid)
699: register ITEMID acid;
700: {
701:
702: /*
703: * Return a pointer to an ld symbol table entry, given the
704: * SDP access ID
705: */
706:
707: #if DEBUG
708: if( dflag > 15 )
709: fprintf( stderr, "\n getsym %8lx ", acid );
710: #endif
711:
712: #if NOSDP
713: if (acid <= 0)
714: lderror(2,0,"internal error: ","negative symbol table id");
715: if (acid <= MYSMTBSZ)
716: return(&mysymtab[acid]);
717: acid -= (MYSMTBSZ + 1);
718: if (acid < xsymcnt * XSMTBSZ)
719: return( (SYMTAB *) ( (long) xsymptr[acid/XSMTBSZ] + ((acid % XSMTBSZ) * SYMSIZ)) );
720: lderror(2,0,"internal error: ","invalid symbol table id");
721: #else
722: return( (SYMTAB *) lock(acid, MISPARTITION, RNLY) );
723: #endif
724: }
725:
726: AUXTAB *
727: getaux(acid)
728: ITEMID acid;
729: {
730:
731: /*
732: * Return a pointer to a ld aux entry, given the
733: * SDP access ID
734: */
735:
736: #if DEBUG
737: if( dflag > 15 )
738: fprintf( stderr, "\n getaux %8lx ", acid );
739: #endif
740:
741: #if NOSDP
742: if (acid <= 0)
743: lderror(2,0,"internal error: ","negative aux table id");
744: if (acid <= MYAXTBSZ)
745: return(&myauxtab[acid]);
746: acid -= (MYAXTBSZ + 1);
747: if (acid < xauxcnt * XAXTBSZ)
748: return( (AUXTAB *) ( (long) xauxptr[acid/XAXTBSZ] + ((acid % XAXTBSZ) * AUXSIZ)) );
749: lderror(2,0,"internal error: ","invalid aux table id");
750: #else
751: return( (AUXTAB *) lock(acid, MISPARTITION, RNLY) );
752: #endif
753: }
754: /*eject*/
755: long
756: #if FLEXNAMES
757: psymtab(fdes, numsyms, filp, symbuf,strtabptr)
758: char *strtabptr; /* pointer to string table with long symbol names, if
759: one exists */
760: #else
761: psymtab(fdes, numsyms, filp, symbuf, strtabptr)
762: #endif
763: FILE *fdes; /* pointer to the file, positioned to the symbol table */
764: long numsyms; /* total number of symbol table entries for the file */
765: INFILE *filp; /* pointer to the infilist entry for the file */
766: register SYMENT *symbuf;
767: {
768:
769: /*
770: * This routine is called during the scanning of the LDFILE list.
771: *
772: * Every *.o and archive library member which is to be link edited
773: * is processed exactly once by this function:
774: *
775: * 1. Add all ld symbols from the file to ld's cumulative
776: * ld symbol table
777: * ********** for FLEXNAMES ***********
778: * 1a. When there is a long symbol name, change the
779: * offset of the name in the symbol table to a pointer
780: * to the name
781: * ************************************
782: * 2. Compute and return the number of local symbol table
783: * entries (locals, statics, functions, etc.) for this
784: * file
785: */
786:
787:
788: register SYMENT *sym; /* input file symbol table entry */
789: register AUXENT *aux; /* symbol aux entry */
790: register SYMTAB *symp; /* ld symbol table entry pointer */
791: register long n;
792: long locsyms, /* nbr local symbols from input file */
793: relsyms, /* nbr relocatable symbols */
794: l;
795: int i; /* for-loop index */
796: char tmp_numaux,
797: tmp_sclass;
798: SYMENT lsymbuf;
799: AUXENT lauxbuf;
800:
801: sym = &lsymbuf;
802: aux = &lauxbuf;
803:
804: locsyms = 0L;
805: relsyms = 0L;
806:
807: for( n = 0L; n < numsyms; n++ ) {
808:
809: #if !PORTAR && !PORT5AR
810: if (symbuf != NULL)
811: sym = symbuf++;
812: else
813: #endif
814: if (fread(sym,SYMESZ,1,fdes) != 1)
815: lderror(2,0,NULL,"fail to read symbol table of file %s",
816: filp->flname);
817:
818: #if FLEXNAMES
819: /* this symbol has a long name - change offset to ptr */
820: if (sym->n_zeroes == 0L)
821: {
822: if (strtabptr == NULL)
823: lderror( 2, 90, NULL, "no string table in file %s", filp->flname );
824: sym->n_nptr = strtabptr + sym->n_offset;
825: }
826: #endif
827:
828: switch( sym->n_sclass ) {
829:
830: /*
831: * Symbols of type C_EXT are global, and must be added
832: * to ld's cumulative symbol table
833: */
834: case C_EXT:
835: relsyms++;
836: symp = makesym(sym, filp);
837:
838: if( sym->n_scnum > 0 )
839: symp->smscnptr = sectnum(sym->n_scnum,filp);
840:
841:
842: /*
843: * Functions, although added to ld's symbol
844: * table, must be put in the "local symbol"
845: * section of the final output file
846: */
847: if( ISFCN(sym->n_type) ) {
848: symp->smoutndx = locsyms;
849: locsyms += (long) (sym->n_numaux + 1);
850: symp->smlocflg = 1;
851: }
852:
853: n += (long) sym->n_numaux;
854: tmp_numaux = sym->n_numaux;
855: for( i = 0; i < tmp_numaux; i++ ) {
856: #if !PORTAR && !PORT5AR
857: if (symbuf != NULL)
858: aux = (AUXENT *) symbuf++;
859: else
860: #endif
861: if (fread(aux,AUXESZ,1,fdes) != 1)
862: lderror(2,0,NULL,"fail to read aux entries of file %s",
863: filp->flname);
864:
865: #if TRVEC
866: if ( i == 0 && (ISFCN( sym->n_type ) || (sym->n_type == 0)))
867: if (aux->x_sym.x_tvndx == N_TV) {
868: aux->x_sym.x_tvndx = P_TV;
869: tvspec.tvosptr->oshdr.s_size += TVENTSZ;
870: }
871: #endif
872: putaux( makeaux(symp, aux, i), 1 );
873: }
874:
875: PUTSYM(symp, 1);
876: break;
877:
878: case C_FILE:
879: #if DMERT || XL
880: if (!dmertplib)
881: #endif
882: locsyms += 1 + (long) sym->n_numaux;
883: if (sym->n_numaux) {
884: n += sym->n_numaux;
885: #if !PORTAR && !PORT5AR
886: if (symbuf != NULL)
887: symbuf++;
888: else
889: #endif
890: if (fseek( fdes, (long) (AUXESZ) * sym->n_numaux, 1 ) != 0)
891: lderror( 2, 0, NULL, "fail to skip aux entry of %s", filp->flname);
892: }
893: break;
894:
895: case C_STAT:
896: #if UNIX
897: relsyms++;
898: locsyms += 1 + sym->n_numaux;
899: if (sym->n_numaux == 1) {
900: n++;
901: #if !PORTAR && !PORT5AR
902: if (symbuf != NULL)
903: symbuf++;
904: else
905: #endif
906: if (fseek( fdes, (long) AUXESZ, 1 ) != 0)
907: lderror( 2, 0, NULL, "fail to skip the aux entry of %s", filp->flname);
908: };
909: continue;
910: #endif
911:
912: case C_HIDDEN:
913: relsyms++;
914:
915: default:
916: #if DMERT || XL
917: if (!dmertplib)
918: #endif
919: #if UNIX || XL
920: if (!xflag)
921: #endif
922: locsyms++;
923:
924: if( sym->n_numaux > 0 ) {
925:
926: #if DMERT || XL
927: if (!dmertplib)
928: #endif
929: #if UNIX || XL
930: if (!xflag)
931: #endif
932: locsyms += (long) sym->n_numaux;
933: n += (long) sym->n_numaux;
934: tmp_sclass = sym->n_sclass;
935: tmp_numaux = sym->n_numaux;
936: #if !PORTAR && !PORT5AR
937: if (symbuf != NULL)
938: aux = (AUXENT *) symbuf++;
939: else
940: #endif
941: if (fread(aux,AUXESZ,1,fdes) != 1)
942: lderror(2,0,NULL,"fail to read aux entries of %s",
943: filp->flname);
944:
945: /*
946: * Skip all aux entries after the first
947: */
948: if( tmp_numaux > 1 )
949: #if !PORTAR && !PORT5AR
950: if (symbuf != NULL)
951: symbuf++;
952: else
953: #endif
954: if (fseek(fdes, (long) (AUXESZ * (tmp_numaux-1)), 1) != 0)
955: lderror(2,0,NULL,"fail to skip the aux entry of %s",
956: filp->flname);
957:
958: /*
959: * Skip all members of structures and
960: * unions
961: */
962: if( ISTAG(tmp_sclass) ) {
963: l = aux->x_sym.x_fcnary.x_fcn.x_endndx - n - 1;
964: #if DMERT || XL
965: if (!dmertplib)
966: #endif
967: #if UNIX || XL
968: if (!xflag)
969: #endif
970: locsyms += l;
971: n = aux->x_sym.x_fcnary.x_fcn.x_endndx - 1;
972: #if !PORTAR && !PORT5AR
973: if (symbuf != NULL)
974: symbuf += l;
975: else
976: #endif
977: if (fseek(fdes, l * SYMESZ, 1) != 0)
978: lderror(2,0,NULL,"fail to skip the mem of struct of %s",
979: filp->flname);
980: }
981: #if TRVEC
982:
983: /*
984: * Increment size of .tv if this
985: * symbol needs a slot in the tv.
986: */
987: if( aflag && tvflag && (tmp_sclass == C_STAT) && (aux->x_sym.x_tvndx == N_TV) )
988: tvspec.tvosptr->oshdr.s_size += TVENTSZ;
989: #endif
990: }
991: }
992: }
993:
994: if( relsyms > maxrelocsms )
995: maxrelocsms = relsyms;
996:
997: return( locsyms );
998: }
999: /*eject*/
1000: SYMTAB *
1001: loopsym(sym, changed)
1002: SYMTAB *sym;
1003: int changed;
1004: {
1005:
1006: /*
1007: * Loop through all symbol table entries
1008: */
1009:
1010: #if NOSDP
1011: static long ndx;
1012: if (sym == NULL) ndx = 0;
1013: if (ndx < numldsyms)
1014: return(getsym(++ndx));
1015: else
1016: return(NULL);
1017: #else
1018: static long offset, /* offset of next symbol in page */
1019: page; /* SDP page number */
1020: register ITEMID acid;
1021: /*
1022: * WARNING: this implementation of loopsym() is extremely dependent
1023: * upon knowing exactly how SDP does things. In particular, it
1024: * is dependent upon symbol table entries being in one SDP space,
1025: * separate from aux entries. Anyone touching SDP
1026: * defines or code should check this function for accuracy.
1027: */
1028:
1029: #if DEBUG
1030: if( dflag > 15 )
1031: fprintf( stderr, "\nloopsym %8s ", sym->sment.n_name );
1032: #endif
1033:
1034: /*
1035: * This routine is used as follows:
1036: *
1037: * For the first call to this routine, sym is set to NULL.
1038: * For all subsequent calls, sym equals the value returned by
1039: * the previous call.
1040: * When sym again equals NULL, the entire table has been searched.
1041: */
1042:
1043: if( sym == NULL ) {
1044: /*
1045: * Build the itemid for first entry in symbol table
1046: */
1047: page = 1L;
1048: offset = 0L;
1049: acid = BUILDPN(page, SYMSPACE) + offset;
1050: if ( global_frames[SYMSPACE].maxpage == 0L )
1051: return( NULL ); /* no symbols */
1052: return( (SYMTAB *) lock(acid, MISPARTITION, RNLY) );
1053: }
1054:
1055: /*
1056: * Find the next symbol table entry:
1057: *
1058: */
1059:
1060: unlock(sym->smmyacid, (changed ? WRTN : RNLY));
1061:
1062: offset += (long) SYMSIZ;
1063: if ( (offset + (long) SYMSIZ) > (long) PAGESIZE ) {
1064: offset = 0L;
1065: if ( ++page > global_frames[SYMSPACE].maxpage )
1066: return(NULL);
1067: } else {
1068: /*
1069: * are we past the last entry on the last page?
1070: */
1071: if ( (page == global_frames[SYMSPACE].curpage) &&
1072: (offset == global_frames[SYMSPACE].curoffset) )
1073: return(NULL);
1074: }
1075: acid = BUILDPN(page, SYMSPACE) + offset;
1076: return( (SYMTAB *) lock(acid, MISPARTITION, RNLY) );
1077: #endif
1078: }
1079: /*eject*/
1080: AUXTAB *
1081: loopaux(sym, aux, changed)
1082: SYMTAB *sym;
1083: AUXTAB *aux;
1084: int changed;
1085: {
1086:
1087: /*
1088: * Loop through all the aux entries for a given ld symbol table entry
1089: *
1090: *
1091: * This routine is used as follows:
1092: *
1093: * For the first call to this routine, aux is set to NULL.
1094: * For all subsequent calls, aux equals the value returned by
1095: * the previous call.
1096: * When aux again equals NULL, all aux entries have been returned
1097: */
1098:
1099: #if DEBUG
1100: if( dflag > 15 )
1101: fprintf( stderr, "\nloopaux %s ", SYMNAME( sym->sment ) );
1102: #endif
1103:
1104: if( aux == NULL ) {
1105: /*
1106: * Get the first aux entry, pointed to by the ld symbol
1107: * table entry
1108: */
1109: if( sym->smauxid != 0 )
1110: #if NOSDP
1111: return(getaux(sym->smauxid));
1112: #else
1113: return( (AUXTAB *) lock(sym->smauxid, MISPARTITION, WRTN) );
1114: #endif
1115:
1116: return( NULL );
1117: }
1118:
1119: /*
1120: * Find the next aux entry
1121: */
1122:
1123: #if NOSDP
1124: if (aux->axchainid != 0)
1125: return(getaux(aux->axchainid));
1126: #else
1127: unlock(aux->axmyacid, (changed ? WRTN : RNLY));
1128:
1129: if( aux->axchainid != 0 )
1130: return( (AUXTAB *) lock(aux->axchainid, MISPARTITION, WRTN) );
1131: #endif
1132:
1133: return( NULL );
1134: }
1135: /*eject*/
1136: INSECT *
1137: sectnum(i, fp)
1138: int i;
1139: INFILE *fp;
1140: {
1141:
1142: /*
1143: * Called by psymtab to retrieve a pointer to the i-th section header
1144: */
1145:
1146: register INSECT *sptr;
1147:
1148: if (i == 0)
1149: return(NULL);
1150:
1151:
1152: for ( sptr = fp->flishead; sptr != NULL; sptr = sptr->isnext )
1153: if ( sptr->isecnum == i)
1154: return(sptr);
1155: return(NULL);
1156: }
1157: /*eject*/
1158: ITEMID
1159: add_dot(dot_val, dot_sec)
1160: long dot_val;
1161: INSECT *dot_sec;
1162: {
1163: register SYMTAB *sym;
1164: register ITEMID acid;
1165: static int count = 0;
1166:
1167: /*
1168: * This is a special-purpose "makesym()" designed for exclusive use
1169: * in assignment expressions. It will create a symbol table entry
1170: * having the following characteristics:
1171: *
1172: * n_name: .dotnnn 001 <= nnn <= 999
1173: * n_value: dot_val
1174: * n_scnum: 0
1175: * n_type: T_NULL
1176: * n_sclass: C_NULL
1177: * n_numaux: 0
1178: *
1179: * smscnptr: dot_sec
1180: * smlocflg: 1
1181: *
1182: * The symbol table entry will NOT appear in the hash table, and hence
1183: * will not be accessible except thorugh the stored itemid returned
1184: * by this function
1185: */
1186:
1187: #if NOSDP
1188: if (numldsyms >= MYSMTBSZ + (xsymcnt * XSMTBSZ)) {
1189: if (xsymcnt >= MAXEXTRA)
1190: lderror(2,0,"internal error: ","symbol table overflow");
1191: xsymptr[xsymcnt++] = (SYMTAB *) myalloc(XSMTBSZ * SYMSIZ);
1192: }
1193: acid = ++numldsyms;
1194: sym = getsym(acid);
1195: #else
1196: acid = allocate(SYMSIZ, SYMSPACE, MISPARTITION);
1197: sym = (SYMTAB *) lock(acid, MISPARTITION, WRTN);
1198:
1199: zero(sym, SYMSIZ);
1200: #endif
1201: sprintf(sym->sment.n_name, ".dot%03d", ++count);
1202: sym->sment.n_value = dot_val;
1203: sym->smscnptr = dot_sec;
1204: sym->smmyacid = acid;
1205: sym->smchainid = acid;
1206: sym->smlocflg = 1;
1207:
1208: #if !NOSDP
1209: unlock(acid, WRTN);
1210: #endif
1211:
1212: return( acid );
1213:
1214: }
1215:
1216: #if !NOSDP
1217: auxinit()
1218: {
1219: /* initialize SDP */
1220:
1221: if ( aux_called )
1222: lderror(2,0,NULL,"attempt to re-initialize SDP aux space");
1223:
1224: sprintf( auxname, "%s/%s", TMPDIR, "ldXXXXXX");
1225: mktemp(auxname);
1226: aux_called++;
1227: if ( sdpinit(auxname, CREATE, AUXSPACE) != AUXSPACE )
1228: lderror(2,0,NULL,"failure to initialize SDP aux space");
1229: else
1230: aux_called++;
1231: }
1232:
1233: auxfini()
1234: {
1235:
1236: char buf[sizeof(auxname)*2+20];
1237:
1238: if ( aux_called == 2 ) {
1239: aux_called--;
1240: if ( sdpterm(AUXSPACE) < 0 )
1241: lderror(2,0,NULL,"failure in closing SDP aux space");
1242: }
1243:
1244: if ( aux_called != 1)
1245: return;
1246: aux_called--;
1247:
1248: #if TS || RT
1249: sprintf(buf, "rm -r %s", auxname);
1250: #else
1251: sprintf(buf, "rm -r %s; rmdir %s", auxname, auxname);
1252: #endif
1253:
1254: if ( fork() == 0 ) {
1255: execl("/bin/sh", "sh", "-c", buf, 0);
1256: lderror(0,0,NULL, "failure in the execl of %s",buf);
1257: _exit(127);
1258: }
1259: }
1260: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.