1 /* write.c - emit .o file
2 Copyright (C) 1986-2016 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* This thing should be set up to do byteordering correctly. But... */
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
29 #include "compress-debug.h"
31 #ifndef TC_FORCE_RELOCATION
32 #define TC_FORCE_RELOCATION(FIX) \
33 (generic_force_reloc (FIX))
36 #ifndef TC_FORCE_RELOCATION_ABS
37 #define TC_FORCE_RELOCATION_ABS(FIX) \
38 (TC_FORCE_RELOCATION (FIX))
41 #ifndef TC_FORCE_RELOCATION_LOCAL
42 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
44 || TC_FORCE_RELOCATION (FIX))
47 #ifndef TC_FORCE_RELOCATION_SUB_SAME
48 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
52 #ifndef md_register_arithmetic
53 # define md_register_arithmetic 1
56 #ifndef TC_FORCE_RELOCATION_SUB_ABS
57 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
58 (!md_register_arithmetic && (SEG) == reg_section)
61 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
64 (!md_register_arithmetic && (SEG) == reg_section)
66 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
70 #ifndef TC_VALIDATE_FIX_SUB
71 #ifdef UNDEFINED_DIFFERENCE_OK
72 /* The PA needs this for PIC code generation. */
73 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
74 (md_register_arithmetic || (SEG) != reg_section)
76 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
77 ((md_register_arithmetic || (SEG) != reg_section) \
78 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
79 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
83 #ifndef TC_LINKRELAX_FIXUP
84 #define TC_LINKRELAX_FIXUP(SEG) 1
87 #ifndef MD_APPLY_SYM_VALUE
88 #define MD_APPLY_SYM_VALUE(FIX) 1
91 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
92 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
95 #ifndef MD_PCREL_FROM_SECTION
96 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
103 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
104 fixups that far past the end of a frag. Having such fixups
105 is of course most most likely a bug in setting fx_size correctly.
106 A negative value disables the fixup check entirely, which is
107 appropriate for something like the Renesas / SuperH SH_COUNT
109 #ifndef TC_FX_SIZE_SLACK
110 #define TC_FX_SIZE_SLACK(FIX) 0
113 /* Used to control final evaluation of expressions. */
114 int finalize_syms
= 0;
116 int symbol_table_frozen
;
118 symbolS
*abs_section_sym
;
120 /* Remember the value of dot when parsing expressions. */
123 /* The frag that dot_value is based from. */
126 /* Relocs generated by ".reloc" pseudo. */
127 struct reloc_list
* reloc_list
;
129 void print_fixup (fixS
*);
131 /* We generally attach relocs to frag chains. However, after we have
132 chained these all together into a segment, any relocs we add after
133 that must be attached to a segment. This will include relocs added
134 in md_estimate_size_for_relax, for example. */
135 static int frags_chained
= 0;
139 #define RELOC_ENUM enum bfd_reloc_code_real
141 /* Create a fixS in obstack 'notes'. */
144 fix_new_internal (fragS
*frag
, /* Which frag? */
145 int where
, /* Where in that frag? */
146 int size
, /* 1, 2, or 4 usually. */
147 symbolS
*add_symbol
, /* X_add_symbol. */
148 symbolS
*sub_symbol
, /* X_op_symbol. */
149 offsetT offset
, /* X_add_number. */
150 int pcrel
, /* TRUE if PC-relative relocation. */
151 RELOC_ENUM r_type
/* Relocation type. */,
152 int at_beginning
) /* Add to the start of the list? */
158 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
160 fixP
->fx_frag
= frag
;
161 fixP
->fx_where
= where
;
162 fixP
->fx_size
= size
;
163 /* We've made fx_size a narrow field; check that it's wide enough. */
164 if (fixP
->fx_size
!= size
)
166 as_bad (_("field fx_size too small to hold %d"), size
);
169 fixP
->fx_addsy
= add_symbol
;
170 fixP
->fx_subsy
= sub_symbol
;
171 fixP
->fx_offset
= offset
;
172 fixP
->fx_dot_value
= dot_value
;
173 fixP
->fx_dot_frag
= dot_frag
;
174 fixP
->fx_pcrel
= pcrel
;
175 fixP
->fx_r_type
= r_type
;
176 fixP
->fx_im_disp
= 0;
177 fixP
->fx_pcrel_adjust
= 0;
178 fixP
->fx_bit_fixP
= 0;
179 fixP
->fx_addnumber
= 0;
183 fixP
->fx_no_overflow
= 0;
187 fixP
->fx_cgen
.insn
= NULL
;
188 fixP
->fx_cgen
.opinfo
= 0;
192 TC_INIT_FIX_DATA (fixP
);
195 fixP
->fx_file
= as_where (&fixP
->fx_line
);
199 fixS
**seg_fix_rootP
= (frags_chained
200 ? &seg_info (now_seg
)->fix_root
201 : &frchain_now
->fix_root
);
202 fixS
**seg_fix_tailP
= (frags_chained
203 ? &seg_info (now_seg
)->fix_tail
204 : &frchain_now
->fix_tail
);
208 fixP
->fx_next
= *seg_fix_rootP
;
209 *seg_fix_rootP
= fixP
;
210 if (fixP
->fx_next
== NULL
)
211 *seg_fix_tailP
= fixP
;
215 fixP
->fx_next
= NULL
;
217 (*seg_fix_tailP
)->fx_next
= fixP
;
219 *seg_fix_rootP
= fixP
;
220 *seg_fix_tailP
= fixP
;
227 /* Create a fixup relative to a symbol (plus a constant). */
230 fix_new (fragS
*frag
, /* Which frag? */
231 int where
, /* Where in that frag? */
232 int size
, /* 1, 2, or 4 usually. */
233 symbolS
*add_symbol
, /* X_add_symbol. */
234 offsetT offset
, /* X_add_number. */
235 int pcrel
, /* TRUE if PC-relative relocation. */
236 RELOC_ENUM r_type
/* Relocation type. */)
238 return fix_new_internal (frag
, where
, size
, add_symbol
,
239 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
242 /* Create a fixup for an expression. Currently we only support fixups
243 for difference expressions. That is itself more than most object
244 file formats support anyhow. */
247 fix_new_exp (fragS
*frag
, /* Which frag? */
248 int where
, /* Where in that frag? */
249 int size
, /* 1, 2, or 4 usually. */
250 expressionS
*exp
, /* Expression. */
251 int pcrel
, /* TRUE if PC-relative relocation. */
252 RELOC_ENUM r_type
/* Relocation type. */)
264 as_bad (_("register value used as expression"));
268 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
269 the difference expression cannot immediately be reduced. */
271 symbolS
*stmp
= make_expr_symbol (exp
);
273 exp
->X_op
= O_symbol
;
274 exp
->X_op_symbol
= 0;
275 exp
->X_add_symbol
= stmp
;
276 exp
->X_add_number
= 0;
278 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
282 add
= exp
->X_add_symbol
;
283 off
= exp
->X_add_number
;
284 r_type
= BFD_RELOC_RVA
;
288 sub
= exp
->X_add_symbol
;
289 off
= exp
->X_add_number
;
293 sub
= exp
->X_op_symbol
;
296 add
= exp
->X_add_symbol
;
299 off
= exp
->X_add_number
;
303 add
= make_expr_symbol (exp
);
307 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
311 /* Create a fixup at the beginning of FRAG. The arguments are the same
312 as for fix_new, except that WHERE is implicitly 0. */
315 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
316 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
318 return fix_new_internal (frag
, 0, size
, add_symbol
,
319 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
322 /* Generic function to determine whether a fixup requires a relocation. */
324 generic_force_reloc (fixS
*fix
)
326 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
327 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
330 if (fix
->fx_addsy
== NULL
)
333 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
336 /* Append a string onto another string, bumping the pointer along. */
338 append (char **charPP
, char *fromP
, unsigned long length
)
340 /* Don't trust memcpy() of 0 chars. */
344 memcpy (*charPP
, fromP
, length
);
348 /* This routine records the largest alignment seen for each segment.
349 If the beginning of the segment is aligned on the worst-case
350 boundary, all of the other alignments within it will work. At
351 least one object format really uses this info. */
354 record_alignment (/* Segment to which alignment pertains. */
356 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
357 boundary, 2 => 4-byte boundary, etc.) */
360 if (seg
== absolute_section
)
363 if (align
<= OCTETS_PER_BYTE_POWER
)
366 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
367 bfd_set_section_alignment (stdoutput
, seg
, align
);
371 get_recorded_alignment (segT seg
)
373 if (seg
== absolute_section
)
376 return bfd_get_section_alignment (stdoutput
, seg
);
379 /* Reset the section indices after removing the gas created sections. */
382 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
384 int *countp
= (int *) countparg
;
386 sec
->index
= *countp
;
391 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
393 fragS dummy
, *prev_frag
= &dummy
;
394 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
396 for (; frchp
; frchp
= frchp
->frch_next
)
398 prev_frag
->fr_next
= frchp
->frch_root
;
399 prev_frag
= frchp
->frch_last
;
400 gas_assert (prev_frag
->fr_type
!= 0);
401 if (frchp
->fix_root
!= (fixS
*) NULL
)
403 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
404 seg_info (section
)->fix_root
= frchp
->fix_root
;
405 prev_fix
->fx_next
= frchp
->fix_root
;
406 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
407 prev_fix
= frchp
->fix_tail
;
410 gas_assert (prev_frag
!= &dummy
411 && prev_frag
->fr_type
!= 0);
412 prev_frag
->fr_next
= 0;
417 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
419 void *xxx ATTRIBUTE_UNUSED
)
421 segment_info_type
*info
;
423 /* BFD may have introduced its own sections without using
424 subseg_new, so it is possible that seg_info is NULL. */
425 info
= seg_info (section
);
426 if (info
!= (segment_info_type
*) NULL
)
427 info
->frchainP
->frch_last
428 = chain_frchains_together_1 (section
, info
->frchainP
);
430 /* Now that we've chained the frags together, we must add new fixups
431 to the segment, not to the frag chain. */
436 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
438 switch (fragP
->fr_type
)
446 HANDLE_ALIGN (fragP
);
448 know (fragP
->fr_next
!= NULL
);
449 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
451 - fragP
->fr_fix
) / fragP
->fr_var
;
452 if (fragP
->fr_offset
< 0)
454 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
455 _("attempt to .org/.space backwards? (%ld)"),
456 (long) fragP
->fr_offset
);
457 fragP
->fr_offset
= 0;
459 fragP
->fr_type
= rs_fill
;
467 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
470 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
473 fragP
->fr_fix
+= size
;
474 fragP
->fr_type
= rs_fill
;
476 fragP
->fr_offset
= 0;
477 fragP
->fr_symbol
= NULL
;
482 eh_frame_convert_frag (fragP
);
486 dwarf2dbg_convert_frag (fragP
);
489 case rs_machine_dependent
:
490 md_convert_frag (stdoutput
, sec
, fragP
);
492 gas_assert (fragP
->fr_next
== NULL
493 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
496 /* After md_convert_frag, we make the frag into a ".space 0".
497 md_convert_frag() should set up any fixSs and constants
502 #ifndef WORKING_DOT_WORD
505 struct broken_word
*lie
;
507 if (fragP
->fr_subtype
)
509 fragP
->fr_fix
+= md_short_jump_size
;
510 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
511 lie
&& lie
->dispfrag
== fragP
;
512 lie
= lie
->next_broken_word
)
514 fragP
->fr_fix
+= md_long_jump_size
;
522 BAD_CASE (fragP
->fr_type
);
526 md_frag_check (fragP
);
530 struct relax_seg_info
537 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
539 segment_info_type
*seginfo
= seg_info (sec
);
540 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
542 if (seginfo
&& seginfo
->frchainP
543 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
548 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
552 segment_info_type
*seginfo
;
554 valueT size
, newsize
;
556 subseg_change (sec
, 0);
558 seginfo
= seg_info (sec
);
559 if (seginfo
&& seginfo
->frchainP
)
561 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
562 cvt_frag_to_fill (sec
, fragp
);
563 for (fragp
= seginfo
->frchainP
->frch_root
;
565 fragp
= fragp
->fr_next
)
566 /* Walk to last elt. */
568 size
= fragp
->fr_address
+ fragp
->fr_fix
;
573 flags
= bfd_get_section_flags (abfd
, sec
);
574 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
575 (flags
& SEC_HAS_CONTENTS
) != 0)
578 if (size
> 0 && ! seginfo
->bss
)
579 flags
|= SEC_HAS_CONTENTS
;
582 x
= bfd_set_section_flags (abfd
, sec
, flags
);
585 newsize
= md_section_align (sec
, size
);
586 x
= bfd_set_section_size (abfd
, sec
, newsize
);
589 /* If the size had to be rounded up, add some padding in the last
591 gas_assert (newsize
>= size
);
594 fragS
*last
= seginfo
->frchainP
->frch_last
;
595 fragp
= seginfo
->frchainP
->frch_root
;
596 while (fragp
->fr_next
!= last
)
597 fragp
= fragp
->fr_next
;
598 last
->fr_address
= size
;
599 if ((newsize
- size
) % fragp
->fr_var
== 0)
600 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
602 /* If we hit this abort, it's likely due to subsegs_finish not
603 providing sufficient alignment on the last frag, and the
604 machine dependent code using alignment frags with fr_var
609 #ifdef tc_frob_section
610 tc_frob_section (sec
);
612 #ifdef obj_frob_section
613 obj_frob_section (sec
);
619 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
621 segment_info_type
*seginfo
= seg_info (sec
);
622 fixS
*fixp
= seginfo
->fix_root
;
627 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
630 symbolS
*s
= fixp
->fx_addsy
;
632 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
633 (int) fixp
->fx_r_type
);
635 fprintf (stream
, "no sym\n");
638 print_symbol_value_1 (stream
, s
);
639 fprintf (stream
, "\n");
641 fixp
= fixp
->fx_next
;
645 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
648 #ifndef EMIT_SECTION_SYMBOLS
649 #define EMIT_SECTION_SYMBOLS 1
652 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
653 and check for validity. Convert RELOC_LIST from using U.A fields
656 resolve_reloc_expr_symbols (void)
658 bfd_vma addr_mask
= 1;
659 struct reloc_list
*r
;
661 /* Avoid a shift by the width of type. */
662 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
666 for (r
= reloc_list
; r
; r
= r
->next
)
668 reloc_howto_type
*howto
= r
->u
.a
.howto
;
671 bfd_vma offset
, addend
;
674 resolve_symbol_value (r
->u
.a
.offset_sym
);
675 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
679 if (symval
->X_op
== O_constant
)
680 sym
= r
->u
.a
.offset_sym
;
681 else if (symval
->X_op
== O_symbol
)
683 sym
= symval
->X_add_symbol
;
684 offset
= symval
->X_add_number
;
685 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
688 || symval
->X_op
!= O_constant
689 || (sec
= S_GET_SEGMENT (sym
)) == NULL
690 || !SEG_NORMAL (sec
))
692 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
696 offset
+= S_GET_VALUE (sym
);
699 addend
= r
->u
.a
.addend
;
700 if (r
->u
.a
.sym
!= NULL
)
702 resolve_symbol_value (r
->u
.a
.sym
);
703 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
704 if (symval
->X_op
== O_constant
)
706 else if (symval
->X_op
== O_symbol
)
708 sym
= symval
->X_add_symbol
;
709 addend
+= symval
->X_add_number
;
710 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
712 if (symval
->X_op
!= O_constant
)
714 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
717 else if (sym
!= NULL
)
719 /* Convert relocs against local symbols to refer to the
720 corresponding section symbol plus offset instead. Keep
721 PC-relative relocs of the REL variety intact though to
722 prevent the offset from overflowing the relocated field,
723 unless it has enough bits to cover the whole address
725 if (S_IS_LOCAL (sym
) && !symbol_section_p (sym
)
727 || (howto
->partial_inplace
728 && (!howto
->pc_relative
729 || howto
->src_mask
== addr_mask
))))
731 asection
*symsec
= S_GET_SEGMENT (sym
);
732 if (!(((symsec
->flags
& SEC_MERGE
) != 0
734 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
736 addend
+= S_GET_VALUE (sym
);
737 sym
= section_symbol (symsec
);
740 symbol_mark_used_in_reloc (sym
);
745 if (abs_section_sym
== NULL
)
746 abs_section_sym
= section_symbol (absolute_section
);
747 sym
= abs_section_sym
;
751 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
752 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
753 r
->u
.b
.r
.address
= offset
;
754 r
->u
.b
.r
.addend
= addend
;
755 r
->u
.b
.r
.howto
= howto
;
759 /* This pass over fixups decides whether symbols can be replaced with
763 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
765 void *xxx ATTRIBUTE_UNUSED
)
767 segment_info_type
*seginfo
= seg_info (sec
);
773 dump_section_relocs (abfd
, sec
, stderr
);
775 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
779 else if (fixp
->fx_addsy
)
785 fprintf (stderr
, "\n\nadjusting fixup:\n");
789 sym
= fixp
->fx_addsy
;
791 /* All symbols should have already been resolved at this
792 point. It is possible to see unresolved expression
793 symbols, though, since they are not in the regular symbol
795 resolve_symbol_value (sym
);
797 if (fixp
->fx_subsy
!= NULL
)
798 resolve_symbol_value (fixp
->fx_subsy
);
800 /* If this symbol is equated to an undefined or common symbol,
801 convert the fixup to being against that symbol. */
802 while (symbol_equated_reloc_p (sym
)
803 || S_IS_WEAKREFR (sym
))
805 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
808 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
809 fixp
->fx_addsy
= newsym
;
813 if (symbol_mri_common_p (sym
))
815 fixp
->fx_offset
+= S_GET_VALUE (sym
);
816 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
820 /* If the symbol is undefined, common, weak, or global (ELF
821 shared libs), we can't replace it with the section symbol. */
822 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
825 /* Is there some other (target cpu dependent) reason we can't adjust
826 this one? (E.g. relocations involving function addresses on
828 #ifdef tc_fix_adjustable
829 if (! tc_fix_adjustable (fixp
))
833 /* Since we're reducing to section symbols, don't attempt to reduce
834 anything that's already using one. */
835 if (symbol_section_p (sym
))
838 symsec
= S_GET_SEGMENT (sym
);
842 if (bfd_is_abs_section (symsec
)
843 || symsec
== reg_section
)
845 /* The fixup_segment routine normally will not use this
846 symbol in a relocation. */
850 /* Don't try to reduce relocs which refer to non-local symbols
851 in .linkonce sections. It can lead to confusion when a
852 debugging section refers to a .linkonce section. I hope
853 this will always be correct. */
854 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
856 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
858 /* The GNU toolchain uses an extension for ELF: a
859 section beginning with the magic string
860 .gnu.linkonce is a linkonce section. */
861 && strncmp (segment_name (symsec
), ".gnu.linkonce",
862 sizeof ".gnu.linkonce" - 1) == 0))
866 /* Never adjust a reloc against local symbol in a merge section
867 with non-zero addend. */
868 if ((symsec
->flags
& SEC_MERGE
) != 0
869 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
872 /* Never adjust a reloc against TLS local symbol. */
873 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
876 /* We refetch the segment when calling section_symbol, rather
877 than using symsec, because S_GET_VALUE may wind up changing
878 the section when it calls resolve_symbol_value. */
879 fixp
->fx_offset
+= S_GET_VALUE (sym
);
880 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
882 fprintf (stderr
, "\nadjusted fixup:\n");
887 dump_section_relocs (abfd
, sec
, stderr
);
892 Go through all the fixS's in a segment and see which ones can be
893 handled now. (These consist of fixS where we have since discovered
894 the value of a symbol, or the address of the frag involved.)
895 For each one, call md_apply_fix to put the fix into the frag data.
896 Ones that we couldn't completely handle here will be output later
897 by emit_relocations. */
900 fixup_segment (fixS
*fixP
, segT this_segment
)
904 segT add_symbol_segment
= absolute_section
;
906 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
907 abs_section_sym
= section_symbol (absolute_section
);
909 /* If the linker is doing the relaxing, we must not do any fixups.
911 Well, strictly speaking that's not true -- we could do any that
912 are PC-relative and don't cross regions that could change size.
913 And for the i960 we might be able to turn callx/callj into bal
914 anyways in cases where we know the maximum displacement. */
915 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
917 for (; fixP
; fixP
= fixP
->fx_next
)
920 if (fixP
->fx_addsy
== NULL
)
922 /* There was no symbol required by this relocation.
923 However, BFD doesn't really handle relocations
924 without symbols well. So fake up a local symbol in
925 the absolute section. */
926 fixP
->fx_addsy
= abs_section_sym
;
928 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
929 if (fixP
->fx_subsy
!= NULL
)
930 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
935 for (; fixP
; fixP
= fixP
->fx_next
)
938 fprintf (stderr
, "\nprocessing fixup:\n");
942 fragP
= fixP
->fx_frag
;
944 #ifdef TC_VALIDATE_FIX
945 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
947 add_number
= fixP
->fx_offset
;
949 if (fixP
->fx_addsy
!= NULL
)
950 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
952 if (fixP
->fx_subsy
!= NULL
)
954 segT sub_symbol_segment
;
955 resolve_symbol_value (fixP
->fx_subsy
);
956 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
957 if (fixP
->fx_addsy
!= NULL
958 && sub_symbol_segment
== add_symbol_segment
959 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
960 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
961 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
963 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
964 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
965 fixP
->fx_offset
= add_number
;
966 fixP
->fx_addsy
= NULL
;
967 fixP
->fx_subsy
= NULL
;
969 /* See the comment below about 68k weirdness. */
973 else if (sub_symbol_segment
== absolute_section
974 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
975 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
977 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
978 fixP
->fx_offset
= add_number
;
979 fixP
->fx_subsy
= NULL
;
981 else if (sub_symbol_segment
== this_segment
982 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
983 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
985 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
986 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
987 + fixP
->fx_dot_frag
->fr_address
);
989 /* Make it pc-relative. If the back-end code has not
990 selected a pc-relative reloc, cancel the adjustment
991 we do later on all pc-relative relocs. */
994 /* Do this for m68k even if it's already described
995 as pc-relative. On the m68k, an operand of
996 "pc@(foo-.-2)" should address "foo" in a
1001 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1002 fixP
->fx_subsy
= NULL
;
1005 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1007 if (!md_register_arithmetic
1008 && (add_symbol_segment
== reg_section
1009 || sub_symbol_segment
== reg_section
))
1010 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1011 _("register value used as expression"));
1013 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1014 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1015 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1016 segment_name (add_symbol_segment
),
1017 S_GET_NAME (fixP
->fx_subsy
),
1018 segment_name (sub_symbol_segment
));
1020 else if (sub_symbol_segment
!= undefined_section
1021 && ! bfd_is_com_section (sub_symbol_segment
)
1022 && MD_APPLY_SYM_VALUE (fixP
))
1023 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1028 if (add_symbol_segment
== this_segment
1029 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1030 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1032 /* This fixup was made when the symbol's segment was
1033 SEG_UNKNOWN, but it is now in the local segment.
1034 So we know how to do the address without relocation. */
1035 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1036 fixP
->fx_offset
= add_number
;
1038 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1039 fixP
->fx_addsy
= NULL
;
1042 else if (add_symbol_segment
== absolute_section
1043 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1044 && !TC_FORCE_RELOCATION_ABS (fixP
))
1046 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1047 fixP
->fx_offset
= add_number
;
1048 fixP
->fx_addsy
= NULL
;
1050 else if (add_symbol_segment
!= undefined_section
1051 && ! bfd_is_com_section (add_symbol_segment
)
1052 && MD_APPLY_SYM_VALUE (fixP
))
1053 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1058 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1059 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1061 /* There was no symbol required by this relocation.
1062 However, BFD doesn't really handle relocations
1063 without symbols well. So fake up a local symbol in
1064 the absolute section. */
1065 fixP
->fx_addsy
= abs_section_sym
;
1070 md_apply_fix (fixP
, &add_number
, this_segment
);
1074 if (fixP
->fx_addsy
== NULL
)
1075 fixP
->fx_addsy
= abs_section_sym
;
1076 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1077 if (fixP
->fx_subsy
!= NULL
)
1078 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1081 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1083 if (fixP
->fx_size
< sizeof (valueT
))
1088 mask
--; /* Set all bits to one. */
1089 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1090 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1092 char buf
[50], buf2
[50];
1093 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1094 if (add_number
> 1000)
1095 sprint_value (buf2
, add_number
);
1097 sprintf (buf2
, "%ld", (long) add_number
);
1098 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1099 _("value of %s too large for field of %d bytes at %s"),
1100 buf2
, fixP
->fx_size
, buf
);
1101 } /* Generic error checking. */
1103 #ifdef WARN_SIGNED_OVERFLOW_WORD
1104 /* Warn if a .word value is too large when treated as a signed
1105 number. We already know it is not too negative. This is to
1106 catch over-large switches generated by gcc on the 68k. */
1107 if (!flag_signed_overflow_ok
1108 && fixP
->fx_size
== 2
1109 && add_number
> 0x7fff)
1110 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1111 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1113 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1115 } /* Not a bit fix. */
1117 #ifdef TC_VALIDATE_FIX
1118 skip
: ATTRIBUTE_UNUSED_LABEL
1122 fprintf (stderr
, "result:\n");
1125 } /* For each fixS in this segment. */
1129 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1131 void *xxx ATTRIBUTE_UNUSED
)
1133 segment_info_type
*seginfo
= seg_info (sec
);
1135 fixup_segment (seginfo
->fix_root
, sec
);
1139 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1140 const char *file
, unsigned int line
)
1143 bfd_reloc_status_type s
;
1146 if (reloc
->sym_ptr_ptr
!= NULL
1147 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1148 && (sym
->flags
& BSF_KEEP
) == 0
1149 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1150 || (EMIT_SECTION_SYMBOLS
1151 && !bfd_is_abs_section (sym
->section
))))
1152 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1154 s
= bfd_install_relocation (stdoutput
, reloc
,
1155 fragp
->fr_literal
, fragp
->fr_address
,
1161 case bfd_reloc_overflow
:
1162 as_bad_where (file
, line
, _("relocation overflow"));
1164 case bfd_reloc_outofrange
:
1165 as_bad_where (file
, line
, _("relocation out of range"));
1168 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1174 get_frag_for_reloc (fragS
*last_frag
,
1175 const segment_info_type
*seginfo
,
1176 const struct reloc_list
*r
)
1180 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1181 if (f
->fr_address
<= r
->u
.b
.r
.address
1182 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1185 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1186 if (f
->fr_address
<= r
->u
.b
.r
.address
1187 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1190 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1191 if (f
->fr_address
<= r
->u
.b
.r
.address
1192 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1195 as_bad_where (r
->file
, r
->line
,
1196 _("reloc not within (fixed part of) section"));
1201 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1203 segment_info_type
*seginfo
= seg_info (sec
);
1205 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1210 /* If seginfo is NULL, we did not create this section; don't do
1211 anything with it. */
1212 if (seginfo
== NULL
)
1216 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1220 #ifdef RELOC_EXPANSION_POSSIBLE
1221 n
*= MAX_RELOC_EXPANSION
;
1224 /* Extract relocs for this section from reloc_list. */
1226 my_reloc_list
= NULL
;
1227 while ((r
= *rp
) != NULL
)
1229 if (r
->u
.b
.sec
== sec
)
1232 r
->next
= my_reloc_list
;
1240 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
1245 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1250 #ifndef RELOC_EXPANSION_POSSIBLE
1259 fx_size
= fixp
->fx_size
;
1260 slack
= TC_FX_SIZE_SLACK (fixp
);
1262 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1263 loc
= fixp
->fx_where
+ fx_size
;
1264 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1265 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1266 _("internal error: fixup not contained within frag"));
1268 #ifndef RELOC_EXPANSION_POSSIBLE
1269 *reloc
= tc_gen_reloc (sec
, fixp
);
1271 reloc
= tc_gen_reloc (sec
, fixp
);
1276 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1278 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1282 relocs
[n
++] = &r
->u
.b
.r
;
1283 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1287 relocs
[n
++] = *reloc
;
1288 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1289 fixp
->fx_file
, fixp
->fx_line
);
1290 #ifndef RELOC_EXPANSION_POSSIBLE
1300 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1304 relocs
[n
++] = &r
->u
.b
.r
;
1305 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1312 unsigned int k
, j
, nsyms
;
1314 sympp
= bfd_get_outsymbols (stdoutput
);
1315 nsyms
= bfd_get_symcount (stdoutput
);
1316 for (k
= 0; k
< n
; k
++)
1317 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1319 for (j
= 0; j
< nsyms
; j
++)
1320 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1330 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1332 bfd_set_section_flags (abfd
, sec
, flags
);
1333 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1336 #ifdef SET_SECTION_RELOCS
1337 SET_SECTION_RELOCS (sec
, relocs
, n
);
1344 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1345 for (k
= 0; k
< n
; k
++)
1347 arelent
*rel
= relocs
[k
];
1348 asymbol
*s
= *rel
->sym_ptr_ptr
;
1349 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1350 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1351 (unsigned long)rel
->addend
);
1358 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1359 fragS
**last_newf
, struct obstack
*ob
)
1362 int total_out_size
= 0;
1363 fragS
*f
= *last_newf
;
1367 /* Call the compression routine repeatedly until it has finished
1368 processing the frag. */
1371 /* Reserve all the space available in the current chunk.
1372 If none is available, start a new frag. */
1373 avail_out
= obstack_room (ob
);
1376 obstack_finish (ob
);
1377 f
= frag_alloc (ob
);
1378 f
->fr_type
= rs_fill
;
1379 (*last_newf
)->fr_next
= f
;
1381 avail_out
= obstack_room (ob
);
1384 as_fatal (_("can't extend frag"));
1385 next_out
= obstack_next_free (ob
);
1386 obstack_blank_fast (ob
, avail_out
);
1387 out_size
= compress_data (strm
, &contents
, &in_size
,
1388 &next_out
, &avail_out
);
1392 f
->fr_fix
+= out_size
;
1393 total_out_size
+= out_size
;
1395 /* Return unused space. */
1397 obstack_blank_fast (ob
, -avail_out
);
1400 return total_out_size
;
1404 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1406 segment_info_type
*seginfo
= seg_info (sec
);
1410 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1411 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1412 bfd_size_type compressed_size
;
1413 const char *section_name
;
1414 char *compressed_name
;
1416 struct z_stream_s
*strm
;
1418 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1419 unsigned int header_size
, compression_header_size
;
1423 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1426 section_name
= bfd_get_section_name (stdoutput
, sec
);
1427 if (strncmp (section_name
, ".debug_", 7) != 0)
1430 strm
= compress_init ();
1434 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1436 compression_header_size
1437 = bfd_get_compression_header_size (stdoutput
, NULL
);
1438 header_size
= compression_header_size
;
1442 compression_header_size
= 0;
1446 /* Create a new frag to contain the compression header. */
1447 first_newf
= frag_alloc (ob
);
1448 if (obstack_room (ob
) < header_size
)
1449 first_newf
= frag_alloc (ob
);
1450 if (obstack_room (ob
) < header_size
)
1451 as_fatal (_("can't extend frag %u chars"), header_size
);
1452 last_newf
= first_newf
;
1453 obstack_blank_fast (ob
, header_size
);
1454 last_newf
->fr_type
= rs_fill
;
1455 last_newf
->fr_fix
= header_size
;
1456 header
= last_newf
->fr_literal
;
1457 compressed_size
= header_size
;
1459 /* Stream the frags through the compression engine, adding new frags
1460 as necessary to accomodate the compressed output. */
1461 for (f
= seginfo
->frchainP
->frch_root
;
1470 gas_assert (f
->fr_type
== rs_fill
);
1473 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1477 compressed_size
+= out_size
;
1479 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1480 fill_size
= f
->fr_var
;
1481 count
= f
->fr_offset
;
1482 gas_assert (count
>= 0);
1483 if (fill_size
&& count
)
1487 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1491 compressed_size
+= out_size
;
1496 /* Flush the compression state. */
1503 /* Reserve all the space available in the current chunk.
1504 If none is available, start a new frag. */
1505 avail_out
= obstack_room (ob
);
1510 obstack_finish (ob
);
1511 newf
= frag_alloc (ob
);
1512 newf
->fr_type
= rs_fill
;
1513 last_newf
->fr_next
= newf
;
1515 avail_out
= obstack_room (ob
);
1518 as_fatal (_("can't extend frag"));
1519 next_out
= obstack_next_free (ob
);
1520 obstack_blank_fast (ob
, avail_out
);
1521 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1525 last_newf
->fr_fix
+= out_size
;
1526 compressed_size
+= out_size
;
1528 /* Return unused space. */
1530 obstack_blank_fast (ob
, -avail_out
);
1536 /* PR binutils/18087: If compression didn't make the section smaller,
1537 just keep it uncompressed. */
1538 if (compressed_size
>= uncompressed_size
)
1541 /* Replace the uncompressed frag list with the compressed frag list. */
1542 seginfo
->frchainP
->frch_root
= first_newf
;
1543 seginfo
->frchainP
->frch_last
= last_newf
;
1545 /* Update the section size and its name. */
1546 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1547 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1549 if (!compression_header_size
)
1551 compressed_name
= (char *) xmalloc (strlen (section_name
) + 2);
1552 compressed_name
[0] = '.';
1553 compressed_name
[1] = 'z';
1554 strcpy (compressed_name
+ 2, section_name
+ 1);
1555 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1560 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1562 void *xxx ATTRIBUTE_UNUSED
)
1564 segment_info_type
*seginfo
= seg_info (sec
);
1565 addressT offset
= 0;
1568 /* Write out the frags. */
1570 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1573 for (f
= seginfo
->frchainP
->frch_root
;
1582 gas_assert (f
->fr_type
== rs_fill
);
1585 x
= bfd_set_section_contents (stdoutput
, sec
,
1586 f
->fr_literal
, (file_ptr
) offset
,
1587 (bfd_size_type
) f
->fr_fix
);
1589 as_fatal (_("can't write %ld bytes to section %s of %s because: '%s'"),
1590 (long) f
->fr_fix
, sec
->name
,
1591 stdoutput
->filename
,
1592 bfd_errmsg (bfd_get_error ()));
1593 offset
+= f
->fr_fix
;
1595 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1596 fill_size
= f
->fr_var
;
1597 count
= f
->fr_offset
;
1598 gas_assert (count
>= 0);
1599 if (fill_size
&& count
)
1602 if (fill_size
> sizeof (buf
))
1604 /* Do it the old way. Can this ever happen? */
1607 x
= bfd_set_section_contents (stdoutput
, sec
,
1610 (bfd_size_type
) fill_size
);
1612 as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
1613 (long) fill_size
, sec
->name
,
1614 stdoutput
->filename
,
1615 bfd_errmsg (bfd_get_error ()));
1616 offset
+= fill_size
;
1621 /* Build a buffer full of fill objects and output it as
1622 often as necessary. This saves on the overhead of
1623 potentially lots of bfd_set_section_contents calls. */
1627 n_per_buf
= sizeof (buf
);
1628 memset (buf
, *fill_literal
, n_per_buf
);
1633 n_per_buf
= sizeof (buf
) / fill_size
;
1634 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1635 memcpy (bufp
, fill_literal
, fill_size
);
1637 for (; count
> 0; count
-= n_per_buf
)
1639 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1640 x
= bfd_set_section_contents
1641 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1642 (bfd_size_type
) n_per_buf
* fill_size
);
1644 as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
1645 (long)(n_per_buf
* fill_size
), sec
->name
,
1646 stdoutput
->filename
,
1647 bfd_errmsg (bfd_get_error ()));
1648 offset
+= n_per_buf
* fill_size
;
1656 merge_data_into_text (void)
1658 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1659 seg_info (data_section
)->frchainP
->frch_root
;
1660 seg_info (text_section
)->frchainP
->frch_last
=
1661 seg_info (data_section
)->frchainP
->frch_last
;
1662 seg_info (data_section
)->frchainP
= 0;
1673 /* Count symbols. We can't rely on a count made by the loop in
1674 write_object_file, because *_frob_file may add a new symbol or
1677 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1683 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1685 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1686 symp
= symbol_rootP
;
1687 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1689 asympp
[i
] = symbol_get_bfdsym (symp
);
1690 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1691 || !(bfd_is_const_section (asympp
[i
]->section
)
1692 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1693 asympp
[i
]->flags
|= BSF_KEEP
;
1694 symbol_mark_written (symp
);
1699 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1700 gas_assert (result
);
1701 symbol_table_frozen
= 1;
1704 /* Finish the subsegments. After every sub-segment, we fake an
1705 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1706 ".fill 0" because that is the kind of frag that requires least
1707 thought. ".align" frags like to have a following frag since that
1708 makes calculating their intended length trivial. */
1710 #ifndef SUB_SEGMENT_ALIGN
1712 /* The last subsegment gets an alignment corresponding to the alignment
1713 of the section. This allows proper nop-filling at the end of
1714 code-bearing sections. */
1715 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1716 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1717 ? get_recorded_alignment (SEG) \
1720 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1725 subsegs_finish_section (asection
*s
)
1727 struct frchain
*frchainP
;
1728 segment_info_type
*seginfo
= seg_info (s
);
1732 for (frchainP
= seginfo
->frchainP
;
1734 frchainP
= frchainP
->frch_next
)
1738 subseg_set (s
, frchainP
->frch_subseg
);
1740 /* This now gets called even if we had errors. In that case,
1741 any alignment is meaningless, and, moreover, will look weird
1742 if we are generating a listing. */
1745 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1746 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1747 && now_seg
->entsize
)
1749 unsigned int entsize
= now_seg
->entsize
;
1752 while ((entsize
& 1) == 0)
1758 if (entalign
> alignment
)
1759 alignment
= entalign
;
1763 if (subseg_text_p (now_seg
))
1764 frag_align_code (alignment
, 0);
1766 frag_align (alignment
, 0, 0);
1768 /* frag_align will have left a new frag.
1769 Use this last frag for an empty ".fill".
1771 For this segment ...
1772 Create a last frag. Do not leave a "being filled in frag". */
1773 frag_wane (frag_now
);
1774 frag_now
->fr_fix
= 0;
1775 know (frag_now
->fr_next
== NULL
);
1780 subsegs_finish (void)
1784 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1785 subsegs_finish_section (s
);
1790 create_obj_attrs_section (void)
1797 size
= bfd_elf_obj_attr_size (stdoutput
);
1800 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1802 name
= ".gnu.attributes";
1803 s
= subseg_new (name
, 0);
1804 elf_section_type (s
)
1805 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1806 bfd_set_section_flags (stdoutput
, s
, SEC_READONLY
| SEC_DATA
);
1808 p
= frag_more (size
);
1809 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1811 subsegs_finish_section (s
);
1812 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1813 size_seg (stdoutput
, s
, NULL
);
1818 /* Write the object file. */
1821 write_object_file (void)
1823 struct relax_seg_info rsi
;
1824 #ifndef WORKING_DOT_WORD
1825 fragS
*fragP
; /* Track along all frags. */
1830 #ifdef md_pre_output_hook
1834 #ifdef md_pre_relax_hook
1838 /* From now on, we don't care about sub-segments. Build one frag chain
1839 for each segment. Linked thru fr_next. */
1841 /* Remove the sections created by gas for its own purposes. */
1845 bfd_section_list_remove (stdoutput
, reg_section
);
1846 bfd_section_list_remove (stdoutput
, expr_section
);
1847 stdoutput
->section_count
-= 2;
1849 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1852 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1854 /* We have two segments. If user gave -R flag, then we must put the
1855 data frags into the text segment. Do this before relaxing so
1856 we know to take advantage of -R and make shorter addresses. */
1857 if (flag_readonly_data_in_text
)
1859 merge_data_into_text ();
1865 #ifndef WORKING_DOT_WORD
1866 /* We need to reset the markers in the broken word list and
1867 associated frags between calls to relax_segment (via
1868 relax_seg). Since the broken word list is global, we do it
1869 once per round, rather than locally in relax_segment for each
1871 struct broken_word
*brokp
;
1873 for (brokp
= broken_words
;
1874 brokp
!= (struct broken_word
*) NULL
;
1875 brokp
= brokp
->next_broken_word
)
1879 if (brokp
->dispfrag
!= (fragS
*) NULL
1880 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1881 brokp
->dispfrag
->fr_subtype
= 0;
1886 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1892 /* Note - Most ports will use the default value of
1893 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1894 local symbols to be resolved, removing their frag information.
1895 Some ports however, will not have finished relaxing all of
1896 their frags and will still need the local symbol frag
1897 information. These ports can set
1898 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1899 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1901 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1903 /* Relaxation has completed. Freeze all syms. */
1906 #ifdef md_post_relax_hook
1912 create_obj_attrs_section ();
1915 #ifndef WORKING_DOT_WORD
1917 struct broken_word
*lie
;
1918 struct broken_word
**prevP
;
1920 prevP
= &broken_words
;
1921 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1926 subseg_change (lie
->seg
, lie
->subseg
);
1927 exp
.X_op
= O_subtract
;
1928 exp
.X_add_symbol
= lie
->add
;
1929 exp
.X_op_symbol
= lie
->sub
;
1930 exp
.X_add_number
= lie
->addnum
;
1931 #ifdef TC_CONS_FIX_NEW
1932 TC_CONS_FIX_NEW (lie
->frag
,
1933 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1934 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
1936 fix_new_exp (lie
->frag
,
1937 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1938 2, &exp
, 0, BFD_RELOC_16
);
1940 *prevP
= lie
->next_broken_word
;
1943 prevP
= &(lie
->next_broken_word
);
1945 for (lie
= broken_words
; lie
;)
1947 struct broken_word
*untruth
;
1949 addressT table_addr
;
1950 addressT from_addr
, to_addr
;
1953 subseg_change (lie
->seg
, lie
->subseg
);
1954 fragP
= lie
->dispfrag
;
1956 /* Find out how many broken_words go here. */
1959 untruth
&& untruth
->dispfrag
== fragP
;
1960 untruth
= untruth
->next_broken_word
)
1961 if (untruth
->added
== 1)
1964 table_ptr
= lie
->dispfrag
->fr_opcode
;
1965 table_addr
= (lie
->dispfrag
->fr_address
1966 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1967 /* Create the jump around the long jumps. This is a short
1968 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1969 from_addr
= table_addr
;
1970 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1971 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1973 table_ptr
+= md_short_jump_size
;
1974 table_addr
+= md_short_jump_size
;
1977 lie
&& lie
->dispfrag
== fragP
;
1978 m
++, lie
= lie
->next_broken_word
)
1980 if (lie
->added
== 2)
1982 /* Patch the jump table. */
1983 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
1984 untruth
&& untruth
->dispfrag
== fragP
;
1985 untruth
= untruth
->next_broken_word
)
1987 if (untruth
->use_jump
== lie
)
1989 /* This is the offset from ??? to table_ptr+0.
1990 The target is the same for all users of this
1991 md_long_jump, but the "sub" bases (and hence the
1992 offsets) may be different. */
1993 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
1994 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1995 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
1997 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2001 /* Install the long jump. */
2002 /* This is a long jump from table_ptr+0 to the final target. */
2003 from_addr
= table_addr
;
2004 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2005 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2007 table_ptr
+= md_long_jump_size
;
2008 table_addr
+= md_long_jump_size
;
2012 #endif /* not WORKING_DOT_WORD */
2014 /* Resolve symbol values. This needs to be done before processing
2020 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2021 resolve_symbol_value (symp
);
2023 resolve_local_symbol_values ();
2024 resolve_reloc_expr_symbols ();
2028 #ifdef tc_frob_file_before_adjust
2029 tc_frob_file_before_adjust ();
2031 #ifdef obj_frob_file_before_adjust
2032 obj_frob_file_before_adjust ();
2035 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2037 #ifdef tc_frob_file_before_fix
2038 tc_frob_file_before_fix ();
2040 #ifdef obj_frob_file_before_fix
2041 obj_frob_file_before_fix ();
2044 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2046 /* Set up symbol table, and write it out. */
2050 bfd_boolean skip_next_symbol
= FALSE
;
2052 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2057 if (skip_next_symbol
)
2059 /* Don't do anything besides moving the value of the
2060 symbol from the GAS value-field to the BFD value-field. */
2061 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2062 skip_next_symbol
= FALSE
;
2066 if (symbol_mri_common_p (symp
))
2068 if (S_IS_EXTERNAL (symp
))
2069 as_bad (_("%s: global symbols not supported in common sections"),
2071 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2075 name
= S_GET_NAME (symp
);
2079 decode_local_label_name ((char *) S_GET_NAME (symp
));
2080 /* They only differ if `name' is a fb or dollar local
2082 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2083 as_bad (_("local label `%s' is not defined"), name2
);
2086 /* Do it again, because adjust_reloc_syms might introduce
2087 more symbols. They'll probably only be section symbols,
2088 but they'll still need to have the values computed. */
2089 resolve_symbol_value (symp
);
2091 /* Skip symbols which were equated to undefined or common
2093 if (symbol_equated_reloc_p (symp
)
2094 || S_IS_WEAKREFR (symp
))
2096 const char *sname
= S_GET_NAME (symp
);
2098 if (S_IS_COMMON (symp
)
2099 && !TC_FAKE_LABEL (sname
)
2100 && !S_IS_WEAKREFR (symp
)
2101 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
2103 expressionS
*e
= symbol_get_value_expression (symp
);
2105 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2106 sname
, S_GET_NAME (e
->X_add_symbol
));
2108 if (S_GET_SEGMENT (symp
) == reg_section
)
2110 /* Report error only if we know the symbol name. */
2111 if (S_GET_NAME (symp
) != reg_section
->name
)
2112 as_bad (_("can't make global register symbol `%s'"),
2115 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2119 #ifdef obj_frob_symbol
2120 obj_frob_symbol (symp
, punt
);
2122 #ifdef tc_frob_symbol
2123 if (! punt
|| symbol_used_in_reloc_p (symp
))
2124 tc_frob_symbol (symp
, punt
);
2127 /* If we don't want to keep this symbol, splice it out of
2128 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2129 want section symbols. Otherwise, we skip local symbols
2130 and symbols that the frob_symbol macros told us to punt,
2131 but we keep such symbols if they are used in relocs. */
2132 if (symp
== abs_section_sym
2133 || (! EMIT_SECTION_SYMBOLS
2134 && symbol_section_p (symp
))
2135 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2136 opposites. Sometimes the former checks flags and the
2137 latter examines the name... */
2138 || (!S_IS_EXTERNAL (symp
)
2139 && (punt
|| S_IS_LOCAL (symp
) ||
2140 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2141 && ! symbol_used_in_reloc_p (symp
)))
2143 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2145 /* After symbol_remove, symbol_next(symp) still returns
2146 the one that came after it in the chain. So we don't
2147 need to do any extra cleanup work here. */
2151 /* Make sure we really got a value for the symbol. */
2152 if (! symbol_resolved_p (symp
))
2154 as_bad (_("can't resolve value for symbol `%s'"),
2156 symbol_mark_resolved (symp
);
2159 /* Set the value into the BFD symbol. Up til now the value
2160 has only been kept in the gas symbolS struct. */
2161 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2163 /* A warning construct is a warning symbol followed by the
2164 symbol warned about. Don't let anything object-format or
2165 target-specific muck with it; it's ready for output. */
2166 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2167 skip_next_symbol
= TRUE
;
2173 /* Now do any format-specific adjustments to the symbol table, such
2174 as adding file symbols. */
2175 #ifdef tc_adjust_symtab
2176 tc_adjust_symtab ();
2178 #ifdef obj_adjust_symtab
2179 obj_adjust_symtab ();
2182 /* Stop if there is an error. */
2186 /* Now that all the sizes are known, and contents correct, we can
2187 start writing to the file. */
2190 /* If *_frob_file changes the symbol value at this point, it is
2191 responsible for moving the changed value into symp->bsym->value
2192 as well. Hopefully all symbol value changing can be done in
2197 #ifdef obj_frob_file
2200 #ifdef obj_coff_generate_pdata
2201 obj_coff_generate_pdata ();
2203 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2205 #ifdef tc_frob_file_after_relocs
2206 tc_frob_file_after_relocs ();
2208 #ifdef obj_frob_file_after_relocs
2209 obj_frob_file_after_relocs ();
2212 /* Once all relocations have been written, we can compress the
2213 contents of the debug sections. This needs to be done before
2214 we start writing any sections, because it will affect the file
2215 layout, which is fixed once we start writing contents. */
2216 if (flag_compress_debug
)
2218 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2219 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2221 stdoutput
->flags
|= BFD_COMPRESS
;
2222 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2225 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2228 #ifdef TC_GENERIC_RELAX_TABLE
2229 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2232 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2234 const relax_typeS
*this_type
;
2235 const relax_typeS
*start_type
;
2236 relax_substateT next_state
;
2237 relax_substateT this_state
;
2243 const relax_typeS
*table
;
2245 target
= fragP
->fr_offset
;
2246 address
= fragP
->fr_address
;
2247 table
= TC_GENERIC_RELAX_TABLE
;
2248 this_state
= fragP
->fr_subtype
;
2249 start_type
= this_type
= table
+ this_state
;
2250 symbolP
= fragP
->fr_symbol
;
2256 sym_frag
= symbol_get_frag (symbolP
);
2258 #ifndef DIFF_EXPR_OK
2259 know (sym_frag
!= NULL
);
2261 know (S_GET_SEGMENT (symbolP
) != absolute_section
2262 || sym_frag
== &zero_address_frag
);
2263 target
+= S_GET_VALUE (symbolP
);
2265 /* If SYM_FRAG has yet to be reached on this pass, assume it
2266 will move by STRETCH just as we did, unless there is an
2267 alignment frag between here and SYM_FRAG. An alignment may
2268 well absorb any STRETCH, and we don't want to choose a larger
2269 branch insn by overestimating the needed reach of this
2270 branch. It isn't critical to calculate TARGET exactly; We
2271 know we'll be doing another pass if STRETCH is non-zero. */
2274 && sym_frag
->relax_marker
!= fragP
->relax_marker
2275 && S_GET_SEGMENT (symbolP
) == segment
)
2278 || sym_frag
->region
== fragP
->region
)
2280 /* If we get here we know we have a forward branch. This
2281 relax pass may have stretched previous instructions so
2282 far that omitting STRETCH would make the branch
2283 negative. Don't allow this in case the negative reach is
2284 large enough to require a larger branch instruction. */
2285 else if (target
< address
)
2286 target
= fragP
->fr_next
->fr_address
+ stretch
;
2290 aim
= target
- address
- fragP
->fr_fix
;
2291 #ifdef TC_PCREL_ADJUST
2292 /* Currently only the ns32k family needs this. */
2293 aim
+= TC_PCREL_ADJUST (fragP
);
2296 #ifdef md_prepare_relax_scan
2297 /* Formerly called M68K_AIM_KLUDGE. */
2298 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2303 /* Look backwards. */
2304 for (next_state
= this_type
->rlx_more
; next_state
;)
2305 if (aim
>= this_type
->rlx_backward
)
2309 /* Grow to next state. */
2310 this_state
= next_state
;
2311 this_type
= table
+ this_state
;
2312 next_state
= this_type
->rlx_more
;
2317 /* Look forwards. */
2318 for (next_state
= this_type
->rlx_more
; next_state
;)
2319 if (aim
<= this_type
->rlx_forward
)
2323 /* Grow to next state. */
2324 this_state
= next_state
;
2325 this_type
= table
+ this_state
;
2326 next_state
= this_type
->rlx_more
;
2330 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2332 fragP
->fr_subtype
= this_state
;
2336 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2338 /* Relax_align. Advance location counter to next address that has 'alignment'
2339 lowest order bits all 0s, return size of adjustment made. */
2340 static relax_addressT
2341 relax_align (relax_addressT address
, /* Address now. */
2342 int alignment
/* Alignment (binary). */)
2344 relax_addressT mask
;
2345 relax_addressT new_address
;
2347 mask
= ~((relax_addressT
) ~0 << alignment
);
2348 new_address
= (address
+ mask
) & (~mask
);
2349 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2351 /* We must provide lots of padding, so the linker can discard it
2352 when needed. The linker will not add extra space, ever. */
2353 new_address
+= (1 << alignment
);
2355 return (new_address
- address
);
2358 /* Now we have a segment, not a crowd of sub-segments, we can make
2363 After this, all frags in this segment have addresses that are correct
2364 within the segment. Since segments live in different file addresses,
2365 these frag addresses may not be the same as final object-file
2369 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2371 unsigned long frag_count
;
2373 relax_addressT address
;
2377 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2378 subseg_change (segment
, 0);
2380 /* For each frag in segment: count and store (a 1st guess of)
2384 for (frag_count
= 0, fragP
= segment_frag_root
;
2386 fragP
= fragP
->fr_next
, frag_count
++)
2388 fragP
->region
= region
;
2389 fragP
->relax_marker
= 0;
2390 fragP
->fr_address
= address
;
2391 address
+= fragP
->fr_fix
;
2393 switch (fragP
->fr_type
)
2396 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2403 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2405 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2408 if (offset
% fragP
->fr_var
!= 0)
2410 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2411 _("alignment padding (%lu bytes) not a multiple of %ld"),
2412 (unsigned long) offset
, (long) fragP
->fr_var
);
2413 offset
-= (offset
% fragP
->fr_var
);
2422 /* Assume .org is nugatory. It will grow with 1st relax. */
2429 case rs_machine_dependent
:
2430 /* If fr_symbol is an expression, this call to
2431 resolve_symbol_value sets up the correct segment, which will
2432 likely be needed in md_estimate_size_before_relax. */
2433 if (fragP
->fr_symbol
)
2434 resolve_symbol_value (fragP
->fr_symbol
);
2436 address
+= md_estimate_size_before_relax (fragP
, segment
);
2439 #ifndef WORKING_DOT_WORD
2440 /* Broken words don't concern us yet. */
2441 case rs_broken_word
:
2446 /* Initial guess is always 1; doing otherwise can result in
2447 stable solutions that are larger than the minimum. */
2448 address
+= fragP
->fr_offset
= 1;
2452 address
+= eh_frame_estimate_size_before_relax (fragP
);
2456 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2460 BAD_CASE (fragP
->fr_type
);
2467 unsigned long max_iterations
;
2469 /* Cumulative address adjustment. */
2472 /* Have we made any adjustment this pass? We can't just test
2473 stretch because one piece of code may have grown and another
2477 /* Most horrible, but gcc may give us some exception data that
2478 is impossible to assemble, of the form
2482 .uleb128 end - start
2488 If the leb128 is two bytes in size, then end-start is 128*128,
2489 which requires a three byte leb128. If the leb128 is three
2490 bytes in size, then end-start is 128*128-1, which requires a
2491 two byte leb128. We work around this dilemma by inserting
2492 an extra 4 bytes of alignment just after the .align. This
2493 works because the data after the align is accessed relative to
2496 This counter is used in a tiny state machine to detect
2497 whether a leb128 followed by an align is impossible to
2499 int rs_leb128_fudge
= 0;
2501 /* We want to prevent going into an infinite loop where one frag grows
2502 depending upon the location of a symbol which is in turn moved by
2503 the growing frag. eg:
2509 So we dictate that this algorithm can be at most O2. */
2510 max_iterations
= frag_count
* frag_count
;
2511 /* Check for overflow. */
2512 if (max_iterations
< frag_count
)
2513 max_iterations
= frag_count
;
2521 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2524 addressT was_address
;
2528 fragP
->relax_marker
^= 1;
2529 was_address
= fragP
->fr_address
;
2530 address
= fragP
->fr_address
+= stretch
;
2531 symbolP
= fragP
->fr_symbol
;
2532 offset
= fragP
->fr_offset
;
2534 switch (fragP
->fr_type
)
2536 case rs_fill
: /* .fill never relaxes. */
2540 #ifndef WORKING_DOT_WORD
2541 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2542 for it I do not want to write it. I do not want to have
2543 anything to do with it. This is not the proper way to
2544 implement this misfeature. */
2545 case rs_broken_word
:
2547 struct broken_word
*lie
;
2548 struct broken_word
*untruth
;
2550 /* Yes this is ugly (storing the broken_word pointer
2551 in the symbol slot). Still, this whole chunk of
2552 code is ugly, and I don't feel like doing anything
2553 about it. Think of it as stubbornness in action. */
2555 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2556 lie
&& lie
->dispfrag
== fragP
;
2557 lie
= lie
->next_broken_word
)
2563 offset
= (S_GET_VALUE (lie
->add
)
2565 - S_GET_VALUE (lie
->sub
));
2566 if (offset
<= -32768 || offset
>= 32767)
2568 if (flag_warn_displacement
)
2571 sprint_value (buf
, (addressT
) lie
->addnum
);
2572 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2573 _(".word %s-%s+%s didn't fit"),
2574 S_GET_NAME (lie
->add
),
2575 S_GET_NAME (lie
->sub
),
2578 if (fragP
->fr_subtype
== 0)
2580 fragP
->fr_subtype
++;
2581 growth
+= md_short_jump_size
;
2584 /* Redirect *all* words of this table with the same
2585 target, lest we have to handle the case where the
2586 same target but with a offset that fits on this
2587 round overflows at the next relaxation round. */
2588 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2589 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2590 untruth
= untruth
->next_broken_word
)
2591 if ((symbol_get_frag (untruth
->add
)
2592 == symbol_get_frag (lie
->add
))
2593 && (S_GET_VALUE (untruth
->add
)
2594 == S_GET_VALUE (lie
->add
)))
2597 untruth
->use_jump
= lie
;
2601 growth
+= md_long_jump_size
;
2606 } /* case rs_broken_word */
2612 addressT oldoff
, newoff
;
2614 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2616 newoff
= relax_align (address
+ fragP
->fr_fix
,
2619 if (fragP
->fr_subtype
!= 0)
2621 if (oldoff
> fragP
->fr_subtype
)
2623 if (newoff
> fragP
->fr_subtype
)
2627 growth
= newoff
- oldoff
;
2629 /* If this align happens to follow a leb128 and
2630 we have determined that the leb128 is bouncing
2631 in size, then break the cycle by inserting an
2634 && (rs_leb128_fudge
& 16) != 0
2635 && (rs_leb128_fudge
& 15) >= 2)
2637 segment_info_type
*seginfo
= seg_info (segment
);
2638 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2641 newf
= frag_alloc (ob
);
2642 obstack_blank_fast (ob
, fragP
->fr_var
);
2643 obstack_finish (ob
);
2644 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2645 memcpy (newf
->fr_literal
,
2646 fragP
->fr_literal
+ fragP
->fr_fix
,
2648 newf
->fr_type
= rs_fill
;
2649 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2651 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2653 if (newf
->fr_offset
* newf
->fr_var
2654 != (offsetT
) 1 << fragP
->fr_offset
)
2656 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2659 /* Include size of new frag in GROWTH. */
2660 growth
+= newf
->fr_offset
* newf
->fr_var
;
2661 /* Adjust the new frag address for the amount
2662 we'll add when we process the new frag. */
2663 newf
->fr_address
-= stretch
+ growth
;
2664 newf
->relax_marker
^= 1;
2665 fragP
->fr_next
= newf
;
2667 as_warn (_("padding added"));
2675 addressT target
= offset
;
2680 /* Convert from an actual address to an octet offset
2681 into the section. Here it is assumed that the
2682 section's VMA is zero, and can omit subtracting it
2683 from the symbol's value to get the address offset. */
2684 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2685 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2688 know (fragP
->fr_next
);
2689 after
= fragP
->fr_next
->fr_address
+ stretch
;
2690 growth
= target
- after
;
2695 /* Don't error on first few frag relax passes.
2696 The symbol might be an expression involving
2697 symbol values from other sections. If those
2698 sections have not yet been processed their
2699 frags will all have zero addresses, so we
2700 will calculate incorrect values for them. The
2701 number of passes we allow before giving an
2702 error is somewhat arbitrary. It should be at
2703 least one, with larger values requiring
2704 increasingly contrived dependencies between
2705 frags to trigger a false error. */
2708 /* Force another pass. */
2713 /* Growth may be negative, but variable part of frag
2714 cannot have fewer than 0 chars. That is, we can't
2716 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2717 _("attempt to move .org backwards"));
2719 /* We've issued an error message. Change the
2720 frag to avoid cascading errors. */
2721 fragP
->fr_type
= rs_align
;
2722 fragP
->fr_subtype
= 0;
2723 fragP
->fr_offset
= 0;
2724 fragP
->fr_fix
= after
- address
;
2735 amount
= S_GET_VALUE (symbolP
);
2736 if (S_GET_SEGMENT (symbolP
) != absolute_section
2737 || S_IS_COMMON (symbolP
)
2738 || ! S_IS_DEFINED (symbolP
))
2740 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2741 _(".space specifies non-absolute value"));
2742 /* Prevent repeat of this error message. */
2743 fragP
->fr_symbol
= 0;
2745 else if (amount
< 0)
2747 /* Don't error on first few frag relax passes.
2748 See rs_org comment for a longer explanation. */
2755 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2756 _(".space or .fill with negative value, ignored"));
2757 fragP
->fr_symbol
= 0;
2760 growth
= (was_address
+ fragP
->fr_fix
+ amount
2761 - fragP
->fr_next
->fr_address
);
2765 case rs_machine_dependent
:
2766 #ifdef md_relax_frag
2767 growth
= md_relax_frag (segment
, fragP
, stretch
);
2769 #ifdef TC_GENERIC_RELAX_TABLE
2770 /* The default way to relax a frag is to look through
2771 TC_GENERIC_RELAX_TABLE. */
2772 growth
= relax_frag (segment
, fragP
, stretch
);
2773 #endif /* TC_GENERIC_RELAX_TABLE */
2782 value
= resolve_symbol_value (fragP
->fr_symbol
);
2783 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2784 growth
= size
- fragP
->fr_offset
;
2785 fragP
->fr_offset
= size
;
2790 growth
= eh_frame_relax_frag (fragP
);
2794 growth
= dwarf2dbg_relax_frag (fragP
);
2798 BAD_CASE (fragP
->fr_type
);
2805 if (fragP
->fr_type
== rs_leb128
)
2806 rs_leb128_fudge
+= 16;
2807 else if (fragP
->fr_type
== rs_align
2808 && (rs_leb128_fudge
& 16) != 0
2810 rs_leb128_fudge
+= 16;
2812 rs_leb128_fudge
= 0;
2817 && (rs_leb128_fudge
& 16) == 0
2818 && (rs_leb128_fudge
& -16) != 0)
2819 rs_leb128_fudge
+= 1;
2821 rs_leb128_fudge
= 0;
2823 /* Until nothing further to relax. */
2824 while (stretched
&& -- max_iterations
);
2827 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2828 segment_name (segment
));
2831 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2832 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2834 fragP
->last_fr_address
= fragP
->fr_address
;
2841 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2847 buf
[n
] = val
& 0xff;
2853 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2859 *buf
++ = val
& 0xff;
2865 write_print_statistics (FILE *file
)
2867 fprintf (file
, "fixups: %d\n", n_fixups
);
2870 /* For debugging. */
2871 extern int indent_level
;
2874 print_fixup (fixS
*fixp
)
2877 fprintf (stderr
, "fix ");
2878 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2879 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2881 fprintf (stderr
, " pcrel");
2882 if (fixp
->fx_pcrel_adjust
)
2883 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2884 if (fixp
->fx_im_disp
)
2887 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2889 fprintf (stderr
, " im_disp");
2893 fprintf (stderr
, " tcbit");
2895 fprintf (stderr
, " done");
2896 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2897 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2898 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2899 (long) fixp
->fx_where
,
2900 (unsigned long) fixp
->fx_offset
,
2901 (unsigned long) fixp
->fx_addnumber
);
2902 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2906 fprintf (stderr
, "\n +<");
2907 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2908 fprintf (stderr
, ">");
2912 fprintf (stderr
, "\n -<");
2913 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2914 fprintf (stderr
, ">");
2916 fprintf (stderr
, "\n");
2917 #ifdef TC_FIX_DATA_PRINT
2918 TC_FIX_DATA_PRINT (stderr
, fixp
);