1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This thing should be set up to do byteordering correctly. But... */
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 #ifndef TC_ADJUST_RELOC_COUNT
32 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
35 #ifndef TC_FORCE_RELOCATION
36 #define TC_FORCE_RELOCATION(FIX) \
37 (generic_force_reloc (FIX))
40 #ifndef TC_FORCE_RELOCATION_ABS
41 #define TC_FORCE_RELOCATION_ABS(FIX) \
42 (TC_FORCE_RELOCATION (FIX))
45 #ifndef TC_FORCE_RELOCATION_LOCAL
46 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
49 || TC_FORCE_RELOCATION (FIX))
52 #ifndef TC_FORCE_RELOCATION_SUB_SAME
53 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX) 0
61 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 0
65 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 1
69 #ifndef TC_VALIDATE_FIX_SUB
70 #ifdef UNDEFINED_DIFFERENCE_OK
71 /* The PA needs this for PIC code generation. */
72 #define TC_VALIDATE_FIX_SUB(FIX) 1
74 #define TC_VALIDATE_FIX_SUB(FIX) \
75 ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
76 || (FIX)->fx_r_type == BFD_RELOC_GPREL16)
80 #ifndef TC_LINKRELAX_FIXUP
81 #define TC_LINKRELAX_FIXUP(SEG) 1
84 #ifndef MD_APPLY_SYM_VALUE
85 #define MD_APPLY_SYM_VALUE(FIX) 1
88 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
89 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
92 #ifndef MD_PCREL_FROM_SECTION
93 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
97 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
100 /* Used to control final evaluation of expressions. */
101 int finalize_syms
= 0;
103 int symbol_table_frozen
;
105 symbolS
*abs_section_sym
;
107 /* Remember the value of dot when parsing expressions. */
110 void print_fixup (fixS
*);
112 static void renumber_sections (bfd
*, asection
*, PTR
);
114 /* We generally attach relocs to frag chains. However, after we have
115 chained these all together into a segment, any relocs we add after
116 that must be attached to a segment. This will include relocs added
117 in md_estimate_size_for_relax, for example. */
118 static int frags_chained
= 0;
122 #define RELOC_ENUM enum bfd_reloc_code_real
124 static fixS
*fix_new_internal (fragS
*, int where
, int size
,
125 symbolS
*add
, symbolS
*sub
,
126 offsetT offset
, int pcrel
,
128 static long fixup_segment (fixS
*, segT
);
129 static relax_addressT
relax_align (relax_addressT addr
, int align
);
130 static fragS
*chain_frchains_together_1 (segT
, struct frchain
*);
131 static void chain_frchains_together (bfd
*, segT
, PTR
);
132 static void cvt_frag_to_fill (segT
, fragS
*);
133 static void adjust_reloc_syms (bfd
*, asection
*, PTR
);
134 static void fix_segment (bfd
*, asection
*, PTR
);
135 static void write_relocs (bfd
*, asection
*, PTR
);
136 static void write_contents (bfd
*, asection
*, PTR
);
137 static void set_symtab (void);
138 static void merge_data_into_text (void);
140 /* Create a fixS in obstack 'notes'. */
143 fix_new_internal (fragS
*frag
, /* Which frag? */
144 int where
, /* Where in that frag? */
145 int size
, /* 1, 2, or 4 usually. */
146 symbolS
*add_symbol
, /* X_add_symbol. */
147 symbolS
*sub_symbol
, /* X_op_symbol. */
148 offsetT offset
, /* X_add_number. */
149 int pcrel
, /* TRUE if PC-relative relocation. */
150 RELOC_ENUM r_type ATTRIBUTE_UNUSED
/* Relocation type. */)
156 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
158 fixP
->fx_frag
= frag
;
159 fixP
->fx_where
= where
;
160 fixP
->fx_size
= size
;
161 /* We've made fx_size a narrow field; check that it's wide enough. */
162 if (fixP
->fx_size
!= size
)
164 as_bad (_("field fx_size too small to hold %d"), size
);
167 fixP
->fx_addsy
= add_symbol
;
168 fixP
->fx_subsy
= sub_symbol
;
169 fixP
->fx_offset
= offset
;
170 fixP
->fx_dot_value
= dot_value
;
171 fixP
->fx_pcrel
= pcrel
;
173 fixP
->fx_r_type
= r_type
;
174 fixP
->fx_im_disp
= 0;
175 fixP
->fx_pcrel_adjust
= 0;
176 fixP
->fx_bit_fixP
= 0;
177 fixP
->fx_addnumber
= 0;
180 fixP
->fx_no_overflow
= 0;
184 fixP
->fx_cgen
.insn
= NULL
;
185 fixP
->fx_cgen
.opinfo
= 0;
189 TC_INIT_FIX_DATA (fixP
);
192 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
194 /* Usually, we want relocs sorted numerically, but while
195 comparing to older versions of gas that have relocs
196 reverse sorted, it is convenient to have this compile
197 time option. xoxorich. */
200 fixS
**seg_fix_rootP
= (frags_chained
201 ? &seg_info (now_seg
)->fix_root
202 : &frchain_now
->fix_root
);
203 fixS
**seg_fix_tailP
= (frags_chained
204 ? &seg_info (now_seg
)->fix_tail
205 : &frchain_now
->fix_tail
);
207 #ifdef REVERSE_SORT_RELOCS
209 fixP
->fx_next
= *seg_fix_rootP
;
210 *seg_fix_rootP
= fixP
;
212 #else /* REVERSE_SORT_RELOCS */
214 fixP
->fx_next
= NULL
;
217 (*seg_fix_tailP
)->fx_next
= fixP
;
219 *seg_fix_rootP
= fixP
;
220 *seg_fix_tailP
= fixP
;
222 #endif /* REVERSE_SORT_RELOCS */
228 /* Create a fixup relative to a symbol (plus a constant). */
231 fix_new (fragS
*frag
, /* Which frag? */
232 int where
, /* Where in that frag? */
233 int size
, /* 1, 2, or 4 usually. */
234 symbolS
*add_symbol
, /* X_add_symbol. */
235 offsetT offset
, /* X_add_number. */
236 int pcrel
, /* TRUE if PC-relative relocation. */
237 RELOC_ENUM r_type
/* Relocation type. */)
239 return fix_new_internal (frag
, where
, size
, add_symbol
,
240 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
243 /* Create a fixup for an expression. Currently we only support fixups
244 for difference expressions. That is itself more than most object
245 file formats support anyhow. */
248 fix_new_exp (fragS
*frag
, /* Which frag? */
249 int where
, /* Where in that frag? */
250 int size
, /* 1, 2, or 4 usually. */
251 expressionS
*exp
, /* Expression. */
252 int pcrel
, /* TRUE if PC-relative relocation. */
253 RELOC_ENUM r_type
/* Relocation type. */)
265 as_bad (_("register value used as expression"));
269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
270 the difference expression cannot immediately be reduced. */
272 symbolS
*stmp
= make_expr_symbol (exp
);
274 exp
->X_op
= O_symbol
;
275 exp
->X_op_symbol
= 0;
276 exp
->X_add_symbol
= stmp
;
277 exp
->X_add_number
= 0;
279 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
283 add
= exp
->X_add_symbol
;
284 off
= exp
->X_add_number
;
285 r_type
= BFD_RELOC_RVA
;
289 sub
= exp
->X_add_symbol
;
290 off
= exp
->X_add_number
;
294 sub
= exp
->X_op_symbol
;
297 add
= exp
->X_add_symbol
;
300 off
= exp
->X_add_number
;
304 add
= make_expr_symbol (exp
);
308 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
, r_type
);
311 /* Generic function to determine whether a fixup requires a relocation. */
313 generic_force_reloc (fixS
*fix
)
315 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
316 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
319 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
322 /* Append a string onto another string, bumping the pointer along. */
324 append (char **charPP
, char *fromP
, unsigned long length
)
326 /* Don't trust memcpy() of 0 chars. */
330 memcpy (*charPP
, fromP
, length
);
334 /* This routine records the largest alignment seen for each segment.
335 If the beginning of the segment is aligned on the worst-case
336 boundary, all of the other alignments within it will work. At
337 least one object format really uses this info. */
340 record_alignment (/* Segment to which alignment pertains. */
342 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
343 boundary, 2 => 4-byte boundary, etc.) */
346 if (seg
== absolute_section
)
349 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
350 bfd_set_section_alignment (stdoutput
, seg
, align
);
354 get_recorded_alignment (segT seg
)
356 if (seg
== absolute_section
)
359 return bfd_get_section_alignment (stdoutput
, seg
);
362 /* Reset the section indices after removing the gas created sections. */
365 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, PTR countparg
)
367 int *countp
= (int *) countparg
;
369 sec
->index
= *countp
;
374 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
376 fragS dummy
, *prev_frag
= &dummy
;
377 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
379 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
381 prev_frag
->fr_next
= frchp
->frch_root
;
382 prev_frag
= frchp
->frch_last
;
383 assert (prev_frag
->fr_type
!= 0);
384 if (frchp
->fix_root
!= (fixS
*) NULL
)
386 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
387 seg_info (section
)->fix_root
= frchp
->fix_root
;
388 prev_fix
->fx_next
= frchp
->fix_root
;
389 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
390 prev_fix
= frchp
->fix_tail
;
393 assert (prev_frag
->fr_type
!= 0);
394 prev_frag
->fr_next
= 0;
399 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
401 PTR xxx ATTRIBUTE_UNUSED
)
403 segment_info_type
*info
;
405 /* BFD may have introduced its own sections without using
406 subseg_new, so it is possible that seg_info is NULL. */
407 info
= seg_info (section
);
408 if (info
!= (segment_info_type
*) NULL
)
409 info
->frchainP
->frch_last
410 = chain_frchains_together_1 (section
, info
->frchainP
);
412 /* Now that we've chained the frags together, we must add new fixups
413 to the segment, not to the frag chain. */
418 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
420 switch (fragP
->fr_type
)
428 HANDLE_ALIGN (fragP
);
430 know (fragP
->fr_next
!= NULL
);
431 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
433 - fragP
->fr_fix
) / fragP
->fr_var
;
434 if (fragP
->fr_offset
< 0)
436 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
437 _("attempt to .org/.space backwards? (%ld)"),
438 (long) fragP
->fr_offset
);
439 fragP
->fr_offset
= 0;
441 fragP
->fr_type
= rs_fill
;
449 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
452 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
455 fragP
->fr_fix
+= size
;
456 fragP
->fr_type
= rs_fill
;
458 fragP
->fr_offset
= 0;
459 fragP
->fr_symbol
= NULL
;
464 eh_frame_convert_frag (fragP
);
468 dwarf2dbg_convert_frag (fragP
);
471 case rs_machine_dependent
:
472 md_convert_frag (stdoutput
, sec
, fragP
);
474 assert (fragP
->fr_next
== NULL
475 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
478 /* After md_convert_frag, we make the frag into a ".space 0".
479 md_convert_frag() should set up any fixSs and constants
484 #ifndef WORKING_DOT_WORD
487 struct broken_word
*lie
;
489 if (fragP
->fr_subtype
)
491 fragP
->fr_fix
+= md_short_jump_size
;
492 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
493 lie
&& lie
->dispfrag
== fragP
;
494 lie
= lie
->next_broken_word
)
496 fragP
->fr_fix
+= md_long_jump_size
;
504 BAD_CASE (fragP
->fr_type
);
508 md_frag_check (fragP
);
512 static void relax_seg (bfd
*, asection
*, PTR
);
515 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, PTR xxx
)
517 segment_info_type
*seginfo
= seg_info (sec
);
519 if (seginfo
&& seginfo
->frchainP
520 && relax_segment (seginfo
->frchainP
->frch_root
, sec
))
522 int *result
= (int *) xxx
;
527 static void size_seg (bfd
*, asection
*, PTR
);
530 size_seg (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
534 segment_info_type
*seginfo
;
536 valueT size
, newsize
;
538 subseg_change (sec
, 0);
540 seginfo
= seg_info (sec
);
541 if (seginfo
&& seginfo
->frchainP
)
543 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
544 cvt_frag_to_fill (sec
, fragp
);
545 for (fragp
= seginfo
->frchainP
->frch_root
;
547 fragp
= fragp
->fr_next
)
548 /* Walk to last elt. */
550 size
= fragp
->fr_address
+ fragp
->fr_fix
;
555 flags
= bfd_get_section_flags (abfd
, sec
);
557 if (size
> 0 && ! seginfo
->bss
)
558 flags
|= SEC_HAS_CONTENTS
;
560 /* @@ This is just an approximation. */
561 if (seginfo
&& seginfo
->fix_root
)
565 x
= bfd_set_section_flags (abfd
, sec
, flags
);
568 newsize
= md_section_align (sec
, size
);
569 x
= bfd_set_section_size (abfd
, sec
, newsize
);
572 /* If the size had to be rounded up, add some padding in the last
574 assert (newsize
>= size
);
577 fragS
*last
= seginfo
->frchainP
->frch_last
;
578 fragp
= seginfo
->frchainP
->frch_root
;
579 while (fragp
->fr_next
!= last
)
580 fragp
= fragp
->fr_next
;
581 last
->fr_address
= size
;
582 if ((newsize
- size
) % fragp
->fr_var
== 0)
583 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
585 /* If we hit this abort, it's likely due to subsegs_finish not
586 providing sufficient alignment on the last frag, and the
587 machine dependent code using alignment frags with fr_var
592 #ifdef tc_frob_section
593 tc_frob_section (sec
);
595 #ifdef obj_frob_section
596 obj_frob_section (sec
);
602 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
604 segment_info_type
*seginfo
= seg_info (sec
);
605 fixS
*fixp
= seginfo
->fix_root
;
610 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
613 symbolS
*s
= fixp
->fx_addsy
;
615 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
616 (int) fixp
->fx_r_type
);
618 fprintf (stream
, "no sym\n");
621 print_symbol_value_1 (stream
, s
);
622 fprintf (stream
, "\n");
624 fixp
= fixp
->fx_next
;
628 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
631 #ifndef EMIT_SECTION_SYMBOLS
632 #define EMIT_SECTION_SYMBOLS 1
635 /* This pass over fixups decides whether symbols can be replaced with
639 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
641 PTR xxx ATTRIBUTE_UNUSED
)
643 segment_info_type
*seginfo
= seg_info (sec
);
649 dump_section_relocs (abfd
, sec
, stderr
);
651 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
655 else if (fixp
->fx_addsy
)
661 fprintf (stderr
, "\n\nadjusting fixup:\n");
665 sym
= fixp
->fx_addsy
;
667 /* All symbols should have already been resolved at this
668 point. It is possible to see unresolved expression
669 symbols, though, since they are not in the regular symbol
671 resolve_symbol_value (sym
);
673 if (fixp
->fx_subsy
!= NULL
)
674 resolve_symbol_value (fixp
->fx_subsy
);
676 /* If this symbol is equated to an undefined or common symbol,
677 convert the fixup to being against that symbol. */
678 if (symbol_equated_reloc_p (sym
))
681 = symbol_get_value_expression (sym
)->X_add_symbol
;
682 const char *name
= S_GET_NAME (sym
);
683 if (!S_IS_COMMON (new_sym
)
684 && !TC_FAKE_LABEL (name
)
685 && (!S_IS_EXTERNAL (sym
) || S_IS_LOCAL (sym
)))
686 as_bad (_("Local symbol `%s' can't be equated to undefined symbol `%s'"),
687 name
, S_GET_NAME (new_sym
));
688 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
690 fixp
->fx_addsy
= sym
;
693 if (symbol_mri_common_p (sym
))
695 /* These symbols are handled specially in fixup_segment. */
699 /* If the symbol is undefined, common, weak, or global (ELF
700 shared libs), we can't replace it with the section symbol. */
701 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
704 /* Is there some other (target cpu dependent) reason we can't adjust
705 this one? (E.g. relocations involving function addresses on
707 #ifdef tc_fix_adjustable
708 if (! tc_fix_adjustable (fixp
))
712 /* Since we're reducing to section symbols, don't attempt to reduce
713 anything that's already using one. */
714 if (symbol_section_p (sym
))
717 symsec
= S_GET_SEGMENT (sym
);
721 if (bfd_is_abs_section (symsec
))
723 /* The fixup_segment routine normally will not use this
724 symbol in a relocation. */
728 /* Don't try to reduce relocs which refer to non-local symbols
729 in .linkonce sections. It can lead to confusion when a
730 debugging section refers to a .linkonce section. I hope
731 this will always be correct. */
732 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
734 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
736 /* The GNU toolchain uses an extension for ELF: a
737 section beginning with the magic string
738 .gnu.linkonce is a linkonce section. */
739 && strncmp (segment_name (symsec
), ".gnu.linkonce",
740 sizeof ".gnu.linkonce" - 1) == 0))
744 /* Never adjust a reloc against local symbol in a merge section
745 with non-zero addend. */
746 if ((symsec
->flags
& SEC_MERGE
) != 0
747 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
750 /* Never adjust a reloc against TLS local symbol. */
751 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
754 /* We refetch the segment when calling section_symbol, rather
755 than using symsec, because S_GET_VALUE may wind up changing
756 the section when it calls resolve_symbol_value. */
757 fixp
->fx_offset
+= S_GET_VALUE (sym
);
758 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
760 fprintf (stderr
, "\nadjusted fixup:\n");
765 dump_section_relocs (abfd
, sec
, stderr
);
769 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
771 PTR xxx ATTRIBUTE_UNUSED
)
773 segment_info_type
*seginfo
= seg_info (sec
);
775 fixup_segment (seginfo
->fix_root
, sec
);
779 write_relocs (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
781 segment_info_type
*seginfo
= seg_info (sec
);
788 /* If seginfo is NULL, we did not create this section; don't do
794 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
797 #ifndef RELOC_EXPANSION_POSSIBLE
798 /* Set up reloc information as well. */
799 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
802 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
805 bfd_reloc_status_type s
;
814 /* If this is an undefined symbol which was equated to another
815 symbol, then generate the reloc against the latter symbol
816 rather than the former. */
817 sym
= fixp
->fx_addsy
;
818 while (symbol_equated_reloc_p (sym
))
822 /* We must avoid looping, as that can occur with a badly
824 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
827 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
830 fixp
->fx_addsy
= sym
;
832 reloc
= tc_gen_reloc (sec
, fixp
);
840 This test is triggered inappropriately for the SH:
841 if (fixp->fx_where + fixp->fx_size
842 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
846 s
= bfd_install_relocation (stdoutput
, reloc
,
847 fixp
->fx_frag
->fr_literal
,
848 fixp
->fx_frag
->fr_address
,
854 case bfd_reloc_overflow
:
855 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
856 _("relocation overflow"));
858 case bfd_reloc_outofrange
:
859 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
860 _("relocation out of range"));
863 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
864 fixp
->fx_file
, fixp
->fx_line
, s
);
869 n
= n
* MAX_RELOC_EXPANSION
;
870 /* Set up reloc information as well. */
871 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
874 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
877 bfd_reloc_status_type s
;
887 /* If this is an undefined symbol which was equated to another
888 symbol, then generate the reloc against the latter symbol
889 rather than the former. */
890 sym
= fixp
->fx_addsy
;
891 while (symbol_equated_reloc_p (sym
))
895 /* We must avoid looping, as that can occur with a badly
897 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
900 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
903 fixp
->fx_addsy
= sym
;
905 reloc
= tc_gen_reloc (sec
, fixp
);
907 for (j
= 0; reloc
[j
]; j
++)
909 relocs
[i
++] = reloc
[j
];
912 if (fixp
->fx_where
+ fixp
->fx_size
913 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
914 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
915 _("internal error: fixup not contained within frag"));
916 for (j
= 0; reloc
[j
]; j
++)
918 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
919 fixp
->fx_frag
->fr_literal
,
920 fixp
->fx_frag
->fr_address
,
926 case bfd_reloc_overflow
:
927 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
928 _("relocation overflow"));
930 case bfd_reloc_outofrange
:
931 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
932 _("relocation out of range"));
935 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
936 fixp
->fx_file
, fixp
->fx_line
, s
);
945 unsigned int i
, j
, nsyms
;
947 sympp
= bfd_get_outsymbols (stdoutput
);
948 nsyms
= bfd_get_symcount (stdoutput
);
949 for (i
= 0; i
< n
; i
++)
950 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
952 for (j
= 0; j
< nsyms
; j
++)
953 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
962 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
964 bfd_set_section_flags (abfd
, sec
,
965 (bfd_get_section_flags (abfd
, sec
)
966 & (flagword
) ~SEC_RELOC
));
968 #ifdef SET_SECTION_RELOCS
969 SET_SECTION_RELOCS (sec
, relocs
, n
);
977 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
978 for (i
= 0; i
< n
; i
++)
982 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
983 i
, r
, (unsigned long)r
->address
, s
->name
, (unsigned long)r
->addend
);
990 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
992 PTR xxx ATTRIBUTE_UNUSED
)
994 segment_info_type
*seginfo
= seg_info (sec
);
998 /* Write out the frags. */
1000 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1003 for (f
= seginfo
->frchainP
->frch_root
;
1012 assert (f
->fr_type
== rs_fill
);
1015 x
= bfd_set_section_contents (stdoutput
, sec
,
1016 f
->fr_literal
, (file_ptr
) offset
,
1017 (bfd_size_type
) f
->fr_fix
);
1020 bfd_perror (stdoutput
->filename
);
1021 as_perror (_("FATAL: Can't write %s"), stdoutput
->filename
);
1022 exit (EXIT_FAILURE
);
1024 offset
+= f
->fr_fix
;
1026 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1027 fill_size
= f
->fr_var
;
1028 count
= f
->fr_offset
;
1029 assert (count
>= 0);
1030 if (fill_size
&& count
)
1033 if (fill_size
> sizeof (buf
))
1035 /* Do it the old way. Can this ever happen? */
1038 x
= bfd_set_section_contents (stdoutput
, sec
,
1041 (bfd_size_type
) fill_size
);
1044 bfd_perror (stdoutput
->filename
);
1045 as_perror (_("FATAL: Can't write %s"),
1046 stdoutput
->filename
);
1047 exit (EXIT_FAILURE
);
1049 offset
+= fill_size
;
1054 /* Build a buffer full of fill objects and output it as
1055 often as necessary. This saves on the overhead of
1056 potentially lots of bfd_set_section_contents calls. */
1060 n_per_buf
= sizeof (buf
);
1061 memset (buf
, *fill_literal
, n_per_buf
);
1066 n_per_buf
= sizeof (buf
) / fill_size
;
1067 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1068 memcpy (bufp
, fill_literal
, fill_size
);
1070 for (; count
> 0; count
-= n_per_buf
)
1072 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1073 x
= bfd_set_section_contents
1074 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1075 (bfd_size_type
) n_per_buf
* fill_size
);
1077 as_fatal (_("cannot write to output file"));
1078 offset
+= n_per_buf
* fill_size
;
1086 merge_data_into_text (void)
1088 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1089 seg_info (data_section
)->frchainP
->frch_root
;
1090 seg_info (text_section
)->frchainP
->frch_last
=
1091 seg_info (data_section
)->frchainP
->frch_last
;
1092 seg_info (data_section
)->frchainP
= 0;
1102 extern PTR
bfd_alloc (bfd
*, bfd_size_type
);
1104 /* Count symbols. We can't rely on a count made by the loop in
1105 write_object_file, because *_frob_file may add a new symbol or
1108 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1114 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1116 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1117 symp
= symbol_rootP
;
1118 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1120 asympp
[i
] = symbol_get_bfdsym (symp
);
1121 symbol_mark_written (symp
);
1126 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1128 symbol_table_frozen
= 1;
1131 /* Finish the subsegments. After every sub-segment, we fake an
1132 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1133 ".fill 0" because that is the kind of frag that requires least
1134 thought. ".align" frags like to have a following frag since that
1135 makes calculating their intended length trivial. */
1137 #ifndef SUB_SEGMENT_ALIGN
1139 /* The last subsegment gets an alignment corresponding to the alignment
1140 of the section. This allows proper nop-filling at the end of
1141 code-bearing sections. */
1142 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1143 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
1144 ? get_recorded_alignment (SEG) : 0)
1146 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1151 subsegs_finish (void)
1153 struct frchain
*frchainP
;
1155 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1159 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1161 /* This now gets called even if we had errors. In that case,
1162 any alignment is meaningless, and, moreover, will look weird
1163 if we are generating a listing. */
1166 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1167 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1168 && now_seg
->entsize
)
1170 unsigned int entsize
= now_seg
->entsize
;
1173 while ((entsize
& 1) == 0)
1178 if (entalign
> alignment
)
1179 alignment
= entalign
;
1183 if (subseg_text_p (now_seg
))
1184 frag_align_code (alignment
, 0);
1186 frag_align (alignment
, 0, 0);
1188 /* frag_align will have left a new frag.
1189 Use this last frag for an empty ".fill".
1191 For this segment ...
1192 Create a last frag. Do not leave a "being filled in frag". */
1193 frag_wane (frag_now
);
1194 frag_now
->fr_fix
= 0;
1195 know (frag_now
->fr_next
== NULL
);
1199 /* Write the object file. */
1202 write_object_file (void)
1204 #ifndef WORKING_DOT_WORD
1205 fragS
*fragP
; /* Track along all frags. */
1208 /* Do we really want to write it? */
1210 int n_warns
, n_errs
;
1211 n_warns
= had_warnings ();
1212 n_errs
= had_errors ();
1213 /* The -Z flag indicates that an object file should be generated,
1214 regardless of warnings and errors. */
1215 if (flag_always_generate_output
)
1217 if (n_warns
|| n_errs
)
1218 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1219 n_errs
, n_errs
== 1 ? "" : "s",
1220 n_warns
, n_warns
== 1 ? "" : "s");
1225 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1226 n_errs
, n_errs
== 1 ? "" : "s",
1227 n_warns
, n_warns
== 1 ? "" : "s");
1232 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1233 a routine to check for the definition of the procedure "_main",
1234 and if so -- fix it up so that it can be program entry point. */
1235 vms_check_for_main ();
1236 #endif /* OBJ_VMS */
1238 /* From now on, we don't care about sub-segments. Build one frag chain
1239 for each segment. Linked thru fr_next. */
1241 /* Remove the sections created by gas for its own purposes. */
1245 bfd_section_list_remove (stdoutput
, reg_section
);
1246 bfd_section_list_remove (stdoutput
, expr_section
);
1247 stdoutput
->section_count
-= 2;
1249 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1252 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1254 /* We have two segments. If user gave -R flag, then we must put the
1255 data frags into the text segment. Do this before relaxing so
1256 we know to take advantage of -R and make shorter addresses. */
1257 if (flag_readonly_data_in_text
)
1259 merge_data_into_text ();
1266 #ifndef WORKING_DOT_WORD
1267 /* We need to reset the markers in the broken word list and
1268 associated frags between calls to relax_segment (via
1269 relax_seg). Since the broken word list is global, we do it
1270 once per round, rather than locally in relax_segment for each
1272 struct broken_word
*brokp
;
1274 for (brokp
= broken_words
;
1275 brokp
!= (struct broken_word
*) NULL
;
1276 brokp
= brokp
->next_broken_word
)
1280 if (brokp
->dispfrag
!= (fragS
*) NULL
1281 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1282 brokp
->dispfrag
->fr_subtype
= 0;
1287 bfd_map_over_sections (stdoutput
, relax_seg
, &changed
);
1292 /* Note - Most ports will use the default value of
1293 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1294 local symbols to be resolved, removing their frag information.
1295 Some ports however, will not have finished relaxing all of
1296 their frags and will still need the local symbol frag
1297 information. These ports can set
1298 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1299 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1301 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1303 /* Relaxation has completed. Freeze all syms. */
1306 #ifdef md_post_relax_hook
1310 #ifndef WORKING_DOT_WORD
1312 struct broken_word
*lie
;
1313 struct broken_word
**prevP
;
1315 prevP
= &broken_words
;
1316 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1321 subseg_change (lie
->seg
, lie
->subseg
);
1322 exp
.X_op
= O_subtract
;
1323 exp
.X_add_symbol
= lie
->add
;
1324 exp
.X_op_symbol
= lie
->sub
;
1325 exp
.X_add_number
= lie
->addnum
;
1326 #ifdef TC_CONS_FIX_NEW
1327 TC_CONS_FIX_NEW (lie
->frag
,
1328 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1331 fix_new_exp (lie
->frag
,
1332 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1333 2, &exp
, 0, BFD_RELOC_16
);
1335 *prevP
= lie
->next_broken_word
;
1338 prevP
= &(lie
->next_broken_word
);
1340 for (lie
= broken_words
; lie
;)
1342 struct broken_word
*untruth
;
1344 addressT table_addr
;
1345 addressT from_addr
, to_addr
;
1348 subseg_change (lie
->seg
, lie
->subseg
);
1349 fragP
= lie
->dispfrag
;
1351 /* Find out how many broken_words go here. */
1354 untruth
&& untruth
->dispfrag
== fragP
;
1355 untruth
= untruth
->next_broken_word
)
1356 if (untruth
->added
== 1)
1359 table_ptr
= lie
->dispfrag
->fr_opcode
;
1360 table_addr
= (lie
->dispfrag
->fr_address
1361 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1362 /* Create the jump around the long jumps. This is a short
1363 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1364 from_addr
= table_addr
;
1365 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1366 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1368 table_ptr
+= md_short_jump_size
;
1369 table_addr
+= md_short_jump_size
;
1372 lie
&& lie
->dispfrag
== fragP
;
1373 m
++, lie
= lie
->next_broken_word
)
1375 if (lie
->added
== 2)
1377 /* Patch the jump table. */
1378 /* This is the offset from ??? to table_ptr+0. */
1379 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1380 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1381 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr
, lie
);
1383 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1384 for (untruth
= lie
->next_broken_word
;
1385 untruth
&& untruth
->dispfrag
== fragP
;
1386 untruth
= untruth
->next_broken_word
)
1388 if (untruth
->use_jump
== lie
)
1389 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1392 /* Install the long jump. */
1393 /* This is a long jump from table_ptr+0 to the final target. */
1394 from_addr
= table_addr
;
1395 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1396 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1398 table_ptr
+= md_long_jump_size
;
1399 table_addr
+= md_long_jump_size
;
1403 #endif /* not WORKING_DOT_WORD */
1405 /* Resolve symbol values. This needs to be done before processing
1411 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1412 resolve_symbol_value (symp
);
1414 resolve_local_symbol_values ();
1418 #ifdef tc_frob_file_before_adjust
1419 tc_frob_file_before_adjust ();
1421 #ifdef obj_frob_file_before_adjust
1422 obj_frob_file_before_adjust ();
1425 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1427 #ifdef tc_frob_file_before_fix
1428 tc_frob_file_before_fix ();
1430 #ifdef obj_frob_file_before_fix
1431 obj_frob_file_before_fix ();
1434 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1436 /* Set up symbol table, and write it out. */
1440 bfd_boolean skip_next_symbol
= FALSE
;
1442 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1447 if (skip_next_symbol
)
1449 /* Don't do anything besides moving the value of the
1450 symbol from the GAS value-field to the BFD value-field. */
1451 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1452 skip_next_symbol
= FALSE
;
1456 if (symbol_mri_common_p (symp
))
1458 if (S_IS_EXTERNAL (symp
))
1459 as_bad (_("%s: global symbols not supported in common sections"),
1461 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1465 name
= S_GET_NAME (symp
);
1469 decode_local_label_name ((char *) S_GET_NAME (symp
));
1470 /* They only differ if `name' is a fb or dollar local
1472 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1473 as_bad (_("local label `%s' is not defined"), name2
);
1476 /* Do it again, because adjust_reloc_syms might introduce
1477 more symbols. They'll probably only be section symbols,
1478 but they'll still need to have the values computed. */
1479 resolve_symbol_value (symp
);
1481 /* Skip symbols which were equated to undefined or common
1483 if (symbol_equated_reloc_p (symp
))
1485 const char *name
= S_GET_NAME (symp
);
1486 if (S_IS_COMMON (symp
)
1487 && !TC_FAKE_LABEL (name
)
1488 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
1490 expressionS
*e
= symbol_get_value_expression (symp
);
1491 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1492 name
, S_GET_NAME (e
->X_add_symbol
));
1494 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1498 /* So far, common symbols have been treated like undefined symbols.
1499 Put them in the common section now. */
1500 if (S_IS_DEFINED (symp
) == 0
1501 && S_GET_VALUE (symp
) != 0)
1502 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1504 #ifdef obj_frob_symbol
1505 obj_frob_symbol (symp
, punt
);
1507 #ifdef tc_frob_symbol
1508 if (! punt
|| symbol_used_in_reloc_p (symp
))
1509 tc_frob_symbol (symp
, punt
);
1512 /* If we don't want to keep this symbol, splice it out of
1513 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1514 want section symbols. Otherwise, we skip local symbols
1515 and symbols that the frob_symbol macros told us to punt,
1516 but we keep such symbols if they are used in relocs. */
1517 if (symp
== abs_section_sym
1518 || (! EMIT_SECTION_SYMBOLS
1519 && symbol_section_p (symp
))
1520 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1521 opposites. Sometimes the former checks flags and the
1522 latter examines the name... */
1523 || (!S_IS_EXTERNAL (symp
)
1524 && (punt
|| S_IS_LOCAL (symp
))
1525 && ! symbol_used_in_reloc_p (symp
)))
1527 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1529 /* After symbol_remove, symbol_next(symp) still returns
1530 the one that came after it in the chain. So we don't
1531 need to do any extra cleanup work here. */
1535 /* Make sure we really got a value for the symbol. */
1536 if (! symbol_resolved_p (symp
))
1538 as_bad (_("can't resolve value for symbol `%s'"),
1540 symbol_mark_resolved (symp
);
1543 /* Set the value into the BFD symbol. Up til now the value
1544 has only been kept in the gas symbolS struct. */
1545 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1547 /* A warning construct is a warning symbol followed by the
1548 symbol warned about. Don't let anything object-format or
1549 target-specific muck with it; it's ready for output. */
1550 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
1551 skip_next_symbol
= TRUE
;
1557 /* Now do any format-specific adjustments to the symbol table, such
1558 as adding file symbols. */
1559 #ifdef tc_adjust_symtab
1560 tc_adjust_symtab ();
1562 #ifdef obj_adjust_symtab
1563 obj_adjust_symtab ();
1566 /* Now that all the sizes are known, and contents correct, we can
1567 start writing to the file. */
1570 /* If *_frob_file changes the symbol value at this point, it is
1571 responsible for moving the changed value into symp->bsym->value
1572 as well. Hopefully all symbol value changing can be done in
1577 #ifdef obj_frob_file
1581 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1583 #ifdef tc_frob_file_after_relocs
1584 tc_frob_file_after_relocs ();
1586 #ifdef obj_frob_file_after_relocs
1587 obj_frob_file_after_relocs ();
1590 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1593 #ifdef TC_GENERIC_RELAX_TABLE
1594 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1597 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
1599 const relax_typeS
*this_type
;
1600 const relax_typeS
*start_type
;
1601 relax_substateT next_state
;
1602 relax_substateT this_state
;
1608 const relax_typeS
*table
;
1610 target
= fragP
->fr_offset
;
1611 address
= fragP
->fr_address
;
1612 table
= TC_GENERIC_RELAX_TABLE
;
1613 this_state
= fragP
->fr_subtype
;
1614 start_type
= this_type
= table
+ this_state
;
1615 symbolP
= fragP
->fr_symbol
;
1621 sym_frag
= symbol_get_frag (symbolP
);
1623 #ifndef DIFF_EXPR_OK
1624 know (sym_frag
!= NULL
);
1626 know (S_GET_SEGMENT (symbolP
) != absolute_section
1627 || sym_frag
== &zero_address_frag
);
1628 target
+= S_GET_VALUE (symbolP
);
1630 /* If frag has yet to be reached on this pass,
1631 assume it will move by STRETCH just as we did.
1632 If this is not so, it will be because some frag
1633 between grows, and that will force another pass. */
1636 && sym_frag
->relax_marker
!= fragP
->relax_marker
1637 && S_GET_SEGMENT (symbolP
) == segment
)
1643 aim
= target
- address
- fragP
->fr_fix
;
1644 #ifdef TC_PCREL_ADJUST
1645 /* Currently only the ns32k family needs this. */
1646 aim
+= TC_PCREL_ADJUST (fragP
);
1649 #ifdef md_prepare_relax_scan
1650 /* Formerly called M68K_AIM_KLUDGE. */
1651 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
1656 /* Look backwards. */
1657 for (next_state
= this_type
->rlx_more
; next_state
;)
1658 if (aim
>= this_type
->rlx_backward
)
1662 /* Grow to next state. */
1663 this_state
= next_state
;
1664 this_type
= table
+ this_state
;
1665 next_state
= this_type
->rlx_more
;
1670 /* Look forwards. */
1671 for (next_state
= this_type
->rlx_more
; next_state
;)
1672 if (aim
<= this_type
->rlx_forward
)
1676 /* Grow to next state. */
1677 this_state
= next_state
;
1678 this_type
= table
+ this_state
;
1679 next_state
= this_type
->rlx_more
;
1683 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1685 fragP
->fr_subtype
= this_state
;
1689 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1691 /* Relax_align. Advance location counter to next address that has 'alignment'
1692 lowest order bits all 0s, return size of adjustment made. */
1693 static relax_addressT
1694 relax_align (register relax_addressT address
, /* Address now. */
1695 register int alignment
/* Alignment (binary). */)
1697 relax_addressT mask
;
1698 relax_addressT new_address
;
1700 mask
= ~((~0) << alignment
);
1701 new_address
= (address
+ mask
) & (~mask
);
1702 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1704 /* We must provide lots of padding, so the linker can discard it
1705 when needed. The linker will not add extra space, ever. */
1706 new_address
+= (1 << alignment
);
1708 return (new_address
- address
);
1711 /* Now we have a segment, not a crowd of sub-segments, we can make
1716 After this, all frags in this segment have addresses that are correct
1717 within the segment. Since segments live in different file addresses,
1718 these frag addresses may not be the same as final object-file
1722 relax_segment (struct frag
*segment_frag_root
, segT segment
)
1724 unsigned long frag_count
;
1726 relax_addressT address
;
1729 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1730 subseg_change (segment
, 0);
1732 /* For each frag in segment: count and store (a 1st guess of)
1735 for (frag_count
= 0, fragP
= segment_frag_root
;
1737 fragP
= fragP
->fr_next
, frag_count
++)
1739 fragP
->relax_marker
= 0;
1740 fragP
->fr_address
= address
;
1741 address
+= fragP
->fr_fix
;
1743 switch (fragP
->fr_type
)
1746 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1753 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
1755 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
1758 if (offset
% fragP
->fr_var
!= 0)
1760 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1761 _("alignment padding (%lu bytes) not a multiple of %ld"),
1762 (unsigned long) offset
, (long) fragP
->fr_var
);
1763 offset
-= (offset
% fragP
->fr_var
);
1772 /* Assume .org is nugatory. It will grow with 1st relax. */
1775 case rs_machine_dependent
:
1776 /* If fr_symbol is an expression, this call to
1777 resolve_symbol_value sets up the correct segment, which will
1778 likely be needed in md_estimate_size_before_relax. */
1779 if (fragP
->fr_symbol
)
1780 resolve_symbol_value (fragP
->fr_symbol
);
1782 address
+= md_estimate_size_before_relax (fragP
, segment
);
1785 #ifndef WORKING_DOT_WORD
1786 /* Broken words don't concern us yet. */
1787 case rs_broken_word
:
1792 /* Initial guess is always 1; doing otherwise can result in
1793 stable solutions that are larger than the minimum. */
1794 address
+= fragP
->fr_offset
= 1;
1798 address
+= eh_frame_estimate_size_before_relax (fragP
);
1802 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
1806 BAD_CASE (fragP
->fr_type
);
1813 unsigned long max_iterations
;
1814 offsetT stretch
; /* May be any size, 0 or negative. */
1815 /* Cumulative number of addresses we have relaxed this pass.
1816 We may have relaxed more than one address. */
1817 int stretched
; /* Have we stretched on this pass? */
1818 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1819 grew, and another shrank. If a branch instruction doesn't fit anymore,
1820 we could be scrod. */
1822 /* We want to prevent going into an infinite loop where one frag grows
1823 depending upon the location of a symbol which is in turn moved by
1824 the growing frag. eg:
1830 So we dictate that this algorithm can be at most O2. */
1831 max_iterations
= frag_count
* frag_count
;
1832 /* Check for overflow. */
1833 if (max_iterations
< frag_count
)
1834 max_iterations
= frag_count
;
1841 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1844 addressT was_address
;
1848 fragP
->relax_marker
^= 1;
1849 was_address
= fragP
->fr_address
;
1850 address
= fragP
->fr_address
+= stretch
;
1851 symbolP
= fragP
->fr_symbol
;
1852 offset
= fragP
->fr_offset
;
1854 switch (fragP
->fr_type
)
1856 case rs_fill
: /* .fill never relaxes. */
1860 #ifndef WORKING_DOT_WORD
1861 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1862 for it I do not want to write it. I do not want to have
1863 anything to do with it. This is not the proper way to
1864 implement this misfeature. */
1865 case rs_broken_word
:
1867 struct broken_word
*lie
;
1868 struct broken_word
*untruth
;
1870 /* Yes this is ugly (storing the broken_word pointer
1871 in the symbol slot). Still, this whole chunk of
1872 code is ugly, and I don't feel like doing anything
1873 about it. Think of it as stubbornness in action. */
1875 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1876 lie
&& lie
->dispfrag
== fragP
;
1877 lie
= lie
->next_broken_word
)
1883 offset
= (S_GET_VALUE (lie
->add
)
1885 - S_GET_VALUE (lie
->sub
));
1886 if (offset
<= -32768 || offset
>= 32767)
1888 if (flag_warn_displacement
)
1891 sprint_value (buf
, (addressT
) lie
->addnum
);
1892 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
1893 _(".word %s-%s+%s didn't fit"),
1894 S_GET_NAME (lie
->add
),
1895 S_GET_NAME (lie
->sub
),
1899 if (fragP
->fr_subtype
== 0)
1901 fragP
->fr_subtype
++;
1902 growth
+= md_short_jump_size
;
1904 for (untruth
= lie
->next_broken_word
;
1905 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1906 untruth
= untruth
->next_broken_word
)
1907 if ((symbol_get_frag (untruth
->add
)
1908 == symbol_get_frag (lie
->add
))
1909 && (S_GET_VALUE (untruth
->add
)
1910 == S_GET_VALUE (lie
->add
)))
1913 untruth
->use_jump
= lie
;
1915 growth
+= md_long_jump_size
;
1920 } /* case rs_broken_word */
1926 addressT oldoff
, newoff
;
1928 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
1930 newoff
= relax_align (address
+ fragP
->fr_fix
,
1933 if (fragP
->fr_subtype
!= 0)
1935 if (oldoff
> fragP
->fr_subtype
)
1937 if (newoff
> fragP
->fr_subtype
)
1941 growth
= newoff
- oldoff
;
1947 addressT target
= offset
;
1952 /* Convert from an actual address to an octet offset
1953 into the section. Here it is assumed that the
1954 section's VMA is zero, and can omit subtracting it
1955 from the symbol's value to get the address offset. */
1956 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
1957 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
1960 know (fragP
->fr_next
);
1961 after
= fragP
->fr_next
->fr_address
;
1962 growth
= target
- after
;
1965 /* Growth may be negative, but variable part of frag
1966 cannot have fewer than 0 chars. That is, we can't
1968 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1969 _("attempt to move .org backwards"));
1971 /* We've issued an error message. Change the
1972 frag to avoid cascading errors. */
1973 fragP
->fr_type
= rs_align
;
1974 fragP
->fr_subtype
= 0;
1975 fragP
->fr_offset
= 0;
1976 fragP
->fr_fix
= after
- was_address
;
1980 /* This is an absolute growth factor */
1991 amount
= S_GET_VALUE (symbolP
);
1992 if (S_GET_SEGMENT (symbolP
) != absolute_section
1993 || S_IS_COMMON (symbolP
)
1994 || ! S_IS_DEFINED (symbolP
))
1996 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1997 _(".space specifies non-absolute value"));
1998 /* Prevent repeat of this error message. */
1999 fragP
->fr_symbol
= 0;
2001 else if (amount
< 0)
2003 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2004 _(".space or .fill with negative value, ignored"));
2005 fragP
->fr_symbol
= 0;
2008 growth
= (was_address
+ fragP
->fr_fix
+ amount
2009 - fragP
->fr_next
->fr_address
);
2013 case rs_machine_dependent
:
2014 #ifdef md_relax_frag
2015 growth
= md_relax_frag (segment
, fragP
, stretch
);
2017 #ifdef TC_GENERIC_RELAX_TABLE
2018 /* The default way to relax a frag is to look through
2019 TC_GENERIC_RELAX_TABLE. */
2020 growth
= relax_frag (segment
, fragP
, stretch
);
2021 #endif /* TC_GENERIC_RELAX_TABLE */
2030 value
= resolve_symbol_value (fragP
->fr_symbol
);
2031 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2032 growth
= size
- fragP
->fr_offset
;
2033 fragP
->fr_offset
= size
;
2038 growth
= eh_frame_relax_frag (fragP
);
2042 growth
= dwarf2dbg_relax_frag (fragP
);
2046 BAD_CASE (fragP
->fr_type
);
2056 /* Until nothing further to relax. */
2057 while (stretched
&& -- max_iterations
);
2060 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2061 segment_name (segment
));
2065 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2066 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2068 fragP
->last_fr_address
= fragP
->fr_address
;
2076 Go through all the fixS's in a segment and see which ones can be
2077 handled now. (These consist of fixS where we have since discovered
2078 the value of a symbol, or the address of the frag involved.)
2079 For each one, call md_apply_fix to put the fix into the frag data.
2081 Result is a count of how many relocation structs will be needed to
2082 handle the remaining fixS's that we couldn't completely handle here.
2083 These will be output later by emit_relocations(). */
2086 fixup_segment (fixS
*fixP
, segT this_segment
)
2088 long seg_reloc_count
= 0;
2091 segT add_symbol_segment
= absolute_section
;
2093 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
2094 abs_section_sym
= section_symbol (absolute_section
);
2096 /* If the linker is doing the relaxing, we must not do any fixups.
2098 Well, strictly speaking that's not true -- we could do any that
2099 are PC-relative and don't cross regions that could change size.
2100 And for the i960 we might be able to turn callx/callj into bal
2101 anyways in cases where we know the maximum displacement. */
2102 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
2104 for (; fixP
; fixP
= fixP
->fx_next
)
2107 if (fixP
->fx_addsy
== NULL
)
2109 /* There was no symbol required by this relocation.
2110 However, BFD doesn't really handle relocations
2111 without symbols well. So fake up a local symbol in
2112 the absolute section. */
2113 fixP
->fx_addsy
= abs_section_sym
;
2115 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2116 if (fixP
->fx_subsy
!= NULL
)
2117 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2120 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2121 return seg_reloc_count
;
2124 for (; fixP
; fixP
= fixP
->fx_next
)
2127 fprintf (stderr
, "\nprocessing fixup:\n");
2131 fragP
= fixP
->fx_frag
;
2133 #ifdef TC_VALIDATE_FIX
2134 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
2136 add_number
= fixP
->fx_offset
;
2138 if (fixP
->fx_addsy
!= NULL
2139 && symbol_mri_common_p (fixP
->fx_addsy
))
2141 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2142 fixP
->fx_offset
= add_number
;
2144 = symbol_get_value_expression (fixP
->fx_addsy
)->X_add_symbol
;
2147 if (fixP
->fx_addsy
!= NULL
)
2148 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
2150 if (fixP
->fx_subsy
!= NULL
)
2152 segT sub_symbol_segment
;
2153 resolve_symbol_value (fixP
->fx_subsy
);
2154 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
2155 if (fixP
->fx_addsy
!= NULL
2156 && sub_symbol_segment
== add_symbol_segment
2157 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
2159 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2160 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2161 fixP
->fx_offset
= add_number
;
2162 fixP
->fx_addsy
= NULL
;
2163 fixP
->fx_subsy
= NULL
;
2165 /* See the comment below about 68k weirdness. */
2169 else if (sub_symbol_segment
== absolute_section
2170 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
))
2172 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2173 fixP
->fx_offset
= add_number
;
2174 fixP
->fx_subsy
= NULL
;
2176 else if (sub_symbol_segment
== this_segment
2177 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
))
2179 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2180 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
2181 + fixP
->fx_frag
->fr_address
);
2183 /* Make it pc-relative. If the back-end code has not
2184 selected a pc-relative reloc, cancel the adjustment
2185 we do later on all pc-relative relocs. */
2188 /* Do this for m68k even if it's already described
2189 as pc-relative. On the m68k, an operand of
2190 "pc@(foo-.-2)" should address "foo" in a
2191 pc-relative mode. */
2195 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2196 fixP
->fx_subsy
= NULL
;
2199 else if (!TC_VALIDATE_FIX_SUB (fixP
))
2201 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2202 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2203 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
2204 segment_name (add_symbol_segment
),
2205 S_GET_NAME (fixP
->fx_subsy
),
2206 segment_name (sub_symbol_segment
));
2212 if (add_symbol_segment
== this_segment
2213 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
2215 /* This fixup was made when the symbol's segment was
2216 SEG_UNKNOWN, but it is now in the local segment.
2217 So we know how to do the address without relocation. */
2218 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2219 fixP
->fx_offset
= add_number
;
2221 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2222 fixP
->fx_addsy
= NULL
;
2225 else if (add_symbol_segment
== absolute_section
2226 && !TC_FORCE_RELOCATION_ABS (fixP
))
2228 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2229 fixP
->fx_offset
= add_number
;
2230 fixP
->fx_addsy
= NULL
;
2232 else if (add_symbol_segment
!= undefined_section
2233 && ! bfd_is_com_section (add_symbol_segment
)
2234 && MD_APPLY_SYM_VALUE (fixP
))
2235 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2240 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2241 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
2243 /* There was no symbol required by this relocation.
2244 However, BFD doesn't really handle relocations
2245 without symbols well. So fake up a local symbol in
2246 the absolute section. */
2247 fixP
->fx_addsy
= abs_section_sym
;
2252 md_apply_fix (fixP
, &add_number
, this_segment
);
2257 if (fixP
->fx_addsy
== NULL
)
2258 fixP
->fx_addsy
= abs_section_sym
;
2259 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2260 if (fixP
->fx_subsy
!= NULL
)
2261 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2264 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
2266 if (fixP
->fx_size
< sizeof (valueT
))
2271 mask
--; /* Set all bits to one. */
2272 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
2273 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
2275 char buf
[50], buf2
[50];
2276 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
2277 if (add_number
> 1000)
2278 sprint_value (buf2
, add_number
);
2280 sprintf (buf2
, "%ld", (long) add_number
);
2281 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2282 _("value of %s too large for field of %d bytes at %s"),
2283 buf2
, fixP
->fx_size
, buf
);
2284 } /* Generic error checking. */
2286 #ifdef WARN_SIGNED_OVERFLOW_WORD
2287 /* Warn if a .word value is too large when treated as a signed
2288 number. We already know it is not too negative. This is to
2289 catch over-large switches generated by gcc on the 68k. */
2290 if (!flag_signed_overflow_ok
2291 && fixP
->fx_size
== 2
2292 && add_number
> 0x7fff)
2293 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2294 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2296 (long) (fragP
->fr_address
+ fixP
->fx_where
));
2298 } /* Not a bit fix. */
2300 #ifdef TC_VALIDATE_FIX
2301 skip
: ATTRIBUTE_UNUSED_LABEL
2305 fprintf (stderr
, "result:\n");
2308 } /* For each fixS in this segment. */
2310 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2311 return seg_reloc_count
;
2315 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2321 buf
[n
] = val
& 0xff;
2327 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2333 *buf
++ = val
& 0xff;
2339 write_print_statistics (FILE *file
)
2341 fprintf (file
, "fixups: %d\n", n_fixups
);
2344 /* For debugging. */
2345 extern int indent_level
;
2348 print_fixup (fixS
*fixp
)
2351 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2353 fprintf (stderr
, " pcrel");
2354 if (fixp
->fx_pcrel_adjust
)
2355 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2356 if (fixp
->fx_im_disp
)
2359 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2361 fprintf (stderr
, " im_disp");
2365 fprintf (stderr
, " tcbit");
2367 fprintf (stderr
, " done");
2368 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2369 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2370 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2371 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2375 fprintf (stderr
, "\n +<");
2376 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2377 fprintf (stderr
, ">");
2381 fprintf (stderr
, "\n -<");
2382 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2383 fprintf (stderr
, ">");
2385 fprintf (stderr
, "\n");
2386 #ifdef TC_FIX_DATA_PRINT
2387 TC_FIX_DATA_PRINT (stderr
, fixp
);