![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to layout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to layout.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* layout.c (was part of write.c in original GAS version)
2: Copyright (C) 1986,1987 Free Software Foundation, Inc.
3:
4: This file is part of GAS, the GNU Assembler.
5:
6: GAS is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GAS is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GAS; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: #include <stdlib.h>
21: #include <string.h>
22: #include "stuff/round.h"
23: #include "as.h"
24: #include "sections.h"
25: #include "frags.h"
26: #include "symbols.h"
27: #include "fixes.h"
28: #include "messages.h"
29: #include "expr.h"
30: #include "md.h"
31: #include "obstack.h"
32:
33: static void fixup_section(
34: fixS *fixP,
35: int nsect);
36: static void relax_section(
37: struct frag *section_frag_root,
38: int nsect);
39: static relax_addressT relax_align(
40: relax_addressT address,
41: long alignment);
42: static int is_down_range(
43: struct frag *f1,
44: struct frag *f2);
45:
46: /*
47: * layout_addresses() is called after all the assembly code has been read and
48: * fragments, symbols and fixups have been created. This routine sets the
49: * address of the fragments and symbols. Then it does the fixups of the frags
50: * and prepares the fixes so relocation entries can be created from them.
51: */
52: void
53: layout_addresses(
54: void)
55: {
56: struct frchain *frchainP;
57: fragS *fragP;
58: relax_addressT slide, tmp;
59: symbolS *symbolP;
60:
61: if(frchain_root == NULL)
62: return;
63:
64: /*
65: * If there is any current frag close it off.
66: */
67: if(frag_now != NULL && frag_now->fr_fix == 0){
68: frag_now->fr_fix = obstack_next_free(&frags) -
69: frag_now->fr_literal;
70: frag_wane(frag_now);
71: }
72:
73: /*
74: * For every section, add a last ".fill 0" frag that will later be used
75: * as the ending address of that section.
76: */
77: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
78: /*
79: * We must do the obstack_finish(), so the next object we put on
80: * obstack frags will not appear to start at the fr_literal of the
81: * current frag. Also, it ensures that the next object will begin
82: * on a address that is aligned correctly for the engine that runs
83: * the assembler.
84: */
85: obstack_finish(&frags);
86:
87: /*
88: * Make a fresh frag for the last frag.
89: */
90: frag_now = (fragS *)obstack_alloc(&frags, SIZEOF_STRUCT_FRAG);
91: memset(frag_now, '\0', SIZEOF_STRUCT_FRAG);
92: frag_now->fr_next = NULL;
93: obstack_finish(&frags);
94:
95: /*
96: * Append the new frag to current frchain.
97: */
98: frchainP->frch_last->fr_next = frag_now;
99: frchainP->frch_last = frag_now;
100: frag_wane(frag_now);
101:
102: }
103:
104: /*
105: * Now set the relitive addresses of frags within the section by
106: * relaxing each section. That is all sections will start at address
107: * zero and addresses of the frags in that section will increase from
108: * there.
109: */
110: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
111: if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL)
112: continue;
113: /*
114: * This is done so in case md_estimate_size_before_relax() (called
115: * by relax_section) wants to make fixSs they are for this
116: * section.
117: */
118: frchain_now = frchainP;
119:
120: relax_section(frchainP->frch_root, frchainP->frch_nsect);
121: }
122:
123: /*
124: * Now set the absolute addresses of all frags by sliding the frags in
125: * each non-zerofill section by the address ranges taken up by the
126: * sections before it.
127: */
128: slide = 0;
129: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
130: if((frchainP->frch_section.flags & SECTION_TYPE) == S_ZEROFILL)
131: continue;
132: slide = round(slide, 1 << frchainP->frch_section.align);
133: tmp = frchainP->frch_last->fr_address;
134: if(slide != 0){
135: for(fragP = frchainP->frch_root; fragP; fragP = fragP->fr_next){
136: fragP->fr_address += slide;
137: }
138: }
139: slide += tmp;
140: }
141: /*
142: * Now with the non-zerofill section addresses set set all of the
143: * addresses of the zerofill sections. Comming in the fr_address is
144: * the size of the section and going out it is the start address. This
145: * will make layout_symbols() work out naturally. The only funky thing
146: * is that section numbers do not end up in address order.
147: */
148: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
149: if((frchainP->frch_section.flags & SECTION_TYPE) != S_ZEROFILL)
150: continue;
151: slide = round(slide, 1 << frchainP->frch_section.align);
152:
153: tmp = frchainP->frch_root->fr_address;
154: frchainP->frch_root->fr_address = slide;
155: frchainP->frch_last->fr_address = tmp + slide;
156: slide += tmp;
157: }
158:
159: /*
160: * Set the symbol addresses based on there frag's address.
161: * First forward references are handled.
162: */
163: for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next){
164: if(symbolP->sy_forward != NULL){
165: if(symbolP->sy_nlist.n_type & N_STAB)
166: symbolP->sy_other = symbolP->sy_forward->sy_other;
167: symbolP->sy_value += symbolP->sy_forward->sy_value +
168: symbolP->sy_forward->sy_frag->fr_address;
169: symbolP->sy_forward = 0;
170: }
171: }
172: for(symbolP = symbol_rootP; symbolP; symbolP = symbolP->sy_next){
173: symbolP->sy_value += symbolP->sy_frag->fr_address;
174: }
175:
176: /*
177: * At this point the addresses of frags now reflect addresses we use in
178: * the object file and the symbol values are correct.
179: * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
180: * Also converting any machine-dependent frags using md_convert_frag();
181: */
182: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
183: /*
184: * This is done so any fixes created by md_convert_frag() are for
185: * this section.
186: */
187: frchain_now = frchainP;
188:
189: for(fragP = frchainP->frch_root; fragP; fragP = fragP->fr_next){
190: switch(fragP->fr_type){
191: case rs_align:
192: case rs_org:
193: fragP->fr_type = rs_fill;
194: know(fragP->fr_var == 1);
195: know(fragP->fr_next != NULL);
196: fragP->fr_offset = fragP->fr_next->fr_address -
197: fragP->fr_address -
198: fragP->fr_fix;
199: break;
200:
201: case rs_fill:
202: break;
203:
204: case rs_machine_dependent:
205: md_convert_frag(fragP);
206: /*
207: * After md_convert_frag, we make the frag into a ".fill 0"
208: * md_convert_frag() should set up any fixSs and constants
209: * required.
210: */
211: frag_wane(fragP);
212: break;
213:
214: default:
215: BAD_CASE(fragP->fr_type);
216: break;
217: }
218: }
219: }
220:
221: /*
222: * For each section do the fixups for the frags.
223: */
224: for(frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next){
225: fixup_section(frchainP->frch_fix_root, frchainP->frch_nsect);
226: }
227: }
228:
229: /*
230: * fixup_section() does the fixups of the frags and prepares the fixes so
231: * relocation entries can be created from them. The fixups cause the contents
232: * of the frag to have the value for the fixup expression. A fix structure that
233: * ends up with a non NULL fx_addsy will have a relocation entry created for it.
234: */
235: static
236: void
237: fixup_section(
238: fixS *fixP,
239: int nsect)
240: {
241: symbolS *add_symbolP;
242: symbolS *sub_symbolP;
243: long value;
244: int size;
245: char *place;
246: long where;
247: char pcrel;
248: fragS *fragP;
249: int add_symbol_N_TYPE;
250: int add_symbol_nsect;
251:
252: /*
253: * The general fix expression is "fx_addsy - fx_subsy + fx_offset".
254: * The goal is to put the result of this expression into the frag at
255: * "place" for size "size". The value of the expression is calculated
256: * in the variable "value" and starts with just the fx_offset.
257: */
258: for( ; fixP != NULL; fixP = fixP->fx_next){
259: fragP = fixP->fx_frag;
260: know(fragP);
261: where = fixP->fx_where;
262: place = fragP->fr_literal + where;
263: size = fixP->fx_size;
264: add_symbolP = fixP->fx_addsy;
265: sub_symbolP = fixP->fx_subsy;
266: value = fixP->fx_offset;
267: pcrel = fixP->fx_pcrel;
268:
269: add_symbol_N_TYPE = 0;
270: add_symbol_nsect = 0;
271:
272: if(add_symbolP != NULL){
273: add_symbol_N_TYPE = add_symbolP->sy_type & N_TYPE;
274: if(add_symbol_N_TYPE == N_SECT)
275: add_symbol_nsect = add_symbolP->sy_other;
276: }
277:
278: /*
279: * Is there a subtract symbol?
280: */
281: if(sub_symbolP){
282: /* is it just -sym ? */
283: if(add_symbolP == NULL){
284: if(sub_symbolP->sy_type != N_ABS)
285: as_warn("Negative of non-absolute symbol %s",
286: sub_symbolP->sy_name);
287: value -= sub_symbolP->sy_value;
288: fixP->fx_subsy = NULL;
289: }
290: /*
291: * There are both an add symbol and a subtract symbol at this
292: * point.
293: *
294: * If both symbols are absolute then just calculate the
295: * value of the fix expression and no relocation entry will be
296: * needed.
297: */
298: else if((sub_symbolP->sy_type & N_TYPE) == N_ABS &&
299: (add_symbolP->sy_type & N_TYPE) == N_ABS){
300: value += add_symbolP->sy_value - sub_symbolP->sy_value;
301: add_symbolP = NULL;
302: fixP->fx_addsy = NULL; /* no relocation entry */
303: fixP->fx_subsy = NULL;
304: }
305: /*
306: * If both symbols are defined in a section then calculate the
307: * value of the fix expression and let a section difference
308: * relocation entry be created.
309: */
310: else if((sub_symbolP->sy_type & N_TYPE) == N_SECT &&
311: (add_symbolP->sy_type & N_TYPE) == N_SECT){
312: /*
313: * If we are allowed to use the new features that are
314: * incompatible with 3.2 then just calculate the value and
315: * let this create a SECTDIFF relocation type.
316: */
317: if(flagseen['k']){
318: value += add_symbolP->sy_value - sub_symbolP->sy_value;
319: goto down;
320: }
321: else{
322: /*
323: * This logic works only if the two symbols can't later
324: * be separated by scattered loading. To make sure that
325: * this can't happen we would have to make sure all
326: * symbols associated with addresses between these two
327: * symbols including the add symbol are of the Lx form
328: * and the -L flag is not see so they will not appear
329: * in the output (if they are not in the output then the
330: * link editor can't separate the chain of frags by
331: * scattered loading). Since this code does not make
332: * sure of this it is broken. But this is a known bug
333: * in the NeXT 3.2 and earilier releases so this code is
334: * if'ed !flagseen['k'] and will make it compatable with
335: * 3.2 and previous releases.
336: */
337: if(sub_symbolP->sy_other == add_symbolP->sy_other){
338: value += add_symbolP->sy_value -
339: sub_symbolP->sy_value;
340: add_symbolP = NULL;
341: fixP->fx_addsy = NULL; /* no relocation entry */
342: fixP->fx_subsy = NULL;
343: }
344: else{
345: as_warn("Can't emit reloc {- symbol \"%s\"} @ file "
346: "address %ld.", sub_symbolP->sy_name,
347: fragP->fr_address + where);
348: }
349: }
350: }
351: /*
352: * If the subtract symbol is absolute subtract it's value from
353: * the fix expression and let a relocation entry get created
354: * that is not a section difference type.
355: */
356: else if(sub_symbolP->sy_type == N_ABS){
357: value -= sub_symbolP->sy_value;
358: fixP->fx_subsy = NULL; /* no SECTDIFF relocation entry */
359: }
360: /*
361: * At this point we have something we can't generate a
362: * relocation entry for (two undefined symbols, etc.).
363: */
364: else{
365: as_warn("Can't emit reloc {- symbol \"%s\"} @ file "
366: "address %ld.", sub_symbolP->sy_name,
367: fragP->fr_address + where);
368: }
369: }
370:
371: /*
372: * If a there is an add symbol in the fixup expression then add
373: * the symbol value into the fixup expression's value.
374: */
375: if(add_symbolP){
376: /*
377: * If this symbol is in this section and is pc-relative and we
378: * do not want to force a pc-relative relocation entry (to
379: * support scattered loading) then just calculate the value.
380: */
381: if(add_symbol_nsect == nsect &&
382: pcrel && !(fixP->fx_pcrel_reloc)){
383: /*
384: * This fixup was made when the symbol's section was
385: * unknown, but it is now in this section. So we know how
386: * to do the address without relocation.
387: */
388: value += add_symbolP->sy_value;
389: value -= size + where + fragP->fr_address;
390: pcrel = 0; /* Lie. Don't want further pcrel processing. */
391: fixP->fx_addsy = NULL; /* No relocations please. */
392: /*
393: * It would be nice to check that the address does not
394: * overflow.
395: * I didn't do this check because:
396: * + It is machine dependent in the general case (eg 32032)
397: * + Compiler output will never need this checking, so why
398: * slow down the usual case?
399: */
400: }
401: else{
402: switch(add_symbol_N_TYPE){
403: case N_ABS:
404: value += add_symbolP->sy_value;
405: fixP->fx_addsy = NULL; /* no relocation entry */
406: add_symbolP = NULL;
407: break;
408:
409: case N_SECT:
410: value += add_symbolP->sy_value;
411: break;
412:
413: case N_UNDF:
414: break;
415:
416: default:
417: BAD_CASE(add_symbol_N_TYPE);
418: break;
419: }
420: }
421: }
422: down:
423: /*
424: * If the fixup expression is pc-relative then the value of the pc
425: * will be added to the expression when the machine executes the
426: * the instruction so we adjust the fixup expression's value by
427: * subtracting off the pc value (where) and adjust for insn size.
428: */
429: if(pcrel){
430: value -= size + where + fragP->fr_address;
431: if(add_symbolP == NULL){
432: fixP->fx_addsy = &abs_symbol; /* force relocation entry */
433: }
434: }
435:
436: if((size == 1 && (value & 0xffffff00) &&
437: ((value & 0xffffff80) != 0xffffff80)) ||
438: (size == 2 && (value & 0xffff8000) &&
439: ((value & 0xffff8000) != 0xffff8000)))
440: as_warn("Fixup of %ld too large for field width of %d",
441: value, size);
442:
443: /*
444: * Now place the fix expression's value in the place for the size.
445: * And save the fix expression's value to be used when creating
446: * a relocation entry if required.
447: */
448: md_number_to_imm(place, value, size, fixP, nsect);
449: fixP->fx_value = value;
450: }
451: }
452:
453:
454: /*
455: * relax_section() here we set the fr_address values in the frags.
456: * After this, all frags in this segment have addresses that are correct
457: * relative to the section (that is the section starts at address zero).
458: * After all of the sections have been processed by this call and their sizes
459: * are know then they can be slid to their final address.
460: */
461: static
462: void
463: relax_section(
464: struct frag *frag_root,
465: int nsect)
466: {
467: struct frag *fragP;
468: relax_addressT address;
469:
470: long stretch; /* May be any size, 0 or negative. */
471: /* Cumulative number of addresses we have */
472: /* relaxed this pass. */
473: /* We may have relaxed more than one address. */
474: long stretched; /* Have we stretched on this pass? */
475: /* This is 'cuz stretch may be zero, when,
476: in fact some piece of code grew, and
477: another shrank. If a branch instruction
478: doesn't fit anymore, we need another pass */
479:
480: const relax_typeS *this_type;
481: const relax_typeS *start_type;
482: relax_substateT next_state;
483: relax_substateT this_state;
484:
485: long growth;
486: long was_address;
487: long offset;
488: symbolS *symbolP;
489: long target;
490: long after;
491: long aim;
492:
493: growth = 0;
494:
495: /*
496: * For each frag in segment count and store (a 1st guess of) fr_address.
497: */
498: address = 0;
499: for(fragP = frag_root; fragP != NULL; fragP = fragP->fr_next){
500: fragP->fr_address = address;
501: address += fragP->fr_fix;
502: switch(fragP->fr_type){
503: case rs_fill:
504: address += fragP->fr_offset * fragP->fr_var;
505: break;
506:
507: case rs_align:
508: address += relax_align(address, fragP->fr_offset);
509: break;
510:
511: case rs_org:
512: /*
513: * Assume .org is nugatory. It will grow with 1st relax.
514: */
515: break;
516:
517: case rs_machine_dependent:
518: address += md_estimate_size_before_relax(fragP, nsect);
519: break;
520:
521: default:
522: BAD_CASE(fragP->fr_type);
523: break;
524: }
525: }
526:
527: /*
528: * Do relax().
529: * Make repeated passes over the chain of frags allowing each frag to
530: * grow if needed. On each pass each frag's address is incremented by
531: * the accumulated growth, kept in stretched. Passes are continued
532: * until there is no stretch on the previous pass.
533: */
534: do{
535: stretch = 0;
536: stretched = 0;
537: for(fragP = frag_root; fragP != NULL; fragP = fragP->fr_next){
538: was_address = fragP->fr_address;
539: fragP->fr_address += stretch;
540: address = fragP->fr_address;
541: symbolP = fragP->fr_symbol;
542: offset = fragP->fr_offset;
543: switch(fragP->fr_type){
544: case rs_fill: /* .fill never relaxes. */
545: growth = 0;
546: break;
547:
548: case rs_align:
549: growth = relax_align((relax_addressT)
550: (address + fragP->fr_fix), offset) -
551: relax_align((relax_addressT)
552: (was_address + fragP->fr_fix), offset);
553: break;
554:
555: case rs_org:
556: target = offset;
557: if(symbolP != NULL){
558: know(((symbolP->sy_type & N_TYPE) == N_ABS) ||
559: ((symbolP->sy_type & N_TYPE) == N_SECT));
560: know(symbolP->sy_frag);
561: know((symbolP->sy_type & N_TYPE) != N_ABS ||
562: symbolP->sy_frag == &zero_address_frag );
563: target += symbolP->sy_value +
564: symbolP->sy_frag->fr_address;
565: }
566: know(fragP->fr_next);
567: after = fragP->fr_next->fr_address;
568: /*
569: * Growth may be negative, but variable part of frag cannot
570: * have < 0 chars. That is, we can't .org backwards.
571: */
572: growth = ((target - after ) > 0) ? (target - after) : 0;
573:
574: growth -= stretch; /* This is an absolute growth factor */
575: break;
576:
577: case rs_machine_dependent:
578: this_state = fragP->fr_subtype;
579: this_type = md_relax_table + this_state;
580: start_type = this_type;
581:
582: target = offset;
583: if(symbolP){
584: know(((symbolP->sy_type & N_TYPE) == N_ABS) ||
585: ((symbolP->sy_type & N_TYPE) == N_SECT));
586: know(symbolP->sy_frag);
587: know((symbolP->sy_type & N_TYPE) != N_ABS ||
588: symbolP->sy_frag == &zero_address_frag);
589:
590: target += symbolP->sy_value +
591: symbolP->sy_frag->fr_address;
592: /*
593: * If frag has yet to be reached on this pass,
594: * assume it will move by STRETCH just as we did.
595: * If this is not so, it will be because some frag
596: * between grows, and that will force another pass.
597: */
598: if(symbolP->sy_frag->fr_address >= was_address &&
599: is_down_range(fragP, symbolP->sy_frag))
600: target += stretch;
601: }
602: aim = target - address - fragP->fr_fix;
603: if(aim < 0){
604: /* Look backwards. */
605: for(next_state = this_type->rlx_more; next_state; ){
606: if(aim >= this_type->rlx_backward)
607: next_state = 0;
608: else{ /* Grow to next state. */
609: this_state = next_state;
610: this_type = md_relax_table + this_state;
611: next_state = this_type->rlx_more;
612: }
613: }
614: }
615: else{
616: /* Look forwards. */
617: for(next_state = this_type->rlx_more; next_state; ){
618: if(aim <= this_type->rlx_forward)
619: next_state = 0;
620: else{ /* Grow to next state. */
621: this_state = next_state;
622: this_type = md_relax_table + this_state;
623: next_state = this_type->rlx_more;
624: }
625: }
626: }
627: if((growth = this_type->rlx_length -start_type->rlx_length))
628: fragP->fr_subtype = this_state;
629: break;
630:
631: default:
632: BAD_CASE(fragP->fr_type);
633: break;
634: }
635: if(growth) {
636: stretch += growth;
637: stretched++;
638: }
639: } /* For each frag in the segment. */
640: }while(stretched); /* Until nothing further to relax. */
641:
642: /*
643: * We now have valid fr_address'es for each frag. All fr_address's
644: * are correct, relative to their own section. We have made all the
645: * fixS for this section that will be made.
646: */
647: }
648:
649: /*
650: * Relax_align. Advance location counter to next address that has 'alignment'
651: * lowest order bits all 0s.
652: */
653: static
654: relax_addressT /* How many addresses does the .align take? */
655: relax_align(
656: relax_addressT address, /* Address now. */
657: long alignment) /* Alignment (binary). */
658: {
659: relax_addressT mask;
660: relax_addressT new_address;
661:
662: mask = ~ ( (~0) << alignment );
663: new_address = (address + mask) & (~ mask);
664: return(new_address - address);
665: }
666:
667: /*
668: * is_down_range() is used in relax_section() to determine it one fragment is
669: * after another to know if it will also be moved if the first is moved.
670: */
671: static
672: int
673: is_down_range(
674: struct frag *f1,
675: struct frag *f2)
676: {
677: while(f1){
678: if(f1->fr_next == f2)
679: return(1);
680: f1 = f1->fr_next;
681: }
682: return(0);
683: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.