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 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
->frch_seg
== section
; 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 prev_frag
->fr_next
= 0;
402 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
404 PTR xxx ATTRIBUTE_UNUSED
)
406 segment_info_type
*info
;
408 /* BFD may have introduced its own sections without using
409 subseg_new, so it is possible that seg_info is NULL. */
410 info
= seg_info (section
);
411 if (info
!= (segment_info_type
*) NULL
)
412 info
->frchainP
->frch_last
413 = chain_frchains_together_1 (section
, info
->frchainP
);
415 /* Now that we've chained the frags together, we must add new fixups
416 to the segment, not to the frag chain. */
421 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
423 switch (fragP
->fr_type
)
431 HANDLE_ALIGN (fragP
);
433 know (fragP
->fr_next
!= NULL
);
434 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
436 - fragP
->fr_fix
) / fragP
->fr_var
;
437 if (fragP
->fr_offset
< 0)
439 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
440 _("attempt to .org/.space backwards? (%ld)"),
441 (long) fragP
->fr_offset
);
442 fragP
->fr_offset
= 0;
444 fragP
->fr_type
= rs_fill
;
452 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
455 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
458 fragP
->fr_fix
+= size
;
459 fragP
->fr_type
= rs_fill
;
461 fragP
->fr_offset
= 0;
462 fragP
->fr_symbol
= NULL
;
467 eh_frame_convert_frag (fragP
);
471 dwarf2dbg_convert_frag (fragP
);
474 case rs_machine_dependent
:
475 md_convert_frag (stdoutput
, sec
, fragP
);
477 assert (fragP
->fr_next
== NULL
478 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
481 /* After md_convert_frag, we make the frag into a ".space 0".
482 md_convert_frag() should set up any fixSs and constants
487 #ifndef WORKING_DOT_WORD
490 struct broken_word
*lie
;
492 if (fragP
->fr_subtype
)
494 fragP
->fr_fix
+= md_short_jump_size
;
495 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
496 lie
&& lie
->dispfrag
== fragP
;
497 lie
= lie
->next_broken_word
)
499 fragP
->fr_fix
+= md_long_jump_size
;
507 BAD_CASE (fragP
->fr_type
);
511 md_frag_check (fragP
);
515 static void relax_seg (bfd
*, asection
*, PTR
);
518 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, PTR xxx
)
520 segment_info_type
*seginfo
= seg_info (sec
);
522 if (seginfo
&& seginfo
->frchainP
523 && relax_segment (seginfo
->frchainP
->frch_root
, sec
))
525 int *result
= (int *) xxx
;
530 static void size_seg (bfd
*, asection
*, PTR
);
533 size_seg (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
537 segment_info_type
*seginfo
;
539 valueT size
, newsize
;
541 subseg_change (sec
, 0);
543 seginfo
= seg_info (sec
);
544 if (seginfo
&& seginfo
->frchainP
)
546 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
547 cvt_frag_to_fill (sec
, fragp
);
548 for (fragp
= seginfo
->frchainP
->frch_root
;
550 fragp
= fragp
->fr_next
)
551 /* Walk to last elt. */
553 size
= fragp
->fr_address
+ fragp
->fr_fix
;
558 flags
= bfd_get_section_flags (abfd
, sec
);
560 if (size
> 0 && ! seginfo
->bss
)
561 flags
|= SEC_HAS_CONTENTS
;
563 /* @@ This is just an approximation. */
564 if (seginfo
&& seginfo
->fix_root
)
568 x
= bfd_set_section_flags (abfd
, sec
, flags
);
571 newsize
= md_section_align (sec
, size
);
572 x
= bfd_set_section_size (abfd
, sec
, newsize
);
575 /* If the size had to be rounded up, add some padding in the last
577 assert (newsize
>= size
);
580 fragS
*last
= seginfo
->frchainP
->frch_last
;
581 fragp
= seginfo
->frchainP
->frch_root
;
582 while (fragp
->fr_next
!= last
)
583 fragp
= fragp
->fr_next
;
584 last
->fr_address
= size
;
585 if ((newsize
- size
) % fragp
->fr_var
== 0)
586 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
588 /* If we hit this abort, it's likely due to subsegs_finish not
589 providing sufficient alignment on the last frag, and the
590 machine dependent code using alignment frags with fr_var
595 #ifdef tc_frob_section
596 tc_frob_section (sec
);
598 #ifdef obj_frob_section
599 obj_frob_section (sec
);
605 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
607 segment_info_type
*seginfo
= seg_info (sec
);
608 fixS
*fixp
= seginfo
->fix_root
;
613 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
616 symbolS
*s
= fixp
->fx_addsy
;
618 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
619 (int) fixp
->fx_r_type
);
621 fprintf (stream
, "no sym\n");
624 print_symbol_value_1 (stream
, s
);
625 fprintf (stream
, "\n");
627 fixp
= fixp
->fx_next
;
631 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
634 #ifndef EMIT_SECTION_SYMBOLS
635 #define EMIT_SECTION_SYMBOLS 1
638 /* This pass over fixups decides whether symbols can be replaced with
642 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
644 PTR xxx ATTRIBUTE_UNUSED
)
646 segment_info_type
*seginfo
= seg_info (sec
);
652 dump_section_relocs (abfd
, sec
, stderr
);
654 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
658 else if (fixp
->fx_addsy
)
664 fprintf (stderr
, "\n\nadjusting fixup:\n");
668 sym
= fixp
->fx_addsy
;
670 /* All symbols should have already been resolved at this
671 point. It is possible to see unresolved expression
672 symbols, though, since they are not in the regular symbol
674 resolve_symbol_value (sym
);
676 if (fixp
->fx_subsy
!= NULL
)
677 resolve_symbol_value (fixp
->fx_subsy
);
679 /* If this symbol is equated to an undefined or common symbol,
680 convert the fixup to being against that symbol. */
681 if (symbol_equated_reloc_p (sym
)
682 || S_IS_WEAKREFR (sym
))
685 = symbol_get_value_expression (sym
)->X_add_symbol
;
686 const char *name
= S_GET_NAME (sym
);
687 if (!S_IS_COMMON (new_sym
)
688 && !TC_FAKE_LABEL (name
)
689 && !S_IS_WEAKREFR (sym
)
690 && (!S_IS_EXTERNAL (sym
) || S_IS_LOCAL (sym
)))
691 as_bad (_("Local symbol `%s' can't be equated to undefined symbol `%s'"),
692 name
, S_GET_NAME (new_sym
));
693 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
695 fixp
->fx_addsy
= sym
;
698 if (symbol_mri_common_p (sym
))
700 /* These symbols are handled specially in fixup_segment. */
704 /* If the symbol is undefined, common, weak, or global (ELF
705 shared libs), we can't replace it with the section symbol. */
706 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
709 /* Is there some other (target cpu dependent) reason we can't adjust
710 this one? (E.g. relocations involving function addresses on
712 #ifdef tc_fix_adjustable
713 if (! tc_fix_adjustable (fixp
))
717 /* Since we're reducing to section symbols, don't attempt to reduce
718 anything that's already using one. */
719 if (symbol_section_p (sym
))
722 symsec
= S_GET_SEGMENT (sym
);
726 if (bfd_is_abs_section (symsec
))
728 /* The fixup_segment routine normally will not use this
729 symbol in a relocation. */
733 /* Don't try to reduce relocs which refer to non-local symbols
734 in .linkonce sections. It can lead to confusion when a
735 debugging section refers to a .linkonce section. I hope
736 this will always be correct. */
737 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
739 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
741 /* The GNU toolchain uses an extension for ELF: a
742 section beginning with the magic string
743 .gnu.linkonce is a linkonce section. */
744 && strncmp (segment_name (symsec
), ".gnu.linkonce",
745 sizeof ".gnu.linkonce" - 1) == 0))
749 /* Never adjust a reloc against local symbol in a merge section
750 with non-zero addend. */
751 if ((symsec
->flags
& SEC_MERGE
) != 0
752 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
755 /* Never adjust a reloc against TLS local symbol. */
756 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
759 /* We refetch the segment when calling section_symbol, rather
760 than using symsec, because S_GET_VALUE may wind up changing
761 the section when it calls resolve_symbol_value. */
762 fixp
->fx_offset
+= S_GET_VALUE (sym
);
763 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
765 fprintf (stderr
, "\nadjusted fixup:\n");
770 dump_section_relocs (abfd
, sec
, stderr
);
774 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
776 PTR xxx ATTRIBUTE_UNUSED
)
778 segment_info_type
*seginfo
= seg_info (sec
);
780 fixup_segment (seginfo
->fix_root
, sec
);
784 write_relocs (bfd
*abfd
, asection
*sec
, PTR xxx ATTRIBUTE_UNUSED
)
786 segment_info_type
*seginfo
= seg_info (sec
);
793 /* If seginfo is NULL, we did not create this section; don't do
799 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
802 #ifndef RELOC_EXPANSION_POSSIBLE
803 /* Set up reloc information as well. */
804 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
807 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
810 bfd_reloc_status_type s
;
819 /* If this is an undefined symbol which was equated to another
820 symbol, then generate the reloc against the latter symbol
821 rather than the former. */
822 sym
= fixp
->fx_addsy
;
823 while (symbol_equated_reloc_p (sym
))
827 /* We must avoid looping, as that can occur with a badly
829 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
832 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
835 fixp
->fx_addsy
= sym
;
837 reloc
= tc_gen_reloc (sec
, fixp
);
845 This test is triggered inappropriately for the SH:
846 if (fixp->fx_where + fixp->fx_size
847 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
851 s
= bfd_install_relocation (stdoutput
, reloc
,
852 fixp
->fx_frag
->fr_literal
,
853 fixp
->fx_frag
->fr_address
,
859 case bfd_reloc_overflow
:
860 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
861 _("relocation overflow"));
863 case bfd_reloc_outofrange
:
864 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
865 _("relocation out of range"));
868 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
869 fixp
->fx_file
, fixp
->fx_line
, s
);
874 n
= n
* MAX_RELOC_EXPANSION
;
875 /* Set up reloc information as well. */
876 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
879 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
882 bfd_reloc_status_type s
;
892 /* If this is an undefined symbol which was equated to another
893 symbol, then generate the reloc against the latter symbol
894 rather than the former. */
895 sym
= fixp
->fx_addsy
;
896 while (symbol_equated_reloc_p (sym
))
900 /* We must avoid looping, as that can occur with a badly
902 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
905 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
908 fixp
->fx_addsy
= sym
;
910 reloc
= tc_gen_reloc (sec
, fixp
);
912 for (j
= 0; reloc
[j
]; j
++)
914 relocs
[i
++] = reloc
[j
];
917 if (fixp
->fx_where
+ fixp
->fx_size
918 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
919 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
920 _("internal error: fixup not contained within frag"));
921 for (j
= 0; reloc
[j
]; j
++)
923 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
924 fixp
->fx_frag
->fr_literal
,
925 fixp
->fx_frag
->fr_address
,
931 case bfd_reloc_overflow
:
932 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
933 _("relocation overflow"));
935 case bfd_reloc_outofrange
:
936 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
937 _("relocation out of range"));
940 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
941 fixp
->fx_file
, fixp
->fx_line
, s
);
950 unsigned int i
, j
, nsyms
;
952 sympp
= bfd_get_outsymbols (stdoutput
);
953 nsyms
= bfd_get_symcount (stdoutput
);
954 for (i
= 0; i
< n
; i
++)
955 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
957 for (j
= 0; j
< nsyms
; j
++)
958 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
967 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
969 bfd_set_section_flags (abfd
, sec
,
970 (bfd_get_section_flags (abfd
, sec
)
971 & (flagword
) ~SEC_RELOC
));
973 #ifdef SET_SECTION_RELOCS
974 SET_SECTION_RELOCS (sec
, relocs
, n
);
982 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
983 for (i
= 0; i
< n
; i
++)
987 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
988 i
, r
, (unsigned long)r
->address
, s
->name
, (unsigned long)r
->addend
);
995 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
997 PTR xxx ATTRIBUTE_UNUSED
)
999 segment_info_type
*seginfo
= seg_info (sec
);
1000 addressT offset
= 0;
1003 /* Write out the frags. */
1005 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1008 for (f
= seginfo
->frchainP
->frch_root
;
1017 assert (f
->fr_type
== rs_fill
);
1020 x
= bfd_set_section_contents (stdoutput
, sec
,
1021 f
->fr_literal
, (file_ptr
) offset
,
1022 (bfd_size_type
) f
->fr_fix
);
1025 bfd_perror (stdoutput
->filename
);
1026 as_perror (_("FATAL: Can't write %s"), stdoutput
->filename
);
1027 exit (EXIT_FAILURE
);
1029 offset
+= f
->fr_fix
;
1031 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1032 fill_size
= f
->fr_var
;
1033 count
= f
->fr_offset
;
1034 assert (count
>= 0);
1035 if (fill_size
&& count
)
1038 if (fill_size
> sizeof (buf
))
1040 /* Do it the old way. Can this ever happen? */
1043 x
= bfd_set_section_contents (stdoutput
, sec
,
1046 (bfd_size_type
) fill_size
);
1049 bfd_perror (stdoutput
->filename
);
1050 as_perror (_("FATAL: Can't write %s"),
1051 stdoutput
->filename
);
1052 exit (EXIT_FAILURE
);
1054 offset
+= fill_size
;
1059 /* Build a buffer full of fill objects and output it as
1060 often as necessary. This saves on the overhead of
1061 potentially lots of bfd_set_section_contents calls. */
1065 n_per_buf
= sizeof (buf
);
1066 memset (buf
, *fill_literal
, n_per_buf
);
1071 n_per_buf
= sizeof (buf
) / fill_size
;
1072 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1073 memcpy (bufp
, fill_literal
, fill_size
);
1075 for (; count
> 0; count
-= n_per_buf
)
1077 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1078 x
= bfd_set_section_contents
1079 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1080 (bfd_size_type
) n_per_buf
* fill_size
);
1082 as_fatal (_("cannot write to output file"));
1083 offset
+= n_per_buf
* fill_size
;
1091 merge_data_into_text (void)
1093 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1094 seg_info (data_section
)->frchainP
->frch_root
;
1095 seg_info (text_section
)->frchainP
->frch_last
=
1096 seg_info (data_section
)->frchainP
->frch_last
;
1097 seg_info (data_section
)->frchainP
= 0;
1107 extern PTR
bfd_alloc (bfd
*, bfd_size_type
);
1109 /* Count symbols. We can't rely on a count made by the loop in
1110 write_object_file, because *_frob_file may add a new symbol or
1113 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1119 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1121 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1122 symp
= symbol_rootP
;
1123 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1125 asympp
[i
] = symbol_get_bfdsym (symp
);
1126 symbol_mark_written (symp
);
1131 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1133 symbol_table_frozen
= 1;
1136 /* Finish the subsegments. After every sub-segment, we fake an
1137 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1138 ".fill 0" because that is the kind of frag that requires least
1139 thought. ".align" frags like to have a following frag since that
1140 makes calculating their intended length trivial. */
1142 #ifndef SUB_SEGMENT_ALIGN
1144 /* The last subsegment gets an alignment corresponding to the alignment
1145 of the section. This allows proper nop-filling at the end of
1146 code-bearing sections. */
1147 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1148 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
1149 ? get_recorded_alignment (SEG) : 0)
1151 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1156 subsegs_finish (void)
1158 struct frchain
*frchainP
;
1160 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1164 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1166 /* This now gets called even if we had errors. In that case,
1167 any alignment is meaningless, and, moreover, will look weird
1168 if we are generating a listing. */
1171 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1172 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1173 && now_seg
->entsize
)
1175 unsigned int entsize
= now_seg
->entsize
;
1178 while ((entsize
& 1) == 0)
1183 if (entalign
> alignment
)
1184 alignment
= entalign
;
1188 if (subseg_text_p (now_seg
))
1189 frag_align_code (alignment
, 0);
1191 frag_align (alignment
, 0, 0);
1193 /* frag_align will have left a new frag.
1194 Use this last frag for an empty ".fill".
1196 For this segment ...
1197 Create a last frag. Do not leave a "being filled in frag". */
1198 frag_wane (frag_now
);
1199 frag_now
->fr_fix
= 0;
1200 know (frag_now
->fr_next
== NULL
);
1204 /* Write the object file. */
1207 write_object_file (void)
1209 #ifndef WORKING_DOT_WORD
1210 fragS
*fragP
; /* Track along all frags. */
1213 /* Do we really want to write it? */
1215 int n_warns
, n_errs
;
1216 n_warns
= had_warnings ();
1217 n_errs
= had_errors ();
1218 /* The -Z flag indicates that an object file should be generated,
1219 regardless of warnings and errors. */
1220 if (flag_always_generate_output
)
1222 if (n_warns
|| n_errs
)
1223 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1224 n_errs
, n_errs
== 1 ? "" : "s",
1225 n_warns
, n_warns
== 1 ? "" : "s");
1230 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1231 n_errs
, n_errs
== 1 ? "" : "s",
1232 n_warns
, n_warns
== 1 ? "" : "s");
1237 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1238 a routine to check for the definition of the procedure "_main",
1239 and if so -- fix it up so that it can be program entry point. */
1240 vms_check_for_main ();
1241 #endif /* OBJ_VMS */
1243 /* From now on, we don't care about sub-segments. Build one frag chain
1244 for each segment. Linked thru fr_next. */
1246 /* Remove the sections created by gas for its own purposes. */
1250 bfd_section_list_remove (stdoutput
, reg_section
);
1251 bfd_section_list_remove (stdoutput
, expr_section
);
1252 stdoutput
->section_count
-= 2;
1254 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1257 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1259 /* We have two segments. If user gave -R flag, then we must put the
1260 data frags into the text segment. Do this before relaxing so
1261 we know to take advantage of -R and make shorter addresses. */
1262 if (flag_readonly_data_in_text
)
1264 merge_data_into_text ();
1271 #ifndef WORKING_DOT_WORD
1272 /* We need to reset the markers in the broken word list and
1273 associated frags between calls to relax_segment (via
1274 relax_seg). Since the broken word list is global, we do it
1275 once per round, rather than locally in relax_segment for each
1277 struct broken_word
*brokp
;
1279 for (brokp
= broken_words
;
1280 brokp
!= (struct broken_word
*) NULL
;
1281 brokp
= brokp
->next_broken_word
)
1285 if (brokp
->dispfrag
!= (fragS
*) NULL
1286 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1287 brokp
->dispfrag
->fr_subtype
= 0;
1292 bfd_map_over_sections (stdoutput
, relax_seg
, &changed
);
1297 /* Note - Most ports will use the default value of
1298 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1299 local symbols to be resolved, removing their frag information.
1300 Some ports however, will not have finished relaxing all of
1301 their frags and will still need the local symbol frag
1302 information. These ports can set
1303 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1304 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1306 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1308 /* Relaxation has completed. Freeze all syms. */
1311 #ifdef md_post_relax_hook
1315 #ifndef WORKING_DOT_WORD
1317 struct broken_word
*lie
;
1318 struct broken_word
**prevP
;
1320 prevP
= &broken_words
;
1321 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1326 subseg_change (lie
->seg
, lie
->subseg
);
1327 exp
.X_op
= O_subtract
;
1328 exp
.X_add_symbol
= lie
->add
;
1329 exp
.X_op_symbol
= lie
->sub
;
1330 exp
.X_add_number
= lie
->addnum
;
1331 #ifdef TC_CONS_FIX_NEW
1332 TC_CONS_FIX_NEW (lie
->frag
,
1333 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1336 fix_new_exp (lie
->frag
,
1337 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1338 2, &exp
, 0, BFD_RELOC_16
);
1340 *prevP
= lie
->next_broken_word
;
1343 prevP
= &(lie
->next_broken_word
);
1345 for (lie
= broken_words
; lie
;)
1347 struct broken_word
*untruth
;
1349 addressT table_addr
;
1350 addressT from_addr
, to_addr
;
1353 subseg_change (lie
->seg
, lie
->subseg
);
1354 fragP
= lie
->dispfrag
;
1356 /* Find out how many broken_words go here. */
1359 untruth
&& untruth
->dispfrag
== fragP
;
1360 untruth
= untruth
->next_broken_word
)
1361 if (untruth
->added
== 1)
1364 table_ptr
= lie
->dispfrag
->fr_opcode
;
1365 table_addr
= (lie
->dispfrag
->fr_address
1366 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1367 /* Create the jump around the long jumps. This is a short
1368 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1369 from_addr
= table_addr
;
1370 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1371 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1373 table_ptr
+= md_short_jump_size
;
1374 table_addr
+= md_short_jump_size
;
1377 lie
&& lie
->dispfrag
== fragP
;
1378 m
++, lie
= lie
->next_broken_word
)
1380 if (lie
->added
== 2)
1382 /* Patch the jump table. */
1383 /* This is the offset from ??? to table_ptr+0. */
1384 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1385 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1386 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr
, lie
);
1388 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1389 for (untruth
= lie
->next_broken_word
;
1390 untruth
&& untruth
->dispfrag
== fragP
;
1391 untruth
= untruth
->next_broken_word
)
1393 if (untruth
->use_jump
== lie
)
1394 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1397 /* Install the long jump. */
1398 /* This is a long jump from table_ptr+0 to the final target. */
1399 from_addr
= table_addr
;
1400 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1401 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1403 table_ptr
+= md_long_jump_size
;
1404 table_addr
+= md_long_jump_size
;
1408 #endif /* not WORKING_DOT_WORD */
1410 /* Resolve symbol values. This needs to be done before processing
1416 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1417 resolve_symbol_value (symp
);
1419 resolve_local_symbol_values ();
1423 #ifdef tc_frob_file_before_adjust
1424 tc_frob_file_before_adjust ();
1426 #ifdef obj_frob_file_before_adjust
1427 obj_frob_file_before_adjust ();
1430 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1432 #ifdef tc_frob_file_before_fix
1433 tc_frob_file_before_fix ();
1435 #ifdef obj_frob_file_before_fix
1436 obj_frob_file_before_fix ();
1439 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1441 /* Set up symbol table, and write it out. */
1445 bfd_boolean skip_next_symbol
= FALSE
;
1447 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1452 if (skip_next_symbol
)
1454 /* Don't do anything besides moving the value of the
1455 symbol from the GAS value-field to the BFD value-field. */
1456 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1457 skip_next_symbol
= FALSE
;
1461 if (symbol_mri_common_p (symp
))
1463 if (S_IS_EXTERNAL (symp
))
1464 as_bad (_("%s: global symbols not supported in common sections"),
1466 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1470 name
= S_GET_NAME (symp
);
1474 decode_local_label_name ((char *) S_GET_NAME (symp
));
1475 /* They only differ if `name' is a fb or dollar local
1477 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1478 as_bad (_("local label `%s' is not defined"), name2
);
1481 /* Do it again, because adjust_reloc_syms might introduce
1482 more symbols. They'll probably only be section symbols,
1483 but they'll still need to have the values computed. */
1484 resolve_symbol_value (symp
);
1486 /* Skip symbols which were equated to undefined or common
1488 if (symbol_equated_reloc_p (symp
)
1489 || S_IS_WEAKREFR (symp
))
1491 const char *name
= S_GET_NAME (symp
);
1492 if (S_IS_COMMON (symp
)
1493 && !TC_FAKE_LABEL (name
)
1494 && !S_IS_WEAKREFR (symp
)
1495 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
1497 expressionS
*e
= symbol_get_value_expression (symp
);
1498 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1499 name
, S_GET_NAME (e
->X_add_symbol
));
1501 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1505 /* So far, common symbols have been treated like undefined symbols.
1506 Put them in the common section now. */
1507 if (S_IS_DEFINED (symp
) == 0
1508 && S_GET_VALUE (symp
) != 0)
1509 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1511 #ifdef obj_frob_symbol
1512 obj_frob_symbol (symp
, punt
);
1514 #ifdef tc_frob_symbol
1515 if (! punt
|| symbol_used_in_reloc_p (symp
))
1516 tc_frob_symbol (symp
, punt
);
1519 /* If we don't want to keep this symbol, splice it out of
1520 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1521 want section symbols. Otherwise, we skip local symbols
1522 and symbols that the frob_symbol macros told us to punt,
1523 but we keep such symbols if they are used in relocs. */
1524 if (symp
== abs_section_sym
1525 || (! EMIT_SECTION_SYMBOLS
1526 && symbol_section_p (symp
))
1527 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1528 opposites. Sometimes the former checks flags and the
1529 latter examines the name... */
1530 || (!S_IS_EXTERNAL (symp
)
1531 && (punt
|| S_IS_LOCAL (symp
) || S_IS_WEAKREFD (symp
))
1532 && ! symbol_used_in_reloc_p (symp
)))
1534 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1536 /* After symbol_remove, symbol_next(symp) still returns
1537 the one that came after it in the chain. So we don't
1538 need to do any extra cleanup work here. */
1542 /* Make sure we really got a value for the symbol. */
1543 if (! symbol_resolved_p (symp
))
1545 as_bad (_("can't resolve value for symbol `%s'"),
1547 symbol_mark_resolved (symp
);
1550 /* Set the value into the BFD symbol. Up til now the value
1551 has only been kept in the gas symbolS struct. */
1552 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1554 /* A warning construct is a warning symbol followed by the
1555 symbol warned about. Don't let anything object-format or
1556 target-specific muck with it; it's ready for output. */
1557 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
1558 skip_next_symbol
= TRUE
;
1564 /* Now do any format-specific adjustments to the symbol table, such
1565 as adding file symbols. */
1566 #ifdef tc_adjust_symtab
1567 tc_adjust_symtab ();
1569 #ifdef obj_adjust_symtab
1570 obj_adjust_symtab ();
1573 /* Now that all the sizes are known, and contents correct, we can
1574 start writing to the file. */
1577 /* If *_frob_file changes the symbol value at this point, it is
1578 responsible for moving the changed value into symp->bsym->value
1579 as well. Hopefully all symbol value changing can be done in
1584 #ifdef obj_frob_file
1588 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1590 #ifdef tc_frob_file_after_relocs
1591 tc_frob_file_after_relocs ();
1593 #ifdef obj_frob_file_after_relocs
1594 obj_frob_file_after_relocs ();
1597 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1600 #ifdef TC_GENERIC_RELAX_TABLE
1601 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1604 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
1606 const relax_typeS
*this_type
;
1607 const relax_typeS
*start_type
;
1608 relax_substateT next_state
;
1609 relax_substateT this_state
;
1615 const relax_typeS
*table
;
1617 target
= fragP
->fr_offset
;
1618 address
= fragP
->fr_address
;
1619 table
= TC_GENERIC_RELAX_TABLE
;
1620 this_state
= fragP
->fr_subtype
;
1621 start_type
= this_type
= table
+ this_state
;
1622 symbolP
= fragP
->fr_symbol
;
1628 sym_frag
= symbol_get_frag (symbolP
);
1630 #ifndef DIFF_EXPR_OK
1631 know (sym_frag
!= NULL
);
1633 know (S_GET_SEGMENT (symbolP
) != absolute_section
1634 || sym_frag
== &zero_address_frag
);
1635 target
+= S_GET_VALUE (symbolP
);
1637 /* If frag has yet to be reached on this pass,
1638 assume it will move by STRETCH just as we did.
1639 If this is not so, it will be because some frag
1640 between grows, and that will force another pass. */
1643 && sym_frag
->relax_marker
!= fragP
->relax_marker
1644 && S_GET_SEGMENT (symbolP
) == segment
)
1650 aim
= target
- address
- fragP
->fr_fix
;
1651 #ifdef TC_PCREL_ADJUST
1652 /* Currently only the ns32k family needs this. */
1653 aim
+= TC_PCREL_ADJUST (fragP
);
1656 #ifdef md_prepare_relax_scan
1657 /* Formerly called M68K_AIM_KLUDGE. */
1658 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
1663 /* Look backwards. */
1664 for (next_state
= this_type
->rlx_more
; next_state
;)
1665 if (aim
>= this_type
->rlx_backward
)
1669 /* Grow to next state. */
1670 this_state
= next_state
;
1671 this_type
= table
+ this_state
;
1672 next_state
= this_type
->rlx_more
;
1677 /* Look forwards. */
1678 for (next_state
= this_type
->rlx_more
; next_state
;)
1679 if (aim
<= this_type
->rlx_forward
)
1683 /* Grow to next state. */
1684 this_state
= next_state
;
1685 this_type
= table
+ this_state
;
1686 next_state
= this_type
->rlx_more
;
1690 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1692 fragP
->fr_subtype
= this_state
;
1696 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1698 /* Relax_align. Advance location counter to next address that has 'alignment'
1699 lowest order bits all 0s, return size of adjustment made. */
1700 static relax_addressT
1701 relax_align (register relax_addressT address
, /* Address now. */
1702 register int alignment
/* Alignment (binary). */)
1704 relax_addressT mask
;
1705 relax_addressT new_address
;
1707 mask
= ~((~0) << alignment
);
1708 new_address
= (address
+ mask
) & (~mask
);
1709 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1711 /* We must provide lots of padding, so the linker can discard it
1712 when needed. The linker will not add extra space, ever. */
1713 new_address
+= (1 << alignment
);
1715 return (new_address
- address
);
1718 /* Now we have a segment, not a crowd of sub-segments, we can make
1723 After this, all frags in this segment have addresses that are correct
1724 within the segment. Since segments live in different file addresses,
1725 these frag addresses may not be the same as final object-file
1729 relax_segment (struct frag
*segment_frag_root
, segT segment
)
1731 unsigned long frag_count
;
1733 relax_addressT address
;
1736 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1737 subseg_change (segment
, 0);
1739 /* For each frag in segment: count and store (a 1st guess of)
1742 for (frag_count
= 0, fragP
= segment_frag_root
;
1744 fragP
= fragP
->fr_next
, frag_count
++)
1746 fragP
->relax_marker
= 0;
1747 fragP
->fr_address
= address
;
1748 address
+= fragP
->fr_fix
;
1750 switch (fragP
->fr_type
)
1753 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1760 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
1762 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
1765 if (offset
% fragP
->fr_var
!= 0)
1767 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1768 _("alignment padding (%lu bytes) not a multiple of %ld"),
1769 (unsigned long) offset
, (long) fragP
->fr_var
);
1770 offset
-= (offset
% fragP
->fr_var
);
1779 /* Assume .org is nugatory. It will grow with 1st relax. */
1782 case rs_machine_dependent
:
1783 /* If fr_symbol is an expression, this call to
1784 resolve_symbol_value sets up the correct segment, which will
1785 likely be needed in md_estimate_size_before_relax. */
1786 if (fragP
->fr_symbol
)
1787 resolve_symbol_value (fragP
->fr_symbol
);
1789 address
+= md_estimate_size_before_relax (fragP
, segment
);
1792 #ifndef WORKING_DOT_WORD
1793 /* Broken words don't concern us yet. */
1794 case rs_broken_word
:
1799 /* Initial guess is always 1; doing otherwise can result in
1800 stable solutions that are larger than the minimum. */
1801 address
+= fragP
->fr_offset
= 1;
1805 address
+= eh_frame_estimate_size_before_relax (fragP
);
1809 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
1813 BAD_CASE (fragP
->fr_type
);
1820 unsigned long max_iterations
;
1821 offsetT stretch
; /* May be any size, 0 or negative. */
1822 /* Cumulative number of addresses we have relaxed this pass.
1823 We may have relaxed more than one address. */
1824 int stretched
; /* Have we stretched on this pass? */
1825 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1826 grew, and another shrank. If a branch instruction doesn't fit anymore,
1827 we could be scrod. */
1829 /* We want to prevent going into an infinite loop where one frag grows
1830 depending upon the location of a symbol which is in turn moved by
1831 the growing frag. eg:
1837 So we dictate that this algorithm can be at most O2. */
1838 max_iterations
= frag_count
* frag_count
;
1839 /* Check for overflow. */
1840 if (max_iterations
< frag_count
)
1841 max_iterations
= frag_count
;
1848 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1851 addressT was_address
;
1855 fragP
->relax_marker
^= 1;
1856 was_address
= fragP
->fr_address
;
1857 address
= fragP
->fr_address
+= stretch
;
1858 symbolP
= fragP
->fr_symbol
;
1859 offset
= fragP
->fr_offset
;
1861 switch (fragP
->fr_type
)
1863 case rs_fill
: /* .fill never relaxes. */
1867 #ifndef WORKING_DOT_WORD
1868 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1869 for it I do not want to write it. I do not want to have
1870 anything to do with it. This is not the proper way to
1871 implement this misfeature. */
1872 case rs_broken_word
:
1874 struct broken_word
*lie
;
1875 struct broken_word
*untruth
;
1877 /* Yes this is ugly (storing the broken_word pointer
1878 in the symbol slot). Still, this whole chunk of
1879 code is ugly, and I don't feel like doing anything
1880 about it. Think of it as stubbornness in action. */
1882 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1883 lie
&& lie
->dispfrag
== fragP
;
1884 lie
= lie
->next_broken_word
)
1890 offset
= (S_GET_VALUE (lie
->add
)
1892 - S_GET_VALUE (lie
->sub
));
1893 if (offset
<= -32768 || offset
>= 32767)
1895 if (flag_warn_displacement
)
1898 sprint_value (buf
, (addressT
) lie
->addnum
);
1899 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
1900 _(".word %s-%s+%s didn't fit"),
1901 S_GET_NAME (lie
->add
),
1902 S_GET_NAME (lie
->sub
),
1906 if (fragP
->fr_subtype
== 0)
1908 fragP
->fr_subtype
++;
1909 growth
+= md_short_jump_size
;
1911 for (untruth
= lie
->next_broken_word
;
1912 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1913 untruth
= untruth
->next_broken_word
)
1914 if ((symbol_get_frag (untruth
->add
)
1915 == symbol_get_frag (lie
->add
))
1916 && (S_GET_VALUE (untruth
->add
)
1917 == S_GET_VALUE (lie
->add
)))
1920 untruth
->use_jump
= lie
;
1922 growth
+= md_long_jump_size
;
1927 } /* case rs_broken_word */
1933 addressT oldoff
, newoff
;
1935 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
1937 newoff
= relax_align (address
+ fragP
->fr_fix
,
1940 if (fragP
->fr_subtype
!= 0)
1942 if (oldoff
> fragP
->fr_subtype
)
1944 if (newoff
> fragP
->fr_subtype
)
1948 growth
= newoff
- oldoff
;
1954 addressT target
= offset
;
1959 /* Convert from an actual address to an octet offset
1960 into the section. Here it is assumed that the
1961 section's VMA is zero, and can omit subtracting it
1962 from the symbol's value to get the address offset. */
1963 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
1964 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
1967 know (fragP
->fr_next
);
1968 after
= fragP
->fr_next
->fr_address
;
1969 growth
= target
- after
;
1972 /* Growth may be negative, but variable part of frag
1973 cannot have fewer than 0 chars. That is, we can't
1975 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
1976 _("attempt to move .org backwards"));
1978 /* We've issued an error message. Change the
1979 frag to avoid cascading errors. */
1980 fragP
->fr_type
= rs_align
;
1981 fragP
->fr_subtype
= 0;
1982 fragP
->fr_offset
= 0;
1983 fragP
->fr_fix
= after
- was_address
;
1987 /* This is an absolute growth factor */
1998 amount
= S_GET_VALUE (symbolP
);
1999 if (S_GET_SEGMENT (symbolP
) != absolute_section
2000 || S_IS_COMMON (symbolP
)
2001 || ! S_IS_DEFINED (symbolP
))
2003 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2004 _(".space specifies non-absolute value"));
2005 /* Prevent repeat of this error message. */
2006 fragP
->fr_symbol
= 0;
2008 else if (amount
< 0)
2010 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2011 _(".space or .fill with negative value, ignored"));
2012 fragP
->fr_symbol
= 0;
2015 growth
= (was_address
+ fragP
->fr_fix
+ amount
2016 - fragP
->fr_next
->fr_address
);
2020 case rs_machine_dependent
:
2021 #ifdef md_relax_frag
2022 growth
= md_relax_frag (segment
, fragP
, stretch
);
2024 #ifdef TC_GENERIC_RELAX_TABLE
2025 /* The default way to relax a frag is to look through
2026 TC_GENERIC_RELAX_TABLE. */
2027 growth
= relax_frag (segment
, fragP
, stretch
);
2028 #endif /* TC_GENERIC_RELAX_TABLE */
2037 value
= resolve_symbol_value (fragP
->fr_symbol
);
2038 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2039 growth
= size
- fragP
->fr_offset
;
2040 fragP
->fr_offset
= size
;
2045 growth
= eh_frame_relax_frag (fragP
);
2049 growth
= dwarf2dbg_relax_frag (fragP
);
2053 BAD_CASE (fragP
->fr_type
);
2063 /* Until nothing further to relax. */
2064 while (stretched
&& -- max_iterations
);
2067 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2068 segment_name (segment
));
2072 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2073 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2075 fragP
->last_fr_address
= fragP
->fr_address
;
2083 Go through all the fixS's in a segment and see which ones can be
2084 handled now. (These consist of fixS where we have since discovered
2085 the value of a symbol, or the address of the frag involved.)
2086 For each one, call md_apply_fix to put the fix into the frag data.
2088 Result is a count of how many relocation structs will be needed to
2089 handle the remaining fixS's that we couldn't completely handle here.
2090 These will be output later by emit_relocations(). */
2093 fixup_segment (fixS
*fixP
, segT this_segment
)
2095 long seg_reloc_count
= 0;
2098 segT add_symbol_segment
= absolute_section
;
2100 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
2101 abs_section_sym
= section_symbol (absolute_section
);
2103 /* If the linker is doing the relaxing, we must not do any fixups.
2105 Well, strictly speaking that's not true -- we could do any that
2106 are PC-relative and don't cross regions that could change size.
2107 And for the i960 we might be able to turn callx/callj into bal
2108 anyways in cases where we know the maximum displacement. */
2109 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
2111 for (; fixP
; fixP
= fixP
->fx_next
)
2114 if (fixP
->fx_addsy
== NULL
)
2116 /* There was no symbol required by this relocation.
2117 However, BFD doesn't really handle relocations
2118 without symbols well. So fake up a local symbol in
2119 the absolute section. */
2120 fixP
->fx_addsy
= abs_section_sym
;
2122 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2123 if (fixP
->fx_subsy
!= NULL
)
2124 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2127 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2128 return seg_reloc_count
;
2131 for (; fixP
; fixP
= fixP
->fx_next
)
2134 fprintf (stderr
, "\nprocessing fixup:\n");
2138 fragP
= fixP
->fx_frag
;
2140 #ifdef TC_VALIDATE_FIX
2141 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
2143 add_number
= fixP
->fx_offset
;
2145 if (fixP
->fx_addsy
!= NULL
2146 && symbol_mri_common_p (fixP
->fx_addsy
))
2148 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2149 fixP
->fx_offset
= add_number
;
2151 = symbol_get_value_expression (fixP
->fx_addsy
)->X_add_symbol
;
2154 if (fixP
->fx_addsy
!= NULL
)
2155 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
2157 if (fixP
->fx_subsy
!= NULL
)
2159 segT sub_symbol_segment
;
2160 resolve_symbol_value (fixP
->fx_subsy
);
2161 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
2162 if (fixP
->fx_addsy
!= NULL
2163 && sub_symbol_segment
== add_symbol_segment
2164 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
2166 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2167 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2168 fixP
->fx_offset
= add_number
;
2169 fixP
->fx_addsy
= NULL
;
2170 fixP
->fx_subsy
= NULL
;
2172 /* See the comment below about 68k weirdness. */
2176 else if (sub_symbol_segment
== absolute_section
2177 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
))
2179 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2180 fixP
->fx_offset
= add_number
;
2181 fixP
->fx_subsy
= NULL
;
2183 else if (sub_symbol_segment
== this_segment
2184 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
))
2186 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
2187 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
2188 + fixP
->fx_frag
->fr_address
);
2190 /* Make it pc-relative. If the back-end code has not
2191 selected a pc-relative reloc, cancel the adjustment
2192 we do later on all pc-relative relocs. */
2195 /* Do this for m68k even if it's already described
2196 as pc-relative. On the m68k, an operand of
2197 "pc@(foo-.-2)" should address "foo" in a
2198 pc-relative mode. */
2202 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2203 fixP
->fx_subsy
= NULL
;
2206 else if (!TC_VALIDATE_FIX_SUB (fixP
))
2208 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2209 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2210 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
2211 segment_name (add_symbol_segment
),
2212 S_GET_NAME (fixP
->fx_subsy
),
2213 segment_name (sub_symbol_segment
));
2219 if (add_symbol_segment
== this_segment
2220 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
2222 /* This fixup was made when the symbol's segment was
2223 SEG_UNKNOWN, but it is now in the local segment.
2224 So we know how to do the address without relocation. */
2225 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2226 fixP
->fx_offset
= add_number
;
2228 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2229 fixP
->fx_addsy
= NULL
;
2232 else if (add_symbol_segment
== absolute_section
2233 && !TC_FORCE_RELOCATION_ABS (fixP
))
2235 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2236 fixP
->fx_offset
= add_number
;
2237 fixP
->fx_addsy
= NULL
;
2239 else if (add_symbol_segment
!= undefined_section
2240 && ! bfd_is_com_section (add_symbol_segment
)
2241 && MD_APPLY_SYM_VALUE (fixP
))
2242 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
2247 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
2248 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
2250 /* There was no symbol required by this relocation.
2251 However, BFD doesn't really handle relocations
2252 without symbols well. So fake up a local symbol in
2253 the absolute section. */
2254 fixP
->fx_addsy
= abs_section_sym
;
2259 md_apply_fix (fixP
, &add_number
, this_segment
);
2264 if (fixP
->fx_addsy
== NULL
)
2265 fixP
->fx_addsy
= abs_section_sym
;
2266 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2267 if (fixP
->fx_subsy
!= NULL
)
2268 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
2271 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
2273 if (fixP
->fx_size
< sizeof (valueT
))
2278 mask
--; /* Set all bits to one. */
2279 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
2280 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
2282 char buf
[50], buf2
[50];
2283 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
2284 if (add_number
> 1000)
2285 sprint_value (buf2
, add_number
);
2287 sprintf (buf2
, "%ld", (long) add_number
);
2288 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2289 _("value of %s too large for field of %d bytes at %s"),
2290 buf2
, fixP
->fx_size
, buf
);
2291 } /* Generic error checking. */
2293 #ifdef WARN_SIGNED_OVERFLOW_WORD
2294 /* Warn if a .word value is too large when treated as a signed
2295 number. We already know it is not too negative. This is to
2296 catch over-large switches generated by gcc on the 68k. */
2297 if (!flag_signed_overflow_ok
2298 && fixP
->fx_size
== 2
2299 && add_number
> 0x7fff)
2300 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2301 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2303 (long) (fragP
->fr_address
+ fixP
->fx_where
));
2305 } /* Not a bit fix. */
2307 #ifdef TC_VALIDATE_FIX
2308 skip
: ATTRIBUTE_UNUSED_LABEL
2312 fprintf (stderr
, "result:\n");
2315 } /* For each fixS in this segment. */
2317 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2318 return seg_reloc_count
;
2322 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2328 buf
[n
] = val
& 0xff;
2334 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2340 *buf
++ = val
& 0xff;
2346 write_print_statistics (FILE *file
)
2348 fprintf (file
, "fixups: %d\n", n_fixups
);
2351 /* For debugging. */
2352 extern int indent_level
;
2355 print_fixup (fixS
*fixp
)
2358 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2360 fprintf (stderr
, " pcrel");
2361 if (fixp
->fx_pcrel_adjust
)
2362 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2363 if (fixp
->fx_im_disp
)
2366 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2368 fprintf (stderr
, " im_disp");
2372 fprintf (stderr
, " tcbit");
2374 fprintf (stderr
, " done");
2375 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2376 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2377 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2378 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2382 fprintf (stderr
, "\n +<");
2383 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2384 fprintf (stderr
, ">");
2388 fprintf (stderr
, "\n -<");
2389 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2390 fprintf (stderr
, ">");
2392 fprintf (stderr
, "\n");
2393 #ifdef TC_FIX_DATA_PRINT
2394 TC_FIX_DATA_PRINT (stderr
, fixp
);