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, 2006
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 if (fix
->fx_addsy
== NULL
)
322 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
325 /* Append a string onto another string, bumping the pointer along. */
327 append (char **charPP
, char *fromP
, unsigned long length
)
329 /* Don't trust memcpy() of 0 chars. */
333 memcpy (*charPP
, fromP
, length
);
337 /* This routine records the largest alignment seen for each segment.
338 If the beginning of the segment is aligned on the worst-case
339 boundary, all of the other alignments within it will work. At
340 least one object format really uses this info. */
343 record_alignment (/* Segment to which alignment pertains. */
345 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
346 boundary, 2 => 4-byte boundary, etc.) */
349 if (seg
== absolute_section
)
352 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
353 bfd_set_section_alignment (stdoutput
, seg
, align
);
357 get_recorded_alignment (segT seg
)
359 if (seg
== absolute_section
)
362 return bfd_get_section_alignment (stdoutput
, seg
);
365 /* Reset the section indices after removing the gas created sections. */
368 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, PTR countparg
)
370 int *countp
= (int *) countparg
;
372 sec
->index
= *countp
;
377 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
379 fragS dummy
, *prev_frag
= &dummy
;
380 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
382 for (; frchp
; frchp
= frchp
->frch_next
)
384 prev_frag
->fr_next
= frchp
->frch_root
;
385 prev_frag
= frchp
->frch_last
;
386 assert (prev_frag
->fr_type
!= 0);
387 if (frchp
->fix_root
!= (fixS
*) NULL
)
389 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
390 seg_info (section
)->fix_root
= frchp
->fix_root
;
391 prev_fix
->fx_next
= frchp
->fix_root
;
392 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
393 prev_fix
= frchp
->fix_tail
;
396 assert (prev_frag
->fr_type
!= 0);
397 assert (prev_frag
!= &dummy
);
398 prev_frag
->fr_next
= 0;
403 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
405 PTR xxx ATTRIBUTE_UNUSED
)
407 segment_info_type
*info
;
409 /* BFD may have introduced its own sections without using
410 subseg_new, so it is possible that seg_info is NULL. */
411 info
= seg_info (section
);
412 if (info
!= (segment_info_type
*) NULL
)
413 info
->frchainP
->frch_last
414 = chain_frchains_together_1 (section
, info
->frchainP
);
416 /* Now that we've chained the frags together, we must add new fixups
417 to the segment, not to the frag chain. */
422 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
424 switch (fragP
->fr_type
)
432 HANDLE_ALIGN (fragP
);
434 know (fragP
->fr_next
!= NULL
);
435 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
437 - fragP
->fr_fix
) / fragP
->fr_var
;
438 if (fragP
->fr_offset
< 0)
440 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
441 _("attempt to .org/.space backwards? (%ld)"),
442 (long) fragP
->fr_offset
);
443 fragP
->fr_offset
= 0;
445 fragP
->fr_type
= rs_fill
;
453 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
456 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
459 fragP
->fr_fix
+= size
;
460 fragP
->fr_type
= rs_fill
;
462 fragP
->fr_offset
= 0;
463 fragP
->fr_symbol
= NULL
;
468 eh_frame_convert_frag (fragP
);
472 dwarf2dbg_convert_frag (fragP
);
475 case rs_machine_dependent
:
476 md_convert_frag (stdoutput
, sec
, fragP
);
478 assert (fragP
->fr_next
== NULL
479 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
482 /* After md_convert_frag, we make the frag into a ".space 0".
483 md_convert_frag() should set up any fixSs and constants
488 #ifndef WORKING_DOT_WORD
491 struct broken_word
*lie
;
493 if (fragP
->fr_subtype
)
495 fragP
->fr_fix
+= md_short_jump_size
;
496 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
497 lie
&& lie
->dispfrag
== fragP
;
498 lie
= lie
->next_broken_word
)
500 fragP
->fr_fix
+= md_long_jump_size
;
508 BAD_CASE (fragP
->fr_type
);
512 md_frag_check (fragP
);
516 struct relax_seg_info
523 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
525 segment_info_type
*seginfo
= seg_info (sec
);
526 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
528 if (seginfo
&& seginfo
->frchainP
529 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
533 static void size_seg (bfd
*, asection
*, PTR
);
536 size_seg (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
540 segment_info_type
*seginfo
;
542 valueT size
, newsize
;
544 subseg_change (sec
, 0);
546 seginfo
= seg_info (sec
);
547 if (seginfo
&& seginfo
->frchainP
)
549 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
550 cvt_frag_to_fill (sec
, fragp
);
551 for (fragp
= seginfo
->frchainP
->frch_root
;
553 fragp
= fragp
->fr_next
)
554 /* Walk to last elt. */
556 size
= fragp
->fr_address
+ fragp
->fr_fix
;
561 flags
= bfd_get_section_flags (abfd
, sec
);
563 if (size
> 0 && ! seginfo
->bss
)
564 flags
|= SEC_HAS_CONTENTS
;
566 /* @@ This is just an approximation. */
567 if (seginfo
&& seginfo
->fix_root
)
571 x
= bfd_set_section_flags (abfd
, sec
, flags
);
574 newsize
= md_section_align (sec
, size
);
575 x
= bfd_set_section_size (abfd
, sec
, newsize
);
578 /* If the size had to be rounded up, add some padding in the last
580 assert (newsize
>= size
);
583 fragS
*last
= seginfo
->frchainP
->frch_last
;
584 fragp
= seginfo
->frchainP
->frch_root
;
585 while (fragp
->fr_next
!= last
)
586 fragp
= fragp
->fr_next
;
587 last
->fr_address
= size
;
588 if ((newsize
- size
) % fragp
->fr_var
== 0)
589 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
591 /* If we hit this abort, it's likely due to subsegs_finish not
592 providing sufficient alignment on the last frag, and the
593 machine dependent code using alignment frags with fr_var
598 #ifdef tc_frob_section
599 tc_frob_section (sec
);
601 #ifdef obj_frob_section
602 obj_frob_section (sec
);
608 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
610 segment_info_type
*seginfo
= seg_info (sec
);
611 fixS
*fixp
= seginfo
->fix_root
;
616 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
619 symbolS
*s
= fixp
->fx_addsy
;
621 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
622 (int) fixp
->fx_r_type
);
624 fprintf (stream
, "no sym\n");
627 print_symbol_value_1 (stream
, s
);
628 fprintf (stream
, "\n");
630 fixp
= fixp
->fx_next
;
634 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
637 #ifndef EMIT_SECTION_SYMBOLS
638 #define EMIT_SECTION_SYMBOLS 1
641 /* This pass over fixups decides whether symbols can be replaced with
645 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
647 PTR xxx ATTRIBUTE_UNUSED
)
649 segment_info_type
*seginfo
= seg_info (sec
);
655 dump_section_relocs (abfd
, sec
, stderr
);
657 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
661 else if (fixp
->fx_addsy
)
667 fprintf (stderr
, "\n\nadjusting fixup:\n");
671 sym
= fixp
->fx_addsy
;
673 /* All symbols should have already been resolved at this
674 point. It is possible to see unresolved expression
675 symbols, though, since they are not in the regular symbol
677 resolve_symbol_value (sym
);
679 if (fixp
->fx_subsy
!= NULL
)
680 resolve_symbol_value (fixp
->fx_subsy
);
682 /* If this symbol is equated to an undefined or common symbol,
683 convert the fixup to being against that symbol. */
684 if (symbol_equated_reloc_p (sym
)
685 || S_IS_WEAKREFR (sym
))
687 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
688 sym
= symbol_get_value_expression (sym
)->X_add_symbol
;
689 fixp
->fx_addsy
= sym
;
692 if (symbol_mri_common_p (sym
))
694 /* These symbols are handled specially in fixup_segment. */
698 /* If the symbol is undefined, common, weak, or global (ELF
699 shared libs), we can't replace it with the section symbol. */
700 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
703 /* Is there some other (target cpu dependent) reason we can't adjust
704 this one? (E.g. relocations involving function addresses on
706 #ifdef tc_fix_adjustable
707 if (! tc_fix_adjustable (fixp
))
711 /* Since we're reducing to section symbols, don't attempt to reduce
712 anything that's already using one. */
713 if (symbol_section_p (sym
))
716 symsec
= S_GET_SEGMENT (sym
);
720 if (bfd_is_abs_section (symsec
))
722 /* The fixup_segment routine normally will not use this
723 symbol in a relocation. */
727 /* Don't try to reduce relocs which refer to non-local symbols
728 in .linkonce sections. It can lead to confusion when a
729 debugging section refers to a .linkonce section. I hope
730 this will always be correct. */
731 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
733 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
735 /* The GNU toolchain uses an extension for ELF: a
736 section beginning with the magic string
737 .gnu.linkonce is a linkonce section. */
738 && strncmp (segment_name (symsec
), ".gnu.linkonce",
739 sizeof ".gnu.linkonce" - 1) == 0))
743 /* Never adjust a reloc against local symbol in a merge section
744 with non-zero addend. */
745 if ((symsec
->flags
& SEC_MERGE
) != 0
746 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
749 /* Never adjust a reloc against TLS local symbol. */
750 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
753 /* We refetch the segment when calling section_symbol, rather
754 than using symsec, because S_GET_VALUE may wind up changing
755 the section when it calls resolve_symbol_value. */
756 fixp
->fx_offset
+= S_GET_VALUE (sym
);
757 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
759 fprintf (stderr
, "\nadjusted fixup:\n");
764 dump_section_relocs (abfd
, sec
, stderr
);
768 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
770 PTR xxx ATTRIBUTE_UNUSED
)
772 segment_info_type
*seginfo
= seg_info (sec
);
774 fixup_segment (seginfo
->fix_root
, sec
);
778 write_relocs (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
780 segment_info_type
*seginfo
= seg_info (sec
);
787 /* If seginfo is NULL, we did not create this section; don't do
793 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
796 #ifndef RELOC_EXPANSION_POSSIBLE
797 /* Set up reloc information as well. */
798 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
801 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
804 bfd_reloc_status_type s
;
813 /* If this is an undefined symbol which was equated to another
814 symbol, then generate the reloc against the latter symbol
815 rather than the former. */
816 sym
= fixp
->fx_addsy
;
817 while (symbol_equated_reloc_p (sym
))
821 /* We must avoid looping, as that can occur with a badly
823 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
826 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
829 fixp
->fx_addsy
= sym
;
831 reloc
= tc_gen_reloc (sec
, fixp
);
839 This test is triggered inappropriately for the SH:
840 if (fixp->fx_where + fixp->fx_size
841 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
845 s
= bfd_install_relocation (stdoutput
, reloc
,
846 fixp
->fx_frag
->fr_literal
,
847 fixp
->fx_frag
->fr_address
,
853 case bfd_reloc_overflow
:
854 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
855 _("relocation overflow"));
857 case bfd_reloc_outofrange
:
858 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
859 _("relocation out of range"));
862 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
863 fixp
->fx_file
, fixp
->fx_line
, s
);
868 n
= n
* MAX_RELOC_EXPANSION
;
869 /* Set up reloc information as well. */
870 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
873 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
876 bfd_reloc_status_type s
;
886 /* If this is an undefined symbol which was equated to another
887 symbol, then generate the reloc against the latter symbol
888 rather than the former. */
889 sym
= fixp
->fx_addsy
;
890 while (symbol_equated_reloc_p (sym
))
894 /* We must avoid looping, as that can occur with a badly
896 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
899 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
902 fixp
->fx_addsy
= sym
;
904 reloc
= tc_gen_reloc (sec
, fixp
);
906 for (j
= 0; reloc
[j
]; j
++)
908 relocs
[i
++] = reloc
[j
];
911 if (fixp
->fx_where
+ fixp
->fx_size
912 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
913 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
914 _("internal error: fixup not contained within frag"));
915 for (j
= 0; reloc
[j
]; j
++)
917 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
918 fixp
->fx_frag
->fr_literal
,
919 fixp
->fx_frag
->fr_address
,
925 case bfd_reloc_overflow
:
926 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
927 _("relocation overflow"));
929 case bfd_reloc_outofrange
:
930 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
931 _("relocation out of range"));
934 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
935 fixp
->fx_file
, fixp
->fx_line
, s
);
944 unsigned int i
, j
, nsyms
;
946 sympp
= bfd_get_outsymbols (stdoutput
);
947 nsyms
= bfd_get_symcount (stdoutput
);
948 for (i
= 0; i
< n
; i
++)
949 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
951 for (j
= 0; j
< nsyms
; j
++)
952 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
961 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
963 bfd_set_section_flags (abfd
, sec
,
964 (bfd_get_section_flags (abfd
, sec
)
965 & (flagword
) ~SEC_RELOC
));
967 #ifdef SET_SECTION_RELOCS
968 SET_SECTION_RELOCS (sec
, relocs
, n
);
976 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
977 for (i
= 0; i
< n
; i
++)
981 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
982 i
, r
, (unsigned long)r
->address
, s
->name
, (unsigned long)r
->addend
);
989 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
991 PTR xxx ATTRIBUTE_UNUSED
)
993 segment_info_type
*seginfo
= seg_info (sec
);
997 /* Write out the frags. */
999 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1002 for (f
= seginfo
->frchainP
->frch_root
;
1011 assert (f
->fr_type
== rs_fill
);
1014 x
= bfd_set_section_contents (stdoutput
, sec
,
1015 f
->fr_literal
, (file_ptr
) offset
,
1016 (bfd_size_type
) f
->fr_fix
);
1018 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1019 bfd_errmsg (bfd_get_error ()));
1020 offset
+= f
->fr_fix
;
1022 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1023 fill_size
= f
->fr_var
;
1024 count
= f
->fr_offset
;
1025 assert (count
>= 0);
1026 if (fill_size
&& count
)
1029 if (fill_size
> sizeof (buf
))
1031 /* Do it the old way. Can this ever happen? */
1034 x
= bfd_set_section_contents (stdoutput
, sec
,
1037 (bfd_size_type
) fill_size
);
1039 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1040 bfd_errmsg (bfd_get_error ()));
1041 offset
+= fill_size
;
1046 /* Build a buffer full of fill objects and output it as
1047 often as necessary. This saves on the overhead of
1048 potentially lots of bfd_set_section_contents calls. */
1052 n_per_buf
= sizeof (buf
);
1053 memset (buf
, *fill_literal
, n_per_buf
);
1058 n_per_buf
= sizeof (buf
) / fill_size
;
1059 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1060 memcpy (bufp
, fill_literal
, fill_size
);
1062 for (; count
> 0; count
-= n_per_buf
)
1064 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1065 x
= bfd_set_section_contents
1066 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1067 (bfd_size_type
) n_per_buf
* fill_size
);
1069 as_fatal (_("cannot write to output file"));
1070 offset
+= n_per_buf
* fill_size
;
1078 merge_data_into_text (void)
1080 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1081 seg_info (data_section
)->frchainP
->frch_root
;
1082 seg_info (text_section
)->frchainP
->frch_last
=
1083 seg_info (data_section
)->frchainP
->frch_last
;
1084 seg_info (data_section
)->frchainP
= 0;
1094 extern PTR
bfd_alloc (bfd
*, bfd_size_type
);
1096 /* Count symbols. We can't rely on a count made by the loop in
1097 write_object_file, because *_frob_file may add a new symbol or
1100 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1106 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1108 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1109 symp
= symbol_rootP
;
1110 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1112 asympp
[i
] = symbol_get_bfdsym (symp
);
1113 symbol_mark_written (symp
);
1118 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1120 symbol_table_frozen
= 1;
1123 /* Finish the subsegments. After every sub-segment, we fake an
1124 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1125 ".fill 0" because that is the kind of frag that requires least
1126 thought. ".align" frags like to have a following frag since that
1127 makes calculating their intended length trivial. */
1129 #ifndef SUB_SEGMENT_ALIGN
1131 /* The last subsegment gets an alignment corresponding to the alignment
1132 of the section. This allows proper nop-filling at the end of
1133 code-bearing sections. */
1134 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1135 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1137 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1142 subsegs_finish (void)
1144 struct frchain
*frchainP
;
1147 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1149 segment_info_type
*seginfo
= seg_info (s
);
1153 for (frchainP
= seginfo
->frchainP
;
1155 frchainP
= frchainP
->frch_next
)
1159 subseg_set (s
, 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
);
1200 /* Write the object file. */
1203 write_object_file (void)
1205 struct relax_seg_info rsi
;
1206 #ifndef WORKING_DOT_WORD
1207 fragS
*fragP
; /* Track along all frags. */
1210 /* Do we really want to write it? */
1212 int n_warns
, n_errs
;
1213 n_warns
= had_warnings ();
1214 n_errs
= had_errors ();
1215 /* The -Z flag indicates that an object file should be generated,
1216 regardless of warnings and errors. */
1217 if (flag_always_generate_output
)
1219 if (n_warns
|| n_errs
)
1220 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1221 n_errs
, n_errs
== 1 ? "" : "s",
1222 n_warns
, n_warns
== 1 ? "" : "s");
1227 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1228 n_errs
, n_errs
== 1 ? "" : "s",
1229 n_warns
, n_warns
== 1 ? "" : "s");
1234 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1235 a routine to check for the definition of the procedure "_main",
1236 and if so -- fix it up so that it can be program entry point. */
1237 vms_check_for_main ();
1238 #endif /* OBJ_VMS */
1240 /* From now on, we don't care about sub-segments. Build one frag chain
1241 for each segment. Linked thru fr_next. */
1243 /* Remove the sections created by gas for its own purposes. */
1247 bfd_section_list_remove (stdoutput
, reg_section
);
1248 bfd_section_list_remove (stdoutput
, expr_section
);
1249 stdoutput
->section_count
-= 2;
1251 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1254 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1256 /* We have two segments. If user gave -R flag, then we must put the
1257 data frags into the text segment. Do this before relaxing so
1258 we know to take advantage of -R and make shorter addresses. */
1259 if (flag_readonly_data_in_text
)
1261 merge_data_into_text ();
1267 #ifndef WORKING_DOT_WORD
1268 /* We need to reset the markers in the broken word list and
1269 associated frags between calls to relax_segment (via
1270 relax_seg). Since the broken word list is global, we do it
1271 once per round, rather than locally in relax_segment for each
1273 struct broken_word
*brokp
;
1275 for (brokp
= broken_words
;
1276 brokp
!= (struct broken_word
*) NULL
;
1277 brokp
= brokp
->next_broken_word
)
1281 if (brokp
->dispfrag
!= (fragS
*) NULL
1282 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1283 brokp
->dispfrag
->fr_subtype
= 0;
1288 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1294 /* Note - Most ports will use the default value of
1295 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1296 local symbols to be resolved, removing their frag information.
1297 Some ports however, will not have finished relaxing all of
1298 their frags and will still need the local symbol frag
1299 information. These ports can set
1300 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1301 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1303 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1305 /* Relaxation has completed. Freeze all syms. */
1308 #ifdef md_post_relax_hook
1312 #ifndef WORKING_DOT_WORD
1314 struct broken_word
*lie
;
1315 struct broken_word
**prevP
;
1317 prevP
= &broken_words
;
1318 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1323 subseg_change (lie
->seg
, lie
->subseg
);
1324 exp
.X_op
= O_subtract
;
1325 exp
.X_add_symbol
= lie
->add
;
1326 exp
.X_op_symbol
= lie
->sub
;
1327 exp
.X_add_number
= lie
->addnum
;
1328 #ifdef TC_CONS_FIX_NEW
1329 TC_CONS_FIX_NEW (lie
->frag
,
1330 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1333 fix_new_exp (lie
->frag
,
1334 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1335 2, &exp
, 0, BFD_RELOC_16
);
1337 *prevP
= lie
->next_broken_word
;
1340 prevP
= &(lie
->next_broken_word
);
1342 for (lie
= broken_words
; lie
;)
1344 struct broken_word
*untruth
;
1346 addressT table_addr
;
1347 addressT from_addr
, to_addr
;
1350 subseg_change (lie
->seg
, lie
->subseg
);
1351 fragP
= lie
->dispfrag
;
1353 /* Find out how many broken_words go here. */
1356 untruth
&& untruth
->dispfrag
== fragP
;
1357 untruth
= untruth
->next_broken_word
)
1358 if (untruth
->added
== 1)
1361 table_ptr
= lie
->dispfrag
->fr_opcode
;
1362 table_addr
= (lie
->dispfrag
->fr_address
1363 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1364 /* Create the jump around the long jumps. This is a short
1365 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1366 from_addr
= table_addr
;
1367 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1368 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1370 table_ptr
+= md_short_jump_size
;
1371 table_addr
+= md_short_jump_size
;
1374 lie
&& lie
->dispfrag
== fragP
;
1375 m
++, lie
= lie
->next_broken_word
)
1377 if (lie
->added
== 2)
1379 /* Patch the jump table. */
1380 /* This is the offset from ??? to table_ptr+0. */
1381 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1382 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1383 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr
, lie
);
1385 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1386 for (untruth
= lie
->next_broken_word
;
1387 untruth
&& untruth
->dispfrag
== fragP
;
1388 untruth
= untruth
->next_broken_word
)
1390 if (untruth
->use_jump
== lie
)
1391 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1394 /* Install the long jump. */
1395 /* This is a long jump from table_ptr+0 to the final target. */
1396 from_addr
= table_addr
;
1397 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1398 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1400 table_ptr
+= md_long_jump_size
;
1401 table_addr
+= md_long_jump_size
;
1405 #endif /* not WORKING_DOT_WORD */
1407 /* Resolve symbol values. This needs to be done before processing
1413 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1414 resolve_symbol_value (symp
);
1416 resolve_local_symbol_values ();
1420 #ifdef tc_frob_file_before_adjust
1421 tc_frob_file_before_adjust ();
1423 #ifdef obj_frob_file_before_adjust
1424 obj_frob_file_before_adjust ();
1427 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1429 #ifdef tc_frob_file_before_fix
1430 tc_frob_file_before_fix ();
1432 #ifdef obj_frob_file_before_fix
1433 obj_frob_file_before_fix ();
1436 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1438 /* Set up symbol table, and write it out. */
1442 bfd_boolean skip_next_symbol
= FALSE
;
1444 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1449 if (skip_next_symbol
)
1451 /* Don't do anything besides moving the value of the
1452 symbol from the GAS value-field to the BFD value-field. */
1453 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1454 skip_next_symbol
= FALSE
;
1458 if (symbol_mri_common_p (symp
))
1460 if (S_IS_EXTERNAL (symp
))
1461 as_bad (_("%s: global symbols not supported in common sections"),
1463 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1467 name
= S_GET_NAME (symp
);
1471 decode_local_label_name ((char *) S_GET_NAME (symp
));
1472 /* They only differ if `name' is a fb or dollar local
1474 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1475 as_bad (_("local label `%s' is not defined"), name2
);
1478 /* Do it again, because adjust_reloc_syms might introduce
1479 more symbols. They'll probably only be section symbols,
1480 but they'll still need to have the values computed. */
1481 resolve_symbol_value (symp
);
1483 /* Skip symbols which were equated to undefined or common
1485 if (symbol_equated_reloc_p (symp
)
1486 || S_IS_WEAKREFR (symp
))
1488 const char *name
= S_GET_NAME (symp
);
1489 if (S_IS_COMMON (symp
)
1490 && !TC_FAKE_LABEL (name
)
1491 && !S_IS_WEAKREFR (symp
)
1492 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
1494 expressionS
*e
= symbol_get_value_expression (symp
);
1495 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1496 name
, S_GET_NAME (e
->X_add_symbol
));
1498 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1502 #ifdef obj_frob_symbol
1503 obj_frob_symbol (symp
, punt
);
1505 #ifdef tc_frob_symbol
1506 if (! punt
|| symbol_used_in_reloc_p (symp
))
1507 tc_frob_symbol (symp
, punt
);
1510 /* If we don't want to keep this symbol, splice it out of
1511 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1512 want section symbols. Otherwise, we skip local symbols
1513 and symbols that the frob_symbol macros told us to punt,
1514 but we keep such symbols if they are used in relocs. */
1515 if (symp
== abs_section_sym
1516 || (! EMIT_SECTION_SYMBOLS
1517 && symbol_section_p (symp
))
1518 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1519 opposites. Sometimes the former checks flags and the
1520 latter examines the name... */
1521 || (!S_IS_EXTERNAL (symp
)
1522 && (punt
|| S_IS_LOCAL (symp
) ||
1523 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
1524 && ! symbol_used_in_reloc_p (symp
)))
1526 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1528 /* After symbol_remove, symbol_next(symp) still returns
1529 the one that came after it in the chain. So we don't
1530 need to do any extra cleanup work here. */
1534 /* Make sure we really got a value for the symbol. */
1535 if (! symbol_resolved_p (symp
))
1537 as_bad (_("can't resolve value for symbol `%s'"),
1539 symbol_mark_resolved (symp
);
1542 /* Set the value into the BFD symbol. Up til now the value
1543 has only been kept in the gas symbolS struct. */
1544 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1546 /* A warning construct is a warning symbol followed by the
1547 symbol warned about. Don't let anything object-format or
1548 target-specific muck with it; it's ready for output. */
1549 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
1550 skip_next_symbol
= TRUE
;
1556 /* Now do any format-specific adjustments to the symbol table, such
1557 as adding file symbols. */
1558 #ifdef tc_adjust_symtab
1559 tc_adjust_symtab ();
1561 #ifdef obj_adjust_symtab
1562 obj_adjust_symtab ();
1565 /* Now that all the sizes are known, and contents correct, we can
1566 start writing to the file. */
1569 /* If *_frob_file changes the symbol value at this point, it is
1570 responsible for moving the changed value into symp->bsym->value
1571 as well. Hopefully all symbol value changing can be done in
1576 #ifdef obj_frob_file
1580 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1582 #ifdef tc_frob_file_after_relocs
1583 tc_frob_file_after_relocs ();
1585 #ifdef obj_frob_file_after_relocs
1586 obj_frob_file_after_relocs ();
1589 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1592 #ifdef TC_GENERIC_RELAX_TABLE
1593 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1596 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
1598 const relax_typeS
*this_type
;
1599 const relax_typeS
*start_type
;
1600 relax_substateT next_state
;
1601 relax_substateT this_state
;
1607 const relax_typeS
*table
;
1609 target
= fragP
->fr_offset
;
1610 address
= fragP
->fr_address
;
1611 table
= TC_GENERIC_RELAX_TABLE
;
1612 this_state
= fragP
->fr_subtype
;
1613 start_type
= this_type
= table
+ this_state
;
1614 symbolP
= fragP
->fr_symbol
;
1620 sym_frag
= symbol_get_frag (symbolP
);
1622 #ifndef DIFF_EXPR_OK
1623 know (sym_frag
!= NULL
);
1625 know (S_GET_SEGMENT (symbolP
) != absolute_section
1626 || sym_frag
== &zero_address_frag
);
1627 target
+= S_GET_VALUE (symbolP
);
1629 /* If frag has yet to be reached on this pass,
1630 assume it will move by STRETCH just as we did.
1631 If this is not so, it will be because some frag
1632 between grows, and that will force another pass. */
1635 && sym_frag
->relax_marker
!= fragP
->relax_marker
1636 && S_GET_SEGMENT (symbolP
) == segment
)
1642 aim
= target
- address
- fragP
->fr_fix
;
1643 #ifdef TC_PCREL_ADJUST
1644 /* Currently only the ns32k family needs this. */
1645 aim
+= TC_PCREL_ADJUST (fragP
);
1648 #ifdef md_prepare_relax_scan
1649 /* Formerly called M68K_AIM_KLUDGE. */
1650 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
1655 /* Look backwards. */
1656 for (next_state
= this_type
->rlx_more
; next_state
;)
1657 if (aim
>= this_type
->rlx_backward
)
1661 /* Grow to next state. */
1662 this_state
= next_state
;
1663 this_type
= table
+ this_state
;
1664 next_state
= this_type
->rlx_more
;
1669 /* Look forwards. */
1670 for (next_state
= this_type
->rlx_more
; next_state
;)
1671 if (aim
<= this_type
->rlx_forward
)
1675 /* Grow to next state. */
1676 this_state
= next_state
;
1677 this_type
= table
+ this_state
;
1678 next_state
= this_type
->rlx_more
;
1682 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1684 fragP
->fr_subtype
= this_state
;
1688 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1690 /* Relax_align. Advance location counter to next address that has 'alignment'
1691 lowest order bits all 0s, return size of adjustment made. */
1692 static relax_addressT
1693 relax_align (register relax_addressT address
, /* Address now. */
1694 register int alignment
/* Alignment (binary). */)
1696 relax_addressT mask
;
1697 relax_addressT new_address
;
1699 mask
= ~((~0) << alignment
);
1700 new_address
= (address
+ mask
) & (~mask
);
1701 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1703 /* We must provide lots of padding, so the linker can discard it
1704 when needed. The linker will not add extra space, ever. */
1705 new_address
+= (1 << alignment
);
1707 return (new_address
- address
);
1710 /* Now we have a segment, not a crowd of sub-segments, we can make
1715 After this, all frags in this segment have addresses that are correct
1716 within the segment. Since segments live in different file addresses,
1717 these frag addresses may not be the same as final object-file
1721 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
1723 unsigned long frag_count
;
1725 relax_addressT address
;
1728 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1729 subseg_change (segment
, 0);
1731 /* For each frag in segment: count and store (a 1st guess of)
1734 for (frag_count
= 0, fragP
= segment_frag_root
;
1736 fragP
= fragP
->fr_next
, frag_count
++)
1738 fragP
->relax_marker
= 0;
1739 fragP
->fr_address
= address
;
1740 address
+= fragP
->fr_fix
;
1742 switch (fragP
->fr_type
)
1745 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1752 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
1754 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
1757 if (offset
% fragP
->fr_var
!= 0)
1759 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1760 _("alignment padding (%lu bytes) not a multiple of %ld"),
1761 (unsigned long) offset
, (long) fragP
->fr_var
);
1762 offset
-= (offset
% fragP
->fr_var
);
1771 /* Assume .org is nugatory. It will grow with 1st relax. */
1774 case rs_machine_dependent
:
1775 /* If fr_symbol is an expression, this call to
1776 resolve_symbol_value sets up the correct segment, which will
1777 likely be needed in md_estimate_size_before_relax. */
1778 if (fragP
->fr_symbol
)
1779 resolve_symbol_value (fragP
->fr_symbol
);
1781 address
+= md_estimate_size_before_relax (fragP
, segment
);
1784 #ifndef WORKING_DOT_WORD
1785 /* Broken words don't concern us yet. */
1786 case rs_broken_word
:
1791 /* Initial guess is always 1; doing otherwise can result in
1792 stable solutions that are larger than the minimum. */
1793 address
+= fragP
->fr_offset
= 1;
1797 address
+= eh_frame_estimate_size_before_relax (fragP
);
1801 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
1805 BAD_CASE (fragP
->fr_type
);
1812 unsigned long max_iterations
;
1813 offsetT stretch
; /* May be any size, 0 or negative. */
1814 /* Cumulative number of addresses we have relaxed this pass.
1815 We may have relaxed more than one address. */
1816 int stretched
; /* Have we stretched on this pass? */
1817 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1818 grew, and another shrank. If a branch instruction doesn't fit anymore,
1819 we could be scrod. */
1821 /* We want to prevent going into an infinite loop where one frag grows
1822 depending upon the location of a symbol which is in turn moved by
1823 the growing frag. eg:
1829 So we dictate that this algorithm can be at most O2. */
1830 max_iterations
= frag_count
* frag_count
;
1831 /* Check for overflow. */
1832 if (max_iterations
< frag_count
)
1833 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
;
1967 /* Don't error on first few frag relax passes.
1968 The symbol might be an expression involving
1969 symbol values from other sections. If those
1970 sections have not yet been processed their
1971 frags will all have zero addresses, so we
1972 will calculate incorrect values for them. The
1973 number of passes we allow before giving an
1974 error is somewhat arbitrary. It should be at
1975 least one, with larger values requiring
1976 increasingly contrived dependencies between
1977 frags to trigger a false error. */
1980 /* Force another pass. */
1985 /* Growth may be negative, but variable part of frag
1986 cannot have fewer than 0 chars. That is, we can't
1988 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1989 _("attempt to move .org backwards"));
1991 /* We've issued an error message. Change the
1992 frag to avoid cascading errors. */
1993 fragP
->fr_type
= rs_align
;
1994 fragP
->fr_subtype
= 0;
1995 fragP
->fr_offset
= 0;
1996 fragP
->fr_fix
= after
- was_address
;
2000 /* This is an absolute growth factor */
2011 amount
= S_GET_VALUE (symbolP
);
2012 if (S_GET_SEGMENT (symbolP
) != absolute_section
2013 || S_IS_COMMON (symbolP
)
2014 || ! S_IS_DEFINED (symbolP
))
2016 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2017 _(".space specifies non-absolute value"));
2018 /* Prevent repeat of this error message. */
2019 fragP
->fr_symbol
= 0;
2021 else if (amount
< 0)
2023 /* Don't error on first few frag relax passes.
2024 See rs_org comment for a longer explanation. */
2031 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2032 _(".space or .fill with negative value, ignored"));
2033 fragP
->fr_symbol
= 0;
2036 growth
= (was_address
+ fragP
->fr_fix
+ amount
2037 - fragP
->fr_next
->fr_address
);
2041 case rs_machine_dependent
:
2042 #ifdef md_relax_frag
2043 growth
= md_relax_frag (segment
, fragP
, stretch
);
2045 #ifdef TC_GENERIC_RELAX_TABLE
2046 /* The default way to relax a frag is to look through
2047 TC_GENERIC_RELAX_TABLE. */
2048 growth
= relax_frag (segment
, fragP
, stretch
);
2049 #endif /* TC_GENERIC_RELAX_TABLE */
2058 value
= resolve_symbol_value (fragP
->fr_symbol
);
2059 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2060 growth
= size
- fragP
->fr_offset
;
2061 fragP
->fr_offset
= size
;
2066 growth
= eh_frame_relax_frag (fragP
);
2070 growth
= dwarf2dbg_relax_frag (fragP
);
2074 BAD_CASE (fragP
->fr_type
);
2084 /* Until nothing further to relax. */
2085 while (stretched
&& -- max_iterations
);
2088 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2089 segment_name (segment
));
2092 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2093 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2095 fragP
->last_fr_address
= fragP
->fr_address
;
2103 Go through all the fixS's in a segment and see which ones can be
2104 handled now. (These consist of fixS where we have since discovered
2105 the value of a symbol, or the address of the frag involved.)
2106 For each one, call md_apply_fix to put the fix into the frag data.
2108 Result is a count of how many relocation structs will be needed to
2109 handle the remaining fixS's that we couldn't completely handle here.
2110 These will be output later by emit_relocations(). */
2113 fixup_segment (fixS
*fixP
, segT this_segment
)
2115 long seg_reloc_count
= 0;
2118 segT add_symbol_segment
= absolute_section
;
2120 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
2121 abs_section_sym
= section_symbol (absolute_section
);
2123 /* If the linker is doing the relaxing, we must not do any fixups.
2125 Well, strictly speaking that's not true -- we could do any that
2126 are PC-relative and don't cross regions that could change size.
2127 And for the i960 we might be able to turn callx/callj into bal
2128 anyways in cases where we know the maximum displacement. */
2129 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
2131 for (; fixP
; fixP
= fixP
->fx_next
)
2134 if (fixP
->fx_addsy
== NULL
)
2136 /* There was no symbol required by this relocation.
2137 However, BFD doesn't really handle relocations
2138 without symbols well. So fake up a local symbol in
2139 the absolute section. */
2140 fixP
->fx_addsy
= abs_section_sym
;
2142 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2143 if (fixP
->fx_subsy
!= NULL
)
2144 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2147 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2148 return seg_reloc_count
;
2151 for (; fixP
; fixP
= fixP
->fx_next
)
2154 fprintf (stderr
, "\nprocessing fixup:\n");
2158 fragP
= fixP
->fx_frag
;
2160 #ifdef TC_VALIDATE_FIX
2161 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
2163 add_number
= fixP
->fx_offset
;
2165 if (fixP
->fx_addsy
!= NULL
2166 && symbol_mri_common_p (fixP
->fx_addsy
))
2168 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2169 fixP
->fx_offset
= add_number
;
2171 = symbol_get_value_expression (fixP
->fx_addsy
)->X_add_symbol
;
2174 if (fixP
->fx_addsy
!= NULL
)
2175 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
2177 if (fixP
->fx_subsy
!= NULL
)
2179 segT sub_symbol_segment
;
2180 resolve_symbol_value (fixP
->fx_subsy
);
2181 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
2182 if (fixP
->fx_addsy
!= NULL
2183 && sub_symbol_segment
== add_symbol_segment
2184 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
2186 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2187 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2188 fixP
->fx_offset
= add_number
;
2189 fixP
->fx_addsy
= NULL
;
2190 fixP
->fx_subsy
= NULL
;
2192 /* See the comment below about 68k weirdness. */
2196 else if (sub_symbol_segment
== absolute_section
2197 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
))
2199 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2200 fixP
->fx_offset
= add_number
;
2201 fixP
->fx_subsy
= NULL
;
2203 else if (sub_symbol_segment
== this_segment
2204 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
))
2206 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2207 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
2208 + fixP
->fx_frag
->fr_address
);
2210 /* Make it pc-relative. If the back-end code has not
2211 selected a pc-relative reloc, cancel the adjustment
2212 we do later on all pc-relative relocs. */
2215 /* Do this for m68k even if it's already described
2216 as pc-relative. On the m68k, an operand of
2217 "pc@(foo-.-2)" should address "foo" in a
2218 pc-relative mode. */
2222 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2223 fixP
->fx_subsy
= NULL
;
2226 else if (!TC_VALIDATE_FIX_SUB (fixP
))
2228 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2229 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2230 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
2231 segment_name (add_symbol_segment
),
2232 S_GET_NAME (fixP
->fx_subsy
),
2233 segment_name (sub_symbol_segment
));
2239 if (add_symbol_segment
== this_segment
2240 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
2242 /* This fixup was made when the symbol's segment was
2243 SEG_UNKNOWN, but it is now in the local segment.
2244 So we know how to do the address without relocation. */
2245 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2246 fixP
->fx_offset
= add_number
;
2248 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2249 fixP
->fx_addsy
= NULL
;
2252 else if (add_symbol_segment
== absolute_section
2253 && !TC_FORCE_RELOCATION_ABS (fixP
))
2255 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2256 fixP
->fx_offset
= add_number
;
2257 fixP
->fx_addsy
= NULL
;
2259 else if (add_symbol_segment
!= undefined_section
2260 && ! bfd_is_com_section (add_symbol_segment
)
2261 && MD_APPLY_SYM_VALUE (fixP
))
2262 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2267 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2268 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
2270 /* There was no symbol required by this relocation.
2271 However, BFD doesn't really handle relocations
2272 without symbols well. So fake up a local symbol in
2273 the absolute section. */
2274 fixP
->fx_addsy
= abs_section_sym
;
2279 md_apply_fix (fixP
, &add_number
, this_segment
);
2284 if (fixP
->fx_addsy
== NULL
)
2285 fixP
->fx_addsy
= abs_section_sym
;
2286 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2287 if (fixP
->fx_subsy
!= NULL
)
2288 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2291 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
2293 if (fixP
->fx_size
< sizeof (valueT
))
2298 mask
--; /* Set all bits to one. */
2299 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
2300 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
2302 char buf
[50], buf2
[50];
2303 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
2304 if (add_number
> 1000)
2305 sprint_value (buf2
, add_number
);
2307 sprintf (buf2
, "%ld", (long) add_number
);
2308 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2309 _("value of %s too large for field of %d bytes at %s"),
2310 buf2
, fixP
->fx_size
, buf
);
2311 } /* Generic error checking. */
2313 #ifdef WARN_SIGNED_OVERFLOW_WORD
2314 /* Warn if a .word value is too large when treated as a signed
2315 number. We already know it is not too negative. This is to
2316 catch over-large switches generated by gcc on the 68k. */
2317 if (!flag_signed_overflow_ok
2318 && fixP
->fx_size
== 2
2319 && add_number
> 0x7fff)
2320 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2321 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2323 (long) (fragP
->fr_address
+ fixP
->fx_where
));
2325 } /* Not a bit fix. */
2327 #ifdef TC_VALIDATE_FIX
2328 skip
: ATTRIBUTE_UNUSED_LABEL
2332 fprintf (stderr
, "result:\n");
2335 } /* For each fixS in this segment. */
2337 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2338 return seg_reloc_count
;
2342 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2348 buf
[n
] = val
& 0xff;
2354 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2360 *buf
++ = val
& 0xff;
2366 write_print_statistics (FILE *file
)
2368 fprintf (file
, "fixups: %d\n", n_fixups
);
2371 /* For debugging. */
2372 extern int indent_level
;
2375 print_fixup (fixS
*fixp
)
2378 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2380 fprintf (stderr
, " pcrel");
2381 if (fixp
->fx_pcrel_adjust
)
2382 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2383 if (fixp
->fx_im_disp
)
2386 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2388 fprintf (stderr
, " im_disp");
2392 fprintf (stderr
, " tcbit");
2394 fprintf (stderr
, " done");
2395 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2396 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2397 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2398 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2402 fprintf (stderr
, "\n +<");
2403 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2404 fprintf (stderr
, ">");
2408 fprintf (stderr
, "\n -<");
2409 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2410 fprintf (stderr
, ">");
2412 fprintf (stderr
, "\n");
2413 #ifdef TC_FIX_DATA_PRINT
2414 TC_FIX_DATA_PRINT (stderr
, fixp
);