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 && strncmp (segment_name (symsec
), ".gnu.linkonce",
884 sizeof ".gnu.linkonce" - 1) == 0))
888 /* Never adjust a reloc against local symbol in a merge section
889 with non-zero addend. */
890 if ((symsec
->flags
& SEC_MERGE
) != 0
891 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
894 /* Never adjust a reloc against TLS local symbol. */
895 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
898 /* We refetch the segment when calling section_symbol, rather
899 than using symsec, because S_GET_VALUE may wind up changing
900 the section when it calls resolve_symbol_value. */
901 fixp
->fx_offset
+= S_GET_VALUE (sym
);
902 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
904 fprintf (stderr
, "\nadjusted fixup:\n");
909 dump_section_relocs (abfd
, sec
, stderr
);
914 Go through all the fixS's in a segment and see which ones can be
915 handled now. (These consist of fixS where we have since discovered
916 the value of a symbol, or the address of the frag involved.)
917 For each one, call md_apply_fix to put the fix into the frag data.
918 Ones that we couldn't completely handle here will be output later
919 by emit_relocations. */
922 fixup_segment (fixS
*fixP
, segT this_segment
)
926 segT add_symbol_segment
= absolute_section
;
928 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
929 abs_section_sym
= section_symbol (absolute_section
);
931 /* If the linker is doing the relaxing, we must not do any fixups.
933 Well, strictly speaking that's not true -- we could do any that
934 are PC-relative and don't cross regions that could change size. */
935 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
937 for (; fixP
; fixP
= fixP
->fx_next
)
940 if (fixP
->fx_addsy
== NULL
)
942 /* There was no symbol required by this relocation.
943 However, BFD doesn't really handle relocations
944 without symbols well. So fake up a local symbol in
945 the absolute section. */
946 fixP
->fx_addsy
= abs_section_sym
;
948 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
949 if (fixP
->fx_subsy
!= NULL
)
950 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
955 for (; fixP
; fixP
= fixP
->fx_next
)
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 && (add_number
& mask
) != mask
)
1112 char buf
[50], buf2
[50];
1113 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1114 if (add_number
> 1000)
1115 sprint_value (buf2
, add_number
);
1117 sprintf (buf2
, "%ld", (long) add_number
);
1118 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1119 ngettext ("value of %s too large for field "
1121 "value of %s too large for field "
1122 "of %d bytes at %s",
1124 buf2
, fixP
->fx_size
, buf
);
1125 } /* Generic error checking. */
1127 #ifdef WARN_SIGNED_OVERFLOW_WORD
1128 /* Warn if a .word value is too large when treated as a signed
1129 number. We already know it is not too negative. This is to
1130 catch over-large switches generated by gcc on the 68k. */
1131 if (!flag_signed_overflow_ok
1132 && fixP
->fx_size
== 2
1133 && add_number
> 0x7fff)
1134 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1135 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1137 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1141 #ifdef TC_VALIDATE_FIX
1142 skip
: ATTRIBUTE_UNUSED_LABEL
1146 fprintf (stderr
, "result:\n");
1149 } /* For each fixS in this segment. */
1153 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1155 void *xxx ATTRIBUTE_UNUSED
)
1157 segment_info_type
*seginfo
= seg_info (sec
);
1159 fixup_segment (seginfo
->fix_root
, sec
);
1163 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1164 const char *file
, unsigned int line
)
1167 bfd_reloc_status_type s
;
1170 if (reloc
->sym_ptr_ptr
!= NULL
1171 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1172 && (sym
->flags
& BSF_KEEP
) == 0
1173 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1174 || (EMIT_SECTION_SYMBOLS
1175 && !bfd_is_abs_section (sym
->section
))))
1176 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1178 s
= bfd_install_relocation (stdoutput
, reloc
,
1179 fragp
->fr_literal
, fragp
->fr_address
,
1185 case bfd_reloc_overflow
:
1186 as_bad_where (file
, line
, _("relocation overflow"));
1188 case bfd_reloc_outofrange
:
1189 as_bad_where (file
, line
, _("relocation out of range"));
1192 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1198 get_frag_for_reloc (fragS
*last_frag
,
1199 const segment_info_type
*seginfo
,
1200 const struct reloc_list
*r
)
1204 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1205 if (f
->fr_address
<= r
->u
.b
.r
.address
1206 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1209 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1210 if (f
->fr_address
<= r
->u
.b
.r
.address
1211 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1214 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1215 if (f
->fr_address
<= r
->u
.b
.r
.address
1216 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1219 as_bad_where (r
->file
, r
->line
,
1220 _("reloc not within (fixed part of) section"));
1225 write_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
1226 void *xxx ATTRIBUTE_UNUSED
)
1228 segment_info_type
*seginfo
= seg_info (sec
);
1230 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1235 /* If seginfo is NULL, we did not create this section; don't do
1236 anything with it. */
1237 if (seginfo
== NULL
)
1241 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1245 #ifdef RELOC_EXPANSION_POSSIBLE
1246 n
*= MAX_RELOC_EXPANSION
;
1249 /* Extract relocs for this section from reloc_list. */
1252 my_reloc_list
= NULL
;
1253 while ((r
= *rp
) != NULL
)
1255 if (r
->u
.b
.sec
== sec
)
1258 r
->next
= my_reloc_list
;
1266 relocs
= XCNEWVEC (arelent
*, n
);
1271 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1276 #ifndef RELOC_EXPANSION_POSSIBLE
1285 fx_size
= fixp
->fx_size
;
1286 slack
= TC_FX_SIZE_SLACK (fixp
);
1288 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1289 loc
= fixp
->fx_where
+ fx_size
;
1290 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1291 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1292 _("internal error: fixup not contained within frag"));
1294 #ifndef RELOC_EXPANSION_POSSIBLE
1295 *reloc
= tc_gen_reloc (sec
, fixp
);
1297 reloc
= tc_gen_reloc (sec
, fixp
);
1302 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1304 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1308 relocs
[n
++] = &r
->u
.b
.r
;
1309 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1313 relocs
[n
++] = *reloc
;
1314 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1315 fixp
->fx_file
, fixp
->fx_line
);
1316 #ifndef RELOC_EXPANSION_POSSIBLE
1326 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1330 relocs
[n
++] = &r
->u
.b
.r
;
1331 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1338 unsigned int k
, j
, nsyms
;
1340 sympp
= bfd_get_outsymbols (stdoutput
);
1341 nsyms
= bfd_get_symcount (stdoutput
);
1342 for (k
= 0; k
< n
; k
++)
1343 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1345 for (j
= 0; j
< nsyms
; j
++)
1346 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1356 flagword flags
= bfd_section_flags (sec
);
1358 bfd_set_section_flags (sec
, flags
);
1359 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1362 #ifdef SET_SECTION_RELOCS
1363 SET_SECTION_RELOCS (sec
, relocs
, n
);
1370 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1371 for (k
= 0; k
< n
; k
++)
1373 arelent
*rel
= relocs
[k
];
1374 asymbol
*s
= *rel
->sym_ptr_ptr
;
1375 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1376 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1377 (unsigned long)rel
->addend
);
1384 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1385 fragS
**last_newf
, struct obstack
*ob
)
1388 int total_out_size
= 0;
1389 fragS
*f
= *last_newf
;
1393 /* Call the compression routine repeatedly until it has finished
1394 processing the frag. */
1397 /* Reserve all the space available in the current chunk.
1398 If none is available, start a new frag. */
1399 avail_out
= obstack_room (ob
);
1402 obstack_finish (ob
);
1403 f
= frag_alloc (ob
);
1404 f
->fr_type
= rs_fill
;
1405 (*last_newf
)->fr_next
= f
;
1407 avail_out
= obstack_room (ob
);
1410 as_fatal (_("can't extend frag"));
1411 next_out
= obstack_next_free (ob
);
1412 obstack_blank_fast (ob
, avail_out
);
1413 out_size
= compress_data (strm
, &contents
, &in_size
,
1414 &next_out
, &avail_out
);
1418 f
->fr_fix
+= out_size
;
1419 total_out_size
+= out_size
;
1421 /* Return unused space. */
1423 obstack_blank_fast (ob
, -avail_out
);
1426 return total_out_size
;
1430 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1432 segment_info_type
*seginfo
= seg_info (sec
);
1436 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1437 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1438 bfd_size_type compressed_size
;
1439 const char *section_name
;
1440 char *compressed_name
;
1442 struct z_stream_s
*strm
;
1444 flagword flags
= bfd_section_flags (sec
);
1445 unsigned int header_size
, compression_header_size
;
1449 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1452 section_name
= bfd_section_name (sec
);
1453 if (strncmp (section_name
, ".debug_", 7) != 0)
1456 strm
= compress_init ();
1460 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1462 compression_header_size
1463 = bfd_get_compression_header_size (stdoutput
, NULL
);
1464 header_size
= compression_header_size
;
1468 compression_header_size
= 0;
1472 /* Create a new frag to contain the compression header. */
1473 first_newf
= frag_alloc (ob
);
1474 if (obstack_room (ob
) < header_size
)
1475 first_newf
= frag_alloc (ob
);
1476 if (obstack_room (ob
) < header_size
)
1477 as_fatal (ngettext ("can't extend frag %lu char",
1478 "can't extend frag %lu chars",
1479 (unsigned long) header_size
),
1480 (unsigned long) header_size
);
1481 last_newf
= first_newf
;
1482 obstack_blank_fast (ob
, header_size
);
1483 last_newf
->fr_type
= rs_fill
;
1484 last_newf
->fr_fix
= header_size
;
1485 header
= last_newf
->fr_literal
;
1486 compressed_size
= header_size
;
1488 /* Stream the frags through the compression engine, adding new frags
1489 as necessary to accommodate the compressed output. */
1490 for (f
= seginfo
->frchainP
->frch_root
;
1499 gas_assert (f
->fr_type
== rs_fill
);
1502 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1506 compressed_size
+= out_size
;
1508 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1509 fill_size
= f
->fr_var
;
1510 count
= f
->fr_offset
;
1511 gas_assert (count
>= 0);
1512 if (fill_size
&& count
)
1516 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1520 compressed_size
+= out_size
;
1525 /* Flush the compression state. */
1532 /* Reserve all the space available in the current chunk.
1533 If none is available, start a new frag. */
1534 avail_out
= obstack_room (ob
);
1539 obstack_finish (ob
);
1540 newf
= frag_alloc (ob
);
1541 newf
->fr_type
= rs_fill
;
1542 last_newf
->fr_next
= newf
;
1544 avail_out
= obstack_room (ob
);
1547 as_fatal (_("can't extend frag"));
1548 next_out
= obstack_next_free (ob
);
1549 obstack_blank_fast (ob
, avail_out
);
1550 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1554 last_newf
->fr_fix
+= out_size
;
1555 compressed_size
+= out_size
;
1557 /* Return unused space. */
1559 obstack_blank_fast (ob
, -avail_out
);
1565 /* PR binutils/18087: If compression didn't make the section smaller,
1566 just keep it uncompressed. */
1567 if (compressed_size
>= uncompressed_size
)
1570 /* Replace the uncompressed frag list with the compressed frag list. */
1571 seginfo
->frchainP
->frch_root
= first_newf
;
1572 seginfo
->frchainP
->frch_last
= last_newf
;
1574 /* Update the section size and its name. */
1575 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1576 x
= bfd_set_section_size (sec
, compressed_size
);
1578 if (!compression_header_size
)
1580 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1581 bfd_rename_section (sec
, compressed_name
);
1585 #ifndef md_generate_nops
1586 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1587 backend must override this with proper no-op instructions. */
1590 md_generate_nops (fragS
*f ATTRIBUTE_UNUSED
,
1591 char *where ATTRIBUTE_UNUSED
,
1592 offsetT count ATTRIBUTE_UNUSED
,
1593 int control ATTRIBUTE_UNUSED
)
1595 as_bad (_("unimplemented .nops directive"));
1600 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1602 void *xxx ATTRIBUTE_UNUSED
)
1604 segment_info_type
*seginfo
= seg_info (sec
);
1605 addressT offset
= 0;
1608 /* Write out the frags. */
1610 || !(bfd_section_flags (sec
) & SEC_HAS_CONTENTS
))
1613 for (f
= seginfo
->frchainP
->frch_root
;
1622 gas_assert (f
->fr_type
== rs_fill
|| f
->fr_type
== rs_fill_nop
);
1625 x
= bfd_set_section_contents (stdoutput
, sec
,
1626 f
->fr_literal
, (file_ptr
) offset
,
1627 (bfd_size_type
) f
->fr_fix
);
1629 as_fatal (ngettext ("can't write %ld byte "
1630 "to section %s of %s: '%s'",
1631 "can't write %ld bytes "
1632 "to section %s of %s: '%s'",
1635 bfd_section_name (sec
), bfd_get_filename (stdoutput
),
1636 bfd_errmsg (bfd_get_error ()));
1637 offset
+= f
->fr_fix
;
1640 fill_size
= f
->fr_var
;
1641 count
= f
->fr_offset
;
1642 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1644 if (f
->fr_type
== rs_fill_nop
)
1646 gas_assert (count
>= 0 && fill_size
== 1);
1649 char *buf
= xmalloc (count
);
1650 md_generate_nops (f
, buf
, count
, *fill_literal
);
1651 x
= bfd_set_section_contents
1652 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1653 (bfd_size_type
) count
);
1655 as_fatal (ngettext ("can't fill %ld byte "
1656 "in section %s of %s: '%s'",
1657 "can't fill %ld bytes "
1658 "in section %s of %s: '%s'",
1661 bfd_section_name (sec
),
1662 bfd_get_filename (stdoutput
),
1663 bfd_errmsg (bfd_get_error ()));
1670 gas_assert (count
>= 0);
1671 if (fill_size
&& count
)
1674 if (fill_size
> sizeof (buf
))
1676 /* Do it the old way. Can this ever happen? */
1679 x
= bfd_set_section_contents (stdoutput
, sec
,
1682 (bfd_size_type
) fill_size
);
1684 as_fatal (ngettext ("can't fill %ld byte "
1685 "in section %s of %s: '%s'",
1686 "can't fill %ld bytes "
1687 "in section %s of %s: '%s'",
1690 bfd_section_name (sec
),
1691 bfd_get_filename (stdoutput
),
1692 bfd_errmsg (bfd_get_error ()));
1693 offset
+= fill_size
;
1698 /* Build a buffer full of fill objects and output it as
1699 often as necessary. This saves on the overhead of
1700 potentially lots of bfd_set_section_contents calls. */
1704 n_per_buf
= sizeof (buf
);
1705 memset (buf
, *fill_literal
, n_per_buf
);
1710 n_per_buf
= sizeof (buf
) / fill_size
;
1711 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1712 memcpy (bufp
, fill_literal
, fill_size
);
1714 for (; count
> 0; count
-= n_per_buf
)
1716 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1717 x
= bfd_set_section_contents
1718 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1719 (bfd_size_type
) n_per_buf
* fill_size
);
1721 as_fatal (ngettext ("can't fill %ld byte "
1722 "in section %s of %s: '%s'",
1723 "can't fill %ld bytes "
1724 "in section %s of %s: '%s'",
1725 (long) (n_per_buf
* fill_size
)),
1726 (long) (n_per_buf
* fill_size
),
1727 bfd_section_name (sec
),
1728 bfd_get_filename (stdoutput
),
1729 bfd_errmsg (bfd_get_error ()));
1730 offset
+= n_per_buf
* fill_size
;
1738 merge_data_into_text (void)
1740 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1741 seg_info (data_section
)->frchainP
->frch_root
;
1742 seg_info (text_section
)->frchainP
->frch_last
=
1743 seg_info (data_section
)->frchainP
->frch_last
;
1744 seg_info (data_section
)->frchainP
= 0;
1755 /* Count symbols. We can't rely on a count made by the loop in
1756 write_object_file, because *_frob_file may add a new symbol or
1757 two. Generate unused section symbols only if needed. */
1759 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1760 if (bfd_keep_unused_section_symbols (stdoutput
)
1761 || !symbol_section_p (symp
)
1762 || symbol_used_in_reloc_p (symp
))
1768 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1770 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1771 symp
= symbol_rootP
;
1772 for (i
= 0; i
< nsyms
; symp
= symbol_next (symp
))
1773 if (bfd_keep_unused_section_symbols (stdoutput
)
1774 || !symbol_section_p (symp
)
1775 || symbol_used_in_reloc_p (symp
))
1777 asympp
[i
] = symbol_get_bfdsym (symp
);
1778 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1779 || !(bfd_is_const_section (asympp
[i
]->section
)
1780 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1781 asympp
[i
]->flags
|= BSF_KEEP
;
1782 symbol_mark_written (symp
);
1783 /* Include this section symbol in the symbol table. */
1784 if (symbol_section_p (symp
))
1785 asympp
[i
]->flags
|= BSF_SECTION_SYM_USED
;
1791 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1792 gas_assert (result
);
1793 symbol_table_frozen
= 1;
1796 /* Finish the subsegments. After every sub-segment, we fake an
1797 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1798 ".fill 0" because that is the kind of frag that requires least
1799 thought. ".align" frags like to have a following frag since that
1800 makes calculating their intended length trivial. */
1802 #ifndef SUB_SEGMENT_ALIGN
1804 /* The last subsegment gets an alignment corresponding to the alignment
1805 of the section. This allows proper nop-filling at the end of
1806 code-bearing sections. */
1807 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1808 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1809 && !do_not_pad_sections_to_alignment \
1810 ? get_recorded_alignment (SEG) \
1813 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1818 subsegs_finish_section (asection
*s
)
1820 struct frchain
*frchainP
;
1821 segment_info_type
*seginfo
= seg_info (s
);
1825 for (frchainP
= seginfo
->frchainP
;
1827 frchainP
= frchainP
->frch_next
)
1831 subseg_set (s
, frchainP
->frch_subseg
);
1833 /* This now gets called even if we had errors. In that case,
1834 any alignment is meaningless, and, moreover, will look weird
1835 if we are generating a listing. */
1837 do_not_pad_sections_to_alignment
= 1;
1839 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1840 if ((bfd_section_flags (now_seg
) & SEC_MERGE
)
1841 && now_seg
->entsize
)
1843 unsigned int entsize
= now_seg
->entsize
;
1846 while ((entsize
& 1) == 0)
1852 if (entalign
> alignment
)
1853 alignment
= entalign
;
1856 if (subseg_text_p (now_seg
))
1857 frag_align_code (alignment
, 0);
1859 frag_align (alignment
, 0, 0);
1861 /* frag_align will have left a new frag.
1862 Use this last frag for an empty ".fill".
1864 For this segment ...
1865 Create a last frag. Do not leave a "being filled in frag". */
1866 frag_wane (frag_now
);
1867 frag_now
->fr_fix
= 0;
1868 know (frag_now
->fr_next
== NULL
);
1873 subsegs_finish (void)
1877 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1878 subsegs_finish_section (s
);
1883 create_obj_attrs_section (void)
1890 size
= bfd_elf_obj_attr_size (stdoutput
);
1894 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1896 name
= ".gnu.attributes";
1897 s
= subseg_new (name
, 0);
1898 elf_section_type (s
)
1899 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1900 bfd_set_section_flags (s
, SEC_READONLY
| SEC_DATA
);
1902 p
= frag_more (size
);
1903 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1905 subsegs_finish_section (s
);
1906 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1907 size_seg (stdoutput
, s
, NULL
);
1910 /* Create a relocation against an entry in a GNU Build attribute section. */
1913 create_note_reloc (segT sec
,
1915 bfd_size_type note_offset
,
1916 bfd_size_type desc2_offset
,
1922 struct reloc_list
* reloc
;
1924 reloc
= XNEW (struct reloc_list
);
1926 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
1927 reloc
->u
.b
.sec
= sec
;
1928 reloc
->u
.b
.s
= symbol_get_bfdsym (sym
);
1929 reloc
->u
.b
.r
.sym_ptr_ptr
= & reloc
->u
.b
.s
;
1930 reloc
->u
.b
.r
.address
= note_offset
+ desc2_offset
;
1931 reloc
->u
.b
.r
.addend
= addend
;
1932 reloc
->u
.b
.r
.howto
= bfd_reloc_type_lookup (stdoutput
, reloc_type
);
1934 if (reloc
->u
.b
.r
.howto
== NULL
)
1936 as_bad (_("unable to create reloc for build note"));
1940 reloc
->file
= N_("<gnu build note>");
1943 reloc
->next
= reloc_list
;
1946 /* For REL relocs, store the addend in the section. */
1947 if (! sec
->use_rela_p
1948 /* The SH target is a special case that uses RELA relocs
1949 but still stores the addend in the word being relocated. */
1950 || strstr (bfd_get_target (stdoutput
), "-sh") != NULL
)
1954 /* Zero out the addend, since it is now stored in the note. */
1955 reloc
->u
.b
.r
.addend
= 0;
1957 if (target_big_endian
)
1959 for (i
= desc2_size
; addend
!= 0 && i
> 0; addend
>>= 8, i
--)
1960 note
[desc2_offset
+ i
- 1] = (addend
& 0xff);
1964 for (i
= 0; addend
!= 0 && i
< desc2_size
; addend
>>= 8, i
++)
1965 note
[desc2_offset
+ i
] = (addend
& 0xff);
1971 maybe_generate_build_notes (void)
1978 offsetT desc2_offset
;
1983 if (! flag_generate_build_notes
1984 || bfd_get_section_by_name (stdoutput
,
1985 GNU_BUILD_ATTRS_SECTION_NAME
) != NULL
)
1988 /* Create a GNU Build Attribute section. */
1989 sec
= subseg_new (GNU_BUILD_ATTRS_SECTION_NAME
, FALSE
);
1990 elf_section_type (sec
) = SHT_NOTE
;
1991 bfd_set_section_flags (sec
, (SEC_READONLY
| SEC_HAS_CONTENTS
| SEC_DATA
1993 bfd_set_section_alignment (sec
, 2);
1995 /* Work out the size of the notes that we will create,
1996 and the relocation we should use. */
1997 if (bfd_arch_bits_per_address (stdoutput
) <= 32)
2000 desc_size
= 8; /* Two 4-byte offsets. */
2003 /* FIXME: The BFD backend for the CRX target does not support the
2004 BFD_RELOC_32, even though it really should. Likewise for the
2005 CR16 target. So we have special case code here... */
2006 if (strstr (bfd_get_target (stdoutput
), "-crx") != NULL
)
2007 desc_reloc
= BFD_RELOC_CRX_NUM32
;
2008 else if (strstr (bfd_get_target (stdoutput
), "-cr16") != NULL
)
2009 desc_reloc
= BFD_RELOC_CR16_NUM32
;
2011 desc_reloc
= BFD_RELOC_32
;
2016 desc_size
= 16; /* Two 8-byte offsets. */
2018 /* FIXME: The BFD backend for the IA64 target does not support the
2019 BFD_RELOC_64, even though it really should. The HPPA backend
2020 has a similar issue, although it does not support BFD_RELOCs at
2021 all! So we have special case code to handle these targets. */
2022 if (strstr (bfd_get_target (stdoutput
), "-ia64") != NULL
)
2023 desc_reloc
= target_big_endian
? BFD_RELOC_IA64_DIR32MSB
: BFD_RELOC_IA64_DIR32LSB
;
2024 else if (strstr (bfd_get_target (stdoutput
), "-hppa") != NULL
)
2025 desc_reloc
= 80; /* R_PARISC_DIR64. */
2027 desc_reloc
= BFD_RELOC_64
;
2030 /* We have to create a note for *each* code section.
2031 Linker garbage collection might discard some. */
2035 for (sym
= symbol_rootP
; sym
!= NULL
; sym
= symbol_next (sym
))
2036 if ((bsym
= symbol_get_bfdsym (sym
)) != NULL
2037 && bsym
->flags
& BSF_SECTION_SYM
2038 && bsym
->section
!= NULL
2039 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
2040 && (bsym
->section
->flags
& (SEC_CODE
| SEC_LINK_ONCE
)) == SEC_CODE
2041 /* Not all linkonce sections are flagged... */
2042 && strncmp (S_GET_NAME (sym
), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0)
2044 /* Create a version note. */
2046 note
= frag_more (note_size
);
2047 memset (note
, 0, note_size
);
2049 if (target_big_endian
)
2051 note
[3] = 8; /* strlen (name) + 1. */
2052 note
[7] = desc_size
; /* Two N-byte offsets. */
2053 note
[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2054 note
[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2058 note
[0] = 8; /* strlen (name) + 1. */
2059 note
[4] = desc_size
; /* Two N-byte offsets. */
2060 note
[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN
& 0xff;
2061 note
[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN
>> 8;
2064 /* The a1 version number indicates that this note was
2065 generated by the assembler and not the gcc annobin plugin. */
2066 memcpy (note
+ 12, "GA$\ 13a1", 8);
2068 /* Create a relocation to install the start address of the note... */
2069 create_note_reloc (sec
, sym
, total_size
, 20, desc_size
/ 2, desc_reloc
, 0, note
);
2071 /* ...and another one to install the end address. */
2072 create_note_reloc (sec
, sym
, total_size
, desc2_offset
,
2075 bfd_section_size (bsym
->section
),
2078 /* Mark the section symbol used in relocation so that it will be
2079 included in the symbol table. */
2080 symbol_mark_used_in_reloc (sym
);
2082 total_size
+= note_size
;
2083 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2086 /* Install the note(s) into the section. */
2088 bfd_set_section_contents (stdoutput
, sec
, (bfd_byte
*) note
, 0, total_size
);
2089 subsegs_finish_section (sec
);
2090 relax_segment (seg_info (sec
)->frchainP
->frch_root
, sec
, 0);
2091 size_seg (stdoutput
, sec
, NULL
);
2093 #endif /* OBJ_ELF */
2095 /* Write the object file. */
2098 write_object_file (void)
2100 struct relax_seg_info rsi
;
2101 #ifndef WORKING_DOT_WORD
2102 fragS
*fragP
; /* Track along all frags. */
2107 #ifdef md_pre_output_hook
2111 #ifdef md_pre_relax_hook
2115 /* From now on, we don't care about sub-segments. Build one frag chain
2116 for each segment. Linked through fr_next. */
2118 /* Remove the sections created by gas for its own purposes. */
2122 bfd_section_list_remove (stdoutput
, reg_section
);
2123 bfd_section_list_remove (stdoutput
, expr_section
);
2124 stdoutput
->section_count
-= 2;
2126 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
2129 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
2131 /* We have two segments. If user gave -R flag, then we must put the
2132 data frags into the text segment. Do this before relaxing so
2133 we know to take advantage of -R and make shorter addresses. */
2134 if (flag_readonly_data_in_text
)
2136 merge_data_into_text ();
2142 #ifndef WORKING_DOT_WORD
2143 /* We need to reset the markers in the broken word list and
2144 associated frags between calls to relax_segment (via
2145 relax_seg). Since the broken word list is global, we do it
2146 once per round, rather than locally in relax_segment for each
2148 struct broken_word
*brokp
;
2150 for (brokp
= broken_words
;
2151 brokp
!= (struct broken_word
*) NULL
;
2152 brokp
= brokp
->next_broken_word
)
2156 if (brokp
->dispfrag
!= (fragS
*) NULL
2157 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
2158 brokp
->dispfrag
->fr_subtype
= 0;
2163 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
2169 /* Note - Most ports will use the default value of
2170 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2171 local symbols to be resolved, removing their frag information.
2172 Some ports however, will not have finished relaxing all of
2173 their frags and will still need the local symbol frag
2174 information. These ports can set
2175 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2176 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
2178 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
2180 /* Relaxation has completed. Freeze all syms. */
2183 dwarf2dbg_final_check ();
2185 #ifdef md_post_relax_hook
2191 create_obj_attrs_section ();
2194 #ifndef WORKING_DOT_WORD
2196 struct broken_word
*lie
;
2197 struct broken_word
**prevP
;
2199 prevP
= &broken_words
;
2200 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
2205 subseg_change (lie
->seg
, lie
->subseg
);
2206 exp
.X_op
= O_subtract
;
2207 exp
.X_add_symbol
= lie
->add
;
2208 exp
.X_op_symbol
= lie
->sub
;
2209 exp
.X_add_number
= lie
->addnum
;
2210 #ifdef TC_CONS_FIX_NEW
2211 TC_CONS_FIX_NEW (lie
->frag
,
2212 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2213 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
2215 fix_new_exp (lie
->frag
,
2216 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2217 2, &exp
, 0, BFD_RELOC_16
);
2219 *prevP
= lie
->next_broken_word
;
2222 prevP
= &(lie
->next_broken_word
);
2224 for (lie
= broken_words
; lie
;)
2226 struct broken_word
*untruth
;
2228 addressT table_addr
;
2229 addressT from_addr
, to_addr
;
2232 subseg_change (lie
->seg
, lie
->subseg
);
2233 fragP
= lie
->dispfrag
;
2235 /* Find out how many broken_words go here. */
2238 untruth
&& untruth
->dispfrag
== fragP
;
2239 untruth
= untruth
->next_broken_word
)
2240 if (untruth
->added
== 1)
2243 table_ptr
= lie
->dispfrag
->fr_opcode
;
2244 table_addr
= (lie
->dispfrag
->fr_address
2245 + (table_ptr
- lie
->dispfrag
->fr_literal
));
2246 /* Create the jump around the long jumps. This is a short
2247 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2248 from_addr
= table_addr
;
2249 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
2250 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2252 table_ptr
+= md_short_jump_size
;
2253 table_addr
+= md_short_jump_size
;
2256 lie
&& lie
->dispfrag
== fragP
;
2257 m
++, lie
= lie
->next_broken_word
)
2259 if (lie
->added
== 2)
2261 /* Patch the jump table. */
2262 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2263 untruth
&& untruth
->dispfrag
== fragP
;
2264 untruth
= untruth
->next_broken_word
)
2266 if (untruth
->use_jump
== lie
)
2268 /* This is the offset from ??? to table_ptr+0.
2269 The target is the same for all users of this
2270 md_long_jump, but the "sub" bases (and hence the
2271 offsets) may be different. */
2272 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
2273 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2274 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
2276 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2280 /* Install the long jump. */
2281 /* This is a long jump from table_ptr+0 to the final target. */
2282 from_addr
= table_addr
;
2283 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2284 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2286 table_ptr
+= md_long_jump_size
;
2287 table_addr
+= md_long_jump_size
;
2291 #endif /* not WORKING_DOT_WORD */
2293 /* Resolve symbol values. This needs to be done before processing
2299 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2300 resolve_symbol_value (symp
);
2302 resolve_local_symbol_values ();
2303 resolve_reloc_expr_symbols ();
2307 maybe_generate_build_notes ();
2312 #ifdef tc_frob_file_before_adjust
2313 tc_frob_file_before_adjust ();
2315 #ifdef obj_frob_file_before_adjust
2316 obj_frob_file_before_adjust ();
2319 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2321 #ifdef tc_frob_file_before_fix
2322 tc_frob_file_before_fix ();
2324 #ifdef obj_frob_file_before_fix
2325 obj_frob_file_before_fix ();
2328 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2330 /* Set up symbol table, and write it out. */
2334 bfd_boolean skip_next_symbol
= FALSE
;
2336 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2341 if (skip_next_symbol
)
2343 /* Don't do anything besides moving the value of the
2344 symbol from the GAS value-field to the BFD value-field. */
2345 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2346 skip_next_symbol
= FALSE
;
2350 if (symbol_mri_common_p (symp
))
2352 if (S_IS_EXTERNAL (symp
))
2353 as_bad (_("%s: global symbols not supported in common sections"),
2355 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2359 name
= S_GET_NAME (symp
);
2363 decode_local_label_name ((char *) S_GET_NAME (symp
));
2364 /* They only differ if `name' is a fb or dollar local
2366 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2367 as_bad (_("local label `%s' is not defined"), name2
);
2370 /* Do it again, because adjust_reloc_syms might introduce
2371 more symbols. They'll probably only be section symbols,
2372 but they'll still need to have the values computed. */
2373 resolve_symbol_value (symp
);
2375 /* Skip symbols which were equated to undefined or common
2377 if (symbol_equated_reloc_p (symp
)
2378 || S_IS_WEAKREFR (symp
))
2380 const char *sname
= S_GET_NAME (symp
);
2382 if (S_IS_COMMON (symp
)
2383 && !TC_FAKE_LABEL (sname
)
2384 && !S_IS_WEAKREFR (symp
))
2386 expressionS
*e
= symbol_get_value_expression (symp
);
2388 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2389 sname
, S_GET_NAME (e
->X_add_symbol
));
2391 if (S_GET_SEGMENT (symp
) == reg_section
)
2393 /* Report error only if we know the symbol name. */
2394 if (S_GET_NAME (symp
) != reg_section
->name
)
2395 as_bad (_("can't make global register symbol `%s'"),
2398 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2402 #ifdef obj_frob_symbol
2403 obj_frob_symbol (symp
, punt
);
2405 #ifdef tc_frob_symbol
2406 if (! punt
|| symbol_used_in_reloc_p (symp
))
2407 tc_frob_symbol (symp
, punt
);
2410 /* If we don't want to keep this symbol, splice it out of
2411 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2412 want section symbols. Otherwise, we skip local symbols
2413 and symbols that the frob_symbol macros told us to punt,
2414 but we keep such symbols if they are used in relocs. */
2415 if (symp
== abs_section_sym
2416 || (! EMIT_SECTION_SYMBOLS
2417 && symbol_section_p (symp
))
2418 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2419 opposites. Sometimes the former checks flags and the
2420 latter examines the name... */
2421 || (!S_IS_EXTERNAL (symp
)
2422 && (punt
|| S_IS_LOCAL (symp
) ||
2423 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2424 && ! symbol_used_in_reloc_p (symp
)))
2426 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2428 /* After symbol_remove, symbol_next(symp) still returns
2429 the one that came after it in the chain. So we don't
2430 need to do any extra cleanup work here. */
2434 /* Make sure we really got a value for the symbol. */
2435 if (! symbol_resolved_p (symp
))
2437 as_bad (_("can't resolve value for symbol `%s'"),
2439 symbol_mark_resolved (symp
);
2442 /* Set the value into the BFD symbol. Up til now the value
2443 has only been kept in the gas symbolS struct. */
2444 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2446 /* A warning construct is a warning symbol followed by the
2447 symbol warned about. Don't let anything object-format or
2448 target-specific muck with it; it's ready for output. */
2449 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2450 skip_next_symbol
= TRUE
;
2456 /* Now do any format-specific adjustments to the symbol table, such
2457 as adding file symbols. */
2458 #ifdef tc_adjust_symtab
2459 tc_adjust_symtab ();
2461 #ifdef obj_adjust_symtab
2462 obj_adjust_symtab ();
2465 /* Stop if there is an error. */
2466 if (!flag_always_generate_output
&& had_errors ())
2469 /* Now that all the sizes are known, and contents correct, we can
2470 start writing to the file. */
2473 /* If *_frob_file changes the symbol value at this point, it is
2474 responsible for moving the changed value into symp->bsym->value
2475 as well. Hopefully all symbol value changing can be done in
2480 #ifdef obj_frob_file
2483 #ifdef obj_coff_generate_pdata
2484 obj_coff_generate_pdata ();
2487 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2489 #ifdef tc_frob_file_after_relocs
2490 tc_frob_file_after_relocs ();
2492 #ifdef obj_frob_file_after_relocs
2493 obj_frob_file_after_relocs ();
2496 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2497 if (IS_ELF
&& flag_use_elf_stt_common
)
2498 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2501 /* Once all relocations have been written, we can compress the
2502 contents of the debug sections. This needs to be done before
2503 we start writing any sections, because it will affect the file
2504 layout, which is fixed once we start writing contents. */
2505 if (flag_compress_debug
)
2507 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2508 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2510 stdoutput
->flags
|= BFD_COMPRESS
;
2511 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2514 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2517 #ifdef TC_GENERIC_RELAX_TABLE
2518 #ifndef md_generic_table_relax_frag
2519 #define md_generic_table_relax_frag relax_frag
2522 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2525 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2527 const relax_typeS
*this_type
;
2528 const relax_typeS
*start_type
;
2529 relax_substateT next_state
;
2530 relax_substateT this_state
;
2536 const relax_typeS
*table
;
2538 target
= fragP
->fr_offset
;
2539 address
= fragP
->fr_address
+ fragP
->fr_fix
;
2540 table
= TC_GENERIC_RELAX_TABLE
;
2541 this_state
= fragP
->fr_subtype
;
2542 start_type
= this_type
= table
+ this_state
;
2543 symbolP
= fragP
->fr_symbol
;
2549 sym_frag
= symbol_get_frag (symbolP
);
2551 #ifndef DIFF_EXPR_OK
2552 know (sym_frag
!= NULL
);
2554 know (S_GET_SEGMENT (symbolP
) != absolute_section
2555 || sym_frag
== &zero_address_frag
);
2556 target
+= S_GET_VALUE (symbolP
);
2558 /* If SYM_FRAG has yet to be reached on this pass, assume it
2559 will move by STRETCH just as we did, unless there is an
2560 alignment frag between here and SYM_FRAG. An alignment may
2561 well absorb any STRETCH, and we don't want to choose a larger
2562 branch insn by overestimating the needed reach of this
2563 branch. It isn't critical to calculate TARGET exactly; We
2564 know we'll be doing another pass if STRETCH is non-zero. */
2567 && sym_frag
->relax_marker
!= fragP
->relax_marker
2568 && S_GET_SEGMENT (symbolP
) == segment
)
2571 || sym_frag
->region
== fragP
->region
)
2573 /* If we get here we know we have a forward branch. This
2574 relax pass may have stretched previous instructions so
2575 far that omitting STRETCH would make the branch
2576 negative. Don't allow this in case the negative reach is
2577 large enough to require a larger branch instruction. */
2578 else if (target
< address
)
2583 aim
= target
- address
;
2584 #ifdef TC_PCREL_ADJUST
2585 /* Currently only the ns32k and arc needs this. */
2586 aim
+= TC_PCREL_ADJUST (fragP
);
2589 #ifdef md_prepare_relax_scan
2590 /* Formerly called M68K_AIM_KLUDGE. */
2591 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2596 /* Look backwards. */
2597 for (next_state
= this_type
->rlx_more
; next_state
;)
2598 if (aim
>= this_type
->rlx_backward
)
2602 /* Grow to next state. */
2603 this_state
= next_state
;
2604 this_type
= table
+ this_state
;
2605 next_state
= this_type
->rlx_more
;
2610 /* Look forwards. */
2611 for (next_state
= this_type
->rlx_more
; next_state
;)
2612 if (aim
<= this_type
->rlx_forward
)
2616 /* Grow to next state. */
2617 this_state
= next_state
;
2618 this_type
= table
+ this_state
;
2619 next_state
= this_type
->rlx_more
;
2623 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2625 fragP
->fr_subtype
= this_state
;
2629 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2631 /* Relax_align. Advance location counter to next address that has 'alignment'
2632 lowest order bits all 0s, return size of adjustment made. */
2633 static relax_addressT
2634 relax_align (relax_addressT address
, /* Address now. */
2635 int alignment
/* Alignment (binary). */)
2637 relax_addressT mask
;
2638 relax_addressT new_address
;
2640 mask
= ~((relax_addressT
) ~0 << alignment
);
2641 new_address
= (address
+ mask
) & (~mask
);
2642 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2644 /* We must provide lots of padding, so the linker can discard it
2645 when needed. The linker will not add extra space, ever. */
2646 new_address
+= (1 << alignment
);
2648 return (new_address
- address
);
2651 /* Now we have a segment, not a crowd of sub-segments, we can make
2656 After this, all frags in this segment have addresses that are correct
2657 within the segment. Since segments live in different file addresses,
2658 these frag addresses may not be the same as final object-file
2662 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2664 unsigned long frag_count
;
2666 relax_addressT address
;
2670 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2671 subseg_change (segment
, 0);
2673 /* For each frag in segment: count and store (a 1st guess of)
2677 for (frag_count
= 0, fragP
= segment_frag_root
;
2679 fragP
= fragP
->fr_next
, frag_count
++)
2681 fragP
->region
= region
;
2682 fragP
->relax_marker
= 0;
2683 fragP
->fr_address
= address
;
2684 address
+= fragP
->fr_fix
;
2686 switch (fragP
->fr_type
)
2689 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2696 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2698 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2701 if (offset
% fragP
->fr_var
!= 0)
2703 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2704 ngettext ("alignment padding (%lu byte) "
2705 "not a multiple of %ld",
2706 "alignment padding (%lu bytes) "
2707 "not a multiple of %ld",
2708 (unsigned long) offset
),
2709 (unsigned long) offset
, (long) fragP
->fr_var
);
2710 offset
-= (offset
% fragP
->fr_var
);
2719 /* Assume .org is nugatory. It will grow with 1st relax. */
2727 case rs_machine_dependent
:
2728 /* If fr_symbol is an expression, this call to
2729 resolve_symbol_value sets up the correct segment, which will
2730 likely be needed in md_estimate_size_before_relax. */
2731 if (fragP
->fr_symbol
)
2732 resolve_symbol_value (fragP
->fr_symbol
);
2734 address
+= md_estimate_size_before_relax (fragP
, segment
);
2737 #ifndef WORKING_DOT_WORD
2738 /* Broken words don't concern us yet. */
2739 case rs_broken_word
:
2744 /* Initial guess is always 1; doing otherwise can result in
2745 stable solutions that are larger than the minimum. */
2746 address
+= fragP
->fr_offset
= 1;
2750 address
+= eh_frame_estimate_size_before_relax (fragP
);
2754 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2758 BAD_CASE (fragP
->fr_type
);
2765 unsigned long max_iterations
;
2767 /* Cumulative address adjustment. */
2770 /* Have we made any adjustment this pass? We can't just test
2771 stretch because one piece of code may have grown and another
2775 /* Most horrible, but gcc may give us some exception data that
2776 is impossible to assemble, of the form
2780 .uleb128 end - start
2786 If the leb128 is two bytes in size, then end-start is 128*128,
2787 which requires a three byte leb128. If the leb128 is three
2788 bytes in size, then end-start is 128*128-1, which requires a
2789 two byte leb128. We work around this dilemma by inserting
2790 an extra 4 bytes of alignment just after the .align. This
2791 works because the data after the align is accessed relative to
2794 This counter is used in a tiny state machine to detect
2795 whether a leb128 followed by an align is impossible to
2797 int rs_leb128_fudge
= 0;
2799 /* We want to prevent going into an infinite loop where one frag grows
2800 depending upon the location of a symbol which is in turn moved by
2801 the growing frag. eg:
2807 So we dictate that this algorithm can be at most O2. */
2808 max_iterations
= frag_count
* frag_count
;
2809 /* Check for overflow. */
2810 if (max_iterations
< frag_count
)
2811 max_iterations
= frag_count
;
2819 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2822 addressT was_address
;
2826 fragP
->relax_marker
^= 1;
2827 was_address
= fragP
->fr_address
;
2828 address
= fragP
->fr_address
+= stretch
;
2829 symbolP
= fragP
->fr_symbol
;
2830 offset
= fragP
->fr_offset
;
2832 switch (fragP
->fr_type
)
2834 case rs_fill
: /* .fill never relaxes. */
2838 #ifndef WORKING_DOT_WORD
2839 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2840 for it I do not want to write it. I do not want to have
2841 anything to do with it. This is not the proper way to
2842 implement this misfeature. */
2843 case rs_broken_word
:
2845 struct broken_word
*lie
;
2846 struct broken_word
*untruth
;
2848 /* Yes this is ugly (storing the broken_word pointer
2849 in the symbol slot). Still, this whole chunk of
2850 code is ugly, and I don't feel like doing anything
2851 about it. Think of it as stubbornness in action. */
2853 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2854 lie
&& lie
->dispfrag
== fragP
;
2855 lie
= lie
->next_broken_word
)
2861 offset
= (S_GET_VALUE (lie
->add
)
2863 - S_GET_VALUE (lie
->sub
));
2864 if (offset
<= -32768 || offset
>= 32767)
2866 if (flag_warn_displacement
)
2869 sprint_value (buf
, (addressT
) lie
->addnum
);
2870 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2871 _(".word %s-%s+%s didn't fit"),
2872 S_GET_NAME (lie
->add
),
2873 S_GET_NAME (lie
->sub
),
2876 if (fragP
->fr_subtype
== 0)
2878 fragP
->fr_subtype
++;
2879 growth
+= md_short_jump_size
;
2882 /* Redirect *all* words of this table with the same
2883 target, lest we have to handle the case where the
2884 same target but with a offset that fits on this
2885 round overflows at the next relaxation round. */
2886 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2887 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2888 untruth
= untruth
->next_broken_word
)
2889 if ((symbol_get_frag (untruth
->add
)
2890 == symbol_get_frag (lie
->add
))
2891 && (S_GET_VALUE (untruth
->add
)
2892 == S_GET_VALUE (lie
->add
)))
2895 untruth
->use_jump
= lie
;
2899 growth
+= md_long_jump_size
;
2904 } /* case rs_broken_word */
2910 addressT oldoff
, newoff
;
2912 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2914 newoff
= relax_align (address
+ fragP
->fr_fix
,
2917 if (fragP
->fr_subtype
!= 0)
2919 if (oldoff
> fragP
->fr_subtype
)
2921 if (newoff
> fragP
->fr_subtype
)
2925 growth
= newoff
- oldoff
;
2927 /* If this align happens to follow a leb128 and
2928 we have determined that the leb128 is bouncing
2929 in size, then break the cycle by inserting an
2932 && (rs_leb128_fudge
& 16) != 0
2933 && (rs_leb128_fudge
& 15) >= 2)
2935 segment_info_type
*seginfo
= seg_info (segment
);
2936 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2939 newf
= frag_alloc (ob
);
2940 obstack_blank_fast (ob
, fragP
->fr_var
);
2941 obstack_finish (ob
);
2942 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2943 memcpy (newf
->fr_literal
,
2944 fragP
->fr_literal
+ fragP
->fr_fix
,
2946 newf
->fr_type
= rs_fill
;
2947 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2949 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2951 if (newf
->fr_offset
* newf
->fr_var
2952 != (offsetT
) 1 << fragP
->fr_offset
)
2954 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2957 /* Include size of new frag in GROWTH. */
2958 growth
+= newf
->fr_offset
* newf
->fr_var
;
2959 /* Adjust the new frag address for the amount
2960 we'll add when we process the new frag. */
2961 newf
->fr_address
-= stretch
+ growth
;
2962 newf
->relax_marker
^= 1;
2963 fragP
->fr_next
= newf
;
2965 as_warn (_("padding added"));
2973 offsetT target
= offset
;
2978 /* Convert from an actual address to an octet offset
2979 into the section. Here it is assumed that the
2980 section's VMA is zero, and can omit subtracting it
2981 from the symbol's value to get the address offset. */
2982 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2983 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2986 know (fragP
->fr_next
);
2987 after
= fragP
->fr_next
->fr_address
+ stretch
;
2988 growth
= target
- after
;
2990 /* Growth may be negative, but variable part of frag
2991 cannot have fewer than 0 chars. That is, we can't
2993 if ((offsetT
) (address
+ fragP
->fr_fix
) > target
)
2997 /* Don't error on first few frag relax passes.
2998 The symbol might be an expression involving
2999 symbol values from other sections. If those
3000 sections have not yet been processed their
3001 frags will all have zero addresses, so we
3002 will calculate incorrect values for them. The
3003 number of passes we allow before giving an
3004 error is somewhat arbitrary. It should be at
3005 least one, with larger values requiring
3006 increasingly contrived dependencies between
3007 frags to trigger a false error. */
3010 /* Force another pass. */
3015 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3016 _("attempt to move .org backwards"));
3018 /* We've issued an error message. Change the
3019 frag to avoid cascading errors. */
3020 fragP
->fr_type
= rs_align
;
3021 fragP
->fr_subtype
= 0;
3022 fragP
->fr_offset
= 0;
3023 fragP
->fr_fix
= after
- address
;
3035 amount
= S_GET_VALUE (symbolP
);
3036 if (S_GET_SEGMENT (symbolP
) != absolute_section
3037 || S_IS_COMMON (symbolP
)
3038 || ! S_IS_DEFINED (symbolP
))
3040 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3041 _(".space, .nops or .fill specifies non-absolute value"));
3042 /* Prevent repeat of this error message. */
3043 fragP
->fr_symbol
= 0;
3045 else if (amount
< 0)
3047 /* Don't error on first few frag relax passes.
3048 See rs_org comment for a longer explanation. */
3055 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3056 _(".space, .nops or .fill with negative value, ignored"));
3057 fragP
->fr_symbol
= 0;
3060 growth
= (was_address
+ fragP
->fr_fix
+ amount
3061 - fragP
->fr_next
->fr_address
);
3065 case rs_machine_dependent
:
3066 #ifdef md_relax_frag
3067 growth
= md_relax_frag (segment
, fragP
, stretch
);
3069 #ifdef TC_GENERIC_RELAX_TABLE
3070 /* The default way to relax a frag is to look through
3071 TC_GENERIC_RELAX_TABLE. */
3072 growth
= md_generic_table_relax_frag (segment
, fragP
,
3074 #endif /* TC_GENERIC_RELAX_TABLE */
3083 value
= resolve_symbol_value (fragP
->fr_symbol
);
3084 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
3085 growth
= size
- fragP
->fr_offset
;
3086 fragP
->fr_offset
= size
;
3091 growth
= eh_frame_relax_frag (fragP
);
3095 growth
= dwarf2dbg_relax_frag (fragP
);
3099 BAD_CASE (fragP
->fr_type
);
3106 if (fragP
->fr_type
== rs_leb128
)
3107 rs_leb128_fudge
+= 16;
3108 else if (fragP
->fr_type
== rs_align
3109 && (rs_leb128_fudge
& 16) != 0
3111 rs_leb128_fudge
+= 16;
3113 rs_leb128_fudge
= 0;
3118 && (rs_leb128_fudge
& 16) == 0
3119 && (rs_leb128_fudge
& -16) != 0)
3120 rs_leb128_fudge
+= 1;
3122 rs_leb128_fudge
= 0;
3124 /* Until nothing further to relax. */
3125 while (stretched
&& -- max_iterations
);
3128 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3129 segment_name (segment
));
3132 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3133 if (fragP
->last_fr_address
!= fragP
->fr_address
)
3135 fragP
->last_fr_address
= fragP
->fr_address
;
3142 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
3148 buf
[n
] = val
& 0xff;
3154 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
3160 *buf
++ = val
& 0xff;
3166 write_print_statistics (FILE *file
)
3168 fprintf (file
, "fixups: %d\n", n_fixups
);
3171 /* For debugging. */
3172 extern int indent_level
;
3175 print_fixup (fixS
*fixp
)
3178 fprintf (stderr
, "fix ");
3179 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
3180 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
3182 fprintf (stderr
, " pcrel");
3183 if (fixp
->fx_pcrel_adjust
)
3184 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
3186 fprintf (stderr
, " tcbit");
3188 fprintf (stderr
, " done");
3189 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
3190 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
3191 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
3192 (long) fixp
->fx_where
,
3193 (unsigned long) fixp
->fx_offset
,
3194 (unsigned long) fixp
->fx_addnumber
);
3195 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
3199 fprintf (stderr
, "\n +<");
3200 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
3201 fprintf (stderr
, ">");
3205 fprintf (stderr
, "\n -<");
3206 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3207 fprintf (stderr
, ">");
3209 fprintf (stderr
, "\n");
3210 #ifdef TC_FIX_DATA_PRINT
3211 TC_FIX_DATA_PRINT (stderr
, fixp
);