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
741 && S_IS_DEFINED (sym
)
742 && !symbol_section_p (sym
)
744 || (howto
->partial_inplace
745 && (!howto
->pc_relative
746 || howto
->src_mask
== addr_mask
))))
748 asection
*symsec
= S_GET_SEGMENT (sym
);
749 if (!(((symsec
->flags
& SEC_MERGE
) != 0
751 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
753 addend
+= S_GET_VALUE (sym
);
754 sym
= section_symbol (symsec
);
757 symbol_mark_used_in_reloc (sym
);
762 if (abs_section_sym
== NULL
)
763 abs_section_sym
= section_symbol (absolute_section
);
764 sym
= abs_section_sym
;
768 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
769 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
770 r
->u
.b
.r
.address
= offset
;
771 r
->u
.b
.r
.addend
= addend
;
772 r
->u
.b
.r
.howto
= howto
;
776 /* This pass over fixups decides whether symbols can be replaced with
780 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
782 void *xxx ATTRIBUTE_UNUSED
)
784 segment_info_type
*seginfo
= seg_info (sec
);
790 dump_section_relocs (abfd
, sec
, stderr
);
792 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
796 else if (fixp
->fx_addsy
)
802 fprintf (stderr
, "\n\nadjusting fixup:\n");
806 sym
= fixp
->fx_addsy
;
808 /* All symbols should have already been resolved at this
809 point. It is possible to see unresolved expression
810 symbols, though, since they are not in the regular symbol
812 resolve_symbol_value (sym
);
814 if (fixp
->fx_subsy
!= NULL
)
815 resolve_symbol_value (fixp
->fx_subsy
);
817 /* If this symbol is equated to an undefined or common symbol,
818 convert the fixup to being against that symbol. */
819 while (symbol_equated_reloc_p (sym
)
820 || S_IS_WEAKREFR (sym
))
822 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
825 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
826 fixp
->fx_addsy
= newsym
;
830 if (symbol_mri_common_p (sym
))
832 fixp
->fx_offset
+= S_GET_VALUE (sym
);
833 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
837 /* If the symbol is undefined, common, weak, or global (ELF
838 shared libs), we can't replace it with the section symbol. */
839 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
842 /* Is there some other (target cpu dependent) reason we can't adjust
843 this one? (E.g. relocations involving function addresses on
845 #ifdef tc_fix_adjustable
846 if (! tc_fix_adjustable (fixp
))
850 /* Since we're reducing to section symbols, don't attempt to reduce
851 anything that's already using one. */
852 if (symbol_section_p (sym
))
854 /* Mark the section symbol used in relocation so that it will
855 be included in the symbol table. */
856 symbol_mark_used_in_reloc (sym
);
860 symsec
= S_GET_SEGMENT (sym
);
864 if (bfd_is_abs_section (symsec
)
865 || symsec
== reg_section
)
867 /* The fixup_segment routine normally will not use this
868 symbol in a relocation. */
872 /* Don't try to reduce relocs which refer to non-local symbols
873 in .linkonce sections. It can lead to confusion when a
874 debugging section refers to a .linkonce section. I hope
875 this will always be correct. */
876 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
878 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
880 /* The GNU toolchain uses an extension for ELF: a
881 section beginning with the magic string
882 .gnu.linkonce is a linkonce section. */
883 && startswith (segment_name (symsec
), ".gnu.linkonce")))
887 /* Never adjust a reloc against local symbol in a merge section
888 with non-zero addend. */
889 if ((symsec
->flags
& SEC_MERGE
) != 0
890 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
893 /* Never adjust a reloc against TLS local symbol. */
894 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
897 /* We refetch the segment when calling section_symbol, rather
898 than using symsec, because S_GET_VALUE may wind up changing
899 the section when it calls resolve_symbol_value. */
900 fixp
->fx_offset
+= S_GET_VALUE (sym
);
901 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
903 fprintf (stderr
, "\nadjusted fixup:\n");
908 dump_section_relocs (abfd
, sec
, stderr
);
913 Go through all the fixS's in a segment and see which ones can be
914 handled now. (These consist of fixS where we have since discovered
915 the value of a symbol, or the address of the frag involved.)
916 For each one, call md_apply_fix to put the fix into the frag data.
917 Ones that we couldn't completely handle here will be output later
918 by emit_relocations. */
921 fixup_segment (fixS
*fixP
, segT this_segment
)
925 segT add_symbol_segment
= absolute_section
;
927 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
928 abs_section_sym
= section_symbol (absolute_section
);
930 /* If the linker is doing the relaxing, we must not do any fixups.
932 Well, strictly speaking that's not true -- we could do any that
933 are PC-relative and don't cross regions that could change size. */
934 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
936 for (; fixP
; fixP
= fixP
->fx_next
)
939 if (fixP
->fx_addsy
== NULL
)
941 /* There was no symbol required by this relocation.
942 However, BFD doesn't really handle relocations
943 without symbols well. So fake up a local symbol in
944 the absolute section. */
945 fixP
->fx_addsy
= abs_section_sym
;
947 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
948 if (fixP
->fx_subsy
!= NULL
)
949 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
954 for (; fixP
; fixP
= fixP
->fx_next
)
957 fprintf (stderr
, "\nprocessing fixup:\n");
961 fragP
= fixP
->fx_frag
;
963 #ifdef TC_VALIDATE_FIX
964 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
966 add_number
= fixP
->fx_offset
;
968 if (fixP
->fx_addsy
!= NULL
)
969 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
971 if (fixP
->fx_subsy
!= NULL
)
973 segT sub_symbol_segment
;
974 resolve_symbol_value (fixP
->fx_subsy
);
975 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
976 if (fixP
->fx_addsy
!= NULL
977 && sub_symbol_segment
== add_symbol_segment
978 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
979 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
980 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
982 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
983 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
984 fixP
->fx_offset
= add_number
;
985 fixP
->fx_addsy
= NULL
;
986 fixP
->fx_subsy
= NULL
;
988 /* See the comment below about 68k weirdness. */
992 else if (sub_symbol_segment
== absolute_section
993 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
994 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
996 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
997 fixP
->fx_offset
= add_number
;
998 fixP
->fx_subsy
= NULL
;
1000 else if (sub_symbol_segment
== this_segment
1001 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
1002 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
1004 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1005 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
1006 + fixP
->fx_dot_frag
->fr_address
);
1008 /* Make it pc-relative. If the back-end code has not
1009 selected a pc-relative reloc, cancel the adjustment
1010 we do later on all pc-relative relocs. */
1013 /* Do this for m68k even if it's already described
1014 as pc-relative. On the m68k, an operand of
1015 "pc@(foo-.-2)" should address "foo" in a
1016 pc-relative mode. */
1020 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1021 fixP
->fx_subsy
= NULL
;
1024 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1026 if (!md_register_arithmetic
1027 && (add_symbol_segment
== reg_section
1028 || sub_symbol_segment
== reg_section
))
1029 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1030 _("register value used as expression"));
1032 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1033 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1034 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1035 segment_name (add_symbol_segment
),
1036 S_GET_NAME (fixP
->fx_subsy
),
1037 segment_name (sub_symbol_segment
));
1039 else if (sub_symbol_segment
!= undefined_section
1040 && ! bfd_is_com_section (sub_symbol_segment
)
1041 && MD_APPLY_SYM_VALUE (fixP
))
1042 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1047 if (add_symbol_segment
== this_segment
1048 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1049 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1051 /* This fixup was made when the symbol's segment was
1052 SEG_UNKNOWN, but it is now in the local segment.
1053 So we know how to do the address without relocation. */
1054 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1055 fixP
->fx_offset
= add_number
;
1057 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1058 fixP
->fx_addsy
= NULL
;
1061 else if (add_symbol_segment
== absolute_section
1062 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1063 && !TC_FORCE_RELOCATION_ABS (fixP
))
1065 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1066 fixP
->fx_offset
= add_number
;
1067 fixP
->fx_addsy
= NULL
;
1069 else if (add_symbol_segment
!= undefined_section
1070 && ! bfd_is_com_section (add_symbol_segment
)
1071 && MD_APPLY_SYM_VALUE (fixP
))
1072 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1077 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1078 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1080 /* There was no symbol required by this relocation.
1081 However, BFD doesn't really handle relocations
1082 without symbols well. So fake up a local symbol in
1083 the absolute section. */
1084 fixP
->fx_addsy
= abs_section_sym
;
1089 md_apply_fix (fixP
, &add_number
, this_segment
);
1093 if (fixP
->fx_addsy
== NULL
)
1094 fixP
->fx_addsy
= abs_section_sym
;
1095 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1096 if (fixP
->fx_subsy
!= NULL
)
1097 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1100 if (!fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1102 if (fixP
->fx_size
< sizeof (valueT
))
1107 mask
--; /* Set all bits to one. */
1108 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1109 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1111 char buf
[50], buf2
[50];
1112 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1113 if (add_number
> 1000)
1114 sprint_value (buf2
, add_number
);
1116 sprintf (buf2
, "%ld", (long) add_number
);
1117 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1118 ngettext ("value of %s too large for field "
1120 "value of %s too large for field "
1121 "of %d bytes at %s",
1123 buf2
, fixP
->fx_size
, buf
);
1124 } /* Generic error checking. */
1126 #ifdef WARN_SIGNED_OVERFLOW_WORD
1127 /* Warn if a .word value is too large when treated as a signed
1128 number. We already know it is not too negative. This is to
1129 catch over-large switches generated by gcc on the 68k. */
1130 if (!flag_signed_overflow_ok
1131 && fixP
->fx_size
== 2
1132 && add_number
> 0x7fff)
1133 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1134 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1136 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1140 #ifdef TC_VALIDATE_FIX
1141 skip
: ATTRIBUTE_UNUSED_LABEL
1145 fprintf (stderr
, "result:\n");
1148 } /* For each fixS in this segment. */
1152 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1154 void *xxx ATTRIBUTE_UNUSED
)
1156 segment_info_type
*seginfo
= seg_info (sec
);
1158 fixup_segment (seginfo
->fix_root
, sec
);
1162 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1163 const char *file
, unsigned int line
)
1166 bfd_reloc_status_type s
;
1169 if (reloc
->sym_ptr_ptr
!= NULL
1170 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1171 && (sym
->flags
& BSF_KEEP
) == 0
1172 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1173 || (EMIT_SECTION_SYMBOLS
1174 && !bfd_is_abs_section (sym
->section
))))
1175 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1177 s
= bfd_install_relocation (stdoutput
, reloc
,
1178 fragp
->fr_literal
, fragp
->fr_address
,
1184 case bfd_reloc_overflow
:
1185 as_bad_where (file
, line
, _("relocation overflow"));
1187 case bfd_reloc_outofrange
:
1188 as_bad_where (file
, line
, _("relocation out of range"));
1191 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1197 get_frag_for_reloc (fragS
*last_frag
,
1198 const segment_info_type
*seginfo
,
1199 const struct reloc_list
*r
)
1203 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1204 if (f
->fr_address
<= r
->u
.b
.r
.address
1205 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1208 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1209 if (f
->fr_address
<= r
->u
.b
.r
.address
1210 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1213 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1214 if (f
->fr_address
<= r
->u
.b
.r
.address
1215 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1218 as_bad_where (r
->file
, r
->line
,
1219 _("reloc not within (fixed part of) section"));
1224 write_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1225 void *xxx ATTRIBUTE_UNUSED
)
1227 segment_info_type
*seginfo
= seg_info (sec
);
1229 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1234 /* If seginfo is NULL, we did not create this section; don't do
1235 anything with it. */
1236 if (seginfo
== NULL
)
1240 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1244 #ifdef RELOC_EXPANSION_POSSIBLE
1245 n
*= MAX_RELOC_EXPANSION
;
1248 /* Extract relocs for this section from reloc_list. */
1251 my_reloc_list
= NULL
;
1252 while ((r
= *rp
) != NULL
)
1254 if (r
->u
.b
.sec
== sec
)
1257 r
->next
= my_reloc_list
;
1265 relocs
= XCNEWVEC (arelent
*, n
);
1270 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1275 #ifndef RELOC_EXPANSION_POSSIBLE
1284 fx_size
= fixp
->fx_size
;
1285 slack
= TC_FX_SIZE_SLACK (fixp
);
1287 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1288 loc
= fixp
->fx_where
+ fx_size
;
1289 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1290 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1291 _("internal error: fixup not contained within frag"));
1293 #ifndef RELOC_EXPANSION_POSSIBLE
1294 *reloc
= tc_gen_reloc (sec
, fixp
);
1296 reloc
= tc_gen_reloc (sec
, fixp
);
1301 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1303 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1307 relocs
[n
++] = &r
->u
.b
.r
;
1308 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1312 relocs
[n
++] = *reloc
;
1313 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1314 fixp
->fx_file
, fixp
->fx_line
);
1315 #ifndef RELOC_EXPANSION_POSSIBLE
1325 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1329 relocs
[n
++] = &r
->u
.b
.r
;
1330 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1337 unsigned int k
, j
, nsyms
;
1339 sympp
= bfd_get_outsymbols (stdoutput
);
1340 nsyms
= bfd_get_symcount (stdoutput
);
1341 for (k
= 0; k
< n
; k
++)
1342 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1344 for (j
= 0; j
< nsyms
; j
++)
1345 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1355 flagword flags
= bfd_section_flags (sec
);
1357 bfd_set_section_flags (sec
, flags
);
1358 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1361 #ifdef SET_SECTION_RELOCS
1362 SET_SECTION_RELOCS (sec
, relocs
, n
);
1369 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1370 for (k
= 0; k
< n
; k
++)
1372 arelent
*rel
= relocs
[k
];
1373 asymbol
*s
= *rel
->sym_ptr_ptr
;
1374 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1375 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1376 (unsigned long)rel
->addend
);
1383 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1384 fragS
**last_newf
, struct obstack
*ob
)
1387 int total_out_size
= 0;
1388 fragS
*f
= *last_newf
;
1392 /* Call the compression routine repeatedly until it has finished
1393 processing the frag. */
1396 /* Reserve all the space available in the current chunk.
1397 If none is available, start a new frag. */
1398 avail_out
= obstack_room (ob
);
1401 obstack_finish (ob
);
1402 f
= frag_alloc (ob
);
1403 f
->fr_type
= rs_fill
;
1404 (*last_newf
)->fr_next
= f
;
1406 avail_out
= obstack_room (ob
);
1409 as_fatal (_("can't extend frag"));
1410 next_out
= obstack_next_free (ob
);
1411 obstack_blank_fast (ob
, avail_out
);
1412 out_size
= compress_data (strm
, &contents
, &in_size
,
1413 &next_out
, &avail_out
);
1417 f
->fr_fix
+= out_size
;
1418 total_out_size
+= out_size
;
1420 /* Return unused space. */
1422 obstack_blank_fast (ob
, -avail_out
);
1425 return total_out_size
;
1429 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1431 segment_info_type
*seginfo
= seg_info (sec
);
1435 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1436 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1437 bfd_size_type compressed_size
;
1438 const char *section_name
;
1439 char *compressed_name
;
1441 struct z_stream_s
*strm
;
1443 flagword flags
= bfd_section_flags (sec
);
1444 unsigned int header_size
, compression_header_size
;
1448 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1451 section_name
= bfd_section_name (sec
);
1452 if (!startswith (section_name
, ".debug_"))
1455 strm
= compress_init ();
1459 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1461 compression_header_size
1462 = bfd_get_compression_header_size (stdoutput
, NULL
);
1463 header_size
= compression_header_size
;
1467 compression_header_size
= 0;
1471 /* Create a new frag to contain the compression header. */
1472 first_newf
= frag_alloc (ob
);
1473 if (obstack_room (ob
) < header_size
)
1474 first_newf
= frag_alloc (ob
);
1475 if (obstack_room (ob
) < header_size
)
1476 as_fatal (ngettext ("can't extend frag %lu char",
1477 "can't extend frag %lu chars",
1478 (unsigned long) header_size
),
1479 (unsigned long) header_size
);
1480 last_newf
= first_newf
;
1481 obstack_blank_fast (ob
, header_size
);
1482 last_newf
->fr_type
= rs_fill
;
1483 last_newf
->fr_fix
= header_size
;
1484 header
= last_newf
->fr_literal
;
1485 compressed_size
= header_size
;
1487 /* Stream the frags through the compression engine, adding new frags
1488 as necessary to accommodate the compressed output. */
1489 for (f
= seginfo
->frchainP
->frch_root
;
1498 gas_assert (f
->fr_type
== rs_fill
);
1501 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1505 compressed_size
+= out_size
;
1507 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1508 fill_size
= f
->fr_var
;
1509 count
= f
->fr_offset
;
1510 gas_assert (count
>= 0);
1511 if (fill_size
&& count
)
1515 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1519 compressed_size
+= out_size
;
1524 /* Flush the compression state. */
1531 /* Reserve all the space available in the current chunk.
1532 If none is available, start a new frag. */
1533 avail_out
= obstack_room (ob
);
1538 obstack_finish (ob
);
1539 newf
= frag_alloc (ob
);
1540 newf
->fr_type
= rs_fill
;
1541 last_newf
->fr_next
= newf
;
1543 avail_out
= obstack_room (ob
);
1546 as_fatal (_("can't extend frag"));
1547 next_out
= obstack_next_free (ob
);
1548 obstack_blank_fast (ob
, avail_out
);
1549 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1553 last_newf
->fr_fix
+= out_size
;
1554 compressed_size
+= out_size
;
1556 /* Return unused space. */
1558 obstack_blank_fast (ob
, -avail_out
);
1564 /* PR binutils/18087: If compression didn't make the section smaller,
1565 just keep it uncompressed. */
1566 if (compressed_size
>= uncompressed_size
)
1569 /* Replace the uncompressed frag list with the compressed frag list. */
1570 seginfo
->frchainP
->frch_root
= first_newf
;
1571 seginfo
->frchainP
->frch_last
= last_newf
;
1573 /* Update the section size and its name. */
1574 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1575 x
= bfd_set_section_size (sec
, compressed_size
);
1577 if (!compression_header_size
)
1579 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1580 bfd_rename_section (sec
, compressed_name
);
1584 #ifndef md_generate_nops
1585 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1586 backend must override this with proper no-op instructions. */
1589 md_generate_nops (fragS
*f ATTRIBUTE_UNUSED
,
1590 char *where ATTRIBUTE_UNUSED
,
1591 offsetT count ATTRIBUTE_UNUSED
,
1592 int control ATTRIBUTE_UNUSED
)
1594 as_bad (_("unimplemented .nops directive"));
1599 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1601 void *xxx ATTRIBUTE_UNUSED
)
1603 segment_info_type
*seginfo
= seg_info (sec
);
1604 addressT offset
= 0;
1607 /* Write out the frags. */
1609 || !(bfd_section_flags (sec
) & SEC_HAS_CONTENTS
))
1612 for (f
= seginfo
->frchainP
->frch_root
;
1621 gas_assert (f
->fr_type
== rs_fill
|| f
->fr_type
== rs_fill_nop
);
1624 x
= bfd_set_section_contents (stdoutput
, sec
,
1625 f
->fr_literal
, (file_ptr
) offset
,
1626 (bfd_size_type
) f
->fr_fix
);
1628 as_fatal (ngettext ("can't write %ld byte "
1629 "to section %s of %s: '%s'",
1630 "can't write %ld bytes "
1631 "to section %s of %s: '%s'",
1634 bfd_section_name (sec
), bfd_get_filename (stdoutput
),
1635 bfd_errmsg (bfd_get_error ()));
1636 offset
+= f
->fr_fix
;
1639 fill_size
= f
->fr_var
;
1640 count
= f
->fr_offset
;
1641 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1643 if (f
->fr_type
== rs_fill_nop
)
1645 gas_assert (count
>= 0 && fill_size
== 1);
1648 char *buf
= xmalloc (count
);
1649 md_generate_nops (f
, buf
, count
, *fill_literal
);
1650 x
= bfd_set_section_contents
1651 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1652 (bfd_size_type
) count
);
1654 as_fatal (ngettext ("can't fill %ld byte "
1655 "in section %s of %s: '%s'",
1656 "can't fill %ld bytes "
1657 "in section %s of %s: '%s'",
1660 bfd_section_name (sec
),
1661 bfd_get_filename (stdoutput
),
1662 bfd_errmsg (bfd_get_error ()));
1669 gas_assert (count
>= 0);
1670 if (fill_size
&& count
)
1673 if (fill_size
> sizeof (buf
))
1675 /* Do it the old way. Can this ever happen? */
1678 x
= bfd_set_section_contents (stdoutput
, sec
,
1681 (bfd_size_type
) fill_size
);
1683 as_fatal (ngettext ("can't fill %ld byte "
1684 "in section %s of %s: '%s'",
1685 "can't fill %ld bytes "
1686 "in section %s of %s: '%s'",
1689 bfd_section_name (sec
),
1690 bfd_get_filename (stdoutput
),
1691 bfd_errmsg (bfd_get_error ()));
1692 offset
+= fill_size
;
1697 /* Build a buffer full of fill objects and output it as
1698 often as necessary. This saves on the overhead of
1699 potentially lots of bfd_set_section_contents calls. */
1703 n_per_buf
= sizeof (buf
);
1704 memset (buf
, *fill_literal
, n_per_buf
);
1709 n_per_buf
= sizeof (buf
) / fill_size
;
1710 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1711 memcpy (bufp
, fill_literal
, fill_size
);
1713 for (; count
> 0; count
-= n_per_buf
)
1715 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1716 x
= bfd_set_section_contents
1717 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1718 (bfd_size_type
) n_per_buf
* fill_size
);
1720 as_fatal (ngettext ("can't fill %ld byte "
1721 "in section %s of %s: '%s'",
1722 "can't fill %ld bytes "
1723 "in section %s of %s: '%s'",
1724 (long) (n_per_buf
* fill_size
)),
1725 (long) (n_per_buf
* fill_size
),
1726 bfd_section_name (sec
),
1727 bfd_get_filename (stdoutput
),
1728 bfd_errmsg (bfd_get_error ()));
1729 offset
+= n_per_buf
* fill_size
;
1737 merge_data_into_text (void)
1739 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1740 seg_info (data_section
)->frchainP
->frch_root
;
1741 seg_info (text_section
)->frchainP
->frch_last
=
1742 seg_info (data_section
)->frchainP
->frch_last
;
1743 seg_info (data_section
)->frchainP
= 0;
1754 /* Count symbols. We can't rely on a count made by the loop in
1755 write_object_file, because *_frob_file may add a new symbol or
1756 two. Generate unused section symbols only if needed. */
1758 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1759 if (bfd_keep_unused_section_symbols (stdoutput
)
1760 || !symbol_section_p (symp
)
1761 || symbol_used_in_reloc_p (symp
))
1767 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1769 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1770 symp
= symbol_rootP
;
1771 for (i
= 0; i
< nsyms
; symp
= symbol_next (symp
))
1772 if (bfd_keep_unused_section_symbols (stdoutput
)
1773 || !symbol_section_p (symp
)
1774 || symbol_used_in_reloc_p (symp
))
1776 asympp
[i
] = symbol_get_bfdsym (symp
);
1777 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1778 || !(bfd_is_const_section (asympp
[i
]->section
)
1779 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1780 asympp
[i
]->flags
|= BSF_KEEP
;
1781 symbol_mark_written (symp
);
1782 /* Include this section symbol in the symbol table. */
1783 if (symbol_section_p (symp
))
1784 asympp
[i
]->flags
|= BSF_SECTION_SYM_USED
;
1790 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1791 gas_assert (result
);
1792 symbol_table_frozen
= 1;
1795 /* Finish the subsegments. After every sub-segment, we fake an
1796 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1797 ".fill 0" because that is the kind of frag that requires least
1798 thought. ".align" frags like to have a following frag since that
1799 makes calculating their intended length trivial. */
1801 #ifndef SUB_SEGMENT_ALIGN
1803 /* The last subsegment gets an alignment corresponding to the alignment
1804 of the section. This allows proper nop-filling at the end of
1805 code-bearing sections. */
1806 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1807 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1808 && !do_not_pad_sections_to_alignment \
1809 ? get_recorded_alignment (SEG) \
1812 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1817 subsegs_finish_section (asection
*s
)
1819 struct frchain
*frchainP
;
1820 segment_info_type
*seginfo
= seg_info (s
);
1824 for (frchainP
= seginfo
->frchainP
;
1826 frchainP
= frchainP
->frch_next
)
1830 subseg_set (s
, frchainP
->frch_subseg
);
1832 /* This now gets called even if we had errors. In that case,
1833 any alignment is meaningless, and, moreover, will look weird
1834 if we are generating a listing. */
1836 do_not_pad_sections_to_alignment
= 1;
1838 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1839 if ((bfd_section_flags (now_seg
) & SEC_MERGE
)
1840 && now_seg
->entsize
)
1842 unsigned int entsize
= now_seg
->entsize
;
1845 while ((entsize
& 1) == 0)
1851 if (entalign
> alignment
)
1852 alignment
= entalign
;
1855 if (subseg_text_p (now_seg
))
1856 frag_align_code (alignment
, 0);
1858 frag_align (alignment
, 0, 0);
1860 /* frag_align will have left a new frag.
1861 Use this last frag for an empty ".fill".
1863 For this segment ...
1864 Create a last frag. Do not leave a "being filled in frag". */
1865 frag_wane (frag_now
);
1866 frag_now
->fr_fix
= 0;
1867 know (frag_now
->fr_next
== NULL
);
1872 subsegs_finish (void)
1876 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1877 subsegs_finish_section (s
);
1882 create_obj_attrs_section (void)
1889 size
= bfd_elf_obj_attr_size (stdoutput
);
1893 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1895 name
= ".gnu.attributes";
1896 s
= subseg_new (name
, 0);
1897 elf_section_type (s
)
1898 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1899 bfd_set_section_flags (s
, SEC_READONLY
| SEC_DATA
);
1901 p
= frag_more (size
);
1902 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1904 subsegs_finish_section (s
);
1905 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1906 size_seg (stdoutput
, s
, NULL
);
1909 /* Create a relocation against an entry in a GNU Build attribute section. */
1912 create_note_reloc (segT sec
,
1914 bfd_size_type note_offset
,
1915 bfd_size_type desc2_offset
,
1921 struct reloc_list
* reloc
;
1923 reloc
= XNEW (struct reloc_list
);
1925 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
1926 reloc
->u
.b
.sec
= sec
;
1927 reloc
->u
.b
.s
= symbol_get_bfdsym (sym
);
1928 reloc
->u
.b
.r
.sym_ptr_ptr
= & reloc
->u
.b
.s
;
1929 reloc
->u
.b
.r
.address
= note_offset
+ desc2_offset
;
1930 reloc
->u
.b
.r
.addend
= addend
;
1931 reloc
->u
.b
.r
.howto
= bfd_reloc_type_lookup (stdoutput
, reloc_type
);
1933 if (reloc
->u
.b
.r
.howto
== NULL
)
1935 as_bad (_("unable to create reloc for build note"));
1939 reloc
->file
= N_("<gnu build note>");
1942 reloc
->next
= reloc_list
;
1945 /* For REL relocs, store the addend in the section. */
1946 if (! sec
->use_rela_p
1947 /* The SH target is a special case that uses RELA relocs
1948 but still stores the addend in the word being relocated. */
1949 || strstr (bfd_get_target (stdoutput
), "-sh") != NULL
)
1953 /* Zero out the addend, since it is now stored in the note. */
1954 reloc
->u
.b
.r
.addend
= 0;
1956 if (target_big_endian
)
1958 for (i
= desc2_size
; addend
!= 0 && i
> 0; addend
>>= 8, i
--)
1959 note
[desc2_offset
+ i
- 1] = (addend
& 0xff);
1963 for (i
= 0; addend
!= 0 && i
< desc2_size
; addend
>>= 8, i
++)
1964 note
[desc2_offset
+ i
] = (addend
& 0xff);
1970 maybe_generate_build_notes (void)
1977 offsetT desc2_offset
;
1982 if (! flag_generate_build_notes
1983 || bfd_get_section_by_name (stdoutput
,
1984 GNU_BUILD_ATTRS_SECTION_NAME
) != NULL
)
1987 /* Create a GNU Build Attribute section. */
1988 sec
= subseg_new (GNU_BUILD_ATTRS_SECTION_NAME
, false);
1989 elf_section_type (sec
) = SHT_NOTE
;
1990 bfd_set_section_flags (sec
, (SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_DATA
1992 bfd_set_section_alignment (sec
, 2);
1994 /* Work out the size of the notes that we will create,
1995 and the relocation we should use. */
1996 if (bfd_arch_bits_per_address (stdoutput
) <= 32)
1999 desc_size
= 8; /* Two 4-byte offsets. */
2002 /* FIXME: The BFD backend for the CRX target does not support the
2003 BFD_RELOC_32, even though it really should. Likewise for the
2004 CR16 target. So we have special case code here... */
2005 if (strstr (bfd_get_target (stdoutput
), "-crx") != NULL
)
2006 desc_reloc
= BFD_RELOC_CRX_NUM32
;
2007 else if (strstr (bfd_get_target (stdoutput
), "-cr16") != NULL
)
2008 desc_reloc
= BFD_RELOC_CR16_NUM32
;
2010 desc_reloc
= BFD_RELOC_32
;
2015 desc_size
= 16; /* Two 8-byte offsets. */
2017 /* FIXME: The BFD backend for the IA64 target does not support the
2018 BFD_RELOC_64, even though it really should. The HPPA backend
2019 has a similar issue, although it does not support BFD_RELOCs at
2020 all! So we have special case code to handle these targets. */
2021 if (strstr (bfd_get_target (stdoutput
), "-ia64") != NULL
)
2022 desc_reloc
= target_big_endian
? BFD_RELOC_IA64_DIR32MSB
: BFD_RELOC_IA64_DIR32LSB
;
2023 else if (strstr (bfd_get_target (stdoutput
), "-hppa") != NULL
)
2024 desc_reloc
= 80; /* R_PARISC_DIR64. */
2026 desc_reloc
= BFD_RELOC_64
;
2029 /* We have to create a note for *each* code section.
2030 Linker garbage collection might discard some. */
2034 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
2035 if ((bsym
= symbol_get_bfdsym (sym
)) != NULL
2036 && bsym
->flags
& BSF_SECTION_SYM
2037 && bsym
->section
!= NULL
2038 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
2039 && (bsym
->section
->flags
& (SEC_CODE
| SEC_LINK_ONCE
)) == SEC_CODE
2040 /* Not all linkonce sections are flagged... */
2041 && !startswith (S_GET_NAME (sym
), ".gnu.linkonce"))
2043 /* Create a version note. */
2045 note
= frag_more (note_size
);
2046 memset (note
, 0, note_size
);
2048 if (target_big_endian
)
2050 note
[3] = 8; /* strlen (name) + 1. */
2051 note
[7] = desc_size
; /* Two N-byte offsets. */
2052 note
[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2053 note
[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2057 note
[0] = 8; /* strlen (name) + 1. */
2058 note
[4] = desc_size
; /* Two N-byte offsets. */
2059 note
[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2060 note
[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2063 /* The a1 version number indicates that this note was
2064 generated by the assembler and not the gcc annobin plugin. */
2065 memcpy (note
+ 12, "GA$\ 13a1", 8);
2067 /* Create a relocation to install the start address of the note... */
2068 create_note_reloc (sec
, sym
, total_size
, 20, desc_size
/ 2, desc_reloc
, 0, note
);
2070 /* ...and another one to install the end address. */
2071 create_note_reloc (sec
, sym
, total_size
, desc2_offset
,
2074 bfd_section_size (bsym
->section
),
2077 /* Mark the section symbol used in relocation so that it will be
2078 included in the symbol table. */
2079 symbol_mark_used_in_reloc (sym
);
2081 total_size
+= note_size
;
2082 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2085 /* Install the note(s) into the section. */
2087 bfd_set_section_contents (stdoutput
, sec
, (bfd_byte
*) note
, 0, total_size
);
2088 subsegs_finish_section (sec
);
2089 relax_segment (seg_info (sec
)->frchainP
->frch_root
, sec
, 0);
2090 size_seg (stdoutput
, sec
, NULL
);
2092 #endif /* OBJ_ELF */
2094 /* Write the object file. */
2097 write_object_file (void)
2099 struct relax_seg_info rsi
;
2100 #ifndef WORKING_DOT_WORD
2101 fragS
*fragP
; /* Track along all frags. */
2106 #ifdef md_pre_output_hook
2110 #ifdef md_pre_relax_hook
2114 /* From now on, we don't care about sub-segments. Build one frag chain
2115 for each segment. Linked through fr_next. */
2117 /* Remove the sections created by gas for its own purposes. */
2121 bfd_section_list_remove (stdoutput
, reg_section
);
2122 bfd_section_list_remove (stdoutput
, expr_section
);
2123 stdoutput
->section_count
-= 2;
2125 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
2128 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
2130 /* We have two segments. If user gave -R flag, then we must put the
2131 data frags into the text segment. Do this before relaxing so
2132 we know to take advantage of -R and make shorter addresses. */
2133 if (flag_readonly_data_in_text
)
2135 merge_data_into_text ();
2141 #ifndef WORKING_DOT_WORD
2142 /* We need to reset the markers in the broken word list and
2143 associated frags between calls to relax_segment (via
2144 relax_seg). Since the broken word list is global, we do it
2145 once per round, rather than locally in relax_segment for each
2147 struct broken_word
*brokp
;
2149 for (brokp
= broken_words
;
2150 brokp
!= (struct broken_word
*) NULL
;
2151 brokp
= brokp
->next_broken_word
)
2155 if (brokp
->dispfrag
!= (fragS
*) NULL
2156 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
2157 brokp
->dispfrag
->fr_subtype
= 0;
2162 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
2168 /* Note - Most ports will use the default value of
2169 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2170 local symbols to be resolved, removing their frag information.
2171 Some ports however, will not have finished relaxing all of
2172 their frags and will still need the local symbol frag
2173 information. These ports can set
2174 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2175 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
2177 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
2179 /* Relaxation has completed. Freeze all syms. */
2182 dwarf2dbg_final_check ();
2184 #ifdef md_post_relax_hook
2190 create_obj_attrs_section ();
2193 #ifndef WORKING_DOT_WORD
2195 struct broken_word
*lie
;
2196 struct broken_word
**prevP
;
2198 prevP
= &broken_words
;
2199 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
2204 subseg_change (lie
->seg
, lie
->subseg
);
2205 exp
.X_op
= O_subtract
;
2206 exp
.X_add_symbol
= lie
->add
;
2207 exp
.X_op_symbol
= lie
->sub
;
2208 exp
.X_add_number
= lie
->addnum
;
2209 #ifdef TC_CONS_FIX_NEW
2210 TC_CONS_FIX_NEW (lie
->frag
,
2211 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2212 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
2214 fix_new_exp (lie
->frag
,
2215 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2216 2, &exp
, 0, BFD_RELOC_16
);
2218 *prevP
= lie
->next_broken_word
;
2221 prevP
= &(lie
->next_broken_word
);
2223 for (lie
= broken_words
; lie
;)
2225 struct broken_word
*untruth
;
2227 addressT table_addr
;
2228 addressT from_addr
, to_addr
;
2231 subseg_change (lie
->seg
, lie
->subseg
);
2232 fragP
= lie
->dispfrag
;
2234 /* Find out how many broken_words go here. */
2237 untruth
&& untruth
->dispfrag
== fragP
;
2238 untruth
= untruth
->next_broken_word
)
2239 if (untruth
->added
== 1)
2242 table_ptr
= lie
->dispfrag
->fr_opcode
;
2243 table_addr
= (lie
->dispfrag
->fr_address
2244 + (table_ptr
- lie
->dispfrag
->fr_literal
));
2245 /* Create the jump around the long jumps. This is a short
2246 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2247 from_addr
= table_addr
;
2248 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
2249 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2251 table_ptr
+= md_short_jump_size
;
2252 table_addr
+= md_short_jump_size
;
2255 lie
&& lie
->dispfrag
== fragP
;
2256 m
++, lie
= lie
->next_broken_word
)
2258 if (lie
->added
== 2)
2260 /* Patch the jump table. */
2261 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2262 untruth
&& untruth
->dispfrag
== fragP
;
2263 untruth
= untruth
->next_broken_word
)
2265 if (untruth
->use_jump
== lie
)
2267 /* This is the offset from ??? to table_ptr+0.
2268 The target is the same for all users of this
2269 md_long_jump, but the "sub" bases (and hence the
2270 offsets) may be different. */
2271 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
2272 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2273 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
2275 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2279 /* Install the long jump. */
2280 /* This is a long jump from table_ptr+0 to the final target. */
2281 from_addr
= table_addr
;
2282 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2283 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2285 table_ptr
+= md_long_jump_size
;
2286 table_addr
+= md_long_jump_size
;
2290 #endif /* not WORKING_DOT_WORD */
2292 /* Resolve symbol values. This needs to be done before processing
2298 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2299 resolve_symbol_value (symp
);
2301 resolve_local_symbol_values ();
2302 resolve_reloc_expr_symbols ();
2306 maybe_generate_build_notes ();
2311 #ifdef tc_frob_file_before_adjust
2312 tc_frob_file_before_adjust ();
2314 #ifdef obj_frob_file_before_adjust
2315 obj_frob_file_before_adjust ();
2318 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2320 #ifdef tc_frob_file_before_fix
2321 tc_frob_file_before_fix ();
2323 #ifdef obj_frob_file_before_fix
2324 obj_frob_file_before_fix ();
2327 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2329 /* Set up symbol table, and write it out. */
2333 bool skip_next_symbol
= false;
2335 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2340 if (skip_next_symbol
)
2342 /* Don't do anything besides moving the value of the
2343 symbol from the GAS value-field to the BFD value-field. */
2344 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2345 skip_next_symbol
= false;
2349 if (symbol_mri_common_p (symp
))
2351 if (S_IS_EXTERNAL (symp
))
2352 as_bad (_("%s: global symbols not supported in common sections"),
2354 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2358 name
= S_GET_NAME (symp
);
2362 decode_local_label_name ((char *) S_GET_NAME (symp
));
2363 /* They only differ if `name' is a fb or dollar local
2365 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2366 as_bad (_("local label `%s' is not defined"), name2
);
2369 /* Do it again, because adjust_reloc_syms might introduce
2370 more symbols. They'll probably only be section symbols,
2371 but they'll still need to have the values computed. */
2372 resolve_symbol_value (symp
);
2374 /* Skip symbols which were equated to undefined or common
2376 if (symbol_equated_reloc_p (symp
)
2377 || S_IS_WEAKREFR (symp
))
2379 const char *sname
= S_GET_NAME (symp
);
2381 if (S_IS_COMMON (symp
)
2382 && !TC_FAKE_LABEL (sname
)
2383 && !S_IS_WEAKREFR (symp
))
2385 expressionS
*e
= symbol_get_value_expression (symp
);
2387 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2388 sname
, S_GET_NAME (e
->X_add_symbol
));
2390 if (S_GET_SEGMENT (symp
) == reg_section
)
2392 /* Report error only if we know the symbol name. */
2393 if (S_GET_NAME (symp
) != reg_section
->name
)
2394 as_bad (_("can't make global register symbol `%s'"),
2397 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2401 #ifdef obj_frob_symbol
2402 obj_frob_symbol (symp
, punt
);
2404 #ifdef tc_frob_symbol
2405 if (! punt
|| symbol_used_in_reloc_p (symp
))
2406 tc_frob_symbol (symp
, punt
);
2409 /* If we don't want to keep this symbol, splice it out of
2410 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2411 want section symbols. Otherwise, we skip local symbols
2412 and symbols that the frob_symbol macros told us to punt,
2413 but we keep such symbols if they are used in relocs. */
2414 if (symp
== abs_section_sym
2415 || (! EMIT_SECTION_SYMBOLS
2416 && symbol_section_p (symp
))
2417 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2418 opposites. Sometimes the former checks flags and the
2419 latter examines the name... */
2420 || (!S_IS_EXTERNAL (symp
)
2421 && (punt
|| S_IS_LOCAL (symp
) ||
2422 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2423 && ! symbol_used_in_reloc_p (symp
)))
2425 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2427 /* After symbol_remove, symbol_next(symp) still returns
2428 the one that came after it in the chain. So we don't
2429 need to do any extra cleanup work here. */
2433 /* Make sure we really got a value for the symbol. */
2434 if (! symbol_resolved_p (symp
))
2436 as_bad (_("can't resolve value for symbol `%s'"),
2438 symbol_mark_resolved (symp
);
2441 /* Set the value into the BFD symbol. Up til now the value
2442 has only been kept in the gas symbolS struct. */
2443 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2445 /* A warning construct is a warning symbol followed by the
2446 symbol warned about. Don't let anything object-format or
2447 target-specific muck with it; it's ready for output. */
2448 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2449 skip_next_symbol
= true;
2455 /* Now do any format-specific adjustments to the symbol table, such
2456 as adding file symbols. */
2457 #ifdef tc_adjust_symtab
2458 tc_adjust_symtab ();
2460 #ifdef obj_adjust_symtab
2461 obj_adjust_symtab ();
2464 /* Stop if there is an error. */
2465 if (!flag_always_generate_output
&& had_errors ())
2468 /* Now that all the sizes are known, and contents correct, we can
2469 start writing to the file. */
2472 /* If *_frob_file changes the symbol value at this point, it is
2473 responsible for moving the changed value into symp->bsym->value
2474 as well. Hopefully all symbol value changing can be done in
2479 #ifdef obj_frob_file
2482 #ifdef obj_coff_generate_pdata
2483 obj_coff_generate_pdata ();
2486 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2488 #ifdef tc_frob_file_after_relocs
2489 tc_frob_file_after_relocs ();
2491 #ifdef obj_frob_file_after_relocs
2492 obj_frob_file_after_relocs ();
2495 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2496 if (IS_ELF
&& flag_use_elf_stt_common
)
2497 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2500 /* Once all relocations have been written, we can compress the
2501 contents of the debug sections. This needs to be done before
2502 we start writing any sections, because it will affect the file
2503 layout, which is fixed once we start writing contents. */
2504 if (flag_compress_debug
)
2506 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2507 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2509 stdoutput
->flags
|= BFD_COMPRESS
;
2510 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2513 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2516 #ifdef TC_GENERIC_RELAX_TABLE
2517 #ifndef md_generic_table_relax_frag
2518 #define md_generic_table_relax_frag relax_frag
2521 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2524 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2526 const relax_typeS
*this_type
;
2527 const relax_typeS
*start_type
;
2528 relax_substateT next_state
;
2529 relax_substateT this_state
;
2535 const relax_typeS
*table
;
2537 target
= fragP
->fr_offset
;
2538 address
= fragP
->fr_address
+ fragP
->fr_fix
;
2539 table
= TC_GENERIC_RELAX_TABLE
;
2540 this_state
= fragP
->fr_subtype
;
2541 start_type
= this_type
= table
+ this_state
;
2542 symbolP
= fragP
->fr_symbol
;
2548 sym_frag
= symbol_get_frag (symbolP
);
2550 #ifndef DIFF_EXPR_OK
2551 know (sym_frag
!= NULL
);
2553 know (S_GET_SEGMENT (symbolP
) != absolute_section
2554 || sym_frag
== &zero_address_frag
);
2555 target
+= S_GET_VALUE (symbolP
);
2557 /* If SYM_FRAG has yet to be reached on this pass, assume it
2558 will move by STRETCH just as we did, unless there is an
2559 alignment frag between here and SYM_FRAG. An alignment may
2560 well absorb any STRETCH, and we don't want to choose a larger
2561 branch insn by overestimating the needed reach of this
2562 branch. It isn't critical to calculate TARGET exactly; We
2563 know we'll be doing another pass if STRETCH is non-zero. */
2566 && sym_frag
->relax_marker
!= fragP
->relax_marker
2567 && S_GET_SEGMENT (symbolP
) == segment
)
2570 || sym_frag
->region
== fragP
->region
)
2572 /* If we get here we know we have a forward branch. This
2573 relax pass may have stretched previous instructions so
2574 far that omitting STRETCH would make the branch
2575 negative. Don't allow this in case the negative reach is
2576 large enough to require a larger branch instruction. */
2577 else if (target
< address
)
2582 aim
= target
- address
;
2583 #ifdef TC_PCREL_ADJUST
2584 /* Currently only the ns32k and arc needs this. */
2585 aim
+= TC_PCREL_ADJUST (fragP
);
2588 #ifdef md_prepare_relax_scan
2589 /* Formerly called M68K_AIM_KLUDGE. */
2590 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2595 /* Look backwards. */
2596 for (next_state
= this_type
->rlx_more
; next_state
;)
2597 if (aim
>= this_type
->rlx_backward
)
2601 /* Grow to next state. */
2602 this_state
= next_state
;
2603 this_type
= table
+ this_state
;
2604 next_state
= this_type
->rlx_more
;
2609 /* Look forwards. */
2610 for (next_state
= this_type
->rlx_more
; next_state
;)
2611 if (aim
<= this_type
->rlx_forward
)
2615 /* Grow to next state. */
2616 this_state
= next_state
;
2617 this_type
= table
+ this_state
;
2618 next_state
= this_type
->rlx_more
;
2622 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2624 fragP
->fr_subtype
= this_state
;
2628 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2630 /* Relax_align. Advance location counter to next address that has 'alignment'
2631 lowest order bits all 0s, return size of adjustment made. */
2632 static relax_addressT
2633 relax_align (relax_addressT address
, /* Address now. */
2634 int alignment
/* Alignment (binary). */)
2636 relax_addressT mask
;
2637 relax_addressT new_address
;
2639 mask
= ~((relax_addressT
) ~0 << alignment
);
2640 new_address
= (address
+ mask
) & (~mask
);
2641 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2643 /* We must provide lots of padding, so the linker can discard it
2644 when needed. The linker will not add extra space, ever. */
2645 new_address
+= (1 << alignment
);
2647 return (new_address
- address
);
2650 /* Now we have a segment, not a crowd of sub-segments, we can make
2655 After this, all frags in this segment have addresses that are correct
2656 within the segment. Since segments live in different file addresses,
2657 these frag addresses may not be the same as final object-file
2661 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2663 unsigned long frag_count
;
2665 relax_addressT address
;
2669 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2670 subseg_change (segment
, 0);
2672 /* For each frag in segment: count and store (a 1st guess of)
2676 for (frag_count
= 0, fragP
= segment_frag_root
;
2678 fragP
= fragP
->fr_next
, frag_count
++)
2680 fragP
->region
= region
;
2681 fragP
->relax_marker
= 0;
2682 fragP
->fr_address
= address
;
2683 address
+= fragP
->fr_fix
;
2685 switch (fragP
->fr_type
)
2688 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2695 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2697 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2700 if (offset
% fragP
->fr_var
!= 0)
2702 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2703 ngettext ("alignment padding (%lu byte) "
2704 "not a multiple of %ld",
2705 "alignment padding (%lu bytes) "
2706 "not a multiple of %ld",
2707 (unsigned long) offset
),
2708 (unsigned long) offset
, (long) fragP
->fr_var
);
2709 offset
-= (offset
% fragP
->fr_var
);
2718 /* Assume .org is nugatory. It will grow with 1st relax. */
2726 case rs_machine_dependent
:
2727 /* If fr_symbol is an expression, this call to
2728 resolve_symbol_value sets up the correct segment, which will
2729 likely be needed in md_estimate_size_before_relax. */
2730 if (fragP
->fr_symbol
)
2731 resolve_symbol_value (fragP
->fr_symbol
);
2733 address
+= md_estimate_size_before_relax (fragP
, segment
);
2736 #ifndef WORKING_DOT_WORD
2737 /* Broken words don't concern us yet. */
2738 case rs_broken_word
:
2743 /* Initial guess is always 1; doing otherwise can result in
2744 stable solutions that are larger than the minimum. */
2745 address
+= fragP
->fr_offset
= 1;
2749 address
+= eh_frame_estimate_size_before_relax (fragP
);
2753 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2757 BAD_CASE (fragP
->fr_type
);
2764 unsigned long max_iterations
;
2766 /* Cumulative address adjustment. */
2769 /* Have we made any adjustment this pass? We can't just test
2770 stretch because one piece of code may have grown and another
2774 /* Most horrible, but gcc may give us some exception data that
2775 is impossible to assemble, of the form
2779 .uleb128 end - start
2785 If the leb128 is two bytes in size, then end-start is 128*128,
2786 which requires a three byte leb128. If the leb128 is three
2787 bytes in size, then end-start is 128*128-1, which requires a
2788 two byte leb128. We work around this dilemma by inserting
2789 an extra 4 bytes of alignment just after the .align. This
2790 works because the data after the align is accessed relative to
2793 This counter is used in a tiny state machine to detect
2794 whether a leb128 followed by an align is impossible to
2796 int rs_leb128_fudge
= 0;
2798 /* We want to prevent going into an infinite loop where one frag grows
2799 depending upon the location of a symbol which is in turn moved by
2800 the growing frag. eg:
2806 So we dictate that this algorithm can be at most O2. */
2807 max_iterations
= frag_count
* frag_count
;
2808 /* Check for overflow. */
2809 if (max_iterations
< frag_count
)
2810 max_iterations
= frag_count
;
2818 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2821 addressT was_address
;
2825 fragP
->relax_marker
^= 1;
2826 was_address
= fragP
->fr_address
;
2827 address
= fragP
->fr_address
+= stretch
;
2828 symbolP
= fragP
->fr_symbol
;
2829 offset
= fragP
->fr_offset
;
2831 switch (fragP
->fr_type
)
2833 case rs_fill
: /* .fill never relaxes. */
2837 #ifndef WORKING_DOT_WORD
2838 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2839 for it I do not want to write it. I do not want to have
2840 anything to do with it. This is not the proper way to
2841 implement this misfeature. */
2842 case rs_broken_word
:
2844 struct broken_word
*lie
;
2845 struct broken_word
*untruth
;
2847 /* Yes this is ugly (storing the broken_word pointer
2848 in the symbol slot). Still, this whole chunk of
2849 code is ugly, and I don't feel like doing anything
2850 about it. Think of it as stubbornness in action. */
2852 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2853 lie
&& lie
->dispfrag
== fragP
;
2854 lie
= lie
->next_broken_word
)
2860 offset
= (S_GET_VALUE (lie
->add
)
2862 - S_GET_VALUE (lie
->sub
));
2863 if (offset
<= -32768 || offset
>= 32767)
2865 if (flag_warn_displacement
)
2868 sprint_value (buf
, (addressT
) lie
->addnum
);
2869 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2870 _(".word %s-%s+%s didn't fit"),
2871 S_GET_NAME (lie
->add
),
2872 S_GET_NAME (lie
->sub
),
2875 if (fragP
->fr_subtype
== 0)
2877 fragP
->fr_subtype
++;
2878 growth
+= md_short_jump_size
;
2881 /* Redirect *all* words of this table with the same
2882 target, lest we have to handle the case where the
2883 same target but with a offset that fits on this
2884 round overflows at the next relaxation round. */
2885 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2886 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2887 untruth
= untruth
->next_broken_word
)
2888 if ((symbol_get_frag (untruth
->add
)
2889 == symbol_get_frag (lie
->add
))
2890 && (S_GET_VALUE (untruth
->add
)
2891 == S_GET_VALUE (lie
->add
)))
2894 untruth
->use_jump
= lie
;
2898 growth
+= md_long_jump_size
;
2903 } /* case rs_broken_word */
2909 addressT oldoff
, newoff
;
2911 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2913 newoff
= relax_align (address
+ fragP
->fr_fix
,
2916 if (fragP
->fr_subtype
!= 0)
2918 if (oldoff
> fragP
->fr_subtype
)
2920 if (newoff
> fragP
->fr_subtype
)
2924 growth
= newoff
- oldoff
;
2926 /* If this align happens to follow a leb128 and
2927 we have determined that the leb128 is bouncing
2928 in size, then break the cycle by inserting an
2931 && (rs_leb128_fudge
& 16) != 0
2932 && (rs_leb128_fudge
& 15) >= 2)
2934 segment_info_type
*seginfo
= seg_info (segment
);
2935 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2938 newf
= frag_alloc (ob
);
2939 obstack_blank_fast (ob
, fragP
->fr_var
);
2940 obstack_finish (ob
);
2941 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2942 memcpy (newf
->fr_literal
,
2943 fragP
->fr_literal
+ fragP
->fr_fix
,
2945 newf
->fr_type
= rs_fill
;
2946 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2948 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2950 if (newf
->fr_offset
* newf
->fr_var
2951 != (offsetT
) 1 << fragP
->fr_offset
)
2953 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2956 /* Include size of new frag in GROWTH. */
2957 growth
+= newf
->fr_offset
* newf
->fr_var
;
2958 /* Adjust the new frag address for the amount
2959 we'll add when we process the new frag. */
2960 newf
->fr_address
-= stretch
+ growth
;
2961 newf
->relax_marker
^= 1;
2962 fragP
->fr_next
= newf
;
2964 as_warn (_("padding added"));
2972 offsetT target
= offset
;
2977 /* Convert from an actual address to an octet offset
2978 into the section. Here it is assumed that the
2979 section's VMA is zero, and can omit subtracting it
2980 from the symbol's value to get the address offset. */
2981 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2982 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2985 know (fragP
->fr_next
);
2986 after
= fragP
->fr_next
->fr_address
+ stretch
;
2987 growth
= target
- after
;
2989 /* Growth may be negative, but variable part of frag
2990 cannot have fewer than 0 chars. That is, we can't
2992 if ((offsetT
) (address
+ fragP
->fr_fix
) > target
)
2996 /* Don't error on first few frag relax passes.
2997 The symbol might be an expression involving
2998 symbol values from other sections. If those
2999 sections have not yet been processed their
3000 frags will all have zero addresses, so we
3001 will calculate incorrect values for them. The
3002 number of passes we allow before giving an
3003 error is somewhat arbitrary. It should be at
3004 least one, with larger values requiring
3005 increasingly contrived dependencies between
3006 frags to trigger a false error. */
3009 /* Force another pass. */
3014 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3015 _("attempt to move .org backwards"));
3017 /* We've issued an error message. Change the
3018 frag to avoid cascading errors. */
3019 fragP
->fr_type
= rs_align
;
3020 fragP
->fr_subtype
= 0;
3021 fragP
->fr_offset
= 0;
3022 fragP
->fr_fix
= after
- address
;
3034 amount
= S_GET_VALUE (symbolP
);
3035 if (S_GET_SEGMENT (symbolP
) != absolute_section
3036 || S_IS_COMMON (symbolP
)
3037 || ! S_IS_DEFINED (symbolP
))
3039 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3040 _(".space, .nops or .fill specifies non-absolute value"));
3041 /* Prevent repeat of this error message. */
3042 fragP
->fr_symbol
= 0;
3044 else if (amount
< 0)
3046 /* Don't error on first few frag relax passes.
3047 See rs_org comment for a longer explanation. */
3054 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3055 _(".space, .nops or .fill with negative value, ignored"));
3056 fragP
->fr_symbol
= 0;
3059 growth
= (was_address
+ fragP
->fr_fix
+ amount
3060 - fragP
->fr_next
->fr_address
);
3064 case rs_machine_dependent
:
3065 #ifdef md_relax_frag
3066 growth
= md_relax_frag (segment
, fragP
, stretch
);
3068 #ifdef TC_GENERIC_RELAX_TABLE
3069 /* The default way to relax a frag is to look through
3070 TC_GENERIC_RELAX_TABLE. */
3071 growth
= md_generic_table_relax_frag (segment
, fragP
,
3073 #endif /* TC_GENERIC_RELAX_TABLE */
3082 value
= resolve_symbol_value (fragP
->fr_symbol
);
3083 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
3084 growth
= size
- fragP
->fr_offset
;
3085 fragP
->fr_offset
= size
;
3090 growth
= eh_frame_relax_frag (fragP
);
3094 growth
= dwarf2dbg_relax_frag (fragP
);
3098 BAD_CASE (fragP
->fr_type
);
3105 if (fragP
->fr_type
== rs_leb128
)
3106 rs_leb128_fudge
+= 16;
3107 else if (fragP
->fr_type
== rs_align
3108 && (rs_leb128_fudge
& 16) != 0
3110 rs_leb128_fudge
+= 16;
3112 rs_leb128_fudge
= 0;
3117 && (rs_leb128_fudge
& 16) == 0
3118 && (rs_leb128_fudge
& -16) != 0)
3119 rs_leb128_fudge
+= 1;
3121 rs_leb128_fudge
= 0;
3123 /* Until nothing further to relax. */
3124 while (stretched
&& -- max_iterations
);
3127 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3128 segment_name (segment
));
3131 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3132 if (fragP
->last_fr_address
!= fragP
->fr_address
)
3134 fragP
->last_fr_address
= fragP
->fr_address
;
3141 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
3147 buf
[n
] = val
& 0xff;
3153 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
3159 *buf
++ = val
& 0xff;
3165 write_print_statistics (FILE *file
)
3167 fprintf (file
, "fixups: %d\n", n_fixups
);
3170 /* For debugging. */
3171 extern int indent_level
;
3174 print_fixup (fixS
*fixp
)
3177 fprintf (stderr
, "fix ");
3178 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
3179 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
3181 fprintf (stderr
, " pcrel");
3182 if (fixp
->fx_pcrel_adjust
)
3183 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
3185 fprintf (stderr
, " tcbit");
3187 fprintf (stderr
, " done");
3188 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
3189 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
3190 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
3191 (long) fixp
->fx_where
,
3192 (unsigned long) fixp
->fx_offset
,
3193 (unsigned long) fixp
->fx_addnumber
);
3194 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
3198 fprintf (stderr
, "\n +<");
3199 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
3200 fprintf (stderr
, ">");
3204 fprintf (stderr
, "\n -<");
3205 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3206 fprintf (stderr
, ">");
3208 fprintf (stderr
, "\n");
3209 #ifdef TC_FIX_DATA_PRINT
3210 TC_FIX_DATA_PRINT (stderr
, fixp
);