1 /* write.c - emit .o file
2 Copyright (C) 1986-2018 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 int where
, /* Where in that frag? */
147 int 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 %d"), 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_im_disp
= 0;
178 fixP
->fx_pcrel_adjust
= 0;
179 fixP
->fx_bit_fixP
= 0;
180 fixP
->fx_addnumber
= 0;
184 fixP
->fx_no_overflow
= 0;
188 fixP
->fx_cgen
.insn
= NULL
;
189 fixP
->fx_cgen
.opinfo
= 0;
193 TC_INIT_FIX_DATA (fixP
);
196 fixP
->fx_file
= as_where (&fixP
->fx_line
);
200 fixS
**seg_fix_rootP
= (frags_chained
201 ? &seg_info (now_seg
)->fix_root
202 : &frchain_now
->fix_root
);
203 fixS
**seg_fix_tailP
= (frags_chained
204 ? &seg_info (now_seg
)->fix_tail
205 : &frchain_now
->fix_tail
);
209 fixP
->fx_next
= *seg_fix_rootP
;
210 *seg_fix_rootP
= fixP
;
211 if (fixP
->fx_next
== NULL
)
212 *seg_fix_tailP
= fixP
;
216 fixP
->fx_next
= NULL
;
218 (*seg_fix_tailP
)->fx_next
= fixP
;
220 *seg_fix_rootP
= fixP
;
221 *seg_fix_tailP
= fixP
;
228 /* Create a fixup relative to a symbol (plus a constant). */
231 fix_new (fragS
*frag
, /* Which frag? */
232 int where
, /* Where in that frag? */
233 int size
, /* 1, 2, or 4 usually. */
234 symbolS
*add_symbol
, /* X_add_symbol. */
235 offsetT offset
, /* X_add_number. */
236 int pcrel
, /* TRUE if PC-relative relocation. */
237 RELOC_ENUM r_type
/* Relocation type. */)
239 return fix_new_internal (frag
, where
, size
, add_symbol
,
240 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
243 /* Create a fixup for an expression. Currently we only support fixups
244 for difference expressions. That is itself more than most object
245 file formats support anyhow. */
248 fix_new_exp (fragS
*frag
, /* Which frag? */
249 int where
, /* Where in that frag? */
250 int size
, /* 1, 2, or 4 usually. */
251 expressionS
*exp
, /* Expression. */
252 int pcrel
, /* TRUE if PC-relative relocation. */
253 RELOC_ENUM r_type
/* Relocation type. */)
265 as_bad (_("register value used as expression"));
269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
270 the difference expression cannot immediately be reduced. */
272 symbolS
*stmp
= make_expr_symbol (exp
);
274 exp
->X_op
= O_symbol
;
275 exp
->X_op_symbol
= 0;
276 exp
->X_add_symbol
= stmp
;
277 exp
->X_add_number
= 0;
279 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
283 add
= exp
->X_add_symbol
;
284 off
= exp
->X_add_number
;
285 r_type
= BFD_RELOC_RVA
;
289 sub
= exp
->X_add_symbol
;
290 off
= exp
->X_add_number
;
294 sub
= exp
->X_op_symbol
;
297 add
= exp
->X_add_symbol
;
300 off
= exp
->X_add_number
;
304 add
= make_expr_symbol (exp
);
308 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
312 /* Create a fixup at the beginning of FRAG. The arguments are the same
313 as for fix_new, except that WHERE is implicitly 0. */
316 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
317 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
319 return fix_new_internal (frag
, 0, size
, add_symbol
,
320 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
323 /* Generic function to determine whether a fixup requires a relocation. */
325 generic_force_reloc (fixS
*fix
)
327 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
328 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
331 if (fix
->fx_addsy
== NULL
)
334 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
337 /* Append a string onto another string, bumping the pointer along. */
339 append (char **charPP
, char *fromP
, unsigned long length
)
341 /* Don't trust memcpy() of 0 chars. */
345 memcpy (*charPP
, fromP
, length
);
349 /* This routine records the largest alignment seen for each segment.
350 If the beginning of the segment is aligned on the worst-case
351 boundary, all of the other alignments within it will work. At
352 least one object format really uses this info. */
355 record_alignment (/* Segment to which alignment pertains. */
357 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
358 boundary, 2 => 4-byte boundary, etc.) */
361 if (seg
== absolute_section
)
364 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
365 bfd_set_section_alignment (stdoutput
, seg
, align
);
369 get_recorded_alignment (segT seg
)
371 if (seg
== absolute_section
)
374 return bfd_get_section_alignment (stdoutput
, seg
);
377 /* Reset the section indices after removing the gas created sections. */
380 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
382 int *countp
= (int *) countparg
;
384 sec
->index
= *countp
;
389 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
391 fragS dummy
, *prev_frag
= &dummy
;
392 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
394 for (; frchp
; frchp
= frchp
->frch_next
)
396 prev_frag
->fr_next
= frchp
->frch_root
;
397 prev_frag
= frchp
->frch_last
;
398 gas_assert (prev_frag
->fr_type
!= 0);
399 if (frchp
->fix_root
!= (fixS
*) NULL
)
401 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
402 seg_info (section
)->fix_root
= frchp
->fix_root
;
403 prev_fix
->fx_next
= frchp
->fix_root
;
404 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
405 prev_fix
= frchp
->fix_tail
;
408 gas_assert (prev_frag
!= &dummy
409 && prev_frag
->fr_type
!= 0);
410 prev_frag
->fr_next
= 0;
415 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
417 void *xxx ATTRIBUTE_UNUSED
)
419 segment_info_type
*info
;
421 /* BFD may have introduced its own sections without using
422 subseg_new, so it is possible that seg_info is NULL. */
423 info
= seg_info (section
);
424 if (info
!= (segment_info_type
*) NULL
)
425 info
->frchainP
->frch_last
426 = chain_frchains_together_1 (section
, info
->frchainP
);
428 /* Now that we've chained the frags together, we must add new fixups
429 to the segment, not to the frag chain. */
434 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
436 switch (fragP
->fr_type
)
446 HANDLE_ALIGN (fragP
);
449 know (fragP
->fr_next
!= NULL
);
450 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
452 - fragP
->fr_fix
) / fragP
->fr_var
;
453 if (fragP
->fr_offset
< 0)
455 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
456 _("attempt to .org/.space/.nops backwards? (%ld)"),
457 (long) fragP
->fr_offset
);
458 fragP
->fr_offset
= 0;
460 if (fragP
->fr_type
== rs_space_nop
)
461 fragP
->fr_type
= rs_fill_nop
;
463 fragP
->fr_type
= rs_fill
;
472 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
475 if (!S_IS_DEFINED (fragP
->fr_symbol
))
477 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
478 _("leb128 operand is an undefined symbol: %s"),
479 S_GET_NAME (fragP
->fr_symbol
));
482 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
485 fragP
->fr_fix
+= size
;
486 fragP
->fr_type
= rs_fill
;
488 fragP
->fr_offset
= 0;
489 fragP
->fr_symbol
= NULL
;
494 eh_frame_convert_frag (fragP
);
498 dwarf2dbg_convert_frag (fragP
);
501 case rs_machine_dependent
:
502 md_convert_frag (stdoutput
, sec
, fragP
);
504 gas_assert (fragP
->fr_next
== NULL
505 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
508 /* After md_convert_frag, we make the frag into a ".space 0".
509 md_convert_frag() should set up any fixSs and constants
514 #ifndef WORKING_DOT_WORD
517 struct broken_word
*lie
;
519 if (fragP
->fr_subtype
)
521 fragP
->fr_fix
+= md_short_jump_size
;
522 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
523 lie
&& lie
->dispfrag
== fragP
;
524 lie
= lie
->next_broken_word
)
526 fragP
->fr_fix
+= md_long_jump_size
;
534 BAD_CASE (fragP
->fr_type
);
538 md_frag_check (fragP
);
542 struct relax_seg_info
549 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
551 segment_info_type
*seginfo
= seg_info (sec
);
552 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
554 if (seginfo
&& seginfo
->frchainP
555 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
560 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
564 segment_info_type
*seginfo
;
566 valueT size
, newsize
;
568 subseg_change (sec
, 0);
570 seginfo
= seg_info (sec
);
571 if (seginfo
&& seginfo
->frchainP
)
573 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
574 cvt_frag_to_fill (sec
, fragp
);
575 for (fragp
= seginfo
->frchainP
->frch_root
;
577 fragp
= fragp
->fr_next
)
578 /* Walk to last elt. */
580 size
= fragp
->fr_address
+ fragp
->fr_fix
;
585 flags
= bfd_get_section_flags (abfd
, sec
);
586 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
587 (flags
& SEC_HAS_CONTENTS
) != 0)
590 if (size
> 0 && ! seginfo
->bss
)
591 flags
|= SEC_HAS_CONTENTS
;
594 x
= bfd_set_section_flags (abfd
, sec
, flags
);
597 /* If permitted, allow the backend to pad out the section
598 to some alignment boundary. */
599 if (do_not_pad_sections_to_alignment
)
602 newsize
= md_section_align (sec
, size
);
603 x
= bfd_set_section_size (abfd
, sec
, newsize
);
606 /* If the size had to be rounded up, add some padding in the last
608 gas_assert (newsize
>= size
);
611 fragS
*last
= seginfo
->frchainP
->frch_last
;
612 fragp
= seginfo
->frchainP
->frch_root
;
613 while (fragp
->fr_next
!= last
)
614 fragp
= fragp
->fr_next
;
615 last
->fr_address
= size
;
616 if ((newsize
- size
) % fragp
->fr_var
== 0)
617 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
619 /* If we hit this abort, it's likely due to subsegs_finish not
620 providing sufficient alignment on the last frag, and the
621 machine dependent code using alignment frags with fr_var
626 #ifdef tc_frob_section
627 tc_frob_section (sec
);
629 #ifdef obj_frob_section
630 obj_frob_section (sec
);
636 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
638 segment_info_type
*seginfo
= seg_info (sec
);
639 fixS
*fixp
= seginfo
->fix_root
;
644 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
647 symbolS
*s
= fixp
->fx_addsy
;
649 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
650 (int) fixp
->fx_r_type
);
652 fprintf (stream
, "no sym\n");
655 print_symbol_value_1 (stream
, s
);
656 fprintf (stream
, "\n");
658 fixp
= fixp
->fx_next
;
662 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
665 #ifndef EMIT_SECTION_SYMBOLS
666 #define EMIT_SECTION_SYMBOLS 1
669 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
670 and check for validity. Convert RELOC_LIST from using U.A fields
673 resolve_reloc_expr_symbols (void)
675 bfd_vma addr_mask
= 1;
676 struct reloc_list
*r
;
678 /* Avoid a shift by the width of type. */
679 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
683 for (r
= reloc_list
; r
; r
= r
->next
)
685 reloc_howto_type
*howto
= r
->u
.a
.howto
;
688 bfd_vma offset
, addend
;
691 resolve_symbol_value (r
->u
.a
.offset_sym
);
692 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
696 if (symval
->X_op
== O_constant
)
697 sym
= r
->u
.a
.offset_sym
;
698 else if (symval
->X_op
== O_symbol
)
700 sym
= symval
->X_add_symbol
;
701 offset
= symval
->X_add_number
;
702 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
705 || symval
->X_op
!= O_constant
706 || (sec
= S_GET_SEGMENT (sym
)) == NULL
707 || !SEG_NORMAL (sec
))
709 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
713 offset
+= S_GET_VALUE (sym
);
716 addend
= r
->u
.a
.addend
;
717 if (r
->u
.a
.sym
!= NULL
)
719 resolve_symbol_value (r
->u
.a
.sym
);
720 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
721 if (symval
->X_op
== O_constant
)
723 else if (symval
->X_op
== O_symbol
)
725 sym
= symval
->X_add_symbol
;
726 addend
+= symval
->X_add_number
;
727 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
729 if (symval
->X_op
!= O_constant
)
731 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
734 else if (sym
!= NULL
&& sec
!= NULL
)
736 /* Convert relocs against local symbols to refer to the
737 corresponding section symbol plus offset instead. Keep
738 PC-relative relocs of the REL variety intact though to
739 prevent the offset from overflowing the relocated field,
740 unless it has enough bits to cover the whole address
742 if (S_IS_LOCAL (sym
) && !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
))
855 symsec
= S_GET_SEGMENT (sym
);
859 if (bfd_is_abs_section (symsec
)
860 || symsec
== reg_section
)
862 /* The fixup_segment routine normally will not use this
863 symbol in a relocation. */
867 /* Don't try to reduce relocs which refer to non-local symbols
868 in .linkonce sections. It can lead to confusion when a
869 debugging section refers to a .linkonce section. I hope
870 this will always be correct. */
871 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
873 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
875 /* The GNU toolchain uses an extension for ELF: a
876 section beginning with the magic string
877 .gnu.linkonce is a linkonce section. */
878 && strncmp (segment_name (symsec
), ".gnu.linkonce",
879 sizeof ".gnu.linkonce" - 1) == 0))
883 /* Never adjust a reloc against local symbol in a merge section
884 with non-zero addend. */
885 if ((symsec
->flags
& SEC_MERGE
) != 0
886 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
889 /* Never adjust a reloc against TLS local symbol. */
890 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
893 /* We refetch the segment when calling section_symbol, rather
894 than using symsec, because S_GET_VALUE may wind up changing
895 the section when it calls resolve_symbol_value. */
896 fixp
->fx_offset
+= S_GET_VALUE (sym
);
897 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
899 fprintf (stderr
, "\nadjusted fixup:\n");
904 dump_section_relocs (abfd
, sec
, stderr
);
909 Go through all the fixS's in a segment and see which ones can be
910 handled now. (These consist of fixS where we have since discovered
911 the value of a symbol, or the address of the frag involved.)
912 For each one, call md_apply_fix to put the fix into the frag data.
913 Ones that we couldn't completely handle here will be output later
914 by emit_relocations. */
917 fixup_segment (fixS
*fixP
, segT this_segment
)
921 segT add_symbol_segment
= absolute_section
;
923 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
924 abs_section_sym
= section_symbol (absolute_section
);
926 /* If the linker is doing the relaxing, we must not do any fixups.
928 Well, strictly speaking that's not true -- we could do any that
929 are PC-relative and don't cross regions that could change size.
930 And for the i960 we might be able to turn callx/callj into bal
931 anyways in cases where we know the maximum displacement. */
932 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
934 for (; fixP
; fixP
= fixP
->fx_next
)
937 if (fixP
->fx_addsy
== NULL
)
939 /* There was no symbol required by this relocation.
940 However, BFD doesn't really handle relocations
941 without symbols well. So fake up a local symbol in
942 the absolute section. */
943 fixP
->fx_addsy
= abs_section_sym
;
945 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
946 if (fixP
->fx_subsy
!= NULL
)
947 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
952 for (; fixP
; fixP
= fixP
->fx_next
)
955 fprintf (stderr
, "\nprocessing fixup:\n");
959 fragP
= fixP
->fx_frag
;
961 #ifdef TC_VALIDATE_FIX
962 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
964 add_number
= fixP
->fx_offset
;
966 if (fixP
->fx_addsy
!= NULL
)
967 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
969 if (fixP
->fx_subsy
!= NULL
)
971 segT sub_symbol_segment
;
972 resolve_symbol_value (fixP
->fx_subsy
);
973 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
974 if (fixP
->fx_addsy
!= NULL
975 && sub_symbol_segment
== add_symbol_segment
976 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
977 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
978 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
980 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
981 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
982 fixP
->fx_offset
= add_number
;
983 fixP
->fx_addsy
= NULL
;
984 fixP
->fx_subsy
= NULL
;
986 /* See the comment below about 68k weirdness. */
990 else if (sub_symbol_segment
== absolute_section
991 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
992 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
994 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
995 fixP
->fx_offset
= add_number
;
996 fixP
->fx_subsy
= NULL
;
998 else if (sub_symbol_segment
== this_segment
999 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
1000 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
1002 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1003 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
1004 + fixP
->fx_dot_frag
->fr_address
);
1006 /* Make it pc-relative. If the back-end code has not
1007 selected a pc-relative reloc, cancel the adjustment
1008 we do later on all pc-relative relocs. */
1011 /* Do this for m68k even if it's already described
1012 as pc-relative. On the m68k, an operand of
1013 "pc@(foo-.-2)" should address "foo" in a
1014 pc-relative mode. */
1018 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1019 fixP
->fx_subsy
= NULL
;
1022 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1024 if (!md_register_arithmetic
1025 && (add_symbol_segment
== reg_section
1026 || sub_symbol_segment
== reg_section
))
1027 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1028 _("register value used as expression"));
1030 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1031 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1032 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1033 segment_name (add_symbol_segment
),
1034 S_GET_NAME (fixP
->fx_subsy
),
1035 segment_name (sub_symbol_segment
));
1037 else if (sub_symbol_segment
!= undefined_section
1038 && ! bfd_is_com_section (sub_symbol_segment
)
1039 && MD_APPLY_SYM_VALUE (fixP
))
1040 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1045 if (add_symbol_segment
== this_segment
1046 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1047 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1049 /* This fixup was made when the symbol's segment was
1050 SEG_UNKNOWN, but it is now in the local segment.
1051 So we know how to do the address without relocation. */
1052 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1053 fixP
->fx_offset
= add_number
;
1055 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1056 fixP
->fx_addsy
= NULL
;
1059 else if (add_symbol_segment
== absolute_section
1060 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1061 && !TC_FORCE_RELOCATION_ABS (fixP
))
1063 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1064 fixP
->fx_offset
= add_number
;
1065 fixP
->fx_addsy
= NULL
;
1067 else if (add_symbol_segment
!= undefined_section
1068 && ! bfd_is_com_section (add_symbol_segment
)
1069 && MD_APPLY_SYM_VALUE (fixP
))
1070 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1075 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1076 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1078 /* There was no symbol required by this relocation.
1079 However, BFD doesn't really handle relocations
1080 without symbols well. So fake up a local symbol in
1081 the absolute section. */
1082 fixP
->fx_addsy
= abs_section_sym
;
1087 md_apply_fix (fixP
, &add_number
, this_segment
);
1091 if (fixP
->fx_addsy
== NULL
)
1092 fixP
->fx_addsy
= abs_section_sym
;
1093 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1094 if (fixP
->fx_subsy
!= NULL
)
1095 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1098 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1100 if (fixP
->fx_size
< sizeof (valueT
))
1105 mask
--; /* Set all bits to one. */
1106 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1107 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1109 char buf
[50], buf2
[50];
1110 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1111 if (add_number
> 1000)
1112 sprint_value (buf2
, add_number
);
1114 sprintf (buf2
, "%ld", (long) add_number
);
1115 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1116 ngettext ("value of %s too large for field "
1118 "value of %s too large for field "
1119 "of %d bytes at %s",
1121 buf2
, fixP
->fx_size
, buf
);
1122 } /* Generic error checking. */
1124 #ifdef WARN_SIGNED_OVERFLOW_WORD
1125 /* Warn if a .word value is too large when treated as a signed
1126 number. We already know it is not too negative. This is to
1127 catch over-large switches generated by gcc on the 68k. */
1128 if (!flag_signed_overflow_ok
1129 && fixP
->fx_size
== 2
1130 && add_number
> 0x7fff)
1131 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1132 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1134 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1136 } /* Not a bit fix. */
1138 #ifdef TC_VALIDATE_FIX
1139 skip
: ATTRIBUTE_UNUSED_LABEL
1143 fprintf (stderr
, "result:\n");
1146 } /* For each fixS in this segment. */
1150 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1152 void *xxx ATTRIBUTE_UNUSED
)
1154 segment_info_type
*seginfo
= seg_info (sec
);
1156 fixup_segment (seginfo
->fix_root
, sec
);
1160 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1161 const char *file
, unsigned int line
)
1164 bfd_reloc_status_type s
;
1167 if (reloc
->sym_ptr_ptr
!= NULL
1168 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1169 && (sym
->flags
& BSF_KEEP
) == 0
1170 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1171 || (EMIT_SECTION_SYMBOLS
1172 && !bfd_is_abs_section (sym
->section
))))
1173 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1175 s
= bfd_install_relocation (stdoutput
, reloc
,
1176 fragp
->fr_literal
, fragp
->fr_address
,
1182 case bfd_reloc_overflow
:
1183 as_bad_where (file
, line
, _("relocation overflow"));
1185 case bfd_reloc_outofrange
:
1186 as_bad_where (file
, line
, _("relocation out of range"));
1189 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1195 get_frag_for_reloc (fragS
*last_frag
,
1196 const segment_info_type
*seginfo
,
1197 const struct reloc_list
*r
)
1201 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1202 if (f
->fr_address
<= r
->u
.b
.r
.address
1203 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1206 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1207 if (f
->fr_address
<= r
->u
.b
.r
.address
1208 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1211 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1212 if (f
->fr_address
<= r
->u
.b
.r
.address
1213 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1216 as_bad_where (r
->file
, r
->line
,
1217 _("reloc not within (fixed part of) section"));
1222 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1224 segment_info_type
*seginfo
= seg_info (sec
);
1226 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1231 /* If seginfo is NULL, we did not create this section; don't do
1232 anything with it. */
1233 if (seginfo
== NULL
)
1237 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1241 #ifdef RELOC_EXPANSION_POSSIBLE
1242 n
*= MAX_RELOC_EXPANSION
;
1245 /* Extract relocs for this section from reloc_list. */
1247 my_reloc_list
= NULL
;
1248 while ((r
= *rp
) != NULL
)
1250 if (r
->u
.b
.sec
== sec
)
1253 r
->next
= my_reloc_list
;
1261 relocs
= XCNEWVEC (arelent
*, n
);
1266 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1271 #ifndef RELOC_EXPANSION_POSSIBLE
1280 fx_size
= fixp
->fx_size
;
1281 slack
= TC_FX_SIZE_SLACK (fixp
);
1283 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1284 loc
= fixp
->fx_where
+ fx_size
;
1285 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1286 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1287 _("internal error: fixup not contained within frag"));
1289 #ifndef RELOC_EXPANSION_POSSIBLE
1290 *reloc
= tc_gen_reloc (sec
, fixp
);
1292 reloc
= tc_gen_reloc (sec
, fixp
);
1297 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1299 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1303 relocs
[n
++] = &r
->u
.b
.r
;
1304 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1308 relocs
[n
++] = *reloc
;
1309 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1310 fixp
->fx_file
, fixp
->fx_line
);
1311 #ifndef RELOC_EXPANSION_POSSIBLE
1321 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1325 relocs
[n
++] = &r
->u
.b
.r
;
1326 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1333 unsigned int k
, j
, nsyms
;
1335 sympp
= bfd_get_outsymbols (stdoutput
);
1336 nsyms
= bfd_get_symcount (stdoutput
);
1337 for (k
= 0; k
< n
; k
++)
1338 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1340 for (j
= 0; j
< nsyms
; j
++)
1341 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1351 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1353 bfd_set_section_flags (abfd
, sec
, flags
);
1354 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1357 #ifdef SET_SECTION_RELOCS
1358 SET_SECTION_RELOCS (sec
, relocs
, n
);
1365 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1366 for (k
= 0; k
< n
; k
++)
1368 arelent
*rel
= relocs
[k
];
1369 asymbol
*s
= *rel
->sym_ptr_ptr
;
1370 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1371 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1372 (unsigned long)rel
->addend
);
1379 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1380 fragS
**last_newf
, struct obstack
*ob
)
1383 int total_out_size
= 0;
1384 fragS
*f
= *last_newf
;
1388 /* Call the compression routine repeatedly until it has finished
1389 processing the frag. */
1392 /* Reserve all the space available in the current chunk.
1393 If none is available, start a new frag. */
1394 avail_out
= obstack_room (ob
);
1397 obstack_finish (ob
);
1398 f
= frag_alloc (ob
);
1399 f
->fr_type
= rs_fill
;
1400 (*last_newf
)->fr_next
= f
;
1402 avail_out
= obstack_room (ob
);
1405 as_fatal (_("can't extend frag"));
1406 next_out
= obstack_next_free (ob
);
1407 obstack_blank_fast (ob
, avail_out
);
1408 out_size
= compress_data (strm
, &contents
, &in_size
,
1409 &next_out
, &avail_out
);
1413 f
->fr_fix
+= out_size
;
1414 total_out_size
+= out_size
;
1416 /* Return unused space. */
1418 obstack_blank_fast (ob
, -avail_out
);
1421 return total_out_size
;
1425 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1427 segment_info_type
*seginfo
= seg_info (sec
);
1431 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1432 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1433 bfd_size_type compressed_size
;
1434 const char *section_name
;
1435 char *compressed_name
;
1437 struct z_stream_s
*strm
;
1439 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1440 unsigned int header_size
, compression_header_size
;
1444 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1447 section_name
= bfd_get_section_name (stdoutput
, sec
);
1448 if (strncmp (section_name
, ".debug_", 7) != 0)
1451 strm
= compress_init ();
1455 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1457 compression_header_size
1458 = bfd_get_compression_header_size (stdoutput
, NULL
);
1459 header_size
= compression_header_size
;
1463 compression_header_size
= 0;
1467 /* Create a new frag to contain the compression header. */
1468 first_newf
= frag_alloc (ob
);
1469 if (obstack_room (ob
) < header_size
)
1470 first_newf
= frag_alloc (ob
);
1471 if (obstack_room (ob
) < header_size
)
1472 as_fatal (ngettext ("can't extend frag %lu char",
1473 "can't extend frag %lu chars",
1474 (unsigned long) header_size
),
1475 (unsigned long) header_size
);
1476 last_newf
= first_newf
;
1477 obstack_blank_fast (ob
, header_size
);
1478 last_newf
->fr_type
= rs_fill
;
1479 last_newf
->fr_fix
= header_size
;
1480 header
= last_newf
->fr_literal
;
1481 compressed_size
= header_size
;
1483 /* Stream the frags through the compression engine, adding new frags
1484 as necessary to accommodate the compressed output. */
1485 for (f
= seginfo
->frchainP
->frch_root
;
1494 gas_assert (f
->fr_type
== rs_fill
);
1497 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1501 compressed_size
+= out_size
;
1503 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1504 fill_size
= f
->fr_var
;
1505 count
= f
->fr_offset
;
1506 gas_assert (count
>= 0);
1507 if (fill_size
&& count
)
1511 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1515 compressed_size
+= out_size
;
1520 /* Flush the compression state. */
1527 /* Reserve all the space available in the current chunk.
1528 If none is available, start a new frag. */
1529 avail_out
= obstack_room (ob
);
1534 obstack_finish (ob
);
1535 newf
= frag_alloc (ob
);
1536 newf
->fr_type
= rs_fill
;
1537 last_newf
->fr_next
= newf
;
1539 avail_out
= obstack_room (ob
);
1542 as_fatal (_("can't extend frag"));
1543 next_out
= obstack_next_free (ob
);
1544 obstack_blank_fast (ob
, avail_out
);
1545 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1549 last_newf
->fr_fix
+= out_size
;
1550 compressed_size
+= out_size
;
1552 /* Return unused space. */
1554 obstack_blank_fast (ob
, -avail_out
);
1560 /* PR binutils/18087: If compression didn't make the section smaller,
1561 just keep it uncompressed. */
1562 if (compressed_size
>= uncompressed_size
)
1565 /* Replace the uncompressed frag list with the compressed frag list. */
1566 seginfo
->frchainP
->frch_root
= first_newf
;
1567 seginfo
->frchainP
->frch_last
= last_newf
;
1569 /* Update the section size and its name. */
1570 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1571 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1573 if (!compression_header_size
)
1575 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1576 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1580 #ifndef md_generate_nops
1581 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1582 backend must override this with proper no-op instructions. */
1585 md_generate_nops (fragS
*f ATTRIBUTE_UNUSED
,
1586 char *where ATTRIBUTE_UNUSED
,
1587 offsetT count ATTRIBUTE_UNUSED
,
1588 int control ATTRIBUTE_UNUSED
)
1590 as_bad (_("unimplemented .nops directive"));
1595 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1597 void *xxx ATTRIBUTE_UNUSED
)
1599 segment_info_type
*seginfo
= seg_info (sec
);
1600 addressT offset
= 0;
1603 /* Write out the frags. */
1605 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1608 for (f
= seginfo
->frchainP
->frch_root
;
1617 gas_assert (f
->fr_type
== rs_fill
|| f
->fr_type
== rs_fill_nop
);
1620 x
= bfd_set_section_contents (stdoutput
, sec
,
1621 f
->fr_literal
, (file_ptr
) offset
,
1622 (bfd_size_type
) f
->fr_fix
);
1624 as_fatal (ngettext ("can't write %ld byte "
1625 "to section %s of %s: '%s'",
1626 "can't write %ld bytes "
1627 "to section %s of %s: '%s'",
1630 sec
->name
, stdoutput
->filename
,
1631 bfd_errmsg (bfd_get_error ()));
1632 offset
+= f
->fr_fix
;
1635 fill_size
= f
->fr_var
;
1636 count
= f
->fr_offset
;
1637 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1639 if (f
->fr_type
== rs_fill_nop
)
1641 gas_assert (count
>= 0 && fill_size
== 1);
1644 char *buf
= xmalloc (count
);
1645 md_generate_nops (f
, buf
, count
, *fill_literal
);
1646 x
= bfd_set_section_contents
1647 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1648 (bfd_size_type
) count
);
1650 as_fatal (ngettext ("can't fill %ld byte "
1651 "in section %s of %s: '%s'",
1652 "can't fill %ld bytes "
1653 "in section %s of %s: '%s'",
1654 (long) count
), (long) count
,
1655 sec
->name
, stdoutput
->filename
,
1656 bfd_errmsg (bfd_get_error ()));
1663 gas_assert (count
>= 0);
1664 if (fill_size
&& count
)
1667 if (fill_size
> sizeof (buf
))
1669 /* Do it the old way. Can this ever happen? */
1672 x
= bfd_set_section_contents (stdoutput
, sec
,
1675 (bfd_size_type
) fill_size
);
1677 as_fatal (ngettext ("can't fill %ld byte "
1678 "in section %s of %s: '%s'",
1679 "can't fill %ld bytes "
1680 "in section %s of %s: '%s'",
1683 sec
->name
, stdoutput
->filename
,
1684 bfd_errmsg (bfd_get_error ()));
1685 offset
+= fill_size
;
1690 /* Build a buffer full of fill objects and output it as
1691 often as necessary. This saves on the overhead of
1692 potentially lots of bfd_set_section_contents calls. */
1696 n_per_buf
= sizeof (buf
);
1697 memset (buf
, *fill_literal
, n_per_buf
);
1702 n_per_buf
= sizeof (buf
) / fill_size
;
1703 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1704 memcpy (bufp
, fill_literal
, fill_size
);
1706 for (; count
> 0; count
-= n_per_buf
)
1708 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1709 x
= bfd_set_section_contents
1710 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1711 (bfd_size_type
) n_per_buf
* fill_size
);
1713 as_fatal (ngettext ("can't fill %ld byte "
1714 "in section %s of %s: '%s'",
1715 "can't fill %ld bytes "
1716 "in section %s of %s: '%s'",
1717 (long) (n_per_buf
* fill_size
)),
1718 (long) (n_per_buf
* fill_size
),
1719 sec
->name
, stdoutput
->filename
,
1720 bfd_errmsg (bfd_get_error ()));
1721 offset
+= n_per_buf
* fill_size
;
1729 merge_data_into_text (void)
1731 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1732 seg_info (data_section
)->frchainP
->frch_root
;
1733 seg_info (text_section
)->frchainP
->frch_last
=
1734 seg_info (data_section
)->frchainP
->frch_last
;
1735 seg_info (data_section
)->frchainP
= 0;
1746 /* Count symbols. We can't rely on a count made by the loop in
1747 write_object_file, because *_frob_file may add a new symbol or
1750 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1756 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1758 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1759 symp
= symbol_rootP
;
1760 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1762 asympp
[i
] = symbol_get_bfdsym (symp
);
1763 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1764 || !(bfd_is_const_section (asympp
[i
]->section
)
1765 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1766 asympp
[i
]->flags
|= BSF_KEEP
;
1767 symbol_mark_written (symp
);
1772 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1773 gas_assert (result
);
1774 symbol_table_frozen
= 1;
1777 /* Finish the subsegments. After every sub-segment, we fake an
1778 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1779 ".fill 0" because that is the kind of frag that requires least
1780 thought. ".align" frags like to have a following frag since that
1781 makes calculating their intended length trivial. */
1783 #ifndef SUB_SEGMENT_ALIGN
1785 /* The last subsegment gets an alignment corresponding to the alignment
1786 of the section. This allows proper nop-filling at the end of
1787 code-bearing sections. */
1788 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1789 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1790 && !do_not_pad_sections_to_alignment \
1791 ? get_recorded_alignment (SEG) \
1794 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1799 subsegs_finish_section (asection
*s
)
1801 struct frchain
*frchainP
;
1802 segment_info_type
*seginfo
= seg_info (s
);
1806 for (frchainP
= seginfo
->frchainP
;
1808 frchainP
= frchainP
->frch_next
)
1812 subseg_set (s
, frchainP
->frch_subseg
);
1814 /* This now gets called even if we had errors. In that case,
1815 any alignment is meaningless, and, moreover, will look weird
1816 if we are generating a listing. */
1818 do_not_pad_sections_to_alignment
= 1;
1820 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1821 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1822 && now_seg
->entsize
)
1824 unsigned int entsize
= now_seg
->entsize
;
1827 while ((entsize
& 1) == 0)
1833 if (entalign
> alignment
)
1834 alignment
= entalign
;
1837 if (subseg_text_p (now_seg
))
1838 frag_align_code (alignment
, 0);
1840 frag_align (alignment
, 0, 0);
1842 /* frag_align will have left a new frag.
1843 Use this last frag for an empty ".fill".
1845 For this segment ...
1846 Create a last frag. Do not leave a "being filled in frag". */
1847 frag_wane (frag_now
);
1848 frag_now
->fr_fix
= 0;
1849 know (frag_now
->fr_next
== NULL
);
1854 subsegs_finish (void)
1858 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1859 subsegs_finish_section (s
);
1864 create_obj_attrs_section (void)
1871 size
= bfd_elf_obj_attr_size (stdoutput
);
1874 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1876 name
= ".gnu.attributes";
1877 s
= subseg_new (name
, 0);
1878 elf_section_type (s
)
1879 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1880 bfd_set_section_flags (stdoutput
, s
, SEC_READONLY
| SEC_DATA
);
1882 p
= frag_more (size
);
1883 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1885 subsegs_finish_section (s
);
1886 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1887 size_seg (stdoutput
, s
, NULL
);
1892 /* Write the object file. */
1895 write_object_file (void)
1897 struct relax_seg_info rsi
;
1898 #ifndef WORKING_DOT_WORD
1899 fragS
*fragP
; /* Track along all frags. */
1904 #ifdef md_pre_output_hook
1908 #ifdef md_pre_relax_hook
1912 /* From now on, we don't care about sub-segments. Build one frag chain
1913 for each segment. Linked through fr_next. */
1915 /* Remove the sections created by gas for its own purposes. */
1919 bfd_section_list_remove (stdoutput
, reg_section
);
1920 bfd_section_list_remove (stdoutput
, expr_section
);
1921 stdoutput
->section_count
-= 2;
1923 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1926 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1928 /* We have two segments. If user gave -R flag, then we must put the
1929 data frags into the text segment. Do this before relaxing so
1930 we know to take advantage of -R and make shorter addresses. */
1931 if (flag_readonly_data_in_text
)
1933 merge_data_into_text ();
1939 #ifndef WORKING_DOT_WORD
1940 /* We need to reset the markers in the broken word list and
1941 associated frags between calls to relax_segment (via
1942 relax_seg). Since the broken word list is global, we do it
1943 once per round, rather than locally in relax_segment for each
1945 struct broken_word
*brokp
;
1947 for (brokp
= broken_words
;
1948 brokp
!= (struct broken_word
*) NULL
;
1949 brokp
= brokp
->next_broken_word
)
1953 if (brokp
->dispfrag
!= (fragS
*) NULL
1954 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1955 brokp
->dispfrag
->fr_subtype
= 0;
1960 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1966 /* Note - Most ports will use the default value of
1967 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1968 local symbols to be resolved, removing their frag information.
1969 Some ports however, will not have finished relaxing all of
1970 their frags and will still need the local symbol frag
1971 information. These ports can set
1972 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1973 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1975 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1977 /* Relaxation has completed. Freeze all syms. */
1980 dwarf2dbg_final_check ();
1982 #ifdef md_post_relax_hook
1988 create_obj_attrs_section ();
1991 #ifndef WORKING_DOT_WORD
1993 struct broken_word
*lie
;
1994 struct broken_word
**prevP
;
1996 prevP
= &broken_words
;
1997 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
2002 subseg_change (lie
->seg
, lie
->subseg
);
2003 exp
.X_op
= O_subtract
;
2004 exp
.X_add_symbol
= lie
->add
;
2005 exp
.X_op_symbol
= lie
->sub
;
2006 exp
.X_add_number
= lie
->addnum
;
2007 #ifdef TC_CONS_FIX_NEW
2008 TC_CONS_FIX_NEW (lie
->frag
,
2009 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2010 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
2012 fix_new_exp (lie
->frag
,
2013 lie
->word_goes_here
- lie
->frag
->fr_literal
,
2014 2, &exp
, 0, BFD_RELOC_16
);
2016 *prevP
= lie
->next_broken_word
;
2019 prevP
= &(lie
->next_broken_word
);
2021 for (lie
= broken_words
; lie
;)
2023 struct broken_word
*untruth
;
2025 addressT table_addr
;
2026 addressT from_addr
, to_addr
;
2029 subseg_change (lie
->seg
, lie
->subseg
);
2030 fragP
= lie
->dispfrag
;
2032 /* Find out how many broken_words go here. */
2035 untruth
&& untruth
->dispfrag
== fragP
;
2036 untruth
= untruth
->next_broken_word
)
2037 if (untruth
->added
== 1)
2040 table_ptr
= lie
->dispfrag
->fr_opcode
;
2041 table_addr
= (lie
->dispfrag
->fr_address
2042 + (table_ptr
- lie
->dispfrag
->fr_literal
));
2043 /* Create the jump around the long jumps. This is a short
2044 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2045 from_addr
= table_addr
;
2046 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
2047 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2049 table_ptr
+= md_short_jump_size
;
2050 table_addr
+= md_short_jump_size
;
2053 lie
&& lie
->dispfrag
== fragP
;
2054 m
++, lie
= lie
->next_broken_word
)
2056 if (lie
->added
== 2)
2058 /* Patch the jump table. */
2059 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2060 untruth
&& untruth
->dispfrag
== fragP
;
2061 untruth
= untruth
->next_broken_word
)
2063 if (untruth
->use_jump
== lie
)
2065 /* This is the offset from ??? to table_ptr+0.
2066 The target is the same for all users of this
2067 md_long_jump, but the "sub" bases (and hence the
2068 offsets) may be different. */
2069 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
2070 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2071 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
2073 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2077 /* Install the long jump. */
2078 /* This is a long jump from table_ptr+0 to the final target. */
2079 from_addr
= table_addr
;
2080 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2081 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2083 table_ptr
+= md_long_jump_size
;
2084 table_addr
+= md_long_jump_size
;
2088 #endif /* not WORKING_DOT_WORD */
2090 /* Resolve symbol values. This needs to be done before processing
2096 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2097 resolve_symbol_value (symp
);
2099 resolve_local_symbol_values ();
2100 resolve_reloc_expr_symbols ();
2104 #ifdef tc_frob_file_before_adjust
2105 tc_frob_file_before_adjust ();
2107 #ifdef obj_frob_file_before_adjust
2108 obj_frob_file_before_adjust ();
2111 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2113 #ifdef tc_frob_file_before_fix
2114 tc_frob_file_before_fix ();
2116 #ifdef obj_frob_file_before_fix
2117 obj_frob_file_before_fix ();
2120 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2122 /* Set up symbol table, and write it out. */
2126 bfd_boolean skip_next_symbol
= FALSE
;
2128 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2133 if (skip_next_symbol
)
2135 /* Don't do anything besides moving the value of the
2136 symbol from the GAS value-field to the BFD value-field. */
2137 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2138 skip_next_symbol
= FALSE
;
2142 if (symbol_mri_common_p (symp
))
2144 if (S_IS_EXTERNAL (symp
))
2145 as_bad (_("%s: global symbols not supported in common sections"),
2147 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2151 name
= S_GET_NAME (symp
);
2155 decode_local_label_name ((char *) S_GET_NAME (symp
));
2156 /* They only differ if `name' is a fb or dollar local
2158 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2159 as_bad (_("local label `%s' is not defined"), name2
);
2162 /* Do it again, because adjust_reloc_syms might introduce
2163 more symbols. They'll probably only be section symbols,
2164 but they'll still need to have the values computed. */
2165 resolve_symbol_value (symp
);
2167 /* Skip symbols which were equated to undefined or common
2169 if (symbol_equated_reloc_p (symp
)
2170 || S_IS_WEAKREFR (symp
))
2172 const char *sname
= S_GET_NAME (symp
);
2174 if (S_IS_COMMON (symp
)
2175 && !TC_FAKE_LABEL (sname
)
2176 && !S_IS_WEAKREFR (symp
))
2178 expressionS
*e
= symbol_get_value_expression (symp
);
2180 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2181 sname
, S_GET_NAME (e
->X_add_symbol
));
2183 if (S_GET_SEGMENT (symp
) == reg_section
)
2185 /* Report error only if we know the symbol name. */
2186 if (S_GET_NAME (symp
) != reg_section
->name
)
2187 as_bad (_("can't make global register symbol `%s'"),
2190 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2194 #ifdef obj_frob_symbol
2195 obj_frob_symbol (symp
, punt
);
2197 #ifdef tc_frob_symbol
2198 if (! punt
|| symbol_used_in_reloc_p (symp
))
2199 tc_frob_symbol (symp
, punt
);
2202 /* If we don't want to keep this symbol, splice it out of
2203 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2204 want section symbols. Otherwise, we skip local symbols
2205 and symbols that the frob_symbol macros told us to punt,
2206 but we keep such symbols if they are used in relocs. */
2207 if (symp
== abs_section_sym
2208 || (! EMIT_SECTION_SYMBOLS
2209 && symbol_section_p (symp
))
2210 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2211 opposites. Sometimes the former checks flags and the
2212 latter examines the name... */
2213 || (!S_IS_EXTERNAL (symp
)
2214 && (punt
|| S_IS_LOCAL (symp
) ||
2215 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2216 && ! symbol_used_in_reloc_p (symp
)))
2218 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2220 /* After symbol_remove, symbol_next(symp) still returns
2221 the one that came after it in the chain. So we don't
2222 need to do any extra cleanup work here. */
2226 /* Make sure we really got a value for the symbol. */
2227 if (! symbol_resolved_p (symp
))
2229 as_bad (_("can't resolve value for symbol `%s'"),
2231 symbol_mark_resolved (symp
);
2234 /* Set the value into the BFD symbol. Up til now the value
2235 has only been kept in the gas symbolS struct. */
2236 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2238 /* A warning construct is a warning symbol followed by the
2239 symbol warned about. Don't let anything object-format or
2240 target-specific muck with it; it's ready for output. */
2241 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2242 skip_next_symbol
= TRUE
;
2248 /* Now do any format-specific adjustments to the symbol table, such
2249 as adding file symbols. */
2250 #ifdef tc_adjust_symtab
2251 tc_adjust_symtab ();
2253 #ifdef obj_adjust_symtab
2254 obj_adjust_symtab ();
2257 /* Stop if there is an error. */
2261 /* Now that all the sizes are known, and contents correct, we can
2262 start writing to the file. */
2265 /* If *_frob_file changes the symbol value at this point, it is
2266 responsible for moving the changed value into symp->bsym->value
2267 as well. Hopefully all symbol value changing can be done in
2272 #ifdef obj_frob_file
2275 #ifdef obj_coff_generate_pdata
2276 obj_coff_generate_pdata ();
2278 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2280 #ifdef tc_frob_file_after_relocs
2281 tc_frob_file_after_relocs ();
2283 #ifdef obj_frob_file_after_relocs
2284 obj_frob_file_after_relocs ();
2287 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2288 if (IS_ELF
&& flag_use_elf_stt_common
)
2289 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2292 /* Once all relocations have been written, we can compress the
2293 contents of the debug sections. This needs to be done before
2294 we start writing any sections, because it will affect the file
2295 layout, which is fixed once we start writing contents. */
2296 if (flag_compress_debug
)
2298 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2299 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2301 stdoutput
->flags
|= BFD_COMPRESS
;
2302 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2305 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2308 #ifdef TC_GENERIC_RELAX_TABLE
2309 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2312 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2314 const relax_typeS
*this_type
;
2315 const relax_typeS
*start_type
;
2316 relax_substateT next_state
;
2317 relax_substateT this_state
;
2323 const relax_typeS
*table
;
2325 target
= fragP
->fr_offset
;
2326 address
= fragP
->fr_address
;
2327 table
= TC_GENERIC_RELAX_TABLE
;
2328 this_state
= fragP
->fr_subtype
;
2329 start_type
= this_type
= table
+ this_state
;
2330 symbolP
= fragP
->fr_symbol
;
2336 sym_frag
= symbol_get_frag (symbolP
);
2338 #ifndef DIFF_EXPR_OK
2339 know (sym_frag
!= NULL
);
2341 know (S_GET_SEGMENT (symbolP
) != absolute_section
2342 || sym_frag
== &zero_address_frag
);
2343 target
+= S_GET_VALUE (symbolP
);
2345 /* If SYM_FRAG has yet to be reached on this pass, assume it
2346 will move by STRETCH just as we did, unless there is an
2347 alignment frag between here and SYM_FRAG. An alignment may
2348 well absorb any STRETCH, and we don't want to choose a larger
2349 branch insn by overestimating the needed reach of this
2350 branch. It isn't critical to calculate TARGET exactly; We
2351 know we'll be doing another pass if STRETCH is non-zero. */
2354 && sym_frag
->relax_marker
!= fragP
->relax_marker
2355 && S_GET_SEGMENT (symbolP
) == segment
)
2358 || sym_frag
->region
== fragP
->region
)
2360 /* If we get here we know we have a forward branch. This
2361 relax pass may have stretched previous instructions so
2362 far that omitting STRETCH would make the branch
2363 negative. Don't allow this in case the negative reach is
2364 large enough to require a larger branch instruction. */
2365 else if (target
< address
)
2366 target
= fragP
->fr_next
->fr_address
+ stretch
;
2370 aim
= target
- address
- fragP
->fr_fix
;
2371 #ifdef TC_PCREL_ADJUST
2372 /* Currently only the ns32k family needs this. */
2373 aim
+= TC_PCREL_ADJUST (fragP
);
2376 #ifdef md_prepare_relax_scan
2377 /* Formerly called M68K_AIM_KLUDGE. */
2378 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2383 /* Look backwards. */
2384 for (next_state
= this_type
->rlx_more
; next_state
;)
2385 if (aim
>= this_type
->rlx_backward
)
2389 /* Grow to next state. */
2390 this_state
= next_state
;
2391 this_type
= table
+ this_state
;
2392 next_state
= this_type
->rlx_more
;
2397 /* Look forwards. */
2398 for (next_state
= this_type
->rlx_more
; next_state
;)
2399 if (aim
<= this_type
->rlx_forward
)
2403 /* Grow to next state. */
2404 this_state
= next_state
;
2405 this_type
= table
+ this_state
;
2406 next_state
= this_type
->rlx_more
;
2410 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2412 fragP
->fr_subtype
= this_state
;
2416 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2418 /* Relax_align. Advance location counter to next address that has 'alignment'
2419 lowest order bits all 0s, return size of adjustment made. */
2420 static relax_addressT
2421 relax_align (relax_addressT address
, /* Address now. */
2422 int alignment
/* Alignment (binary). */)
2424 relax_addressT mask
;
2425 relax_addressT new_address
;
2427 mask
= ~((relax_addressT
) ~0 << alignment
);
2428 new_address
= (address
+ mask
) & (~mask
);
2429 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2431 /* We must provide lots of padding, so the linker can discard it
2432 when needed. The linker will not add extra space, ever. */
2433 new_address
+= (1 << alignment
);
2435 return (new_address
- address
);
2438 /* Now we have a segment, not a crowd of sub-segments, we can make
2443 After this, all frags in this segment have addresses that are correct
2444 within the segment. Since segments live in different file addresses,
2445 these frag addresses may not be the same as final object-file
2449 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2451 unsigned long frag_count
;
2453 relax_addressT address
;
2457 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2458 subseg_change (segment
, 0);
2460 /* For each frag in segment: count and store (a 1st guess of)
2464 for (frag_count
= 0, fragP
= segment_frag_root
;
2466 fragP
= fragP
->fr_next
, frag_count
++)
2468 fragP
->region
= region
;
2469 fragP
->relax_marker
= 0;
2470 fragP
->fr_address
= address
;
2471 address
+= fragP
->fr_fix
;
2473 switch (fragP
->fr_type
)
2476 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2483 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2485 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2488 if (offset
% fragP
->fr_var
!= 0)
2490 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2491 ngettext ("alignment padding (%lu byte) "
2492 "not a multiple of %ld",
2493 "alignment padding (%lu bytes) "
2494 "not a multiple of %ld",
2495 (unsigned long) offset
),
2496 (unsigned long) offset
, (long) fragP
->fr_var
);
2497 offset
-= (offset
% fragP
->fr_var
);
2506 /* Assume .org is nugatory. It will grow with 1st relax. */
2514 case rs_machine_dependent
:
2515 /* If fr_symbol is an expression, this call to
2516 resolve_symbol_value sets up the correct segment, which will
2517 likely be needed in md_estimate_size_before_relax. */
2518 if (fragP
->fr_symbol
)
2519 resolve_symbol_value (fragP
->fr_symbol
);
2521 address
+= md_estimate_size_before_relax (fragP
, segment
);
2524 #ifndef WORKING_DOT_WORD
2525 /* Broken words don't concern us yet. */
2526 case rs_broken_word
:
2531 /* Initial guess is always 1; doing otherwise can result in
2532 stable solutions that are larger than the minimum. */
2533 address
+= fragP
->fr_offset
= 1;
2537 address
+= eh_frame_estimate_size_before_relax (fragP
);
2541 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2545 BAD_CASE (fragP
->fr_type
);
2552 unsigned long max_iterations
;
2554 /* Cumulative address adjustment. */
2557 /* Have we made any adjustment this pass? We can't just test
2558 stretch because one piece of code may have grown and another
2562 /* Most horrible, but gcc may give us some exception data that
2563 is impossible to assemble, of the form
2567 .uleb128 end - start
2573 If the leb128 is two bytes in size, then end-start is 128*128,
2574 which requires a three byte leb128. If the leb128 is three
2575 bytes in size, then end-start is 128*128-1, which requires a
2576 two byte leb128. We work around this dilemma by inserting
2577 an extra 4 bytes of alignment just after the .align. This
2578 works because the data after the align is accessed relative to
2581 This counter is used in a tiny state machine to detect
2582 whether a leb128 followed by an align is impossible to
2584 int rs_leb128_fudge
= 0;
2586 /* We want to prevent going into an infinite loop where one frag grows
2587 depending upon the location of a symbol which is in turn moved by
2588 the growing frag. eg:
2594 So we dictate that this algorithm can be at most O2. */
2595 max_iterations
= frag_count
* frag_count
;
2596 /* Check for overflow. */
2597 if (max_iterations
< frag_count
)
2598 max_iterations
= frag_count
;
2606 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2609 addressT was_address
;
2613 fragP
->relax_marker
^= 1;
2614 was_address
= fragP
->fr_address
;
2615 address
= fragP
->fr_address
+= stretch
;
2616 symbolP
= fragP
->fr_symbol
;
2617 offset
= fragP
->fr_offset
;
2619 switch (fragP
->fr_type
)
2621 case rs_fill
: /* .fill never relaxes. */
2625 #ifndef WORKING_DOT_WORD
2626 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2627 for it I do not want to write it. I do not want to have
2628 anything to do with it. This is not the proper way to
2629 implement this misfeature. */
2630 case rs_broken_word
:
2632 struct broken_word
*lie
;
2633 struct broken_word
*untruth
;
2635 /* Yes this is ugly (storing the broken_word pointer
2636 in the symbol slot). Still, this whole chunk of
2637 code is ugly, and I don't feel like doing anything
2638 about it. Think of it as stubbornness in action. */
2640 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2641 lie
&& lie
->dispfrag
== fragP
;
2642 lie
= lie
->next_broken_word
)
2648 offset
= (S_GET_VALUE (lie
->add
)
2650 - S_GET_VALUE (lie
->sub
));
2651 if (offset
<= -32768 || offset
>= 32767)
2653 if (flag_warn_displacement
)
2656 sprint_value (buf
, (addressT
) lie
->addnum
);
2657 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2658 _(".word %s-%s+%s didn't fit"),
2659 S_GET_NAME (lie
->add
),
2660 S_GET_NAME (lie
->sub
),
2663 if (fragP
->fr_subtype
== 0)
2665 fragP
->fr_subtype
++;
2666 growth
+= md_short_jump_size
;
2669 /* Redirect *all* words of this table with the same
2670 target, lest we have to handle the case where the
2671 same target but with a offset that fits on this
2672 round overflows at the next relaxation round. */
2673 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2674 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2675 untruth
= untruth
->next_broken_word
)
2676 if ((symbol_get_frag (untruth
->add
)
2677 == symbol_get_frag (lie
->add
))
2678 && (S_GET_VALUE (untruth
->add
)
2679 == S_GET_VALUE (lie
->add
)))
2682 untruth
->use_jump
= lie
;
2686 growth
+= md_long_jump_size
;
2691 } /* case rs_broken_word */
2697 addressT oldoff
, newoff
;
2699 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2701 newoff
= relax_align (address
+ fragP
->fr_fix
,
2704 if (fragP
->fr_subtype
!= 0)
2706 if (oldoff
> fragP
->fr_subtype
)
2708 if (newoff
> fragP
->fr_subtype
)
2712 growth
= newoff
- oldoff
;
2714 /* If this align happens to follow a leb128 and
2715 we have determined that the leb128 is bouncing
2716 in size, then break the cycle by inserting an
2719 && (rs_leb128_fudge
& 16) != 0
2720 && (rs_leb128_fudge
& 15) >= 2)
2722 segment_info_type
*seginfo
= seg_info (segment
);
2723 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2726 newf
= frag_alloc (ob
);
2727 obstack_blank_fast (ob
, fragP
->fr_var
);
2728 obstack_finish (ob
);
2729 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2730 memcpy (newf
->fr_literal
,
2731 fragP
->fr_literal
+ fragP
->fr_fix
,
2733 newf
->fr_type
= rs_fill
;
2734 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2736 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2738 if (newf
->fr_offset
* newf
->fr_var
2739 != (offsetT
) 1 << fragP
->fr_offset
)
2741 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2744 /* Include size of new frag in GROWTH. */
2745 growth
+= newf
->fr_offset
* newf
->fr_var
;
2746 /* Adjust the new frag address for the amount
2747 we'll add when we process the new frag. */
2748 newf
->fr_address
-= stretch
+ growth
;
2749 newf
->relax_marker
^= 1;
2750 fragP
->fr_next
= newf
;
2752 as_warn (_("padding added"));
2760 addressT target
= offset
;
2765 /* Convert from an actual address to an octet offset
2766 into the section. Here it is assumed that the
2767 section's VMA is zero, and can omit subtracting it
2768 from the symbol's value to get the address offset. */
2769 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2770 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2773 know (fragP
->fr_next
);
2774 after
= fragP
->fr_next
->fr_address
+ stretch
;
2775 growth
= target
- after
;
2777 /* Growth may be negative, but variable part of frag
2778 cannot have fewer than 0 chars. That is, we can't
2780 if (address
+ fragP
->fr_fix
> target
)
2784 /* Don't error on first few frag relax passes.
2785 The symbol might be an expression involving
2786 symbol values from other sections. If those
2787 sections have not yet been processed their
2788 frags will all have zero addresses, so we
2789 will calculate incorrect values for them. The
2790 number of passes we allow before giving an
2791 error is somewhat arbitrary. It should be at
2792 least one, with larger values requiring
2793 increasingly contrived dependencies between
2794 frags to trigger a false error. */
2797 /* Force another pass. */
2802 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2803 _("attempt to move .org backwards"));
2805 /* We've issued an error message. Change the
2806 frag to avoid cascading errors. */
2807 fragP
->fr_type
= rs_align
;
2808 fragP
->fr_subtype
= 0;
2809 fragP
->fr_offset
= 0;
2810 fragP
->fr_fix
= after
- address
;
2822 amount
= S_GET_VALUE (symbolP
);
2823 if (S_GET_SEGMENT (symbolP
) != absolute_section
2824 || S_IS_COMMON (symbolP
)
2825 || ! S_IS_DEFINED (symbolP
))
2827 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2828 _(".space specifies non-absolute value"));
2829 /* Prevent repeat of this error message. */
2830 fragP
->fr_symbol
= 0;
2832 else if (amount
< 0)
2834 /* Don't error on first few frag relax passes.
2835 See rs_org comment for a longer explanation. */
2842 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2843 _(".space, .nops or .fill with negative value, ignored"));
2844 fragP
->fr_symbol
= 0;
2847 growth
= (was_address
+ fragP
->fr_fix
+ amount
2848 - fragP
->fr_next
->fr_address
);
2852 case rs_machine_dependent
:
2853 #ifdef md_relax_frag
2854 growth
= md_relax_frag (segment
, fragP
, stretch
);
2856 #ifdef TC_GENERIC_RELAX_TABLE
2857 /* The default way to relax a frag is to look through
2858 TC_GENERIC_RELAX_TABLE. */
2859 growth
= relax_frag (segment
, fragP
, stretch
);
2860 #endif /* TC_GENERIC_RELAX_TABLE */
2869 value
= resolve_symbol_value (fragP
->fr_symbol
);
2870 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2871 growth
= size
- fragP
->fr_offset
;
2872 fragP
->fr_offset
= size
;
2877 growth
= eh_frame_relax_frag (fragP
);
2881 growth
= dwarf2dbg_relax_frag (fragP
);
2885 BAD_CASE (fragP
->fr_type
);
2892 if (fragP
->fr_type
== rs_leb128
)
2893 rs_leb128_fudge
+= 16;
2894 else if (fragP
->fr_type
== rs_align
2895 && (rs_leb128_fudge
& 16) != 0
2897 rs_leb128_fudge
+= 16;
2899 rs_leb128_fudge
= 0;
2904 && (rs_leb128_fudge
& 16) == 0
2905 && (rs_leb128_fudge
& -16) != 0)
2906 rs_leb128_fudge
+= 1;
2908 rs_leb128_fudge
= 0;
2910 /* Until nothing further to relax. */
2911 while (stretched
&& -- max_iterations
);
2914 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2915 segment_name (segment
));
2918 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2919 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2921 fragP
->last_fr_address
= fragP
->fr_address
;
2928 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2934 buf
[n
] = val
& 0xff;
2940 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2946 *buf
++ = val
& 0xff;
2952 write_print_statistics (FILE *file
)
2954 fprintf (file
, "fixups: %d\n", n_fixups
);
2957 /* For debugging. */
2958 extern int indent_level
;
2961 print_fixup (fixS
*fixp
)
2964 fprintf (stderr
, "fix ");
2965 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2966 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2968 fprintf (stderr
, " pcrel");
2969 if (fixp
->fx_pcrel_adjust
)
2970 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2971 if (fixp
->fx_im_disp
)
2974 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2976 fprintf (stderr
, " im_disp");
2980 fprintf (stderr
, " tcbit");
2982 fprintf (stderr
, " done");
2983 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2984 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2985 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2986 (long) fixp
->fx_where
,
2987 (unsigned long) fixp
->fx_offset
,
2988 (unsigned long) fixp
->fx_addnumber
);
2989 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2993 fprintf (stderr
, "\n +<");
2994 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2995 fprintf (stderr
, ">");
2999 fprintf (stderr
, "\n -<");
3000 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3001 fprintf (stderr
, ">");
3003 fprintf (stderr
, "\n");
3004 #ifdef TC_FIX_DATA_PRINT
3005 TC_FIX_DATA_PRINT (stderr
, fixp
);