![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to alloc.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 alloc.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 root 1: static char ID[] = "@(#) alloc.c: 1.7 5/27/83";
2: #include "system.h"
3:
4: #include <stdio.h>
5: #include "structs.h"
6: #include "extrns.h"
7: #include "list.h"
8: #include "params.h"
9: #include "sgsmacros.h"
10: #include "ldmacros.h"
11:
12: #if TRVEC
13: #include "sdpsrc/hd/define2.h"
14: #include "tv.h"
15: #include "ldtv.h"
16: #endif
17:
18: #define L15 0xfL
19: /*eject*/
20: alloc()
21: {
22:
23: /*
24: * Perform the allocation of the output sections into the configured
25: * memory
26: */
27:
28: bldmemlist(); /* build initial address space from memlist */
29:
30: #if USEREGIONS
31: bldreglist(); /* collate regions into available space */
32: #endif
33:
34: alc_bonds(); /* allocate bonded output sections */
35:
36: #if DEBUG
37: if( dflag > 1 ) {
38: fprintf(stderr, "\n\nalc_bonds");
39: dump_mem();
40: }
41: #endif
42:
43: alc_owners(); /* allocate out sects assigned to owners */
44: alc_attowns(); /* allocate out sects assigned to attributes */
45:
46: #if DEBUG
47: if( dflag > 1 ) {
48: fprintf(stderr, "\n\nalc_own, alc_att");
49: dump_mem();
50: }
51: #endif
52:
53: #if IANDD && USEREGIONS
54: if( iflag && ( ! tvflag ) )
55: alc_iandd(); /* separate I and D */
56: #endif
57:
58: alc_the_rest(); /* allocate everything as yet unallocated */
59:
60: #if DEBUG
61: if( dflag > 1 ) {
62: fprintf(stderr, "\n\nalc_iandd, alc_rest");
63: dump_mem();
64: }
65: #endif
66:
67: #if USEREGIONS
68: if (tvflag && (reglist.head == NULL))
69: bld_regions();
70: #endif
71:
72: audit_groups();
73:
74: audit_regions();
75:
76: #if DEBUG
77: if( dflag > 1 ) {
78: fprintf(stderr, "\nbld_reg, audit_grp, audit_reg");
79: dump_mem();
80: }
81: #endif
82:
83: if (aflag)
84: set_spec_syms(); /* generate special symbols for absolute load */
85:
86: }
87: /*eject*/
88: bldmemlist()
89: {
90:
91: register MEMTYPE *mp;
92: register ANODE *ap;
93:
94: /*
95: * Build the initial address space from the memlist
96: */
97:
98: for( mp = (MEMTYPE *) memlist.head; mp != NULL; mp = mp->mtnext ) {
99: ap = newnode();
100: ap->adpaddr = mp->mtorig;
101: ap->adsize = mp->mtlength;
102: ap->admemp = mp;
103: mp->mtaddrhd=mp->mtaddrtl = ap;
104: listadd(l_ADR, &avlist, ap);
105: }
106:
107: #if DEBUG
108: if( dflag )
109: dump_mem();
110: #endif
111:
112: }
113: /*eject*/
114: alc_bonds()
115: {
116:
117: /*
118: * Process the bond.list, allocating all output sections which have
119: * been bonded to specific addresses
120: */
121:
122: ACTITEM *aip, /* ptr to bonded section */
123: *nextaip; /* ptr to next item on bond.list */
124: ANODE *sap, /* ptr to memory node containing bond address */
125: *eap, *newap, *splitnode();
126: OUTSECT *osp, /* ptr to output section description for the bonded section */
127: *bsp;
128: ADDRESS lastaddr, have, need;
129:
130: for( aip = (ACTITEM *) bondlist.head; aip != NULL; aip = nextaip ) {
131: nextaip = aip->bond.ainext;
132: osp = aip->bond.aioutsec;
133: /*
134: * DSECT sections are bonded at the requested address,
135: * but are not allocated any memory
136: */
137: if( osp->oshdr.s_flags & STYP_DSECT) {
138: osp->oshdr.s_paddr = osp->oshdr.s_vaddr = aip->bond.aiadrbnd;
139: listadd(l_DS, &dsectlst, osp);
140: free(aip);
141: continue;
142: }
143: /*
144: * For the current bonded section, find out in which of
145: * the space nodes the bond address is located
146: */
147: for( sap = (ANODE *) avlist.head; sap != NULL; sap = sap->adnext ) {
148: if( sap->adpaddr+(ADDRESS)sap->adsize > aip->bond.aiadrbnd)
149: break;
150: }
151:
152: if(sap == NULL) {
153: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
154: "bond address %.2lx for %.8s is outside all configured memory",
155: aip->bond.aiadrbnd, (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name);
156: free(aip);
157: continue;
158: }
159: /*
160: * If an space node exists for the bond address, sap
161: * points to it
162: */
163: if( sap->adpaddr > aip->bond.aiadrbnd ) {
164: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
165: "bond address %.2lx for %.8s is not in configured memory",
166: aip->bond.aiadrbnd, (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name);
167: free(aip);
168: continue;
169: }
170: /*
171: * Make sure the space node is of type ADAVAIL (i.e, that
172: * it is unallocated memory
173: */
174: if(sap->adtype != ADAVAIL) {
175: bsp=sap->adscnptr;
176: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
177: "bond address %.2lx for %.8s overlays previously allocated section %.8s at %.2lx",
178: aip->bond.aiadrbnd, (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name,
179: bsp->oshdr.s_name, sap->adpaddr);
180: free(aip);
181: continue;
182: }
183: /*
184: * If the bond address is not the start of an AVAIL
185: * node, split the AVAIL node into two nodes. The
186: * first will be AVAIL, the second SECT
187: */
188: if( sap->adpaddr < aip->bond.aiadrbnd ) {
189: newap = splitnode(sap,aip->bond.aiadrbnd);
190: sap = newap;
191: }
192: /*
193: * Make sure the entire bonded section will fit into memory
194: * 1. The bonded section must fit into configured memory
195: * 2. Each space node into which the section falls
196: * must be of type AVAIL
197: * 3. Each space node must be contiguous
198: */
199: have = sap->adpaddr + sap->adsize;
200: /*
201: * special processing for special people:
202: * if one needs to allocate more memory
203: * than is explicitly demanded, do
204: * so here [ in special.c ]
205: */
206:
207: need = sap->adpaddr + osp->oshdr.s_size;
208: adjneed(&need, osp, sap);
209: eap = sap;
210: lastaddr = sap->adpaddr;
211: while ( have < need ) {
212: lastaddr += eap->adsize;
213: eap = eap->adnext;
214: if(eap == NULL) {
215: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
216: "%.8s, bonded at %.2lx, won't fit into configured memory",
217: (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name, aip->bond.aiadrbnd);
218: free(aip);
219: break;
220: }
221: if(eap->adtype != ADAVAIL) {
222: bsp = eap->adscnptr;
223: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
224: "%.8s at %.2lx overlays previously allocated section %.8s at %.2lx",
225: (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name, aip->bond.aiadrbnd,
226: bsp->oshdr.s_name, eap->adpaddr);
227: eap = NULL;
228: free(aip);
229: break;
230: }
231: if(eap->adpaddr != lastaddr) {
232: lderror(1, aip->bond.aiinlnno, aip->bond.aiinflnm,
233: "%.8s enters unconfigured memory at %.2lx",
234: (*(osp->oshdr.s_name) == '\0') ? "GROUP" : osp->oshdr.s_name, lastaddr);
235: eap = NULL;
236: free(aip);
237: break;
238: }
239: have += eap->adsize;
240: }
241: if( eap == NULL )
242: continue;
243: /*
244: * If the bonded section does not end at the end of the
245: * space node, split the space node up. The first will
246: * be SECT, the second AVAIL
247: */
248: if ( have > need )
249: newap = splitnode(eap, need);
250: /*
251: * Reserve and set the output section ptrs
252: * in the address subspace
253: */
254: do_alloc(sap,eap,osp);
255:
256: free(aip);
257: }
258: }
259: /*eject*/
260: alc_owners()
261: {
262:
263: /*
264: * Allocate the output sections which have been given explicit
265: * owners. The owner of a section can be either a memory area, or a
266: * region
267: */
268:
269: ACTITEM *aip, /* ptr to section having an owner */
270: *nextaip; /* ptr to next item on ownlist */
271: MEMTYPE *mp; /* ptr to a memory area item */
272: #if USEREGIONS
273: REGION *rp; /* ptr to a region item */
274: #endif
275: ANODE *ap1, *ap2;
276: short failure;
277:
278: for( aip = (ACTITEM *) ownlist.head; aip != NULL; aip = nextaip ) {
279: nextaip = aip->dfownr.ainext;
280: /*
281: * It is meaningless to have owners for a DSECT
282: * since they are not allocated
283: */
284: if( aip->dfownr.aioutsec->oshdr.s_flags & STYP_DSECT) {
285: lderror(1, aip->dfownr.aiinlnno, aip->dfownr.aiinflnm,
286: "DSECT %.8s can't be given an owner",
287: aip->dfownr.aioutsec->oshdr.s_name);
288: free(aip);
289: continue;
290: }
291:
292: /*
293: * Look in memlist for the owner's name
294: */
295: failure = 1;
296: for( mp = (MEMTYPE *) memlist.head; mp != NULL; mp = mp->mtnext ) {
297: if( equal(aip->dfownr.ainamown,mp->mtname,8) &&
298: (can_alloc(mp->mtaddrhd,mp->mtaddrtl,aip->dfownr.aioutsec,
299: &ap1,&ap2)) ) {
300: /*
301: * Found where to put the output section
302: */
303: do_alloc(ap1,ap2,aip->dfownr.aioutsec);
304: failure = 0;
305: break;
306: }
307: }
308: #if USEREGIONS
309: /*
310: * If the name was not found in the memlist, (failure still
311: * 1), then try the reglist
312: */
313: if( ! failure ) {
314: free(aip);
315: continue;
316: }
317:
318: for( rp = (REGION *) reglist.head; rp != NULL; rp = rp->rgnext ) {
319: if( equal(aip->dfownr.ainamown,rp->rgname,8) &&
320: (can_alloc(rp->rgaddrhd,rp->rgaddrtl,aip->dfownr.aioutsec,
321: &ap1,&ap2)) ) {
322: /*
323: * Output section goes in this region
324: * between ap1 and ap2
325: */
326: do_alloc(ap1,ap2,aip->dfownr.aioutsec);
327: failure = 0;
328: break;
329: }
330: }
331: #endif
332:
333:
334: /*
335: * If failed in to find where to put the output section,
336: * issue an error message
337: */
338: if(failure)
339: lderror(1, aip->dfownr.aiinlnno, aip->dfownr.aiinflnm,
340: "can't allocate section %.8s into owner %.8s",
341: aip->dfownr.aioutsec->oshdr.s_name,aip->dfownr.ainamown);
342:
343: free(aip);
344: }
345:
346: }
347: /*eject*/
348: alc_attowns()
349: {
350:
351: /*
352: * Allocate the output sections assigned to any memory type
353: * with a given attribute
354: */
355:
356: ACTITEM *aip, /* ptr to section tied to an attribute */
357: *nextaip; /* ptr to next item on atownlst */
358: MEMTYPE *mp; /* ptr to an item on the memlist */
359: ANODE *ap1, *ap2;
360: short failure;
361:
362: for( aip = (ACTITEM *) atownlst.head; aip != NULL; aip = nextaip ) {
363: nextaip = aip->ownatr.ainext;
364: /*
365: * It is meaningless to associate a DSECT with an
366: * attribute, since they are not allocated any memory
367: */
368: if( aip->ownatr.aioutsec->oshdr.s_flags & STYP_DSECT) {
369: lderror(1, aip->ownatr.aiinlnno, aip->ownatr.aiinflnm,
370: "DSECT %.8s can't be linked to an attribute",
371: aip->ownatr.aioutsec->oshdr.s_name);
372: free(aip);
373: continue;
374: }
375:
376: /*
377: * Look for a memory area with the specified attribute
378: */
379: failure = 1;
380: for( mp = (MEMTYPE *) memlist.head; mp != NULL; mp = mp->mtnext ) {
381: if( (aip->ownatr.aiownatt == mp->mtattr) &&
382: (can_alloc(mp->mtaddrhd,mp->mtaddrtl,
383: aip->ownatr.aioutsec,&ap1,&ap2)) ) {
384: do_alloc(ap1,ap2,aip->ownatr.aioutsec);
385: failure = 0;
386: break;
387: }
388: }
389:
390: if(failure)
391: lderror(1,0,NULL, "can't allocate %.8s with attr %x",
392: aip->ownatr.aioutsec->oshdr.s_name,aip->ownatr.aiownatt);
393:
394: free(aip);
395: }
396: }
397: /*eject*/
398: alc_the_rest()
399: {
400:
401: /*
402: * Allocate every output section that is not as yet allocated
403: */
404:
405: ANODE **anlp; /* ptr to (sorted) avail node list */
406: OUTSECT **usp; /* ptr to (sorted) unalloc outsect list */
407:
408: ANODE *ap; /* ptr to element from anlp */
409: short numanods, /* number of avail nodes */
410: nanl; /* working index into anlp */
411: OUTSECT *osp; /* ptr to element from usp */
412: short numuaos, /* number of unalloc outsects */
413: nuaos; /* working index into usp */
414: int cmp_uos(), /* qsort sorting routine */
415: cmp_anl(); /* qsort sorting routine */
416:
417: /*
418: * Build a list of unallocated output sections
419: */
420:
421: numuaos = 0;
422: for( osp = (OUTSECT *) outsclst.head; osp != NULL; osp = osp->osnext )
423: if( (osp->oshdr.s_paddr == -1L) && (! (osp->oshdr.s_flags & STYP_DSECT)) )
424: numuaos++;
425: if(numuaos == 0)
426: return; /* nothing left to allocate */
427:
428: usp = (OUTSECT **) myalloc(sizeof(OUTSECT *) * (numuaos + 1));
429: nuaos = 0;
430: for( osp = (OUTSECT *) outsclst.head; osp != NULL; osp = osp->osnext )
431: if(osp->oshdr.s_paddr == -1L) {
432: /*
433: * Allocate DSECTs so as to start at zero
434: */
435: if( osp->oshdr.s_flags & STYP_DSECT) {
436: osp->oshdr.s_paddr = 0L;
437: listadd(l_DS,&dsectlst,osp);
438: }
439: else
440: usp[nuaos++] = osp;
441: }
442:
443: #if USEREGIONS
444: /*
445: * Sort only if more than 3 output sections. This exempts the
446: * basic load, containing only .text, .data, and .bss sections.
447: * They will usually be in the usual order.
448: *
449: * NOTE: Sort only if REGIONS directives were supplied
450: */
451:
452: if( (numuaos > 3) && (reglist.head != NULL) )
453: qsort(usp, numuaos, sizeof(osp), cmp_uos);
454: #endif
455: usp[nuaos] = NULL;
456:
457: /*
458: * Build the list of avail space nodes
459: *
460: * The size of the list used to hold the AVAIL pointers must be big
461: * enough to allow for possible fragmentation of an existing AVAIL
462: * node during allocation:
463: *
464: * 1 AVAIL node -> 1 AVAIL node (due to ALIGNment)
465: * 1 ADSECT node (assigned to the OUTSECT)
466: * 1 AVAIL node (remainder of original AVAIL node)
467: *
468: */
469:
470: numanods = 0;
471: for( ap = (ANODE *) avlist.head; ap != NULL; ap = ap->adnext )
472: if( (ap->adtype == ADAVAIL) && ((reglist.head == NULL) || (ap->adregp != NULL)) )
473: numanods++;
474:
475: anlp = (ANODE **) myalloc( sizeof(ANODE *) * (numanods + 1) +
476: sizeof(OUTSECT *) * (numuaos) );
477:
478: nanl = 0;
479: for( ap = (ANODE *) avlist.head; ap != NULL; ap = ap->adnext )
480: if( (ap->adtype==ADAVAIL) && ((reglist.head == NULL) || (ap->adregp != NULL)) )
481: anlp[nanl++] = ap;
482:
483: #if USEREGIONS
484: /*
485: * Sort the avail space node list, on space size, from low to high
486: */
487:
488: qsort(anlp,numanods,sizeof(ap),cmp_anl);
489: #endif
490: anlp[nanl] = NULL; /* terminating entry */
491:
492: alc_lists(usp, anlp, nanl);
493:
494: free(usp);
495: free(anlp);
496: }
497: /*eject*/
498: audit_groups()
499: {
500: OUTSECT *grpp, *osp, *prevp, *p;
501: ANODE *ap;
502: ADDRESS addr;
503:
504: prevp = NULL;
505: grpp = (OUTSECT *) outsclst.head;
506: while (grpp) {
507: if( grpp->oshdr.s_flags & STYP_GROUP) {
508: addr = grpp->oshdr.s_paddr;
509: if( (ap=findsanode(grpp)) == NULL )
510: lderror(2,0,NULL, "internal error: audit_groups, findsanode failure");
511: ((OUTSECT *) grpp->osinclhd)->osblock = grpp->osblock;
512: for( osp = (OUTSECT *) grpp->osinclhd; osp != NULL; osp = osp->osnext )
513: if (osp->oshdr.s_flags & STYP_DSECT) {
514: osp->oshdr.s_paddr = addr;
515: listadd( l_DS, &dsectlst, osp );
516: } else {
517: if ( !(ap->adscnptr->oshdr.s_flags & STYP_GROUP))
518: ap = splitnode( ap, addr );
519: ap->adscnptr = osp;
520: if( ap->adpaddr != addr )
521: lderror(2,0,NULL, "internal error: audit_groups, address mismatch");
522: osp->oshdr.s_paddr = addr;
523: addr += osp->oshdr.s_size;
524: }
525: if( prevp )
526: prevp->osnext = (OUTSECT *) grpp->osinclhd;
527: else
528: outsclst.head = (char *) grpp->osinclhd;
529: prevp = (OUTSECT *) grpp->osincltl;
530: prevp->osnext = grpp->osnext;
531: p = grpp;
532: grpp = grpp->osnext;
533: if( grpp == NULL )
534: outsclst.tail = (char *) prevp;
535: free(p);
536: }
537: else {
538: prevp = grpp;
539: grpp = grpp->osnext;
540: }
541: }
542:
543: #if DEBUG
544: if( dflag )
545: dmp_outsects();
546: #endif
547: }
548: /*eject*/
549: audit_regions()
550: {
551:
552: /*
553: * 1. Compute the virtual addresses of each output section
554: * The logic used by ld results in physical addresses being computed
555: * prior to virtual addresses
556: *
557: * 2. Perform a consistency check, to make sure sufficient regions
558: * have been defined, where regions are necessary
559: */
560:
561: register ANODE *ap;
562: register OUTSECT *osp;
563: #if USEREGIONS
564: register REGION *rp;
565:
566: if( reglist.head == NULL ) {
567: lderror(1,0,NULL, "internal error: audit_regions detected no regions built");
568: return;
569: }
570: #endif
571:
572: for( ap = (ANODE *) avlist.head; ap != NULL; ap = ap->adnext ) {
573: if( ap->adtype == ADSECT) {
574: #if USEREGIONS
575: rp = ap->adregp;
576: osp = ap->adscnptr;
577: if( ap->adpaddr == osp->oshdr.s_paddr )
578: if( rp != NULL)
579: osp->oshdr.s_vaddr = rp->rgvaddr + ap->adpaddr - rp->rgorig;
580: else
581: osp->oshdr.s_vaddr = osp->oshdr.s_paddr;
582: /*
583: * Make sure every output section goes into some
584: * region
585: */
586: if( ! ap->adregp )
587: lderror(1,0,NULL,"output section %.8s not allocated into a region",
588: osp->oshdr.s_name);
589: #else
590: osp = ap->adscnptr;
591: if( ap->adpaddr == osp->oshdr.s_paddr )
592: osp->oshdr.s_vaddr = osp->oshdr.s_paddr;
593: #endif
594: }
595: }
596:
597: return;
598:
599: }
600: /*eject*/
601: ANODE *
602: findsanode(osp)
603: OUTSECT *osp;
604: {
605:
606: /*
607: * Run down the avlist and look for a particular
608: * section pointer. Return the pointer to the
609: * ANODE containing it, or return NULL.
610: */
611:
612: register ANODE *ap;
613:
614: for( ap = (ANODE *) avlist.head; ap != NULL; ap = ap->adnext )
615: if( ap->adscnptr == osp )
616: break;
617:
618: return ( ap );
619: }
620: /*eject*/
621: alc_lists(usl,anl,nanl)
622: OUTSECT *usl[]; /* sorted list of output sections */
623: ANODE *anl[]; /* sorted list of available space */
624: short nanl; /* next free entry in the anl list*/
625: {
626: OUTSECT *usp;
627: ANODE *ap1, *ap2, *ap3;
628: short ani, /* index into sorted ANODEs */
629: usi, /* index into sorted OUTSECTs */
630: new_node; /* flag if ANODE was split up */
631: int cmp_anl(); /* qsort sorting routine */
632:
633: /*
634: * For each unallocated output section:
635: * 1. Find the first free AVAIL node which can contain it
636: * 2. Allocate the OUTSECT node to the AVAIL node
637: *
638: * The list of unallocated output sections is sorted DECREASING,
639: * by section size.
640: *
641: * The list of available space is sorted INCREASING, on the size of
642: * the space
643: */
644:
645: for( usi = 0; usl[usi]; usi++ ) {
646:
647: usp = usl[usi];
648:
649: for( ani = 0; anl[ani]; ani++ )
650: if( anl[ani]->adsize >=
651: (alignment(usp->osalign, anl[ani]->adpaddr)
652: + usp->oshdr.s_size) )
653: break;
654:
655: if(anl[ani] == NULL) {
656: lderror(1,0,NULL, "can't allocate output section %.8s, of size %10.1lx",
657: usp->oshdr.s_name, usp->oshdr.s_size);
658: continue;
659: }
660:
661: new_node = (anl[ani]->adsize != usp->oshdr.s_size);
662: ap3 = anl[ani]->adnext;
663: if( ! can_alloc(anl[ani], anl[ani], usp, &ap1, &ap2)) {
664: lderror(2,0,NULL, "internal error: in allocate lists, list confusion (%d %d)",
665: usi, ani);
666: dump_mem();
667: }
668: do_alloc(ap1, ap2, usp);
669:
670: if(new_node) {
671: /*
672: * If the node at anl[ani] was fragmented, then
673: * update the anl list. The current
674: * AVAIL node could have generated either one
675: * or two smaller AVAIL nodes
676: */
677: if( ap1 == anl[ani] )
678: anl[ani] = ap1->adnext;
679: else
680: #if USEREGIONS
681: if( ap2->adnext != ap3 ) {
682: anl[nanl++] = ap2->adnext;
683: anl[nanl] = NULL;
684: }
685: qsort(anl, nanl, sizeof(ap1), cmp_anl);
686: #else
687: if( ap2->adnext != ap3 ) {
688: for( new_node = nanl; new_node > ani; new_node-- )
689: anl[new_node] = anl[new_node-1];
690: anl[ani+1] = ap2->adnext;
691: anl[++nanl] = NULL;
692: }
693: #endif
694: }
695: else {
696: /*
697: * The node at anl[ani] was competely used,
698: * so remove it from the list and move all
699: * the other entries up one space
700: */
701: for( nanl--; anl[ani]; ani++ )
702: anl[ani] = anl[ani+1];
703: }
704: }
705:
706: return(nanl); /* new length of available space list */
707: }
708: /*eject*/
709: can_alloc(sap,eap,scp,pap1,pap2)
710: ANODE *sap, *eap;
711: OUTSECT *scp;
712: ANODE **pap1, **pap2;
713: {
714:
715: /*
716: * Determine if the output section pointed to by scp can fit
717: * somewhere between sap and eap.
718: *
719: * If it can, pap1 and pap2 are given the subrange start and end,
720: * and 1 is returned. Otherwise 0 is returned
721: */
722:
723: ADDRESS disp, /* alignment */
724: have, /* last address allocated */
725: need; /* final needed allocation */
726: register ANODE *ap1, *ap2; /* working pointers */
727: ANODE *splitnode(),
728: *newnode();
729: short success;
730:
731: success = 0;
732: ap2=sap;
733: while(!success) {
734: ap1 = ap2;
735: while(! (ap1->adtype == ADAVAIL && (ap1->adregp != NULL || reglist.head == NULL)) )
736: if( ap1 == eap )
737: return(0);
738: else
739: ap1=ap1->adnext;
740: disp=alignment(scp->osalign,ap1->adpaddr);
741: have = ap1->adsize + ap1->adpaddr;
742: need = ap1->adpaddr + disp + scp->oshdr.s_size;
743: ap2 = ap1;
744: while ( need > have ) {
745: if(ap2 == eap)
746: return(0);
747: ap2 = ap2->adnext;
748:
749: if(ap2->adtype != ADAVAIL)
750: break;
751:
752: if(ap2->adprev->adpaddr+ap2->adprev->adsize != ap2->adpaddr)
753: break;
754:
755: if(ap2->adregp==NULL && reglist.head != NULL )
756: break;
757: have += ap2->adsize;
758: }
759: if ( have >= need )
760: success = 1;
761: }
762:
763: /*
764: * To reach this point, success must have been achieved
765: */
766:
767: if ( disp != 0L ) {
768: /*
769: * Split the node because of alignment
770: */
771: ANODE *newap;
772: newap = splitnode(ap1,ap1->adpaddr+disp);
773: if(ap1 == ap2)
774: ap2 = newap;
775: ap1 = newap;
776: }
777: if ( have > need ) {
778: /*
779: * If ending in the middle of a node, split the node
780: */
781: ANODE *newap;
782: newap = splitnode(ap2,need);
783: }
784:
785: *pap1 = ap1; /* output parameters */
786: *pap2 = ap2;
787:
788: return(1);
789: }
790: /*eject*/
791: ANODE *
792: splitnode(ap,addr)
793: ANODE *ap;
794: ADDRESS addr;
795: {
796: register ANODE *newap;
797: ANODE *newnode();
798:
799: newap = newnode();
800:
801: copynode(newap,ap);
802:
803: if( ap->adnext != NULL )
804: ap->adnext->adprev = newap;
805: newap->adprev = ap;
806: ap->adnext = newap;
807:
808: ap->adsize = addr - ap->adpaddr;
809: newap->adsize -= ap->adsize;
810: newap->adpaddr = addr;
811:
812: if( (ANODE *) avlist.tail == ap )
813: avlist.tail = (char *) newap;
814:
815: if( ap->admemp->mtaddrtl == ap )
816: ap->admemp->mtaddrtl = newap;
817: if( (ap->adregp != NULL) && (ap->adregp->rgaddrtl == ap) )
818: ap->adregp->rgaddrtl = newap;
819:
820: return(newap);
821: }
822: /*eject*/
823: do_alloc(ap1,ap2,scp)
824: ANODE *ap1, *ap2;
825: OUTSECT *scp;
826: {
827: register ANODE *ap;
828:
829: for( ap = ap1; ap != ap2->adnext; ap = ap->adnext ) {
830: ap->adtype = ADSECT;
831: ap->adscnptr = scp;
832: }
833:
834: scp->oshdr.s_paddr = ap1->adpaddr;
835: }
836: /*eject*/
837: ANODE *
838: findnode(adr,flg)
839: ADDRESS adr;
840: int flg;
841: {
842:
843: /*
844: * "flg" is used if the adr falls between two nodes.
845: * flg == 1: return next node,
846: * flg == 0: return prev node.
847: */
848:
849: register ANODE *ap;
850:
851: for( ap = (ANODE *) avlist.head; ap != NULL; ap = ap->adnext ) {
852:
853: if(ap->adpaddr > adr)
854: /*
855: * adr is between nodes
856: */
857: if( flg )
858: return(ap);
859: else
860: return(ap->adprev);
861:
862: if( ap->adpaddr+ap->adsize > adr )
863: /*
864: * adr is within a node
865: */
866: return(ap);
867:
868: }
869:
870: /*
871: * adr is outside all configured memory
872: */
873:
874: return((ANODE *) -1);
875: }
876: /*eject*/
877: cmp_anl(p1,p2)
878: ANODE **p1, **p2;
879: {
880:
881: /*
882: * Compare two ANODEs, returning:
883: *
884: * -1 when p1 < p2
885: * 0 when p1 == p2
886: * +1 when p1 > p2
887: *
888: * The adsize field is used for the comparison
889: */
890:
891: if( (*p1)->adsize < (*p2)->adsize ) return(-1);
892:
893: if( (*p1)->adsize == (*p2)->adsize ) return(0);
894:
895: return(1);
896: }
897:
898:
899:
900:
901:
902: cmp_uos(p1,p2)
903: OUTSECT **p1, **p2;
904: {
905:
906: /*
907: * Compare two OUTSECT nodes, returning:
908: *
909: * +1 when p1 < p2
910: * 0 when p1 == p2
911: * -1 when p1 > p2
912: *
913: * The oshdr.s_size field is used for the comparison
914: */
915:
916: if( (*p1)->oshdr.s_size < (*p2)->oshdr.s_size ) return(1);
917:
918: if( (*p1)->oshdr.s_size == (*p2)->oshdr.s_size ) return(0);
919:
920: return(-1);
921: }
922: /*eject*/
923: ANODE *
924: newnode()
925: {
926:
927: /*
928: * Return a blanked out node
929: */
930:
931: register ANODE *ap;
932:
933: ap = (ANODE *) myalloc(sizeof(ANODE));
934:
935: ap->adtype = ADAVAIL;
936:
937: return(ap);
938: }
939:
940:
941:
942:
943:
944: copynode(new,old)
945: ANODE *new, *old;
946: {
947: new->adnext = old->adnext;
948: new->adprev = old->adprev;
949: new->adpaddr = old->adpaddr;
950: new->adsize = old->adsize;
951: new->admemp = old->admemp;
952: new->adregp = old->adregp;
953: new->adscnptr = old->adscnptr;
954: new->adtype = old->adtype;
955: }
956: /*eject*/
957: long
958: alignment(align,paddr)
959: ADDRESS align ; /* this will be a power or two */
960: ADDRESS paddr;
961: {
962: register ADDRESS l;
963:
964: if ( align <= 1 )
965: return(0);
966:
967: l = (paddr + (align - 1)) & ~(align - 1);
968:
969: return(l - paddr);
970: }
971: /*eject*/
972: creatsym(name,value)
973: char *name;
974: long value;
975: {
976:
977: /*
978: * Generate a special ld-define symbol. The name of the symbol is
979: * pointed to by 'name', and its value is given by 'value'
980: *
981: * Such a symbol is defined to have a basic symbol type of T_NULL
982: */
983:
984: register SYMTAB *p;
985: SYMENT q;
986:
987: /*
988: * Special symbols are generated only under the "-a" flag
989: */
990:
991: if( ! aflag )
992: return;
993:
994: if( (p = (SYMTAB *) findsym(name)) == NULL ) {
995: /*
996: * Case 1: This is the first time the special symbol
997: * has been encountered
998: */
999: zero(&q, SYMESZ);
1000: #if FLEXNAMES
1001: if (strlen(name) > 8) {
1002: q.n_zeroes = 0L;
1003: q.n_nptr = name;
1004: }
1005: else
1006: #endif
1007: copy(q.n_name, name, 8);
1008: q.n_sclass = C_EXT;
1009: q.n_scnum = -1; /* for absolute symbol */
1010: q.n_value = value;
1011: q.n_type = T_NULL;
1012: p = makesym(&q, NULL);
1013: }
1014: else if( p->sment.n_scnum == 0 ) {
1015: /*
1016: * Case 2: The special symbol has been previously
1017: * referenced but not defined
1018: */
1019: p->sment.n_sclass = C_EXT;
1020: p->sment.n_scnum = -1;
1021: p->sment.n_value = value;
1022: p->sment.n_type = T_NULL;
1023: }
1024:
1025: if( p->sment.n_scnum == -1 )
1026: p->smnewval = p->sment.n_value;
1027:
1028: PUTSYM(p, 1);
1029: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.