1 /* write.c - emit .o file
2 Copyright (C) 1986-2021 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 byte ordering correctly. But... */
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
28 #include "compress-debug.h"
30 #ifndef TC_FORCE_RELOCATION
31 #define TC_FORCE_RELOCATION(FIX) \
32 (generic_force_reloc (FIX))
35 #ifndef TC_FORCE_RELOCATION_ABS
36 #define TC_FORCE_RELOCATION_ABS(FIX) \
37 (TC_FORCE_RELOCATION (FIX))
40 #define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \
42 || TC_FORCE_RELOCATION (FIX))
43 #ifndef TC_FORCE_RELOCATION_LOCAL
44 #define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL
47 #define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
49 #ifndef TC_FORCE_RELOCATION_SUB_SAME
50 #define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME
53 #ifndef md_register_arithmetic
54 # define md_register_arithmetic 1
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
59 (!md_register_arithmetic && (SEG) == reg_section)
62 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
64 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
65 (!md_register_arithmetic && (SEG) == reg_section)
67 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
71 #ifndef TC_VALIDATE_FIX_SUB
72 #ifdef UNDEFINED_DIFFERENCE_OK
73 /* The PA needs this for PIC code generation. */
74 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
75 (md_register_arithmetic || (SEG) != reg_section)
77 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
78 ((md_register_arithmetic || (SEG) != reg_section) \
79 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
80 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
84 #ifndef TC_LINKRELAX_FIXUP
85 #define TC_LINKRELAX_FIXUP(SEG) 1
88 #ifndef MD_APPLY_SYM_VALUE
89 #define MD_APPLY_SYM_VALUE(FIX) 1
92 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
93 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
96 #ifndef MD_PCREL_FROM_SECTION
97 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #ifndef TC_FAKE_LABEL
101 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
104 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
105 fixups that far past the end of a frag. Having such fixups
106 is of course most most likely a bug in setting fx_size correctly.
107 A negative value disables the fixup check entirely, which is
108 appropriate for something like the Renesas / SuperH SH_COUNT
110 #ifndef TC_FX_SIZE_SLACK
111 #define TC_FX_SIZE_SLACK(FIX) 0
114 /* Used to control final evaluation of expressions. */
115 int finalize_syms
= 0;
117 int symbol_table_frozen
;
119 symbolS
*abs_section_sym
;
121 /* Remember the value of dot when parsing expressions. */
124 /* The frag that dot_value is based from. */
127 /* Relocs generated by ".reloc" pseudo. */
128 struct reloc_list
* reloc_list
;
130 void print_fixup (fixS
*);
132 /* We generally attach relocs to frag chains. However, after we have
133 chained these all together into a segment, any relocs we add after
134 that must be attached to a segment. This will include relocs added
135 in md_estimate_size_for_relax, for example. */
136 static int frags_chained
= 0;
140 #define RELOC_ENUM enum bfd_reloc_code_real
142 /* Create a fixS in obstack 'notes'. */
145 fix_new_internal (fragS
*frag
, /* Which frag? */
146 unsigned long where
, /* Where in that frag? */
147 unsigned long size
, /* 1, 2, or 4 usually. */
148 symbolS
*add_symbol
, /* X_add_symbol. */
149 symbolS
*sub_symbol
, /* X_op_symbol. */
150 offsetT offset
, /* X_add_number. */
151 int pcrel
, /* TRUE if PC-relative relocation. */
152 RELOC_ENUM r_type
/* Relocation type. */,
153 int at_beginning
) /* Add to the start of the list? */
159 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
161 fixP
->fx_frag
= frag
;
162 fixP
->fx_where
= where
;
163 fixP
->fx_size
= size
;
164 /* We've made fx_size a narrow field; check that it's wide enough. */
165 if (fixP
->fx_size
!= size
)
167 as_bad (_("field fx_size too small to hold %lu"), size
);
170 fixP
->fx_addsy
= add_symbol
;
171 fixP
->fx_subsy
= sub_symbol
;
172 fixP
->fx_offset
= offset
;
173 fixP
->fx_dot_value
= dot_value
;
174 fixP
->fx_dot_frag
= dot_frag
;
175 fixP
->fx_pcrel
= pcrel
;
176 fixP
->fx_r_type
= r_type
;
177 fixP
->fx_pcrel_adjust
= 0;
178 fixP
->fx_addnumber
= 0;
182 fixP
->fx_no_overflow
= 0;
186 fixP
->fx_cgen
.insn
= NULL
;
187 fixP
->fx_cgen
.opinfo
= 0;
191 TC_INIT_FIX_DATA (fixP
);
194 fixP
->fx_file
= as_where (&fixP
->fx_line
);
198 fixS
**seg_fix_rootP
= (frags_chained
199 ? &seg_info (now_seg
)->fix_root
200 : &frchain_now
->fix_root
);
201 fixS
**seg_fix_tailP
= (frags_chained
202 ? &seg_info (now_seg
)->fix_tail
203 : &frchain_now
->fix_tail
);
207 fixP
->fx_next
= *seg_fix_rootP
;
208 *seg_fix_rootP
= fixP
;
209 if (fixP
->fx_next
== NULL
)
210 *seg_fix_tailP
= fixP
;
214 fixP
->fx_next
= NULL
;
216 (*seg_fix_tailP
)->fx_next
= fixP
;
218 *seg_fix_rootP
= fixP
;
219 *seg_fix_tailP
= fixP
;
226 /* Create a fixup relative to a symbol (plus a constant). */
229 fix_new (fragS
*frag
, /* Which frag? */
230 unsigned long where
, /* Where in that frag? */
231 unsigned long size
, /* 1, 2, or 4 usually. */
232 symbolS
*add_symbol
, /* X_add_symbol. */
233 offsetT offset
, /* X_add_number. */
234 int pcrel
, /* TRUE if PC-relative relocation. */
235 RELOC_ENUM r_type
/* Relocation type. */)
237 return fix_new_internal (frag
, where
, size
, add_symbol
,
238 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
241 /* Create a fixup for an expression. Currently we only support fixups
242 for difference expressions. That is itself more than most object
243 file formats support anyhow. */
246 fix_new_exp (fragS
*frag
, /* Which frag? */
247 unsigned long where
, /* Where in that frag? */
248 unsigned long size
, /* 1, 2, or 4 usually. */
249 expressionS
*exp
, /* Expression. */
250 int pcrel
, /* TRUE if PC-relative relocation. */
251 RELOC_ENUM r_type
/* Relocation type. */)
263 as_bad (_("register value used as expression"));
267 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
268 the difference expression cannot immediately be reduced. */
270 symbolS
*stmp
= make_expr_symbol (exp
);
272 exp
->X_op
= O_symbol
;
273 exp
->X_op_symbol
= 0;
274 exp
->X_add_symbol
= stmp
;
275 exp
->X_add_number
= 0;
277 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
281 add
= exp
->X_add_symbol
;
282 off
= exp
->X_add_number
;
283 r_type
= BFD_RELOC_RVA
;
287 sub
= exp
->X_add_symbol
;
288 off
= exp
->X_add_number
;
292 sub
= exp
->X_op_symbol
;
295 add
= exp
->X_add_symbol
;
298 off
= exp
->X_add_number
;
302 add
= make_expr_symbol (exp
);
306 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
310 /* Create a fixup at the beginning of FRAG. The arguments are the same
311 as for fix_new, except that WHERE is implicitly 0. */
314 fix_at_start (fragS
*frag
, unsigned long size
, symbolS
*add_symbol
,
315 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
317 return fix_new_internal (frag
, 0, size
, add_symbol
,
318 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
321 /* Generic function to determine whether a fixup requires a relocation. */
323 generic_force_reloc (fixS
*fix
)
325 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
326 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
329 if (fix
->fx_addsy
== NULL
)
332 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
335 /* Append a string onto another string, bumping the pointer along. */
337 append (char **charPP
, char *fromP
, unsigned long length
)
339 /* Don't trust memcpy() of 0 chars. */
343 memcpy (*charPP
, fromP
, length
);
347 /* This routine records the largest alignment seen for each segment.
348 If the beginning of the segment is aligned on the worst-case
349 boundary, all of the other alignments within it will work. At
350 least one object format really uses this info. */
353 record_alignment (/* Segment to which alignment pertains. */
355 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
356 boundary, 2 => 4-byte boundary, etc.) */
359 if (seg
== absolute_section
)
362 if (align
> bfd_section_alignment (seg
))
363 bfd_set_section_alignment (seg
, align
);
367 get_recorded_alignment (segT seg
)
369 if (seg
== absolute_section
)
372 return bfd_section_alignment (seg
);
375 /* Reset the section indices after removing the gas created sections. */
378 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
380 int *countp
= (int *) countparg
;
382 sec
->index
= *countp
;
387 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
389 fragS dummy
, *prev_frag
= &dummy
;
390 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
392 for (; frchp
; frchp
= frchp
->frch_next
)
394 prev_frag
->fr_next
= frchp
->frch_root
;
395 prev_frag
= frchp
->frch_last
;
396 gas_assert (prev_frag
->fr_type
!= 0);
397 if (frchp
->fix_root
!= (fixS
*) NULL
)
399 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
400 seg_info (section
)->fix_root
= frchp
->fix_root
;
401 prev_fix
->fx_next
= frchp
->fix_root
;
402 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
403 prev_fix
= frchp
->fix_tail
;
406 gas_assert (prev_frag
!= &dummy
407 && prev_frag
->fr_type
!= 0);
408 prev_frag
->fr_next
= 0;
413 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
415 void *xxx ATTRIBUTE_UNUSED
)
417 segment_info_type
*info
;
419 /* BFD may have introduced its own sections without using
420 subseg_new, so it is possible that seg_info is NULL. */
421 info
= seg_info (section
);
422 if (info
!= (segment_info_type
*) NULL
)
423 info
->frchainP
->frch_last
424 = chain_frchains_together_1 (section
, info
->frchainP
);
426 /* Now that we've chained the frags together, we must add new fixups
427 to the segment, not to the frag chain. */
432 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
434 switch (fragP
->fr_type
)
444 HANDLE_ALIGN (fragP
);
447 know (fragP
->fr_next
!= NULL
);
448 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
450 - fragP
->fr_fix
) / fragP
->fr_var
;
451 if (fragP
->fr_offset
< 0)
453 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
454 _("attempt to .org/.space/.nops backwards? (%ld)"),
455 (long) fragP
->fr_offset
);
456 fragP
->fr_offset
= 0;
458 if (fragP
->fr_type
== rs_space_nop
)
459 fragP
->fr_type
= rs_fill_nop
;
461 fragP
->fr_type
= rs_fill
;
470 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
473 if (!S_IS_DEFINED (fragP
->fr_symbol
))
475 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
476 _("leb128 operand is an undefined symbol: %s"),
477 S_GET_NAME (fragP
->fr_symbol
));
480 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
483 fragP
->fr_fix
+= size
;
484 fragP
->fr_type
= rs_fill
;
486 fragP
->fr_offset
= 0;
487 fragP
->fr_symbol
= NULL
;
492 eh_frame_convert_frag (fragP
);
496 dwarf2dbg_convert_frag (fragP
);
499 case rs_machine_dependent
:
500 md_convert_frag (stdoutput
, sec
, fragP
);
502 gas_assert (fragP
->fr_next
== NULL
503 || (fragP
->fr_next
->fr_address
- fragP
->fr_address
506 /* After md_convert_frag, we make the frag into a ".space 0".
507 md_convert_frag() should set up any fixSs and constants
512 #ifndef WORKING_DOT_WORD
515 struct broken_word
*lie
;
517 if (fragP
->fr_subtype
)
519 fragP
->fr_fix
+= md_short_jump_size
;
520 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
521 lie
&& lie
->dispfrag
== fragP
;
522 lie
= lie
->next_broken_word
)
524 fragP
->fr_fix
+= md_long_jump_size
;
532 BAD_CASE (fragP
->fr_type
);
536 md_frag_check (fragP
);
540 struct relax_seg_info
547 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
549 segment_info_type
*seginfo
= seg_info (sec
);
550 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
552 if (seginfo
&& seginfo
->frchainP
553 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
558 size_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
562 segment_info_type
*seginfo
;
564 valueT size
, newsize
;
566 subseg_change (sec
, 0);
568 seginfo
= seg_info (sec
);
569 if (seginfo
&& seginfo
->frchainP
)
571 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
572 cvt_frag_to_fill (sec
, fragp
);
573 for (fragp
= seginfo
->frchainP
->frch_root
;
575 fragp
= fragp
->fr_next
)
576 /* Walk to last elt. */
578 size
= fragp
->fr_address
+ fragp
->fr_fix
;
583 flags
= bfd_section_flags (sec
);
584 if (size
== 0 && bfd_section_size (sec
) != 0 &&
585 (flags
& SEC_HAS_CONTENTS
) != 0)
588 if (size
> 0 && ! seginfo
->bss
)
589 flags
|= SEC_HAS_CONTENTS
;
592 x
= bfd_set_section_flags (sec
, flags
);
595 /* If permitted, allow the backend to pad out the section
596 to some alignment boundary. */
597 if (do_not_pad_sections_to_alignment
)
600 newsize
= md_section_align (sec
, size
);
601 x
= bfd_set_section_size (sec
, newsize
);
604 /* If the size had to be rounded up, add some padding in the last
606 gas_assert (newsize
>= size
);
609 fragS
*last
= seginfo
->frchainP
->frch_last
;
610 fragp
= seginfo
->frchainP
->frch_root
;
611 while (fragp
->fr_next
!= last
)
612 fragp
= fragp
->fr_next
;
613 last
->fr_address
= size
;
614 if ((newsize
- size
) % fragp
->fr_var
== 0)
615 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
617 /* If we hit this abort, it's likely due to subsegs_finish not
618 providing sufficient alignment on the last frag, and the
619 machine dependent code using alignment frags with fr_var
624 #ifdef tc_frob_section
625 tc_frob_section (sec
);
627 #ifdef obj_frob_section
628 obj_frob_section (sec
);
634 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
636 segment_info_type
*seginfo
= seg_info (sec
);
637 fixS
*fixp
= seginfo
->fix_root
;
642 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
645 symbolS
*s
= fixp
->fx_addsy
;
647 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
648 (int) fixp
->fx_r_type
);
650 fprintf (stream
, "no sym\n");
653 print_symbol_value_1 (stream
, s
);
654 fprintf (stream
, "\n");
656 fixp
= fixp
->fx_next
;
660 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
663 #ifndef EMIT_SECTION_SYMBOLS
664 #define EMIT_SECTION_SYMBOLS 1
667 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
668 and check for validity. Convert RELOC_LIST from using U.A fields
671 resolve_reloc_expr_symbols (void)
673 bfd_vma addr_mask
= 1;
674 struct reloc_list
*r
;
676 /* Avoid a shift by the width of type. */
677 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
681 for (r
= reloc_list
; r
; r
= r
->next
)
683 reloc_howto_type
*howto
= r
->u
.a
.howto
;
686 bfd_vma offset
, addend
;
689 resolve_symbol_value (r
->u
.a
.offset_sym
);
690 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
694 if (symval
->X_op
== O_constant
)
695 sym
= r
->u
.a
.offset_sym
;
696 else if (symval
->X_op
== O_symbol
)
698 sym
= symval
->X_add_symbol
;
699 offset
= symval
->X_add_number
;
700 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
703 || symval
->X_op
!= O_constant
704 || (sec
= S_GET_SEGMENT (sym
)) == NULL
705 || !SEG_NORMAL (sec
))
707 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
711 offset
+= S_GET_VALUE (sym
);
714 addend
= r
->u
.a
.addend
;
715 if (r
->u
.a
.sym
!= NULL
)
717 resolve_symbol_value (r
->u
.a
.sym
);
718 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
719 if (symval
->X_op
== O_constant
)
721 else if (symval
->X_op
== O_symbol
)
723 sym
= symval
->X_add_symbol
;
724 addend
+= symval
->X_add_number
;
725 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
727 if (symval
->X_op
!= O_constant
)
729 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
732 else if (sym
!= NULL
&& sec
!= NULL
)
734 /* Convert relocs against local symbols to refer to the
735 corresponding section symbol plus offset instead. Keep
736 PC-relative relocs of the REL variety intact though to
737 prevent the offset from overflowing the relocated field,
738 unless it has enough bits to cover the whole address
740 if (S_IS_LOCAL (sym
) && !symbol_section_p (sym
)
742 || (howto
->partial_inplace
743 && (!howto
->pc_relative
744 || howto
->src_mask
== addr_mask
))))
746 asection
*symsec
= S_GET_SEGMENT (sym
);
747 if (!(((symsec
->flags
& SEC_MERGE
) != 0
749 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
751 addend
+= S_GET_VALUE (sym
);
752 sym
= section_symbol (symsec
);
755 symbol_mark_used_in_reloc (sym
);
760 if (abs_section_sym
== NULL
)
761 abs_section_sym
= section_symbol (absolute_section
);
762 sym
= abs_section_sym
;
766 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
767 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
768 r
->u
.b
.r
.address
= offset
;
769 r
->u
.b
.r
.addend
= addend
;
770 r
->u
.b
.r
.howto
= howto
;
774 /* This pass over fixups decides whether symbols can be replaced with
778 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
780 void *xxx ATTRIBUTE_UNUSED
)
782 segment_info_type
*seginfo
= seg_info (sec
);
788 dump_section_relocs (abfd
, sec
, stderr
);
790 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
794 else if (fixp
->fx_addsy
)
800 fprintf (stderr
, "\n\nadjusting fixup:\n");
804 sym
= fixp
->fx_addsy
;
806 /* All symbols should have already been resolved at this
807 point. It is possible to see unresolved expression
808 symbols, though, since they are not in the regular symbol
810 resolve_symbol_value (sym
);
812 if (fixp
->fx_subsy
!= NULL
)
813 resolve_symbol_value (fixp
->fx_subsy
);
815 /* If this symbol is equated to an undefined or common symbol,
816 convert the fixup to being against that symbol. */
817 while (symbol_equated_reloc_p (sym
)
818 || S_IS_WEAKREFR (sym
))
820 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
823 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
824 fixp
->fx_addsy
= newsym
;
828 if (symbol_mri_common_p (sym
))
830 fixp
->fx_offset
+= S_GET_VALUE (sym
);
831 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
835 /* If the symbol is undefined, common, weak, or global (ELF
836 shared libs), we can't replace it with the section symbol. */
837 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
840 /* Is there some other (target cpu dependent) reason we can't adjust
841 this one? (E.g. relocations involving function addresses on
843 #ifdef tc_fix_adjustable
844 if (! tc_fix_adjustable (fixp
))
848 /* Since we're reducing to section symbols, don't attempt to reduce
849 anything that's already using one. */
850 if (symbol_section_p (sym
))
852 /* Mark the section symbol used in relocation so that it will
853 be included in the symbol table. */
854 symbol_mark_used_in_reloc (sym
);
858 symsec
= S_GET_SEGMENT (sym
);
862 if (bfd_is_abs_section (symsec
)
863 || symsec
== reg_section
)
865 /* The fixup_segment routine normally will not use this
866 symbol in a relocation. */
870 /* Don't try to reduce relocs which refer to non-local symbols
871 in .linkonce sections. It can lead to confusion when a
872 debugging section refers to a .linkonce section. I hope
873 this will always be correct. */
874 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
876 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
878 /* The GNU toolchain uses an extension for ELF: a
879 section beginning with the magic string
880 .gnu.linkonce is a linkonce section. */
881 && strncmp (segment_name (symsec
), ".gnu.linkonce",
882 sizeof ".gnu.linkonce" - 1) == 0))
886 /* Never adjust a reloc against local symbol in a merge section
887 with non-zero addend. */
888 if ((symsec
->flags
& SEC_MERGE
) != 0
889 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
892 /* Never adjust a reloc against TLS local symbol. */
893 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
896 /* We refetch the segment when calling section_symbol, rather
897 than using symsec, because S_GET_VALUE may wind up changing
898 the section when it calls resolve_symbol_value. */
899 fixp
->fx_offset
+= S_GET_VALUE (sym
);
900 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
902 fprintf (stderr
, "\nadjusted fixup:\n");
907 dump_section_relocs (abfd
, sec
, stderr
);
912 Go through all the fixS's in a segment and see which ones can be
913 handled now. (These consist of fixS where we have since discovered
914 the value of a symbol, or the address of the frag involved.)
915 For each one, call md_apply_fix to put the fix into the frag data.
916 Ones that we couldn't completely handle here will be output later
917 by emit_relocations. */
920 fixup_segment (fixS
*fixP
, segT this_segment
)
924 segT add_symbol_segment
= absolute_section
;
926 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
927 abs_section_sym
= section_symbol (absolute_section
);
929 /* If the linker is doing the relaxing, we must not do any fixups.
931 Well, strictly speaking that's not true -- we could do any that
932 are PC-relative and don't cross regions that could change size. */
933 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
935 for (; fixP
; fixP
= fixP
->fx_next
)
938 if (fixP
->fx_addsy
== NULL
)
940 /* There was no symbol required by this relocation.
941 However, BFD doesn't really handle relocations
942 without symbols well. So fake up a local symbol in
943 the absolute section. */
944 fixP
->fx_addsy
= abs_section_sym
;
946 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
947 if (fixP
->fx_subsy
!= NULL
)
948 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
953 for (; fixP
; fixP
= fixP
->fx_next
)
956 fprintf (stderr
, "\nprocessing fixup:\n");
960 fragP
= fixP
->fx_frag
;
962 #ifdef TC_VALIDATE_FIX
963 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
965 add_number
= fixP
->fx_offset
;
967 if (fixP
->fx_addsy
!= NULL
)
968 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
970 if (fixP
->fx_subsy
!= NULL
)
972 segT sub_symbol_segment
;
973 resolve_symbol_value (fixP
->fx_subsy
);
974 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
975 if (fixP
->fx_addsy
!= NULL
976 && sub_symbol_segment
== add_symbol_segment
977 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
978 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
979 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
981 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
982 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
983 fixP
->fx_offset
= add_number
;
984 fixP
->fx_addsy
= NULL
;
985 fixP
->fx_subsy
= NULL
;
987 /* See the comment below about 68k weirdness. */
991 else if (sub_symbol_segment
== absolute_section
992 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
993 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
995 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
996 fixP
->fx_offset
= add_number
;
997 fixP
->fx_subsy
= NULL
;
999 else if (sub_symbol_segment
== this_segment
1000 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
1001 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
1003 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1004 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
1005 + fixP
->fx_dot_frag
->fr_address
);
1007 /* Make it pc-relative. If the back-end code has not
1008 selected a pc-relative reloc, cancel the adjustment
1009 we do later on all pc-relative relocs. */
1012 /* Do this for m68k even if it's already described
1013 as pc-relative. On the m68k, an operand of
1014 "pc@(foo-.-2)" should address "foo" in a
1015 pc-relative mode. */
1019 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1020 fixP
->fx_subsy
= NULL
;
1023 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1025 if (!md_register_arithmetic
1026 && (add_symbol_segment
== reg_section
1027 || sub_symbol_segment
== reg_section
))
1028 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1029 _("register value used as expression"));
1031 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1032 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1033 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1034 segment_name (add_symbol_segment
),
1035 S_GET_NAME (fixP
->fx_subsy
),
1036 segment_name (sub_symbol_segment
));
1038 else if (sub_symbol_segment
!= undefined_section
1039 && ! bfd_is_com_section (sub_symbol_segment
)
1040 && MD_APPLY_SYM_VALUE (fixP
))
1041 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1046 if (add_symbol_segment
== this_segment
1047 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1048 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1050 /* This fixup was made when the symbol's segment was
1051 SEG_UNKNOWN, but it is now in the local segment.
1052 So we know how to do the address without relocation. */
1053 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1054 fixP
->fx_offset
= add_number
;
1056 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1057 fixP
->fx_addsy
= NULL
;
1060 else if (add_symbol_segment
== absolute_section
1061 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1062 && !TC_FORCE_RELOCATION_ABS (fixP
))
1064 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1065 fixP
->fx_offset
= add_number
;
1066 fixP
->fx_addsy
= NULL
;
1068 else if (add_symbol_segment
!= undefined_section
1069 && ! bfd_is_com_section (add_symbol_segment
)
1070 && MD_APPLY_SYM_VALUE (fixP
))
1071 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1076 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1077 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1079 /* There was no symbol required by this relocation.
1080 However, BFD doesn't really handle relocations
1081 without symbols well. So fake up a local symbol in
1082 the absolute section. */
1083 fixP
->fx_addsy
= abs_section_sym
;
1088 md_apply_fix (fixP
, &add_number
, this_segment
);
1092 if (fixP
->fx_addsy
== NULL
)
1093 fixP
->fx_addsy
= abs_section_sym
;
1094 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1095 if (fixP
->fx_subsy
!= NULL
)
1096 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1099 if (!fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1101 if (fixP
->fx_size
< sizeof (valueT
))
1106 mask
--; /* Set all bits to one. */
1107 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1108 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1110 char buf
[50], buf2
[50];
1111 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1112 if (add_number
> 1000)
1113 sprint_value (buf2
, add_number
);
1115 sprintf (buf2
, "%ld", (long) add_number
);
1116 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1117 ngettext ("value of %s too large for field "
1119 "value of %s too large for field "
1120 "of %d bytes at %s",
1122 buf2
, fixP
->fx_size
, buf
);
1123 } /* Generic error checking. */
1125 #ifdef WARN_SIGNED_OVERFLOW_WORD
1126 /* Warn if a .word value is too large when treated as a signed
1127 number. We already know it is not too negative. This is to
1128 catch over-large switches generated by gcc on the 68k. */
1129 if (!flag_signed_overflow_ok
1130 && fixP
->fx_size
== 2
1131 && add_number
> 0x7fff)
1132 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1133 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1135 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1139 #ifdef TC_VALIDATE_FIX
1140 skip
: ATTRIBUTE_UNUSED_LABEL
1144 fprintf (stderr
, "result:\n");
1147 } /* For each fixS in this segment. */
1151 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1153 void *xxx ATTRIBUTE_UNUSED
)
1155 segment_info_type
*seginfo
= seg_info (sec
);
1157 fixup_segment (seginfo
->fix_root
, sec
);
1161 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1162 const char *file
, unsigned int line
)
1165 bfd_reloc_status_type s
;
1168 if (reloc
->sym_ptr_ptr
!= NULL
1169 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1170 && (sym
->flags
& BSF_KEEP
) == 0
1171 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1172 || (EMIT_SECTION_SYMBOLS
1173 && !bfd_is_abs_section (sym
->section
))))
1174 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1176 s
= bfd_install_relocation (stdoutput
, reloc
,
1177 fragp
->fr_literal
, fragp
->fr_address
,
1183 case bfd_reloc_overflow
:
1184 as_bad_where (file
, line
, _("relocation overflow"));
1186 case bfd_reloc_outofrange
:
1187 as_bad_where (file
, line
, _("relocation out of range"));
1190 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1196 get_frag_for_reloc (fragS
*last_frag
,
1197 const segment_info_type
*seginfo
,
1198 const struct reloc_list
*r
)
1202 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1203 if (f
->fr_address
<= r
->u
.b
.r
.address
1204 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1207 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1208 if (f
->fr_address
<= r
->u
.b
.r
.address
1209 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1212 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1213 if (f
->fr_address
<= r
->u
.b
.r
.address
1214 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1217 as_bad_where (r
->file
, r
->line
,
1218 _("reloc not within (fixed part of) section"));
1223 write_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1224 void *xxx ATTRIBUTE_UNUSED
)
1226 segment_info_type
*seginfo
= seg_info (sec
);
1228 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1233 /* If seginfo is NULL, we did not create this section; don't do
1234 anything with it. */
1235 if (seginfo
== NULL
)
1239 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1243 #ifdef RELOC_EXPANSION_POSSIBLE
1244 n
*= MAX_RELOC_EXPANSION
;
1247 /* Extract relocs for this section from reloc_list. */
1250 my_reloc_list
= NULL
;
1251 while ((r
= *rp
) != NULL
)
1253 if (r
->u
.b
.sec
== sec
)
1256 r
->next
= my_reloc_list
;
1264 relocs
= XCNEWVEC (arelent
*, n
);
1269 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1274 #ifndef RELOC_EXPANSION_POSSIBLE
1283 fx_size
= fixp
->fx_size
;
1284 slack
= TC_FX_SIZE_SLACK (fixp
);
1286 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1287 loc
= fixp
->fx_where
+ fx_size
;
1288 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1289 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1290 _("internal error: fixup not contained within frag"));
1292 #ifndef RELOC_EXPANSION_POSSIBLE
1293 *reloc
= tc_gen_reloc (sec
, fixp
);
1295 reloc
= tc_gen_reloc (sec
, fixp
);
1300 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1302 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1306 relocs
[n
++] = &r
->u
.b
.r
;
1307 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1311 relocs
[n
++] = *reloc
;
1312 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1313 fixp
->fx_file
, fixp
->fx_line
);
1314 #ifndef RELOC_EXPANSION_POSSIBLE
1324 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1328 relocs
[n
++] = &r
->u
.b
.r
;
1329 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1336 unsigned int k
, j
, nsyms
;
1338 sympp
= bfd_get_outsymbols (stdoutput
);
1339 nsyms
= bfd_get_symcount (stdoutput
);
1340 for (k
= 0; k
< n
; k
++)
1341 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1343 for (j
= 0; j
< nsyms
; j
++)
1344 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1354 flagword flags
= bfd_section_flags (sec
);
1356 bfd_set_section_flags (sec
, flags
);
1357 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1360 #ifdef SET_SECTION_RELOCS
1361 SET_SECTION_RELOCS (sec
, relocs
, n
);
1368 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1369 for (k
= 0; k
< n
; k
++)
1371 arelent
*rel
= relocs
[k
];
1372 asymbol
*s
= *rel
->sym_ptr_ptr
;
1373 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1374 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1375 (unsigned long)rel
->addend
);
1382 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1383 fragS
**last_newf
, struct obstack
*ob
)
1386 int total_out_size
= 0;
1387 fragS
*f
= *last_newf
;
1391 /* Call the compression routine repeatedly until it has finished
1392 processing the frag. */
1395 /* Reserve all the space available in the current chunk.
1396 If none is available, start a new frag. */
1397 avail_out
= obstack_room (ob
);
1400 obstack_finish (ob
);
1401 f
= frag_alloc (ob
);
1402 f
->fr_type
= rs_fill
;
1403 (*last_newf
)->fr_next
= f
;
1405 avail_out
= obstack_room (ob
);
1408 as_fatal (_("can't extend frag"));
1409 next_out
= obstack_next_free (ob
);
1410 obstack_blank_fast (ob
, avail_out
);
1411 out_size
= compress_data (strm
, &contents
, &in_size
,
1412 &next_out
, &avail_out
);
1416 f
->fr_fix
+= out_size
;
1417 total_out_size
+= out_size
;
1419 /* Return unused space. */
1421 obstack_blank_fast (ob
, -avail_out
);
1424 return total_out_size
;
1428 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1430 segment_info_type
*seginfo
= seg_info (sec
);
1434 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1435 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1436 bfd_size_type compressed_size
;
1437 const char *section_name
;
1438 char *compressed_name
;
1440 struct z_stream_s
*strm
;
1442 flagword flags
= bfd_section_flags (sec
);
1443 unsigned int header_size
, compression_header_size
;
1447 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1450 section_name
= bfd_section_name (sec
);
1451 if (strncmp (section_name
, ".debug_", 7) != 0)
1454 strm
= compress_init ();
1458 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1460 compression_header_size
1461 = bfd_get_compression_header_size (stdoutput
, NULL
);
1462 header_size
= compression_header_size
;
1466 compression_header_size
= 0;
1470 /* Create a new frag to contain the compression header. */
1471 first_newf
= frag_alloc (ob
);
1472 if (obstack_room (ob
) < header_size
)
1473 first_newf
= frag_alloc (ob
);
1474 if (obstack_room (ob
) < header_size
)
1475 as_fatal (ngettext ("can't extend frag %lu char",
1476 "can't extend frag %lu chars",
1477 (unsigned long) header_size
),
1478 (unsigned long) header_size
);
1479 last_newf
= first_newf
;
1480 obstack_blank_fast (ob
, header_size
);
1481 last_newf
->fr_type
= rs_fill
;
1482 last_newf
->fr_fix
= header_size
;
1483 header
= last_newf
->fr_literal
;
1484 compressed_size
= header_size
;
1486 /* Stream the frags through the compression engine, adding new frags
1487 as necessary to accommodate the compressed output. */
1488 for (f
= seginfo
->frchainP
->frch_root
;
1497 gas_assert (f
->fr_type
== rs_fill
);
1500 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1504 compressed_size
+= out_size
;
1506 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1507 fill_size
= f
->fr_var
;
1508 count
= f
->fr_offset
;
1509 gas_assert (count
>= 0);
1510 if (fill_size
&& count
)
1514 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1518 compressed_size
+= out_size
;
1523 /* Flush the compression state. */
1530 /* Reserve all the space available in the current chunk.
1531 If none is available, start a new frag. */
1532 avail_out
= obstack_room (ob
);
1537 obstack_finish (ob
);
1538 newf
= frag_alloc (ob
);
1539 newf
->fr_type
= rs_fill
;
1540 last_newf
->fr_next
= newf
;
1542 avail_out
= obstack_room (ob
);
1545 as_fatal (_("can't extend frag"));
1546 next_out
= obstack_next_free (ob
);
1547 obstack_blank_fast (ob
, avail_out
);
1548 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1552 last_newf
->fr_fix
+= out_size
;
1553 compressed_size
+= out_size
;
1555 /* Return unused space. */
1557 obstack_blank_fast (ob
, -avail_out
);
1563 /* PR binutils/18087: If compression didn't make the section smaller,
1564 just keep it uncompressed. */
1565 if (compressed_size
>= uncompressed_size
)
1568 /* Replace the uncompressed frag list with the compressed frag list. */
1569 seginfo
->frchainP
->frch_root
= first_newf
;
1570 seginfo
->frchainP
->frch_last
= last_newf
;
1572 /* Update the section size and its name. */
1573 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1574 x
= bfd_set_section_size (sec
, compressed_size
);
1576 if (!compression_header_size
)
1578 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1579 bfd_rename_section (sec
, compressed_name
);
1583 #ifndef md_generate_nops
1584 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1585 backend must override this with proper no-op instructions. */
1588 md_generate_nops (fragS
*f ATTRIBUTE_UNUSED
,
1589 char *where ATTRIBUTE_UNUSED
,
1590 offsetT count ATTRIBUTE_UNUSED
,
1591 int control ATTRIBUTE_UNUSED
)
1593 as_bad (_("unimplemented .nops directive"));
1598 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1600 void *xxx ATTRIBUTE_UNUSED
)
1602 segment_info_type
*seginfo
= seg_info (sec
);
1603 addressT offset
= 0;
1606 /* Write out the frags. */
1608 || !(bfd_section_flags (sec
) & SEC_HAS_CONTENTS
))
1611 for (f
= seginfo
->frchainP
->frch_root
;
1620 gas_assert (f
->fr_type
== rs_fill
|| f
->fr_type
== rs_fill_nop
);
1623 x
= bfd_set_section_contents (stdoutput
, sec
,
1624 f
->fr_literal
, (file_ptr
) offset
,
1625 (bfd_size_type
) f
->fr_fix
);
1627 as_fatal (ngettext ("can't write %ld byte "
1628 "to section %s of %s: '%s'",
1629 "can't write %ld bytes "
1630 "to section %s of %s: '%s'",
1633 bfd_section_name (sec
), bfd_get_filename (stdoutput
),
1634 bfd_errmsg (bfd_get_error ()));
1635 offset
+= f
->fr_fix
;
1638 fill_size
= f
->fr_var
;
1639 count
= f
->fr_offset
;
1640 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1642 if (f
->fr_type
== rs_fill_nop
)
1644 gas_assert (count
>= 0 && fill_size
== 1);
1647 char *buf
= xmalloc (count
);
1648 md_generate_nops (f
, buf
, count
, *fill_literal
);
1649 x
= bfd_set_section_contents
1650 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1651 (bfd_size_type
) count
);
1653 as_fatal (ngettext ("can't fill %ld byte "
1654 "in section %s of %s: '%s'",
1655 "can't fill %ld bytes "
1656 "in section %s of %s: '%s'",
1659 bfd_section_name (sec
),
1660 bfd_get_filename (stdoutput
),
1661 bfd_errmsg (bfd_get_error ()));
1668 gas_assert (count
>= 0);
1669 if (fill_size
&& count
)
1672 if (fill_size
> sizeof (buf
))
1674 /* Do it the old way. Can this ever happen? */
1677 x
= bfd_set_section_contents (stdoutput
, sec
,
1680 (bfd_size_type
) fill_size
);
1682 as_fatal (ngettext ("can't fill %ld byte "
1683 "in section %s of %s: '%s'",
1684 "can't fill %ld bytes "
1685 "in section %s of %s: '%s'",
1688 bfd_section_name (sec
),
1689 bfd_get_filename (stdoutput
),
1690 bfd_errmsg (bfd_get_error ()));
1691 offset
+= fill_size
;
1696 /* Build a buffer full of fill objects and output it as
1697 often as necessary. This saves on the overhead of
1698 potentially lots of bfd_set_section_contents calls. */
1702 n_per_buf
= sizeof (buf
);
1703 memset (buf
, *fill_literal
, n_per_buf
);
1708 n_per_buf
= sizeof (buf
) / fill_size
;
1709 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1710 memcpy (bufp
, fill_literal
, fill_size
);
1712 for (; count
> 0; count
-= n_per_buf
)
1714 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1715 x
= bfd_set_section_contents
1716 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1717 (bfd_size_type
) n_per_buf
* fill_size
);
1719 as_fatal (ngettext ("can't fill %ld byte "
1720 "in section %s of %s: '%s'",
1721 "can't fill %ld bytes "
1722 "in section %s of %s: '%s'",
1723 (long) (n_per_buf
* fill_size
)),
1724 (long) (n_per_buf
* fill_size
),
1725 bfd_section_name (sec
),
1726 bfd_get_filename (stdoutput
),
1727 bfd_errmsg (bfd_get_error ()));
1728 offset
+= n_per_buf
* fill_size
;
1736 merge_data_into_text (void)
1738 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1739 seg_info (data_section
)->frchainP
->frch_root
;
1740 seg_info (text_section
)->frchainP
->frch_last
=
1741 seg_info (data_section
)->frchainP
->frch_last
;
1742 seg_info (data_section
)->frchainP
= 0;
1753 /* Count symbols. We can't rely on a count made by the loop in
1754 write_object_file, because *_frob_file may add a new symbol or
1755 two. Generate unused section symbols only if needed. */
1757 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1758 if (bfd_keep_unused_section_symbols (stdoutput
)
1759 || !symbol_section_p (symp
)
1760 || symbol_used_in_reloc_p (symp
))
1766 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1768 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1769 symp
= symbol_rootP
;
1770 for (i
= 0; i
< nsyms
; symp
= symbol_next (symp
))
1771 if (bfd_keep_unused_section_symbols (stdoutput
)
1772 || !symbol_section_p (symp
)
1773 || symbol_used_in_reloc_p (symp
))
1775 asympp
[i
] = symbol_get_bfdsym (symp
);
1776 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1777 || !(bfd_is_const_section (asympp
[i
]->section
)
1778 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1779 asympp
[i
]->flags
|= BSF_KEEP
;
1780 symbol_mark_written (symp
);
1781 /* Include this section symbol in the symbol table. */
1782 if (symbol_section_p (symp
))
1783 asympp
[i
]->flags
|= BSF_SECTION_SYM_USED
;
1789 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1790 gas_assert (result
);
1791 symbol_table_frozen
= 1;
1794 /* Finish the subsegments. After every sub-segment, we fake an
1795 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1796 ".fill 0" because that is the kind of frag that requires least
1797 thought. ".align" frags like to have a following frag since that
1798 makes calculating their intended length trivial. */
1800 #ifndef SUB_SEGMENT_ALIGN
1802 /* The last subsegment gets an alignment corresponding to the alignment
1803 of the section. This allows proper nop-filling at the end of
1804 code-bearing sections. */
1805 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1806 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1807 && !do_not_pad_sections_to_alignment \
1808 ? get_recorded_alignment (SEG) \
1811 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1816 subsegs_finish_section (asection
*s
)
1818 struct frchain
*frchainP
;
1819 segment_info_type
*seginfo
= seg_info (s
);
1823 for (frchainP
= seginfo
->frchainP
;
1825 frchainP
= frchainP
->frch_next
)
1829 subseg_set (s
, frchainP
->frch_subseg
);
1831 /* This now gets called even if we had errors. In that case,
1832 any alignment is meaningless, and, moreover, will look weird
1833 if we are generating a listing. */
1835 do_not_pad_sections_to_alignment
= 1;
1837 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1838 if ((bfd_section_flags (now_seg
) & SEC_MERGE
)
1839 && now_seg
->entsize
)
1841 unsigned int entsize
= now_seg
->entsize
;
1844 while ((entsize
& 1) == 0)
1850 if (entalign
> alignment
)
1851 alignment
= entalign
;
1854 if (subseg_text_p (now_seg
))
1855 frag_align_code (alignment
, 0);
1857 frag_align (alignment
, 0, 0);
1859 /* frag_align will have left a new frag.
1860 Use this last frag for an empty ".fill".
1862 For this segment ...
1863 Create a last frag. Do not leave a "being filled in frag". */
1864 frag_wane (frag_now
);
1865 frag_now
->fr_fix
= 0;
1866 know (frag_now
->fr_next
== NULL
);
1871 subsegs_finish (void)
1875 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1876 subsegs_finish_section (s
);
1881 create_obj_attrs_section (void)
1888 size
= bfd_elf_obj_attr_size (stdoutput
);
1892 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1894 name
= ".gnu.attributes";
1895 s
= subseg_new (name
, 0);
1896 elf_section_type (s
)
1897 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1898 bfd_set_section_flags (s
, SEC_READONLY
| SEC_DATA
);
1900 p
= frag_more (size
);
1901 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1903 subsegs_finish_section (s
);
1904 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1905 size_seg (stdoutput
, s
, NULL
);
1908 /* Create a relocation against an entry in a GNU Build attribute section. */
1911 create_note_reloc (segT sec
,
1913 bfd_size_type note_offset
,
1914 bfd_size_type desc2_offset
,
1920 struct reloc_list
* reloc
;
1922 reloc
= XNEW (struct reloc_list
);
1924 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
1925 reloc
->u
.b
.sec
= sec
;
1926 reloc
->u
.b
.s
= symbol_get_bfdsym (sym
);
1927 reloc
->u
.b
.r
.sym_ptr_ptr
= & reloc
->u
.b
.s
;
1928 reloc
->u
.b
.r
.address
= note_offset
+ desc2_offset
;
1929 reloc
->u
.b
.r
.addend
= addend
;
1930 reloc
->u
.b
.r
.howto
= bfd_reloc_type_lookup (stdoutput
, reloc_type
);
1932 if (reloc
->u
.b
.r
.howto
== NULL
)
1934 as_bad (_("unable to create reloc for build note"));
1938 reloc
->file
= N_("<gnu build note>");
1941 reloc
->next
= reloc_list
;
1944 /* For REL relocs, store the addend in the section. */
1945 if (! sec
->use_rela_p
1946 /* The SH target is a special case that uses RELA relocs
1947 but still stores the addend in the word being relocated. */
1948 || strstr (bfd_get_target (stdoutput
), "-sh") != NULL
)
1952 /* Zero out the addend, since it is now stored in the note. */
1953 reloc
->u
.b
.r
.addend
= 0;
1955 if (target_big_endian
)
1957 for (i
= desc2_size
; addend
!= 0 && i
> 0; addend
>>= 8, i
--)
1958 note
[desc2_offset
+ i
- 1] = (addend
& 0xff);
1962 for (i
= 0; addend
!= 0 && i
< desc2_size
; addend
>>= 8, i
++)
1963 note
[desc2_offset
+ i
] = (addend
& 0xff);
1969 maybe_generate_build_notes (void)
1976 offsetT desc2_offset
;
1981 if (! flag_generate_build_notes
1982 || bfd_get_section_by_name (stdoutput
,
1983 GNU_BUILD_ATTRS_SECTION_NAME
) != NULL
)
1986 /* Create a GNU Build Attribute section. */
1987 sec
= subseg_new (GNU_BUILD_ATTRS_SECTION_NAME
, FALSE
);
1988 elf_section_type (sec
) = SHT_NOTE
;
1989 bfd_set_section_flags (sec
, (SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_DATA
1991 bfd_set_section_alignment (sec
, 2);
1993 /* Work out the size of the notes that we will create,
1994 and the relocation we should use. */
1995 if (bfd_arch_bits_per_address (stdoutput
) <= 32)
1998 desc_size
= 8; /* Two 4-byte offsets. */
2001 /* FIXME: The BFD backend for the CRX target does not support the
2002 BFD_RELOC_32, even though it really should. Likewise for the
2003 CR16 target. So we have special case code here... */
2004 if (strstr (bfd_get_target (stdoutput
), "-crx") != NULL
)
2005 desc_reloc
= BFD_RELOC_CRX_NUM32
;
2006 else if (strstr (bfd_get_target (stdoutput
), "-cr16") != NULL
)
2007 desc_reloc
= BFD_RELOC_CR16_NUM32
;
2009 desc_reloc
= BFD_RELOC_32
;
2014 desc_size
= 16; /* Two 8-byte offsets. */
2016 /* FIXME: The BFD backend for the IA64 target does not support the
2017 BFD_RELOC_64, even though it really should. The HPPA backend
2018 has a similar issue, although it does not support BFD_RELOCs at
2019 all! So we have special case code to handle these targets. */
2020 if (strstr (bfd_get_target (stdoutput
), "-ia64") != NULL
)
2021 desc_reloc
= target_big_endian
? BFD_RELOC_IA64_DIR32MSB
: BFD_RELOC_IA64_DIR32LSB
;
2022 else if (strstr (bfd_get_target (stdoutput
), "-hppa") != NULL
)
2023 desc_reloc
= 80; /* R_PARISC_DIR64. */
2025 desc_reloc
= BFD_RELOC_64
;
2028 /* We have to create a note for *each* code section.
2029 Linker garbage collection might discard some. */
2033 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
2034 if ((bsym
= symbol_get_bfdsym (sym
)) != NULL
2035 && bsym
->flags
& BSF_SECTION_SYM
2036 && bsym
->section
!= NULL
2037 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
2038 && (bsym
->section
->flags
& (SEC_CODE
| SEC_LINK_ONCE
)) == SEC_CODE
2039 /* Not all linkonce sections are flagged... */
2040 && strncmp (S_GET_NAME (sym
), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0)
2042 /* Create a version note. */
2044 note
= frag_more (note_size
);
2045 memset (note
, 0, note_size
);
2047 if (target_big_endian
)
2049 note
[3] = 8; /* strlen (name) + 1. */
2050 note
[7] = desc_size
; /* Two N-byte offsets. */
2051 note
[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2052 note
[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2056 note
[0] = 8; /* strlen (name) + 1. */
2057 note
[4] = desc_size
; /* Two N-byte offsets. */
2058 note
[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2059 note
[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2062 /* The a1 version number indicates that this note was
2063 generated by the assembler and not the gcc annobin plugin. */
2064 memcpy (note
+ 12, "GA$\ 13a1", 8);
2066 /* Create a relocation to install the start address of the note... */
2067 create_note_reloc (sec
, sym
, total_size
, 20, desc_size
/ 2, desc_reloc
, 0, note
);
2069 /* ...and another one to install the end address. */
2070 create_note_reloc (sec
, sym
, total_size
, desc2_offset
,
2073 bfd_section_size (bsym
->section
),
2076 /* Mark the section symbol used in relocation so that it will be
2077 included in the symbol table. */
2078 symbol_mark_used_in_reloc (sym
);
2080 total_size
+= note_size
;
2081 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2084 /* Install the note(s) into the section. */
2086 bfd_set_section_contents (stdoutput
, sec
, (bfd_byte
*) note
, 0, total_size
);
2087 subsegs_finish_section (sec
);
2088 relax_segment (seg_info (sec
)->frchainP
->frch_root
, sec
, 0);
2089 size_seg (stdoutput
, sec
, NULL
);
2091 #endif /* OBJ_ELF */
2093 /* Write the object file. */
2096 write_object_file (void)
2098 struct relax_seg_info rsi
;
2099 #ifndef WORKING_DOT_WORD
2100 fragS
*fragP
; /* Track along all frags. */
2105 #ifdef md_pre_output_hook
2109 #ifdef md_pre_relax_hook
2113 /* From now on, we don't care about sub-segments. Build one frag chain
2114 for each segment. Linked through fr_next. */
2116 /* Remove the sections created by gas for its own purposes. */
2120 bfd_section_list_remove (stdoutput
, reg_section
);
2121 bfd_section_list_remove (stdoutput
, expr_section
);
2122 stdoutput
->section_count
-= 2;
2124 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
2127 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
2129 /* We have two segments. If user gave -R flag, then we must put the
2130 data frags into the text segment. Do this before relaxing so
2131 we know to take advantage of -R and make shorter addresses. */
2132 if (flag_readonly_data_in_text
)
2134 merge_data_into_text ();
2140 #ifndef WORKING_DOT_WORD
2141 /* We need to reset the markers in the broken word list and
2142 associated frags between calls to relax_segment (via
2143 relax_seg). Since the broken word list is global, we do it
2144 once per round, rather than locally in relax_segment for each
2146 struct broken_word
*brokp
;
2148 for (brokp
= broken_words
;
2149 brokp
!= (struct broken_word
*) NULL
;
2150 brokp
= brokp
->next_broken_word
)
2154 if (brokp
->dispfrag
!= (fragS
*) NULL
2155 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
2156 brokp
->dispfrag
->fr_subtype
= 0;
2161 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
2167 /* Note - Most ports will use the default value of
2168 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2169 local symbols to be resolved, removing their frag information.
2170 Some ports however, will not have finished relaxing all of
2171 their frags and will still need the local symbol frag
2172 information. These ports can set
2173 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2174 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
2176 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
2178 /* Relaxation has completed. Freeze all syms. */
2181 dwarf2dbg_final_check ();
2183 #ifdef md_post_relax_hook
2189 create_obj_attrs_section ();
2192 #ifndef WORKING_DOT_WORD
2194 struct broken_word
*lie
;
2195 struct broken_word
**prevP
;
2197 prevP
= &broken_words
;
2198 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
2203 subseg_change (lie
->seg
, lie
->subseg
);
2204 exp
.X_op
= O_subtract
;
2205 exp
.X_add_symbol
= lie
->add
;
2206 exp
.X_op_symbol
= lie
->sub
;
2207 exp
.X_add_number
= lie
->addnum
;
2208 #ifdef TC_CONS_FIX_NEW
2209 TC_CONS_FIX_NEW (lie
->frag
,
2210 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2211 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
2213 fix_new_exp (lie
->frag
,
2214 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2215 2, &exp
, 0, BFD_RELOC_16
);
2217 *prevP
= lie
->next_broken_word
;
2220 prevP
= &(lie
->next_broken_word
);
2222 for (lie
= broken_words
; lie
;)
2224 struct broken_word
*untruth
;
2226 addressT table_addr
;
2227 addressT from_addr
, to_addr
;
2230 subseg_change (lie
->seg
, lie
->subseg
);
2231 fragP
= lie
->dispfrag
;
2233 /* Find out how many broken_words go here. */
2236 untruth
&& untruth
->dispfrag
== fragP
;
2237 untruth
= untruth
->next_broken_word
)
2238 if (untruth
->added
== 1)
2241 table_ptr
= lie
->dispfrag
->fr_opcode
;
2242 table_addr
= (lie
->dispfrag
->fr_address
2243 + (table_ptr
- lie
->dispfrag
->fr_literal
));
2244 /* Create the jump around the long jumps. This is a short
2245 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2246 from_addr
= table_addr
;
2247 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
2248 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2250 table_ptr
+= md_short_jump_size
;
2251 table_addr
+= md_short_jump_size
;
2254 lie
&& lie
->dispfrag
== fragP
;
2255 m
++, lie
= lie
->next_broken_word
)
2257 if (lie
->added
== 2)
2259 /* Patch the jump table. */
2260 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2261 untruth
&& untruth
->dispfrag
== fragP
;
2262 untruth
= untruth
->next_broken_word
)
2264 if (untruth
->use_jump
== lie
)
2266 /* This is the offset from ??? to table_ptr+0.
2267 The target is the same for all users of this
2268 md_long_jump, but the "sub" bases (and hence the
2269 offsets) may be different. */
2270 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
2271 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2272 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
2274 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2278 /* Install the long jump. */
2279 /* This is a long jump from table_ptr+0 to the final target. */
2280 from_addr
= table_addr
;
2281 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2282 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2284 table_ptr
+= md_long_jump_size
;
2285 table_addr
+= md_long_jump_size
;
2289 #endif /* not WORKING_DOT_WORD */
2291 /* Resolve symbol values. This needs to be done before processing
2297 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2298 resolve_symbol_value (symp
);
2300 resolve_local_symbol_values ();
2301 resolve_reloc_expr_symbols ();
2305 maybe_generate_build_notes ();
2310 #ifdef tc_frob_file_before_adjust
2311 tc_frob_file_before_adjust ();
2313 #ifdef obj_frob_file_before_adjust
2314 obj_frob_file_before_adjust ();
2317 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2319 #ifdef tc_frob_file_before_fix
2320 tc_frob_file_before_fix ();
2322 #ifdef obj_frob_file_before_fix
2323 obj_frob_file_before_fix ();
2326 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2328 /* Set up symbol table, and write it out. */
2332 bfd_boolean skip_next_symbol
= FALSE
;
2334 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2339 if (skip_next_symbol
)
2341 /* Don't do anything besides moving the value of the
2342 symbol from the GAS value-field to the BFD value-field. */
2343 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2344 skip_next_symbol
= FALSE
;
2348 if (symbol_mri_common_p (symp
))
2350 if (S_IS_EXTERNAL (symp
))
2351 as_bad (_("%s: global symbols not supported in common sections"),
2353 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2357 name
= S_GET_NAME (symp
);
2361 decode_local_label_name ((char *) S_GET_NAME (symp
));
2362 /* They only differ if `name' is a fb or dollar local
2364 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2365 as_bad (_("local label `%s' is not defined"), name2
);
2368 /* Do it again, because adjust_reloc_syms might introduce
2369 more symbols. They'll probably only be section symbols,
2370 but they'll still need to have the values computed. */
2371 resolve_symbol_value (symp
);
2373 /* Skip symbols which were equated to undefined or common
2375 if (symbol_equated_reloc_p (symp
)
2376 || S_IS_WEAKREFR (symp
))
2378 const char *sname
= S_GET_NAME (symp
);
2380 if (S_IS_COMMON (symp
)
2381 && !TC_FAKE_LABEL (sname
)
2382 && !S_IS_WEAKREFR (symp
))
2384 expressionS
*e
= symbol_get_value_expression (symp
);
2386 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2387 sname
, S_GET_NAME (e
->X_add_symbol
));
2389 if (S_GET_SEGMENT (symp
) == reg_section
)
2391 /* Report error only if we know the symbol name. */
2392 if (S_GET_NAME (symp
) != reg_section
->name
)
2393 as_bad (_("can't make global register symbol `%s'"),
2396 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2400 #ifdef obj_frob_symbol
2401 obj_frob_symbol (symp
, punt
);
2403 #ifdef tc_frob_symbol
2404 if (! punt
|| symbol_used_in_reloc_p (symp
))
2405 tc_frob_symbol (symp
, punt
);
2408 /* If we don't want to keep this symbol, splice it out of
2409 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2410 want section symbols. Otherwise, we skip local symbols
2411 and symbols that the frob_symbol macros told us to punt,
2412 but we keep such symbols if they are used in relocs. */
2413 if (symp
== abs_section_sym
2414 || (! EMIT_SECTION_SYMBOLS
2415 && symbol_section_p (symp
))
2416 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2417 opposites. Sometimes the former checks flags and the
2418 latter examines the name... */
2419 || (!S_IS_EXTERNAL (symp
)
2420 && (punt
|| S_IS_LOCAL (symp
) ||
2421 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2422 && ! symbol_used_in_reloc_p (symp
)))
2424 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2426 /* After symbol_remove, symbol_next(symp) still returns
2427 the one that came after it in the chain. So we don't
2428 need to do any extra cleanup work here. */
2432 /* Make sure we really got a value for the symbol. */
2433 if (! symbol_resolved_p (symp
))
2435 as_bad (_("can't resolve value for symbol `%s'"),
2437 symbol_mark_resolved (symp
);
2440 /* Set the value into the BFD symbol. Up til now the value
2441 has only been kept in the gas symbolS struct. */
2442 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2444 /* A warning construct is a warning symbol followed by the
2445 symbol warned about. Don't let anything object-format or
2446 target-specific muck with it; it's ready for output. */
2447 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2448 skip_next_symbol
= TRUE
;
2454 /* Now do any format-specific adjustments to the symbol table, such
2455 as adding file symbols. */
2456 #ifdef tc_adjust_symtab
2457 tc_adjust_symtab ();
2459 #ifdef obj_adjust_symtab
2460 obj_adjust_symtab ();
2463 /* Stop if there is an error. */
2464 if (!flag_always_generate_output
&& had_errors ())
2467 /* Now that all the sizes are known, and contents correct, we can
2468 start writing to the file. */
2471 /* If *_frob_file changes the symbol value at this point, it is
2472 responsible for moving the changed value into symp->bsym->value
2473 as well. Hopefully all symbol value changing can be done in
2478 #ifdef obj_frob_file
2481 #ifdef obj_coff_generate_pdata
2482 obj_coff_generate_pdata ();
2485 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2487 #ifdef tc_frob_file_after_relocs
2488 tc_frob_file_after_relocs ();
2490 #ifdef obj_frob_file_after_relocs
2491 obj_frob_file_after_relocs ();
2494 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2495 if (IS_ELF
&& flag_use_elf_stt_common
)
2496 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2499 /* Once all relocations have been written, we can compress the
2500 contents of the debug sections. This needs to be done before
2501 we start writing any sections, because it will affect the file
2502 layout, which is fixed once we start writing contents. */
2503 if (flag_compress_debug
)
2505 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2506 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2508 stdoutput
->flags
|= BFD_COMPRESS
;
2509 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2512 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2515 #ifdef TC_GENERIC_RELAX_TABLE
2516 #ifndef md_generic_table_relax_frag
2517 #define md_generic_table_relax_frag relax_frag
2520 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2523 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2525 const relax_typeS
*this_type
;
2526 const relax_typeS
*start_type
;
2527 relax_substateT next_state
;
2528 relax_substateT this_state
;
2534 const relax_typeS
*table
;
2536 target
= fragP
->fr_offset
;
2537 address
= fragP
->fr_address
+ fragP
->fr_fix
;
2538 table
= TC_GENERIC_RELAX_TABLE
;
2539 this_state
= fragP
->fr_subtype
;
2540 start_type
= this_type
= table
+ this_state
;
2541 symbolP
= fragP
->fr_symbol
;
2547 sym_frag
= symbol_get_frag (symbolP
);
2549 #ifndef DIFF_EXPR_OK
2550 know (sym_frag
!= NULL
);
2552 know (S_GET_SEGMENT (symbolP
) != absolute_section
2553 || sym_frag
== &zero_address_frag
);
2554 target
+= S_GET_VALUE (symbolP
);
2556 /* If SYM_FRAG has yet to be reached on this pass, assume it
2557 will move by STRETCH just as we did, unless there is an
2558 alignment frag between here and SYM_FRAG. An alignment may
2559 well absorb any STRETCH, and we don't want to choose a larger
2560 branch insn by overestimating the needed reach of this
2561 branch. It isn't critical to calculate TARGET exactly; We
2562 know we'll be doing another pass if STRETCH is non-zero. */
2565 && sym_frag
->relax_marker
!= fragP
->relax_marker
2566 && S_GET_SEGMENT (symbolP
) == segment
)
2569 || sym_frag
->region
== fragP
->region
)
2571 /* If we get here we know we have a forward branch. This
2572 relax pass may have stretched previous instructions so
2573 far that omitting STRETCH would make the branch
2574 negative. Don't allow this in case the negative reach is
2575 large enough to require a larger branch instruction. */
2576 else if (target
< address
)
2581 aim
= target
- address
;
2582 #ifdef TC_PCREL_ADJUST
2583 /* Currently only the ns32k and arc needs this. */
2584 aim
+= TC_PCREL_ADJUST (fragP
);
2587 #ifdef md_prepare_relax_scan
2588 /* Formerly called M68K_AIM_KLUDGE. */
2589 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2594 /* Look backwards. */
2595 for (next_state
= this_type
->rlx_more
; next_state
;)
2596 if (aim
>= this_type
->rlx_backward
)
2600 /* Grow to next state. */
2601 this_state
= next_state
;
2602 this_type
= table
+ this_state
;
2603 next_state
= this_type
->rlx_more
;
2608 /* Look forwards. */
2609 for (next_state
= this_type
->rlx_more
; next_state
;)
2610 if (aim
<= this_type
->rlx_forward
)
2614 /* Grow to next state. */
2615 this_state
= next_state
;
2616 this_type
= table
+ this_state
;
2617 next_state
= this_type
->rlx_more
;
2621 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2623 fragP
->fr_subtype
= this_state
;
2627 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2629 /* Relax_align. Advance location counter to next address that has 'alignment'
2630 lowest order bits all 0s, return size of adjustment made. */
2631 static relax_addressT
2632 relax_align (relax_addressT address
, /* Address now. */
2633 int alignment
/* Alignment (binary). */)
2635 relax_addressT mask
;
2636 relax_addressT new_address
;
2638 mask
= ~((relax_addressT
) ~0 << alignment
);
2639 new_address
= (address
+ mask
) & (~mask
);
2640 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2642 /* We must provide lots of padding, so the linker can discard it
2643 when needed. The linker will not add extra space, ever. */
2644 new_address
+= (1 << alignment
);
2646 return (new_address
- address
);
2649 /* Now we have a segment, not a crowd of sub-segments, we can make
2654 After this, all frags in this segment have addresses that are correct
2655 within the segment. Since segments live in different file addresses,
2656 these frag addresses may not be the same as final object-file
2660 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2662 unsigned long frag_count
;
2664 relax_addressT address
;
2668 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2669 subseg_change (segment
, 0);
2671 /* For each frag in segment: count and store (a 1st guess of)
2675 for (frag_count
= 0, fragP
= segment_frag_root
;
2677 fragP
= fragP
->fr_next
, frag_count
++)
2679 fragP
->region
= region
;
2680 fragP
->relax_marker
= 0;
2681 fragP
->fr_address
= address
;
2682 address
+= fragP
->fr_fix
;
2684 switch (fragP
->fr_type
)
2687 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2694 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2696 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2699 if (offset
% fragP
->fr_var
!= 0)
2701 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2702 ngettext ("alignment padding (%lu byte) "
2703 "not a multiple of %ld",
2704 "alignment padding (%lu bytes) "
2705 "not a multiple of %ld",
2706 (unsigned long) offset
),
2707 (unsigned long) offset
, (long) fragP
->fr_var
);
2708 offset
-= (offset
% fragP
->fr_var
);
2717 /* Assume .org is nugatory. It will grow with 1st relax. */
2725 case rs_machine_dependent
:
2726 /* If fr_symbol is an expression, this call to
2727 resolve_symbol_value sets up the correct segment, which will
2728 likely be needed in md_estimate_size_before_relax. */
2729 if (fragP
->fr_symbol
)
2730 resolve_symbol_value (fragP
->fr_symbol
);
2732 address
+= md_estimate_size_before_relax (fragP
, segment
);
2735 #ifndef WORKING_DOT_WORD
2736 /* Broken words don't concern us yet. */
2737 case rs_broken_word
:
2742 /* Initial guess is always 1; doing otherwise can result in
2743 stable solutions that are larger than the minimum. */
2744 address
+= fragP
->fr_offset
= 1;
2748 address
+= eh_frame_estimate_size_before_relax (fragP
);
2752 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2756 BAD_CASE (fragP
->fr_type
);
2763 unsigned long max_iterations
;
2765 /* Cumulative address adjustment. */
2768 /* Have we made any adjustment this pass? We can't just test
2769 stretch because one piece of code may have grown and another
2773 /* Most horrible, but gcc may give us some exception data that
2774 is impossible to assemble, of the form
2778 .uleb128 end - start
2784 If the leb128 is two bytes in size, then end-start is 128*128,
2785 which requires a three byte leb128. If the leb128 is three
2786 bytes in size, then end-start is 128*128-1, which requires a
2787 two byte leb128. We work around this dilemma by inserting
2788 an extra 4 bytes of alignment just after the .align. This
2789 works because the data after the align is accessed relative to
2792 This counter is used in a tiny state machine to detect
2793 whether a leb128 followed by an align is impossible to
2795 int rs_leb128_fudge
= 0;
2797 /* We want to prevent going into an infinite loop where one frag grows
2798 depending upon the location of a symbol which is in turn moved by
2799 the growing frag. eg:
2805 So we dictate that this algorithm can be at most O2. */
2806 max_iterations
= frag_count
* frag_count
;
2807 /* Check for overflow. */
2808 if (max_iterations
< frag_count
)
2809 max_iterations
= frag_count
;
2817 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2820 addressT was_address
;
2824 fragP
->relax_marker
^= 1;
2825 was_address
= fragP
->fr_address
;
2826 address
= fragP
->fr_address
+= stretch
;
2827 symbolP
= fragP
->fr_symbol
;
2828 offset
= fragP
->fr_offset
;
2830 switch (fragP
->fr_type
)
2832 case rs_fill
: /* .fill never relaxes. */
2836 #ifndef WORKING_DOT_WORD
2837 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2838 for it I do not want to write it. I do not want to have
2839 anything to do with it. This is not the proper way to
2840 implement this misfeature. */
2841 case rs_broken_word
:
2843 struct broken_word
*lie
;
2844 struct broken_word
*untruth
;
2846 /* Yes this is ugly (storing the broken_word pointer
2847 in the symbol slot). Still, this whole chunk of
2848 code is ugly, and I don't feel like doing anything
2849 about it. Think of it as stubbornness in action. */
2851 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2852 lie
&& lie
->dispfrag
== fragP
;
2853 lie
= lie
->next_broken_word
)
2859 offset
= (S_GET_VALUE (lie
->add
)
2861 - S_GET_VALUE (lie
->sub
));
2862 if (offset
<= -32768 || offset
>= 32767)
2864 if (flag_warn_displacement
)
2867 sprint_value (buf
, (addressT
) lie
->addnum
);
2868 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2869 _(".word %s-%s+%s didn't fit"),
2870 S_GET_NAME (lie
->add
),
2871 S_GET_NAME (lie
->sub
),
2874 if (fragP
->fr_subtype
== 0)
2876 fragP
->fr_subtype
++;
2877 growth
+= md_short_jump_size
;
2880 /* Redirect *all* words of this table with the same
2881 target, lest we have to handle the case where the
2882 same target but with a offset that fits on this
2883 round overflows at the next relaxation round. */
2884 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2885 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2886 untruth
= untruth
->next_broken_word
)
2887 if ((symbol_get_frag (untruth
->add
)
2888 == symbol_get_frag (lie
->add
))
2889 && (S_GET_VALUE (untruth
->add
)
2890 == S_GET_VALUE (lie
->add
)))
2893 untruth
->use_jump
= lie
;
2897 growth
+= md_long_jump_size
;
2902 } /* case rs_broken_word */
2908 addressT oldoff
, newoff
;
2910 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2912 newoff
= relax_align (address
+ fragP
->fr_fix
,
2915 if (fragP
->fr_subtype
!= 0)
2917 if (oldoff
> fragP
->fr_subtype
)
2919 if (newoff
> fragP
->fr_subtype
)
2923 growth
= newoff
- oldoff
;
2925 /* If this align happens to follow a leb128 and
2926 we have determined that the leb128 is bouncing
2927 in size, then break the cycle by inserting an
2930 && (rs_leb128_fudge
& 16) != 0
2931 && (rs_leb128_fudge
& 15) >= 2)
2933 segment_info_type
*seginfo
= seg_info (segment
);
2934 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2937 newf
= frag_alloc (ob
);
2938 obstack_blank_fast (ob
, fragP
->fr_var
);
2939 obstack_finish (ob
);
2940 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2941 memcpy (newf
->fr_literal
,
2942 fragP
->fr_literal
+ fragP
->fr_fix
,
2944 newf
->fr_type
= rs_fill
;
2945 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2947 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2949 if (newf
->fr_offset
* newf
->fr_var
2950 != (offsetT
) 1 << fragP
->fr_offset
)
2952 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2955 /* Include size of new frag in GROWTH. */
2956 growth
+= newf
->fr_offset
* newf
->fr_var
;
2957 /* Adjust the new frag address for the amount
2958 we'll add when we process the new frag. */
2959 newf
->fr_address
-= stretch
+ growth
;
2960 newf
->relax_marker
^= 1;
2961 fragP
->fr_next
= newf
;
2963 as_warn (_("padding added"));
2971 offsetT target
= offset
;
2976 /* Convert from an actual address to an octet offset
2977 into the section. Here it is assumed that the
2978 section's VMA is zero, and can omit subtracting it
2979 from the symbol's value to get the address offset. */
2980 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2981 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2984 know (fragP
->fr_next
);
2985 after
= fragP
->fr_next
->fr_address
+ stretch
;
2986 growth
= target
- after
;
2988 /* Growth may be negative, but variable part of frag
2989 cannot have fewer than 0 chars. That is, we can't
2991 if ((offsetT
) (address
+ fragP
->fr_fix
) > target
)
2995 /* Don't error on first few frag relax passes.
2996 The symbol might be an expression involving
2997 symbol values from other sections. If those
2998 sections have not yet been processed their
2999 frags will all have zero addresses, so we
3000 will calculate incorrect values for them. The
3001 number of passes we allow before giving an
3002 error is somewhat arbitrary. It should be at
3003 least one, with larger values requiring
3004 increasingly contrived dependencies between
3005 frags to trigger a false error. */
3008 /* Force another pass. */
3013 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3014 _("attempt to move .org backwards"));
3016 /* We've issued an error message. Change the
3017 frag to avoid cascading errors. */
3018 fragP
->fr_type
= rs_align
;
3019 fragP
->fr_subtype
= 0;
3020 fragP
->fr_offset
= 0;
3021 fragP
->fr_fix
= after
- address
;
3033 amount
= S_GET_VALUE (symbolP
);
3034 if (S_GET_SEGMENT (symbolP
) != absolute_section
3035 || S_IS_COMMON (symbolP
)
3036 || ! S_IS_DEFINED (symbolP
))
3038 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3039 _(".space, .nops or .fill specifies non-absolute value"));
3040 /* Prevent repeat of this error message. */
3041 fragP
->fr_symbol
= 0;
3043 else if (amount
< 0)
3045 /* Don't error on first few frag relax passes.
3046 See rs_org comment for a longer explanation. */
3053 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3054 _(".space, .nops or .fill with negative value, ignored"));
3055 fragP
->fr_symbol
= 0;
3058 growth
= (was_address
+ fragP
->fr_fix
+ amount
3059 - fragP
->fr_next
->fr_address
);
3063 case rs_machine_dependent
:
3064 #ifdef md_relax_frag
3065 growth
= md_relax_frag (segment
, fragP
, stretch
);
3067 #ifdef TC_GENERIC_RELAX_TABLE
3068 /* The default way to relax a frag is to look through
3069 TC_GENERIC_RELAX_TABLE. */
3070 growth
= md_generic_table_relax_frag (segment
, fragP
,
3072 #endif /* TC_GENERIC_RELAX_TABLE */
3081 value
= resolve_symbol_value (fragP
->fr_symbol
);
3082 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
3083 growth
= size
- fragP
->fr_offset
;
3084 fragP
->fr_offset
= size
;
3089 growth
= eh_frame_relax_frag (fragP
);
3093 growth
= dwarf2dbg_relax_frag (fragP
);
3097 BAD_CASE (fragP
->fr_type
);
3104 if (fragP
->fr_type
== rs_leb128
)
3105 rs_leb128_fudge
+= 16;
3106 else if (fragP
->fr_type
== rs_align
3107 && (rs_leb128_fudge
& 16) != 0
3109 rs_leb128_fudge
+= 16;
3111 rs_leb128_fudge
= 0;
3116 && (rs_leb128_fudge
& 16) == 0
3117 && (rs_leb128_fudge
& -16) != 0)
3118 rs_leb128_fudge
+= 1;
3120 rs_leb128_fudge
= 0;
3122 /* Until nothing further to relax. */
3123 while (stretched
&& -- max_iterations
);
3126 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3127 segment_name (segment
));
3130 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3131 if (fragP
->last_fr_address
!= fragP
->fr_address
)
3133 fragP
->last_fr_address
= fragP
->fr_address
;
3140 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
3146 buf
[n
] = val
& 0xff;
3152 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
3158 *buf
++ = val
& 0xff;
3164 write_print_statistics (FILE *file
)
3166 fprintf (file
, "fixups: %d\n", n_fixups
);
3169 /* For debugging. */
3170 extern int indent_level
;
3173 print_fixup (fixS
*fixp
)
3176 fprintf (stderr
, "fix ");
3177 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
3178 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
3180 fprintf (stderr
, " pcrel");
3181 if (fixp
->fx_pcrel_adjust
)
3182 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
3184 fprintf (stderr
, " tcbit");
3186 fprintf (stderr
, " done");
3187 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
3188 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
3189 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
3190 (long) fixp
->fx_where
,
3191 (unsigned long) fixp
->fx_offset
,
3192 (unsigned long) fixp
->fx_addnumber
);
3193 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
3197 fprintf (stderr
, "\n +<");
3198 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
3199 fprintf (stderr
, ">");
3203 fprintf (stderr
, "\n -<");
3204 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3205 fprintf (stderr
, ">");
3207 fprintf (stderr
, "\n");
3208 #ifdef TC_FIX_DATA_PRINT
3209 TC_FIX_DATA_PRINT (stderr
, fixp
);