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
)
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
)
955 segT add_symbol_segment
= absolute_section
;
958 fprintf (stderr
, "\nprocessing fixup:\n");
962 fragP
= fixP
->fx_frag
;
964 #ifdef TC_VALIDATE_FIX
965 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
967 add_number
= fixP
->fx_offset
;
969 if (fixP
->fx_addsy
!= NULL
)
970 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
972 if (fixP
->fx_subsy
!= NULL
)
974 segT sub_symbol_segment
;
975 resolve_symbol_value (fixP
->fx_subsy
);
976 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
977 if (fixP
->fx_addsy
!= NULL
978 && sub_symbol_segment
== add_symbol_segment
979 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
980 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
981 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
983 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
984 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
985 fixP
->fx_offset
= add_number
;
986 fixP
->fx_addsy
= NULL
;
987 fixP
->fx_subsy
= NULL
;
989 /* See the comment below about 68k weirdness. */
993 else if (sub_symbol_segment
== absolute_section
994 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
995 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
997 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
998 fixP
->fx_offset
= add_number
;
999 fixP
->fx_subsy
= NULL
;
1001 else if (sub_symbol_segment
== this_segment
1002 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
1003 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
1005 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1006 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
1007 + fixP
->fx_dot_frag
->fr_address
);
1009 /* Make it pc-relative. If the back-end code has not
1010 selected a pc-relative reloc, cancel the adjustment
1011 we do later on all pc-relative relocs. */
1014 /* Do this for m68k even if it's already described
1015 as pc-relative. On the m68k, an operand of
1016 "pc@(foo-.-2)" should address "foo" in a
1017 pc-relative mode. */
1021 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1022 fixP
->fx_subsy
= NULL
;
1025 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1027 if (!md_register_arithmetic
1028 && (add_symbol_segment
== reg_section
1029 || sub_symbol_segment
== reg_section
))
1030 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1031 _("register value used as expression"));
1033 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1034 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1035 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1036 segment_name (add_symbol_segment
),
1037 S_GET_NAME (fixP
->fx_subsy
),
1038 segment_name (sub_symbol_segment
));
1040 else if (sub_symbol_segment
!= undefined_section
1041 && ! bfd_is_com_section (sub_symbol_segment
)
1042 && MD_APPLY_SYM_VALUE (fixP
))
1043 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1048 if (add_symbol_segment
== this_segment
1049 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1050 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1052 /* This fixup was made when the symbol's segment was
1053 SEG_UNKNOWN, but it is now in the local segment.
1054 So we know how to do the address without relocation. */
1055 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1056 fixP
->fx_offset
= add_number
;
1058 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1059 fixP
->fx_addsy
= NULL
;
1062 else if (add_symbol_segment
== absolute_section
1063 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1064 && !TC_FORCE_RELOCATION_ABS (fixP
))
1066 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1067 fixP
->fx_offset
= add_number
;
1068 fixP
->fx_addsy
= NULL
;
1070 else if (add_symbol_segment
!= undefined_section
1071 && ! bfd_is_com_section (add_symbol_segment
)
1072 && MD_APPLY_SYM_VALUE (fixP
))
1073 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1078 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1079 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1081 /* There was no symbol required by this relocation.
1082 However, BFD doesn't really handle relocations
1083 without symbols well. So fake up a local symbol in
1084 the absolute section. */
1085 fixP
->fx_addsy
= abs_section_sym
;
1090 md_apply_fix (fixP
, &add_number
, this_segment
);
1094 if (fixP
->fx_addsy
== NULL
)
1095 fixP
->fx_addsy
= abs_section_sym
;
1096 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1097 if (fixP
->fx_subsy
!= NULL
)
1098 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1101 if (!fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1103 if (fixP
->fx_size
< sizeof (valueT
))
1108 mask
--; /* Set all bits to one. */
1109 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1110 if ((add_number
& mask
) != 0
1112 ? (add_number
& mask
) != mask
1113 : (-add_number
& mask
) != 0))
1115 char buf
[50], buf2
[50];
1116 bfd_sprintf_vma (stdoutput
, buf
, fragP
->fr_address
+ fixP
->fx_where
);
1117 if (add_number
> 1000)
1118 bfd_sprintf_vma (stdoutput
, buf2
, add_number
);
1120 sprintf (buf2
, "%ld", (long) add_number
);
1121 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1122 ngettext ("value of %s too large for field "
1124 "value of %s too large for field "
1125 "of %d bytes at %s",
1127 buf2
, fixP
->fx_size
, buf
);
1128 } /* Generic error checking. */
1130 #ifdef WARN_SIGNED_OVERFLOW_WORD
1131 /* Warn if a .word value is too large when treated as a signed
1132 number. We already know it is not too negative. This is to
1133 catch over-large switches generated by gcc on the 68k. */
1134 if (!flag_signed_overflow_ok
1135 && fixP
->fx_size
== 2
1136 && add_number
> 0x7fff)
1137 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1138 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1140 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1144 #ifdef TC_VALIDATE_FIX
1145 skip
: ATTRIBUTE_UNUSED_LABEL
1149 fprintf (stderr
, "result:\n");
1152 } /* For each fixS in this segment. */
1156 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1158 void *xxx ATTRIBUTE_UNUSED
)
1160 segment_info_type
*seginfo
= seg_info (sec
);
1162 fixup_segment (seginfo
->fix_root
, sec
);
1166 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1167 const char *file
, unsigned int line
)
1170 bfd_reloc_status_type s
;
1173 if (reloc
->sym_ptr_ptr
!= NULL
1174 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1175 && (sym
->flags
& BSF_KEEP
) == 0
1176 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1177 || (EMIT_SECTION_SYMBOLS
1178 && !bfd_is_abs_section (sym
->section
))))
1179 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1181 s
= bfd_install_relocation (stdoutput
, reloc
,
1182 fragp
->fr_literal
, fragp
->fr_address
,
1188 case bfd_reloc_overflow
:
1189 as_bad_where (file
, line
, _("relocation overflow"));
1191 case bfd_reloc_outofrange
:
1192 as_bad_where (file
, line
, _("relocation out of range"));
1195 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1201 get_frag_for_reloc (fragS
*last_frag
,
1202 const segment_info_type
*seginfo
,
1203 const struct reloc_list
*r
)
1207 for (f
= last_frag
; 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 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1218 if (f
->fr_address
<= r
->u
.b
.r
.address
1219 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1222 as_bad_where (r
->file
, r
->line
,
1223 _("reloc not within (fixed part of) section"));
1228 write_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1229 void *xxx ATTRIBUTE_UNUSED
)
1231 segment_info_type
*seginfo
= seg_info (sec
);
1233 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1238 /* If seginfo is NULL, we did not create this section; don't do
1239 anything with it. */
1240 if (seginfo
== NULL
)
1244 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1248 #ifdef RELOC_EXPANSION_POSSIBLE
1249 n
*= MAX_RELOC_EXPANSION
;
1252 /* Extract relocs for this section from reloc_list. */
1255 my_reloc_list
= NULL
;
1256 while ((r
= *rp
) != NULL
)
1258 if (r
->u
.b
.sec
== sec
)
1261 r
->next
= my_reloc_list
;
1269 relocs
= XCNEWVEC (arelent
*, n
);
1274 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1279 #ifndef RELOC_EXPANSION_POSSIBLE
1288 fx_size
= fixp
->fx_size
;
1289 slack
= TC_FX_SIZE_SLACK (fixp
);
1291 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1292 loc
= fixp
->fx_where
+ fx_size
;
1293 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1294 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1295 _("internal error: fixup not contained within frag"));
1297 #ifndef RELOC_EXPANSION_POSSIBLE
1298 *reloc
= tc_gen_reloc (sec
, fixp
);
1300 reloc
= tc_gen_reloc (sec
, fixp
);
1305 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1307 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1311 relocs
[n
++] = &r
->u
.b
.r
;
1312 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1316 relocs
[n
++] = *reloc
;
1317 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1318 fixp
->fx_file
, fixp
->fx_line
);
1319 #ifndef RELOC_EXPANSION_POSSIBLE
1329 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1333 relocs
[n
++] = &r
->u
.b
.r
;
1334 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1341 unsigned int k
, j
, nsyms
;
1343 sympp
= bfd_get_outsymbols (stdoutput
);
1344 nsyms
= bfd_get_symcount (stdoutput
);
1345 for (k
= 0; k
< n
; k
++)
1346 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1348 for (j
= 0; j
< nsyms
; j
++)
1349 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1359 flagword flags
= bfd_section_flags (sec
);
1361 bfd_set_section_flags (sec
, flags
);
1362 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1365 #ifdef SET_SECTION_RELOCS
1366 SET_SECTION_RELOCS (sec
, relocs
, n
);
1373 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1374 for (k
= 0; k
< n
; k
++)
1376 arelent
*rel
= relocs
[k
];
1377 asymbol
*s
= *rel
->sym_ptr_ptr
;
1378 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1379 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1380 (unsigned long)rel
->addend
);
1387 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1388 fragS
**last_newf
, struct obstack
*ob
)
1391 int total_out_size
= 0;
1392 fragS
*f
= *last_newf
;
1396 /* Call the compression routine repeatedly until it has finished
1397 processing the frag. */
1400 /* Reserve all the space available in the current chunk.
1401 If none is available, start a new frag. */
1402 avail_out
= obstack_room (ob
);
1405 obstack_finish (ob
);
1406 f
= frag_alloc (ob
);
1407 f
->fr_type
= rs_fill
;
1408 (*last_newf
)->fr_next
= f
;
1410 avail_out
= obstack_room (ob
);
1413 as_fatal (_("can't extend frag"));
1414 next_out
= obstack_next_free (ob
);
1415 obstack_blank_fast (ob
, avail_out
);
1416 out_size
= compress_data (strm
, &contents
, &in_size
,
1417 &next_out
, &avail_out
);
1421 f
->fr_fix
+= out_size
;
1422 total_out_size
+= out_size
;
1424 /* Return unused space. */
1426 obstack_blank_fast (ob
, -avail_out
);
1429 return total_out_size
;
1433 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1435 segment_info_type
*seginfo
= seg_info (sec
);
1439 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1440 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1441 bfd_size_type compressed_size
;
1442 const char *section_name
;
1443 char *compressed_name
;
1445 struct z_stream_s
*strm
;
1447 flagword flags
= bfd_section_flags (sec
);
1448 unsigned int header_size
, compression_header_size
;
1452 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1455 section_name
= bfd_section_name (sec
);
1456 if (!startswith (section_name
, ".debug_"))
1459 strm
= compress_init ();
1463 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1465 compression_header_size
1466 = bfd_get_compression_header_size (stdoutput
, NULL
);
1467 header_size
= compression_header_size
;
1471 compression_header_size
= 0;
1475 /* Create a new frag to contain the compression header. */
1476 first_newf
= frag_alloc (ob
);
1477 if (obstack_room (ob
) < header_size
)
1478 first_newf
= frag_alloc (ob
);
1479 if (obstack_room (ob
) < header_size
)
1480 as_fatal (ngettext ("can't extend frag %lu char",
1481 "can't extend frag %lu chars",
1482 (unsigned long) header_size
),
1483 (unsigned long) header_size
);
1484 last_newf
= first_newf
;
1485 obstack_blank_fast (ob
, header_size
);
1486 last_newf
->fr_type
= rs_fill
;
1487 last_newf
->fr_fix
= header_size
;
1488 header
= last_newf
->fr_literal
;
1489 compressed_size
= header_size
;
1491 /* Stream the frags through the compression engine, adding new frags
1492 as necessary to accommodate the compressed output. */
1493 for (f
= seginfo
->frchainP
->frch_root
;
1502 gas_assert (f
->fr_type
== rs_fill
);
1505 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1509 compressed_size
+= out_size
;
1511 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1512 fill_size
= f
->fr_var
;
1513 count
= f
->fr_offset
;
1514 gas_assert (count
>= 0);
1515 if (fill_size
&& count
)
1519 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1523 compressed_size
+= out_size
;
1528 /* Flush the compression state. */
1535 /* Reserve all the space available in the current chunk.
1536 If none is available, start a new frag. */
1537 avail_out
= obstack_room (ob
);
1542 obstack_finish (ob
);
1543 newf
= frag_alloc (ob
);
1544 newf
->fr_type
= rs_fill
;
1545 last_newf
->fr_next
= newf
;
1547 avail_out
= obstack_room (ob
);
1550 as_fatal (_("can't extend frag"));
1551 next_out
= obstack_next_free (ob
);
1552 obstack_blank_fast (ob
, avail_out
);
1553 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1557 last_newf
->fr_fix
+= out_size
;
1558 compressed_size
+= out_size
;
1560 /* Return unused space. */
1562 obstack_blank_fast (ob
, -avail_out
);
1568 /* PR binutils/18087: If compression didn't make the section smaller,
1569 just keep it uncompressed. */
1570 if (compressed_size
>= uncompressed_size
)
1573 /* Replace the uncompressed frag list with the compressed frag list. */
1574 seginfo
->frchainP
->frch_root
= first_newf
;
1575 seginfo
->frchainP
->frch_last
= last_newf
;
1577 /* Update the section size and its name. */
1578 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1579 x
= bfd_set_section_size (sec
, compressed_size
);
1581 if (!compression_header_size
)
1583 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1584 bfd_rename_section (sec
, compressed_name
);
1588 #ifndef md_generate_nops
1589 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1590 backend must override this with proper no-op instructions. */
1593 md_generate_nops (fragS
*f ATTRIBUTE_UNUSED
,
1594 char *where ATTRIBUTE_UNUSED
,
1595 offsetT count ATTRIBUTE_UNUSED
,
1596 int control ATTRIBUTE_UNUSED
)
1598 as_bad (_("unimplemented .nops directive"));
1603 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1605 void *xxx ATTRIBUTE_UNUSED
)
1607 segment_info_type
*seginfo
= seg_info (sec
);
1608 addressT offset
= 0;
1611 /* Write out the frags. */
1613 || !(bfd_section_flags (sec
) & SEC_HAS_CONTENTS
))
1616 for (f
= seginfo
->frchainP
->frch_root
;
1625 gas_assert (f
->fr_type
== rs_fill
|| f
->fr_type
== rs_fill_nop
);
1628 x
= bfd_set_section_contents (stdoutput
, sec
,
1629 f
->fr_literal
, (file_ptr
) offset
,
1630 (bfd_size_type
) f
->fr_fix
);
1632 as_fatal (ngettext ("can't write %ld byte "
1633 "to section %s of %s: '%s'",
1634 "can't write %ld bytes "
1635 "to section %s of %s: '%s'",
1638 bfd_section_name (sec
), bfd_get_filename (stdoutput
),
1639 bfd_errmsg (bfd_get_error ()));
1640 offset
+= f
->fr_fix
;
1643 fill_size
= f
->fr_var
;
1644 count
= f
->fr_offset
;
1645 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1647 if (f
->fr_type
== rs_fill_nop
)
1649 gas_assert (count
>= 0 && fill_size
== 1);
1652 char *buf
= xmalloc (count
);
1653 md_generate_nops (f
, buf
, count
, *fill_literal
);
1654 x
= bfd_set_section_contents
1655 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1656 (bfd_size_type
) count
);
1658 as_fatal (ngettext ("can't fill %ld byte "
1659 "in section %s of %s: '%s'",
1660 "can't fill %ld bytes "
1661 "in section %s of %s: '%s'",
1664 bfd_section_name (sec
),
1665 bfd_get_filename (stdoutput
),
1666 bfd_errmsg (bfd_get_error ()));
1673 gas_assert (count
>= 0);
1674 if (fill_size
&& count
)
1677 if (fill_size
> sizeof (buf
))
1679 /* Do it the old way. Can this ever happen? */
1682 x
= bfd_set_section_contents (stdoutput
, sec
,
1685 (bfd_size_type
) fill_size
);
1687 as_fatal (ngettext ("can't fill %ld byte "
1688 "in section %s of %s: '%s'",
1689 "can't fill %ld bytes "
1690 "in section %s of %s: '%s'",
1693 bfd_section_name (sec
),
1694 bfd_get_filename (stdoutput
),
1695 bfd_errmsg (bfd_get_error ()));
1696 offset
+= fill_size
;
1701 /* Build a buffer full of fill objects and output it as
1702 often as necessary. This saves on the overhead of
1703 potentially lots of bfd_set_section_contents calls. */
1707 n_per_buf
= sizeof (buf
);
1708 memset (buf
, *fill_literal
, n_per_buf
);
1713 n_per_buf
= sizeof (buf
) / fill_size
;
1714 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1715 memcpy (bufp
, fill_literal
, fill_size
);
1717 for (; count
> 0; count
-= n_per_buf
)
1719 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1720 x
= bfd_set_section_contents
1721 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1722 (bfd_size_type
) n_per_buf
* fill_size
);
1724 as_fatal (ngettext ("can't fill %ld byte "
1725 "in section %s of %s: '%s'",
1726 "can't fill %ld bytes "
1727 "in section %s of %s: '%s'",
1728 (long) (n_per_buf
* fill_size
)),
1729 (long) (n_per_buf
* fill_size
),
1730 bfd_section_name (sec
),
1731 bfd_get_filename (stdoutput
),
1732 bfd_errmsg (bfd_get_error ()));
1733 offset
+= n_per_buf
* fill_size
;
1741 merge_data_into_text (void)
1743 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1744 seg_info (data_section
)->frchainP
->frch_root
;
1745 seg_info (text_section
)->frchainP
->frch_last
=
1746 seg_info (data_section
)->frchainP
->frch_last
;
1747 seg_info (data_section
)->frchainP
= 0;
1758 /* Count symbols. We can't rely on a count made by the loop in
1759 write_object_file, because *_frob_file may add a new symbol or
1760 two. Generate unused section symbols only if needed. */
1762 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1763 if (bfd_keep_unused_section_symbols (stdoutput
)
1764 || !symbol_section_p (symp
)
1765 || symbol_used_in_reloc_p (symp
))
1771 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1773 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1774 symp
= symbol_rootP
;
1775 for (i
= 0; i
< nsyms
; symp
= symbol_next (symp
))
1776 if (bfd_keep_unused_section_symbols (stdoutput
)
1777 || !symbol_section_p (symp
)
1778 || symbol_used_in_reloc_p (symp
))
1780 asympp
[i
] = symbol_get_bfdsym (symp
);
1781 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1782 || !(bfd_is_const_section (asympp
[i
]->section
)
1783 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1784 asympp
[i
]->flags
|= BSF_KEEP
;
1785 symbol_mark_written (symp
);
1786 /* Include this section symbol in the symbol table. */
1787 if (symbol_section_p (symp
))
1788 asympp
[i
]->flags
|= BSF_SECTION_SYM_USED
;
1794 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1795 gas_assert (result
);
1796 symbol_table_frozen
= 1;
1799 /* Finish the subsegments. After every sub-segment, we fake an
1800 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1801 ".fill 0" because that is the kind of frag that requires least
1802 thought. ".align" frags like to have a following frag since that
1803 makes calculating their intended length trivial. */
1805 #ifndef SUB_SEGMENT_ALIGN
1807 /* The last subsegment gets an alignment corresponding to the alignment
1808 of the section. This allows proper nop-filling at the end of
1809 code-bearing sections. */
1810 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1811 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1812 && !do_not_pad_sections_to_alignment \
1813 ? get_recorded_alignment (SEG) \
1816 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1821 subsegs_finish_section (asection
*s
)
1823 struct frchain
*frchainP
;
1824 segment_info_type
*seginfo
= seg_info (s
);
1828 for (frchainP
= seginfo
->frchainP
;
1830 frchainP
= frchainP
->frch_next
)
1834 subseg_set (s
, frchainP
->frch_subseg
);
1836 /* This now gets called even if we had errors. In that case,
1837 any alignment is meaningless, and, moreover, will look weird
1838 if we are generating a listing. */
1840 do_not_pad_sections_to_alignment
= 1;
1842 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1843 if ((bfd_section_flags (now_seg
) & SEC_MERGE
)
1844 && now_seg
->entsize
)
1846 unsigned int entsize
= now_seg
->entsize
;
1849 while ((entsize
& 1) == 0)
1855 if (entalign
> alignment
)
1856 alignment
= entalign
;
1859 if (subseg_text_p (now_seg
))
1860 frag_align_code (alignment
, 0);
1862 frag_align (alignment
, 0, 0);
1864 /* frag_align will have left a new frag.
1865 Use this last frag for an empty ".fill".
1867 For this segment ...
1868 Create a last frag. Do not leave a "being filled in frag". */
1869 frag_wane (frag_now
);
1870 frag_now
->fr_fix
= 0;
1871 know (frag_now
->fr_next
== NULL
);
1876 subsegs_finish (void)
1880 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1881 subsegs_finish_section (s
);
1886 create_obj_attrs_section (void)
1893 size
= bfd_elf_obj_attr_size (stdoutput
);
1897 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1899 name
= ".gnu.attributes";
1900 s
= subseg_new (name
, 0);
1901 elf_section_type (s
)
1902 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1903 bfd_set_section_flags (s
, SEC_READONLY
| SEC_DATA
);
1905 p
= frag_more (size
);
1906 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1908 subsegs_finish_section (s
);
1909 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1910 size_seg (stdoutput
, s
, NULL
);
1913 /* Create a relocation against an entry in a GNU Build attribute section. */
1916 create_note_reloc (segT sec
,
1918 bfd_size_type note_offset
,
1919 bfd_size_type desc2_offset
,
1925 struct reloc_list
* reloc
;
1927 reloc
= XNEW (struct reloc_list
);
1929 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
1930 reloc
->u
.b
.sec
= sec
;
1931 reloc
->u
.b
.s
= symbol_get_bfdsym (sym
);
1932 reloc
->u
.b
.r
.sym_ptr_ptr
= & reloc
->u
.b
.s
;
1933 reloc
->u
.b
.r
.address
= note_offset
+ desc2_offset
;
1934 reloc
->u
.b
.r
.addend
= addend
;
1935 reloc
->u
.b
.r
.howto
= bfd_reloc_type_lookup (stdoutput
, reloc_type
);
1937 if (reloc
->u
.b
.r
.howto
== NULL
)
1939 as_bad (_("unable to create reloc for build note"));
1943 reloc
->file
= N_("<gnu build note>");
1946 reloc
->next
= reloc_list
;
1949 /* For REL relocs, store the addend in the section. */
1950 if (! sec
->use_rela_p
1951 /* The SH target is a special case that uses RELA relocs
1952 but still stores the addend in the word being relocated. */
1953 || strstr (bfd_get_target (stdoutput
), "-sh") != NULL
)
1957 /* Zero out the addend, since it is now stored in the note. */
1958 reloc
->u
.b
.r
.addend
= 0;
1960 if (target_big_endian
)
1962 for (i
= desc2_size
; addend
!= 0 && i
> 0; addend
>>= 8, i
--)
1963 note
[desc2_offset
+ i
- 1] = (addend
& 0xff);
1967 for (i
= 0; addend
!= 0 && i
< desc2_size
; addend
>>= 8, i
++)
1968 note
[desc2_offset
+ i
] = (addend
& 0xff);
1974 maybe_generate_build_notes (void)
1981 offsetT desc2_offset
;
1986 if (! flag_generate_build_notes
1987 || bfd_get_section_by_name (stdoutput
,
1988 GNU_BUILD_ATTRS_SECTION_NAME
) != NULL
)
1991 /* Create a GNU Build Attribute section. */
1992 sec
= subseg_new (GNU_BUILD_ATTRS_SECTION_NAME
, false);
1993 elf_section_type (sec
) = SHT_NOTE
;
1994 bfd_set_section_flags (sec
, (SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_DATA
1996 bfd_set_section_alignment (sec
, 2);
1998 /* Work out the size of the notes that we will create,
1999 and the relocation we should use. */
2000 if (bfd_arch_bits_per_address (stdoutput
) <= 32)
2003 desc_size
= 8; /* Two 4-byte offsets. */
2006 /* FIXME: The BFD backend for the CRX target does not support the
2007 BFD_RELOC_32, even though it really should. Likewise for the
2008 CR16 target. So we have special case code here... */
2009 if (strstr (bfd_get_target (stdoutput
), "-crx") != NULL
)
2010 desc_reloc
= BFD_RELOC_CRX_NUM32
;
2011 else if (strstr (bfd_get_target (stdoutput
), "-cr16") != NULL
)
2012 desc_reloc
= BFD_RELOC_CR16_NUM32
;
2014 desc_reloc
= BFD_RELOC_32
;
2019 desc_size
= 16; /* Two 8-byte offsets. */
2021 /* FIXME: The BFD backend for the IA64 target does not support the
2022 BFD_RELOC_64, even though it really should. The HPPA backend
2023 has a similar issue, although it does not support BFD_RELOCs at
2024 all! So we have special case code to handle these targets. */
2025 if (strstr (bfd_get_target (stdoutput
), "-ia64") != NULL
)
2026 desc_reloc
= target_big_endian
? BFD_RELOC_IA64_DIR32MSB
: BFD_RELOC_IA64_DIR32LSB
;
2027 else if (strstr (bfd_get_target (stdoutput
), "-hppa") != NULL
)
2028 desc_reloc
= 80; /* R_PARISC_DIR64. */
2030 desc_reloc
= BFD_RELOC_64
;
2033 /* We have to create a note for *each* code section.
2034 Linker garbage collection might discard some. */
2038 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
2039 if ((bsym
= symbol_get_bfdsym (sym
)) != NULL
2040 && bsym
->flags
& BSF_SECTION_SYM
2041 && bsym
->section
!= NULL
2042 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
2043 && (bsym
->section
->flags
& (SEC_CODE
| SEC_LINK_ONCE
)) == SEC_CODE
2044 /* Not all linkonce sections are flagged... */
2045 && !startswith (S_GET_NAME (sym
), ".gnu.linkonce"))
2047 /* Create a version note. */
2049 note
= frag_more (note_size
);
2050 memset (note
, 0, note_size
);
2052 if (target_big_endian
)
2054 note
[3] = 8; /* strlen (name) + 1. */
2055 note
[7] = desc_size
; /* Two N-byte offsets. */
2056 note
[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2057 note
[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2061 note
[0] = 8; /* strlen (name) + 1. */
2062 note
[4] = desc_size
; /* Two N-byte offsets. */
2063 note
[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2064 note
[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2067 /* The a1 version number indicates that this note was
2068 generated by the assembler and not the gcc annobin plugin. */
2069 memcpy (note
+ 12, "GA$\ 13a1", 8);
2071 /* Create a relocation to install the start address of the note... */
2072 create_note_reloc (sec
, sym
, total_size
, 20, desc_size
/ 2, desc_reloc
, 0, note
);
2074 /* ...and another one to install the end address. */
2075 create_note_reloc (sec
, sym
, total_size
, desc2_offset
,
2078 bfd_section_size (bsym
->section
),
2081 /* Mark the section symbol used in relocation so that it will be
2082 included in the symbol table. */
2083 symbol_mark_used_in_reloc (sym
);
2085 total_size
+= note_size
;
2086 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2089 /* Install the note(s) into the section. */
2091 bfd_set_section_contents (stdoutput
, sec
, (bfd_byte
*) note
, 0, total_size
);
2092 subsegs_finish_section (sec
);
2093 relax_segment (seg_info (sec
)->frchainP
->frch_root
, sec
, 0);
2094 size_seg (stdoutput
, sec
, NULL
);
2096 #endif /* OBJ_ELF */
2098 /* Write the object file. */
2101 write_object_file (void)
2103 struct relax_seg_info rsi
;
2104 #ifndef WORKING_DOT_WORD
2105 fragS
*fragP
; /* Track along all frags. */
2110 #ifdef md_pre_output_hook
2114 #ifdef md_pre_relax_hook
2118 /* From now on, we don't care about sub-segments. Build one frag chain
2119 for each segment. Linked through fr_next. */
2121 /* Remove the sections created by gas for its own purposes. */
2125 bfd_section_list_remove (stdoutput
, reg_section
);
2126 bfd_section_list_remove (stdoutput
, expr_section
);
2127 stdoutput
->section_count
-= 2;
2129 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
2132 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
2134 /* We have two segments. If user gave -R flag, then we must put the
2135 data frags into the text segment. Do this before relaxing so
2136 we know to take advantage of -R and make shorter addresses. */
2137 if (flag_readonly_data_in_text
)
2139 merge_data_into_text ();
2145 #ifndef WORKING_DOT_WORD
2146 /* We need to reset the markers in the broken word list and
2147 associated frags between calls to relax_segment (via
2148 relax_seg). Since the broken word list is global, we do it
2149 once per round, rather than locally in relax_segment for each
2151 struct broken_word
*brokp
;
2153 for (brokp
= broken_words
;
2154 brokp
!= (struct broken_word
*) NULL
;
2155 brokp
= brokp
->next_broken_word
)
2159 if (brokp
->dispfrag
!= (fragS
*) NULL
2160 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
2161 brokp
->dispfrag
->fr_subtype
= 0;
2166 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
2172 /* Note - Most ports will use the default value of
2173 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2174 local symbols to be resolved, removing their frag information.
2175 Some ports however, will not have finished relaxing all of
2176 their frags and will still need the local symbol frag
2177 information. These ports can set
2178 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2179 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
2181 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
2183 /* Relaxation has completed. Freeze all syms. */
2186 dwarf2dbg_final_check ();
2188 #ifdef md_post_relax_hook
2194 create_obj_attrs_section ();
2197 #ifndef WORKING_DOT_WORD
2199 struct broken_word
*lie
;
2200 struct broken_word
**prevP
;
2202 prevP
= &broken_words
;
2203 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
2208 subseg_change (lie
->seg
, lie
->subseg
);
2209 exp
.X_op
= O_subtract
;
2210 exp
.X_add_symbol
= lie
->add
;
2211 exp
.X_op_symbol
= lie
->sub
;
2212 exp
.X_add_number
= lie
->addnum
;
2213 #ifdef TC_CONS_FIX_NEW
2214 TC_CONS_FIX_NEW (lie
->frag
,
2215 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2216 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
2218 fix_new_exp (lie
->frag
,
2219 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2220 2, &exp
, 0, BFD_RELOC_16
);
2222 *prevP
= lie
->next_broken_word
;
2225 prevP
= &(lie
->next_broken_word
);
2227 for (lie
= broken_words
; lie
;)
2229 struct broken_word
*untruth
;
2231 addressT table_addr
;
2232 addressT from_addr
, to_addr
;
2235 subseg_change (lie
->seg
, lie
->subseg
);
2236 fragP
= lie
->dispfrag
;
2238 /* Find out how many broken_words go here. */
2241 untruth
&& untruth
->dispfrag
== fragP
;
2242 untruth
= untruth
->next_broken_word
)
2243 if (untruth
->added
== 1)
2246 table_ptr
= lie
->dispfrag
->fr_opcode
;
2247 table_addr
= (lie
->dispfrag
->fr_address
2248 + (table_ptr
- lie
->dispfrag
->fr_literal
));
2249 /* Create the jump around the long jumps. This is a short
2250 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2251 from_addr
= table_addr
;
2252 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
2253 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2255 table_ptr
+= md_short_jump_size
;
2256 table_addr
+= md_short_jump_size
;
2259 lie
&& lie
->dispfrag
== fragP
;
2260 m
++, lie
= lie
->next_broken_word
)
2262 if (lie
->added
== 2)
2264 /* Patch the jump table. */
2265 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2266 untruth
&& untruth
->dispfrag
== fragP
;
2267 untruth
= untruth
->next_broken_word
)
2269 if (untruth
->use_jump
== lie
)
2271 /* This is the offset from ??? to table_ptr+0.
2272 The target is the same for all users of this
2273 md_long_jump, but the "sub" bases (and hence the
2274 offsets) may be different. */
2275 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
2276 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2277 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
2279 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2283 /* Install the long jump. */
2284 /* This is a long jump from table_ptr+0 to the final target. */
2285 from_addr
= table_addr
;
2286 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2287 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2289 table_ptr
+= md_long_jump_size
;
2290 table_addr
+= md_long_jump_size
;
2294 #endif /* not WORKING_DOT_WORD */
2296 /* Resolve symbol values. This needs to be done before processing
2302 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2303 resolve_symbol_value (symp
);
2305 resolve_local_symbol_values ();
2306 resolve_reloc_expr_symbols ();
2310 maybe_generate_build_notes ();
2315 #ifdef tc_frob_file_before_adjust
2316 tc_frob_file_before_adjust ();
2318 #ifdef obj_frob_file_before_adjust
2319 obj_frob_file_before_adjust ();
2322 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2324 #ifdef tc_frob_file_before_fix
2325 tc_frob_file_before_fix ();
2327 #ifdef obj_frob_file_before_fix
2328 obj_frob_file_before_fix ();
2331 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2333 /* Set up symbol table, and write it out. */
2337 bool skip_next_symbol
= false;
2339 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2344 if (skip_next_symbol
)
2346 /* Don't do anything besides moving the value of the
2347 symbol from the GAS value-field to the BFD value-field. */
2348 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2349 skip_next_symbol
= false;
2353 if (symbol_mri_common_p (symp
))
2355 if (S_IS_EXTERNAL (symp
))
2356 as_bad (_("%s: global symbols not supported in common sections"),
2358 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2362 name
= S_GET_NAME (symp
);
2366 decode_local_label_name ((char *) S_GET_NAME (symp
));
2367 /* They only differ if `name' is a fb or dollar local
2369 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2370 as_bad (_("local label `%s' is not defined"), name2
);
2373 /* Do it again, because adjust_reloc_syms might introduce
2374 more symbols. They'll probably only be section symbols,
2375 but they'll still need to have the values computed. */
2376 resolve_symbol_value (symp
);
2378 /* Skip symbols which were equated to undefined or common
2380 if (symbol_equated_reloc_p (symp
)
2381 || S_IS_WEAKREFR (symp
))
2383 const char *sname
= S_GET_NAME (symp
);
2385 if (S_IS_COMMON (symp
)
2386 && !TC_FAKE_LABEL (sname
)
2387 && !S_IS_WEAKREFR (symp
))
2389 expressionS
*e
= symbol_get_value_expression (symp
);
2391 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2392 sname
, S_GET_NAME (e
->X_add_symbol
));
2394 if (S_GET_SEGMENT (symp
) == reg_section
)
2396 /* Report error only if we know the symbol name. */
2397 if (S_GET_NAME (symp
) != reg_section
->name
)
2398 as_bad (_("can't make global register symbol `%s'"),
2401 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2405 #ifdef obj_frob_symbol
2406 obj_frob_symbol (symp
, punt
);
2408 #ifdef tc_frob_symbol
2409 if (! punt
|| symbol_used_in_reloc_p (symp
))
2410 tc_frob_symbol (symp
, punt
);
2413 /* If we don't want to keep this symbol, splice it out of
2414 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2415 want section symbols. Otherwise, we skip local symbols
2416 and symbols that the frob_symbol macros told us to punt,
2417 but we keep such symbols if they are used in relocs. */
2418 if (symp
== abs_section_sym
2419 || (! EMIT_SECTION_SYMBOLS
2420 && symbol_section_p (symp
))
2421 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2422 opposites. Sometimes the former checks flags and the
2423 latter examines the name... */
2424 || (!S_IS_EXTERNAL (symp
)
2425 && (punt
|| S_IS_LOCAL (symp
) ||
2426 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2427 && ! symbol_used_in_reloc_p (symp
)))
2429 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2431 /* After symbol_remove, symbol_next(symp) still returns
2432 the one that came after it in the chain. So we don't
2433 need to do any extra cleanup work here. */
2437 /* Make sure we really got a value for the symbol. */
2438 if (! symbol_resolved_p (symp
))
2440 as_bad (_("can't resolve value for symbol `%s'"),
2442 symbol_mark_resolved (symp
);
2445 /* Set the value into the BFD symbol. Up til now the value
2446 has only been kept in the gas symbolS struct. */
2447 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2449 /* A warning construct is a warning symbol followed by the
2450 symbol warned about. Don't let anything object-format or
2451 target-specific muck with it; it's ready for output. */
2452 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2453 skip_next_symbol
= true;
2459 /* Now do any format-specific adjustments to the symbol table, such
2460 as adding file symbols. */
2461 #ifdef tc_adjust_symtab
2462 tc_adjust_symtab ();
2464 #ifdef obj_adjust_symtab
2465 obj_adjust_symtab ();
2468 /* Stop if there is an error. */
2469 if (!flag_always_generate_output
&& had_errors ())
2472 /* Now that all the sizes are known, and contents correct, we can
2473 start writing to the file. */
2476 /* If *_frob_file changes the symbol value at this point, it is
2477 responsible for moving the changed value into symp->bsym->value
2478 as well. Hopefully all symbol value changing can be done in
2483 #ifdef obj_frob_file
2486 #ifdef obj_coff_generate_pdata
2487 obj_coff_generate_pdata ();
2490 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2492 #ifdef tc_frob_file_after_relocs
2493 tc_frob_file_after_relocs ();
2495 #ifdef obj_frob_file_after_relocs
2496 obj_frob_file_after_relocs ();
2499 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2500 if (IS_ELF
&& flag_use_elf_stt_common
)
2501 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2504 /* Once all relocations have been written, we can compress the
2505 contents of the debug sections. This needs to be done before
2506 we start writing any sections, because it will affect the file
2507 layout, which is fixed once we start writing contents. */
2508 if (flag_compress_debug
)
2510 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2511 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2513 stdoutput
->flags
|= BFD_COMPRESS
;
2514 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2517 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2520 #ifdef TC_GENERIC_RELAX_TABLE
2521 #ifndef md_generic_table_relax_frag
2522 #define md_generic_table_relax_frag relax_frag
2525 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2528 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2530 const relax_typeS
*this_type
;
2531 const relax_typeS
*start_type
;
2532 relax_substateT next_state
;
2533 relax_substateT this_state
;
2539 const relax_typeS
*table
;
2541 target
= fragP
->fr_offset
;
2542 address
= fragP
->fr_address
+ fragP
->fr_fix
;
2543 table
= TC_GENERIC_RELAX_TABLE
;
2544 this_state
= fragP
->fr_subtype
;
2545 start_type
= this_type
= table
+ this_state
;
2546 symbolP
= fragP
->fr_symbol
;
2552 sym_frag
= symbol_get_frag (symbolP
);
2554 #ifndef DIFF_EXPR_OK
2555 know (sym_frag
!= NULL
);
2557 know (S_GET_SEGMENT (symbolP
) != absolute_section
2558 || sym_frag
== &zero_address_frag
);
2559 target
+= S_GET_VALUE (symbolP
);
2561 /* If SYM_FRAG has yet to be reached on this pass, assume it
2562 will move by STRETCH just as we did, unless there is an
2563 alignment frag between here and SYM_FRAG. An alignment may
2564 well absorb any STRETCH, and we don't want to choose a larger
2565 branch insn by overestimating the needed reach of this
2566 branch. It isn't critical to calculate TARGET exactly; We
2567 know we'll be doing another pass if STRETCH is non-zero. */
2570 && sym_frag
->relax_marker
!= fragP
->relax_marker
2571 && S_GET_SEGMENT (symbolP
) == segment
)
2574 || sym_frag
->region
== fragP
->region
)
2576 /* If we get here we know we have a forward branch. This
2577 relax pass may have stretched previous instructions so
2578 far that omitting STRETCH would make the branch
2579 negative. Don't allow this in case the negative reach is
2580 large enough to require a larger branch instruction. */
2581 else if (target
< address
)
2586 aim
= target
- address
;
2587 #ifdef TC_PCREL_ADJUST
2588 /* Currently only the ns32k and arc needs this. */
2589 aim
+= TC_PCREL_ADJUST (fragP
);
2592 #ifdef md_prepare_relax_scan
2593 /* Formerly called M68K_AIM_KLUDGE. */
2594 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2599 /* Look backwards. */
2600 for (next_state
= this_type
->rlx_more
; next_state
;)
2601 if (aim
>= this_type
->rlx_backward
)
2605 /* Grow to next state. */
2606 this_state
= next_state
;
2607 this_type
= table
+ this_state
;
2608 next_state
= this_type
->rlx_more
;
2613 /* Look forwards. */
2614 for (next_state
= this_type
->rlx_more
; next_state
;)
2615 if (aim
<= this_type
->rlx_forward
)
2619 /* Grow to next state. */
2620 this_state
= next_state
;
2621 this_type
= table
+ this_state
;
2622 next_state
= this_type
->rlx_more
;
2626 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2628 fragP
->fr_subtype
= this_state
;
2632 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2634 /* Relax_align. Advance location counter to next address that has 'alignment'
2635 lowest order bits all 0s, return size of adjustment made. */
2636 static relax_addressT
2637 relax_align (relax_addressT address
, /* Address now. */
2638 int alignment
/* Alignment (binary). */)
2640 relax_addressT mask
;
2641 relax_addressT new_address
;
2643 mask
= ~((relax_addressT
) ~0 << alignment
);
2644 new_address
= (address
+ mask
) & (~mask
);
2645 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2647 /* We must provide lots of padding, so the linker can discard it
2648 when needed. The linker will not add extra space, ever. */
2649 new_address
+= (1 << alignment
);
2651 return (new_address
- address
);
2654 /* Now we have a segment, not a crowd of sub-segments, we can make
2659 After this, all frags in this segment have addresses that are correct
2660 within the segment. Since segments live in different file addresses,
2661 these frag addresses may not be the same as final object-file
2665 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2667 unsigned long frag_count
;
2669 relax_addressT address
;
2673 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2674 subseg_change (segment
, 0);
2676 /* For each frag in segment: count and store (a 1st guess of)
2680 for (frag_count
= 0, fragP
= segment_frag_root
;
2682 fragP
= fragP
->fr_next
, frag_count
++)
2684 fragP
->region
= region
;
2685 fragP
->relax_marker
= 0;
2686 fragP
->fr_address
= address
;
2687 address
+= fragP
->fr_fix
;
2689 switch (fragP
->fr_type
)
2692 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2699 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2701 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2704 if (offset
% fragP
->fr_var
!= 0)
2706 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2707 ngettext ("alignment padding (%lu byte) "
2708 "not a multiple of %ld",
2709 "alignment padding (%lu bytes) "
2710 "not a multiple of %ld",
2711 (unsigned long) offset
),
2712 (unsigned long) offset
, (long) fragP
->fr_var
);
2713 offset
-= (offset
% fragP
->fr_var
);
2722 /* Assume .org is nugatory. It will grow with 1st relax. */
2730 case rs_machine_dependent
:
2731 /* If fr_symbol is an expression, this call to
2732 resolve_symbol_value sets up the correct segment, which will
2733 likely be needed in md_estimate_size_before_relax. */
2734 if (fragP
->fr_symbol
)
2735 resolve_symbol_value (fragP
->fr_symbol
);
2737 address
+= md_estimate_size_before_relax (fragP
, segment
);
2740 #ifndef WORKING_DOT_WORD
2741 /* Broken words don't concern us yet. */
2742 case rs_broken_word
:
2747 /* Initial guess is always 1; doing otherwise can result in
2748 stable solutions that are larger than the minimum. */
2749 address
+= fragP
->fr_offset
= 1;
2753 address
+= eh_frame_estimate_size_before_relax (fragP
);
2757 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2761 BAD_CASE (fragP
->fr_type
);
2768 unsigned long max_iterations
;
2770 /* Cumulative address adjustment. */
2773 /* Have we made any adjustment this pass? We can't just test
2774 stretch because one piece of code may have grown and another
2778 /* Most horrible, but gcc may give us some exception data that
2779 is impossible to assemble, of the form
2783 .uleb128 end - start
2789 If the leb128 is two bytes in size, then end-start is 128*128,
2790 which requires a three byte leb128. If the leb128 is three
2791 bytes in size, then end-start is 128*128-1, which requires a
2792 two byte leb128. We work around this dilemma by inserting
2793 an extra 4 bytes of alignment just after the .align. This
2794 works because the data after the align is accessed relative to
2797 This counter is used in a tiny state machine to detect
2798 whether a leb128 followed by an align is impossible to
2800 int rs_leb128_fudge
= 0;
2802 /* We want to prevent going into an infinite loop where one frag grows
2803 depending upon the location of a symbol which is in turn moved by
2804 the growing frag. eg:
2810 So we dictate that this algorithm can be at most O2. */
2811 max_iterations
= frag_count
* frag_count
;
2812 /* Check for overflow. */
2813 if (max_iterations
< frag_count
)
2814 max_iterations
= frag_count
;
2822 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2825 addressT was_address
;
2829 fragP
->relax_marker
^= 1;
2830 was_address
= fragP
->fr_address
;
2831 address
= fragP
->fr_address
+= stretch
;
2832 symbolP
= fragP
->fr_symbol
;
2833 offset
= fragP
->fr_offset
;
2835 switch (fragP
->fr_type
)
2837 case rs_fill
: /* .fill never relaxes. */
2841 #ifndef WORKING_DOT_WORD
2842 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2843 for it I do not want to write it. I do not want to have
2844 anything to do with it. This is not the proper way to
2845 implement this misfeature. */
2846 case rs_broken_word
:
2848 struct broken_word
*lie
;
2849 struct broken_word
*untruth
;
2851 /* Yes this is ugly (storing the broken_word pointer
2852 in the symbol slot). Still, this whole chunk of
2853 code is ugly, and I don't feel like doing anything
2854 about it. Think of it as stubbornness in action. */
2856 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2857 lie
&& lie
->dispfrag
== fragP
;
2858 lie
= lie
->next_broken_word
)
2864 offset
= (S_GET_VALUE (lie
->add
)
2866 - S_GET_VALUE (lie
->sub
));
2867 if (offset
<= -32768 || offset
>= 32767)
2869 if (flag_warn_displacement
)
2873 bfd_sprintf_vma (stdoutput
, buf
,
2874 (addressT
) lie
->addnum
);
2875 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2876 _(".word %s-%s+%s didn't fit"),
2877 S_GET_NAME (lie
->add
),
2878 S_GET_NAME (lie
->sub
),
2881 if (fragP
->fr_subtype
== 0)
2883 fragP
->fr_subtype
++;
2884 growth
+= md_short_jump_size
;
2887 /* Redirect *all* words of this table with the same
2888 target, lest we have to handle the case where the
2889 same target but with a offset that fits on this
2890 round overflows at the next relaxation round. */
2891 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2892 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2893 untruth
= untruth
->next_broken_word
)
2894 if ((symbol_get_frag (untruth
->add
)
2895 == symbol_get_frag (lie
->add
))
2896 && (S_GET_VALUE (untruth
->add
)
2897 == S_GET_VALUE (lie
->add
)))
2900 untruth
->use_jump
= lie
;
2904 growth
+= md_long_jump_size
;
2909 } /* case rs_broken_word */
2915 addressT oldoff
, newoff
;
2917 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2919 newoff
= relax_align (address
+ fragP
->fr_fix
,
2922 if (fragP
->fr_subtype
!= 0)
2924 if (oldoff
> fragP
->fr_subtype
)
2926 if (newoff
> fragP
->fr_subtype
)
2930 growth
= newoff
- oldoff
;
2932 /* If this align happens to follow a leb128 and
2933 we have determined that the leb128 is bouncing
2934 in size, then break the cycle by inserting an
2937 && (rs_leb128_fudge
& 16) != 0
2938 && (rs_leb128_fudge
& 15) >= 2)
2940 segment_info_type
*seginfo
= seg_info (segment
);
2941 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2944 newf
= frag_alloc (ob
);
2945 obstack_blank_fast (ob
, fragP
->fr_var
);
2946 obstack_finish (ob
);
2947 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2948 memcpy (newf
->fr_literal
,
2949 fragP
->fr_literal
+ fragP
->fr_fix
,
2951 newf
->fr_type
= rs_fill
;
2952 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2954 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2956 if (newf
->fr_offset
* newf
->fr_var
2957 != (offsetT
) 1 << fragP
->fr_offset
)
2959 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2962 /* Include size of new frag in GROWTH. */
2963 growth
+= newf
->fr_offset
* newf
->fr_var
;
2964 /* Adjust the new frag address for the amount
2965 we'll add when we process the new frag. */
2966 newf
->fr_address
-= stretch
+ growth
;
2967 newf
->relax_marker
^= 1;
2968 fragP
->fr_next
= newf
;
2970 as_warn (_("padding added"));
2978 offsetT target
= offset
;
2983 /* Convert from an actual address to an octet offset
2984 into the section. Here it is assumed that the
2985 section's VMA is zero, and can omit subtracting it
2986 from the symbol's value to get the address offset. */
2987 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2988 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2991 know (fragP
->fr_next
);
2992 after
= fragP
->fr_next
->fr_address
+ stretch
;
2993 growth
= target
- after
;
2995 /* Growth may be negative, but variable part of frag
2996 cannot have fewer than 0 chars. That is, we can't
2998 if ((offsetT
) (address
+ fragP
->fr_fix
) > target
)
3002 /* Don't error on first few frag relax passes.
3003 The symbol might be an expression involving
3004 symbol values from other sections. If those
3005 sections have not yet been processed their
3006 frags will all have zero addresses, so we
3007 will calculate incorrect values for them. The
3008 number of passes we allow before giving an
3009 error is somewhat arbitrary. It should be at
3010 least one, with larger values requiring
3011 increasingly contrived dependencies between
3012 frags to trigger a false error. */
3015 /* Force another pass. */
3020 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3021 _("attempt to move .org backwards"));
3023 /* We've issued an error message. Change the
3024 frag to avoid cascading errors. */
3025 fragP
->fr_type
= rs_align
;
3026 fragP
->fr_subtype
= 0;
3027 fragP
->fr_offset
= 0;
3028 fragP
->fr_fix
= after
- address
;
3040 amount
= S_GET_VALUE (symbolP
);
3041 if (S_GET_SEGMENT (symbolP
) != absolute_section
3042 || S_IS_COMMON (symbolP
)
3043 || ! S_IS_DEFINED (symbolP
))
3045 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3046 _(".space, .nops or .fill specifies non-absolute value"));
3047 /* Prevent repeat of this error message. */
3048 fragP
->fr_symbol
= 0;
3050 else if (amount
< 0)
3052 /* Don't error on first few frag relax passes.
3053 See rs_org comment for a longer explanation. */
3060 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3061 _(".space, .nops or .fill with negative value, ignored"));
3062 fragP
->fr_symbol
= 0;
3065 growth
= (was_address
+ fragP
->fr_fix
+ amount
3066 - fragP
->fr_next
->fr_address
);
3070 case rs_machine_dependent
:
3071 #ifdef md_relax_frag
3072 growth
= md_relax_frag (segment
, fragP
, stretch
);
3074 #ifdef TC_GENERIC_RELAX_TABLE
3075 /* The default way to relax a frag is to look through
3076 TC_GENERIC_RELAX_TABLE. */
3077 growth
= md_generic_table_relax_frag (segment
, fragP
,
3079 #endif /* TC_GENERIC_RELAX_TABLE */
3088 value
= resolve_symbol_value (fragP
->fr_symbol
);
3089 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
3090 growth
= size
- fragP
->fr_offset
;
3091 fragP
->fr_offset
= size
;
3096 growth
= eh_frame_relax_frag (fragP
);
3100 growth
= dwarf2dbg_relax_frag (fragP
);
3104 BAD_CASE (fragP
->fr_type
);
3111 if (fragP
->fr_type
== rs_leb128
)
3112 rs_leb128_fudge
+= 16;
3113 else if (fragP
->fr_type
== rs_align
3114 && (rs_leb128_fudge
& 16) != 0
3116 rs_leb128_fudge
+= 16;
3118 rs_leb128_fudge
= 0;
3123 && (rs_leb128_fudge
& 16) == 0
3124 && (rs_leb128_fudge
& -16) != 0)
3125 rs_leb128_fudge
+= 1;
3127 rs_leb128_fudge
= 0;
3129 /* Until nothing further to relax. */
3130 while (stretched
&& -- max_iterations
);
3133 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3134 segment_name (segment
));
3137 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3138 if (fragP
->last_fr_address
!= fragP
->fr_address
)
3140 fragP
->last_fr_address
= fragP
->fr_address
;
3147 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
3153 buf
[n
] = val
& 0xff;
3159 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
3165 *buf
++ = val
& 0xff;
3171 write_print_statistics (FILE *file
)
3173 fprintf (file
, "fixups: %d\n", n_fixups
);
3176 /* For debugging. */
3177 extern int indent_level
;
3180 print_fixup (fixS
*fixp
)
3183 fprintf (stderr
, "fix ");
3184 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
3185 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
3187 fprintf (stderr
, " pcrel");
3188 if (fixp
->fx_pcrel_adjust
)
3189 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
3191 fprintf (stderr
, " tcbit");
3193 fprintf (stderr
, " done");
3194 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
3195 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
3196 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
3197 (long) fixp
->fx_where
,
3198 (unsigned long) fixp
->fx_offset
,
3199 (unsigned long) fixp
->fx_addnumber
);
3200 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
3204 fprintf (stderr
, "\n +<");
3205 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
3206 fprintf (stderr
, ">");
3210 fprintf (stderr
, "\n -<");
3211 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3212 fprintf (stderr
, ">");
3214 fprintf (stderr
, "\n");
3215 #ifdef TC_FIX_DATA_PRINT
3216 TC_FIX_DATA_PRINT (stderr
, fixp
);