1 /* write.c - emit .o file
2 Copyright (C) 1986-2014 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 byteordering correctly. But... */
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
29 #include "compress-debug.h"
31 #ifndef TC_FORCE_RELOCATION
32 #define TC_FORCE_RELOCATION(FIX) \
33 (generic_force_reloc (FIX))
36 #ifndef TC_FORCE_RELOCATION_ABS
37 #define TC_FORCE_RELOCATION_ABS(FIX) \
38 (TC_FORCE_RELOCATION (FIX))
41 #ifndef TC_FORCE_RELOCATION_LOCAL
42 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
44 || TC_FORCE_RELOCATION (FIX))
47 #ifndef TC_FORCE_RELOCATION_SUB_SAME
48 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
52 #ifndef md_register_arithmetic
53 # define md_register_arithmetic 1
56 #ifndef TC_FORCE_RELOCATION_SUB_ABS
57 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
58 (!md_register_arithmetic && (SEG) == reg_section)
61 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
64 (!md_register_arithmetic && (SEG) == reg_section)
66 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
70 #ifndef TC_VALIDATE_FIX_SUB
71 #ifdef UNDEFINED_DIFFERENCE_OK
72 /* The PA needs this for PIC code generation. */
73 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
74 (md_register_arithmetic || (SEG) != reg_section)
76 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
77 ((md_register_arithmetic || (SEG) != reg_section) \
78 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
79 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
83 #ifndef TC_LINKRELAX_FIXUP
84 #define TC_LINKRELAX_FIXUP(SEG) 1
87 #ifndef MD_APPLY_SYM_VALUE
88 #define MD_APPLY_SYM_VALUE(FIX) 1
91 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
92 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
95 #ifndef MD_PCREL_FROM_SECTION
96 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
103 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
104 fixups that far past the end of a frag. Having such fixups
105 is of course most most likely a bug in setting fx_size correctly.
106 A negative value disables the fixup check entirely, which is
107 appropriate for something like the Renesas / SuperH SH_COUNT
109 #ifndef TC_FX_SIZE_SLACK
110 #define TC_FX_SIZE_SLACK(FIX) 0
113 /* Used to control final evaluation of expressions. */
114 int finalize_syms
= 0;
116 int symbol_table_frozen
;
118 symbolS
*abs_section_sym
;
120 /* Remember the value of dot when parsing expressions. */
123 /* The frag that dot_value is based from. */
126 /* Relocs generated by ".reloc" pseudo. */
127 struct reloc_list
* reloc_list
;
129 void print_fixup (fixS
*);
131 /* We generally attach relocs to frag chains. However, after we have
132 chained these all together into a segment, any relocs we add after
133 that must be attached to a segment. This will include relocs added
134 in md_estimate_size_for_relax, for example. */
135 static int frags_chained
= 0;
139 #define RELOC_ENUM enum bfd_reloc_code_real
141 /* Create a fixS in obstack 'notes'. */
144 fix_new_internal (fragS
*frag
, /* Which frag? */
145 int where
, /* Where in that frag? */
146 int size
, /* 1, 2, or 4 usually. */
147 symbolS
*add_symbol
, /* X_add_symbol. */
148 symbolS
*sub_symbol
, /* X_op_symbol. */
149 offsetT offset
, /* X_add_number. */
150 int pcrel
, /* TRUE if PC-relative relocation. */
151 RELOC_ENUM r_type
/* Relocation type. */,
152 int at_beginning
) /* Add to the start of the list? */
158 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
160 fixP
->fx_frag
= frag
;
161 fixP
->fx_where
= where
;
162 fixP
->fx_size
= size
;
163 /* We've made fx_size a narrow field; check that it's wide enough. */
164 if (fixP
->fx_size
!= size
)
166 as_bad (_("field fx_size too small to hold %d"), size
);
169 fixP
->fx_addsy
= add_symbol
;
170 fixP
->fx_subsy
= sub_symbol
;
171 fixP
->fx_offset
= offset
;
172 fixP
->fx_dot_value
= dot_value
;
173 fixP
->fx_dot_frag
= dot_frag
;
174 fixP
->fx_pcrel
= pcrel
;
175 fixP
->fx_r_type
= r_type
;
176 fixP
->fx_im_disp
= 0;
177 fixP
->fx_pcrel_adjust
= 0;
178 fixP
->fx_bit_fixP
= 0;
179 fixP
->fx_addnumber
= 0;
183 fixP
->fx_no_overflow
= 0;
187 fixP
->fx_cgen
.insn
= NULL
;
188 fixP
->fx_cgen
.opinfo
= 0;
192 TC_INIT_FIX_DATA (fixP
);
195 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
199 fixS
**seg_fix_rootP
= (frags_chained
200 ? &seg_info (now_seg
)->fix_root
201 : &frchain_now
->fix_root
);
202 fixS
**seg_fix_tailP
= (frags_chained
203 ? &seg_info (now_seg
)->fix_tail
204 : &frchain_now
->fix_tail
);
208 fixP
->fx_next
= *seg_fix_rootP
;
209 *seg_fix_rootP
= fixP
;
210 if (fixP
->fx_next
== NULL
)
211 *seg_fix_tailP
= fixP
;
215 fixP
->fx_next
= NULL
;
217 (*seg_fix_tailP
)->fx_next
= fixP
;
219 *seg_fix_rootP
= fixP
;
220 *seg_fix_tailP
= fixP
;
227 /* Create a fixup relative to a symbol (plus a constant). */
230 fix_new (fragS
*frag
, /* Which frag? */
231 int where
, /* Where in that frag? */
232 int size
, /* 1, 2, or 4 usually. */
233 symbolS
*add_symbol
, /* X_add_symbol. */
234 offsetT offset
, /* X_add_number. */
235 int pcrel
, /* TRUE if PC-relative relocation. */
236 RELOC_ENUM r_type
/* Relocation type. */)
238 return fix_new_internal (frag
, where
, size
, add_symbol
,
239 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
242 /* Create a fixup for an expression. Currently we only support fixups
243 for difference expressions. That is itself more than most object
244 file formats support anyhow. */
247 fix_new_exp (fragS
*frag
, /* Which frag? */
248 int where
, /* Where in that frag? */
249 int size
, /* 1, 2, or 4 usually. */
250 expressionS
*exp
, /* Expression. */
251 int pcrel
, /* TRUE if PC-relative relocation. */
252 RELOC_ENUM r_type
/* Relocation type. */)
264 as_bad (_("register value used as expression"));
268 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
269 the difference expression cannot immediately be reduced. */
271 symbolS
*stmp
= make_expr_symbol (exp
);
273 exp
->X_op
= O_symbol
;
274 exp
->X_op_symbol
= 0;
275 exp
->X_add_symbol
= stmp
;
276 exp
->X_add_number
= 0;
278 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
282 add
= exp
->X_add_symbol
;
283 off
= exp
->X_add_number
;
284 r_type
= BFD_RELOC_RVA
;
288 sub
= exp
->X_add_symbol
;
289 off
= exp
->X_add_number
;
293 sub
= exp
->X_op_symbol
;
296 add
= exp
->X_add_symbol
;
299 off
= exp
->X_add_number
;
303 add
= make_expr_symbol (exp
);
307 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
311 /* Create a fixup at the beginning of FRAG. The arguments are the same
312 as for fix_new, except that WHERE is implicitly 0. */
315 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
316 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
318 return fix_new_internal (frag
, 0, size
, add_symbol
,
319 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
322 /* Generic function to determine whether a fixup requires a relocation. */
324 generic_force_reloc (fixS
*fix
)
326 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
327 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
330 if (fix
->fx_addsy
== NULL
)
333 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
336 /* Append a string onto another string, bumping the pointer along. */
338 append (char **charPP
, char *fromP
, unsigned long length
)
340 /* Don't trust memcpy() of 0 chars. */
344 memcpy (*charPP
, fromP
, length
);
348 /* This routine records the largest alignment seen for each segment.
349 If the beginning of the segment is aligned on the worst-case
350 boundary, all of the other alignments within it will work. At
351 least one object format really uses this info. */
354 record_alignment (/* Segment to which alignment pertains. */
356 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
357 boundary, 2 => 4-byte boundary, etc.) */
360 if (seg
== absolute_section
)
363 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
364 bfd_set_section_alignment (stdoutput
, seg
, align
);
368 get_recorded_alignment (segT seg
)
370 if (seg
== absolute_section
)
373 return bfd_get_section_alignment (stdoutput
, seg
);
376 /* Reset the section indices after removing the gas created sections. */
379 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
381 int *countp
= (int *) countparg
;
383 sec
->index
= *countp
;
388 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
390 fragS dummy
, *prev_frag
= &dummy
;
391 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
393 for (; frchp
; frchp
= frchp
->frch_next
)
395 prev_frag
->fr_next
= frchp
->frch_root
;
396 prev_frag
= frchp
->frch_last
;
397 gas_assert (prev_frag
->fr_type
!= 0);
398 if (frchp
->fix_root
!= (fixS
*) NULL
)
400 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
401 seg_info (section
)->fix_root
= frchp
->fix_root
;
402 prev_fix
->fx_next
= frchp
->fix_root
;
403 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
404 prev_fix
= frchp
->fix_tail
;
407 gas_assert (prev_frag
!= &dummy
408 && prev_frag
->fr_type
!= 0);
409 prev_frag
->fr_next
= 0;
414 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
416 void *xxx ATTRIBUTE_UNUSED
)
418 segment_info_type
*info
;
420 /* BFD may have introduced its own sections without using
421 subseg_new, so it is possible that seg_info is NULL. */
422 info
= seg_info (section
);
423 if (info
!= (segment_info_type
*) NULL
)
424 info
->frchainP
->frch_last
425 = chain_frchains_together_1 (section
, info
->frchainP
);
427 /* Now that we've chained the frags together, we must add new fixups
428 to the segment, not to the frag chain. */
433 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
435 switch (fragP
->fr_type
)
443 HANDLE_ALIGN (fragP
);
445 know (fragP
->fr_next
!= NULL
);
446 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
448 - fragP
->fr_fix
) / fragP
->fr_var
;
449 if (fragP
->fr_offset
< 0)
451 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
452 _("attempt to .org/.space backwards? (%ld)"),
453 (long) fragP
->fr_offset
);
454 fragP
->fr_offset
= 0;
456 fragP
->fr_type
= rs_fill
;
464 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
467 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
470 fragP
->fr_fix
+= size
;
471 fragP
->fr_type
= rs_fill
;
473 fragP
->fr_offset
= 0;
474 fragP
->fr_symbol
= NULL
;
479 eh_frame_convert_frag (fragP
);
483 dwarf2dbg_convert_frag (fragP
);
486 case rs_machine_dependent
:
487 md_convert_frag (stdoutput
, sec
, fragP
);
489 gas_assert (fragP
->fr_next
== NULL
490 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
493 /* After md_convert_frag, we make the frag into a ".space 0".
494 md_convert_frag() should set up any fixSs and constants
499 #ifndef WORKING_DOT_WORD
502 struct broken_word
*lie
;
504 if (fragP
->fr_subtype
)
506 fragP
->fr_fix
+= md_short_jump_size
;
507 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
508 lie
&& lie
->dispfrag
== fragP
;
509 lie
= lie
->next_broken_word
)
511 fragP
->fr_fix
+= md_long_jump_size
;
519 BAD_CASE (fragP
->fr_type
);
523 md_frag_check (fragP
);
527 struct relax_seg_info
534 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
536 segment_info_type
*seginfo
= seg_info (sec
);
537 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
539 if (seginfo
&& seginfo
->frchainP
540 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
545 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
549 segment_info_type
*seginfo
;
551 valueT size
, newsize
;
553 subseg_change (sec
, 0);
555 seginfo
= seg_info (sec
);
556 if (seginfo
&& seginfo
->frchainP
)
558 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
559 cvt_frag_to_fill (sec
, fragp
);
560 for (fragp
= seginfo
->frchainP
->frch_root
;
562 fragp
= fragp
->fr_next
)
563 /* Walk to last elt. */
565 size
= fragp
->fr_address
+ fragp
->fr_fix
;
570 flags
= bfd_get_section_flags (abfd
, sec
);
571 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
572 (flags
& SEC_HAS_CONTENTS
) != 0)
575 if (size
> 0 && ! seginfo
->bss
)
576 flags
|= SEC_HAS_CONTENTS
;
579 x
= bfd_set_section_flags (abfd
, sec
, flags
);
582 newsize
= md_section_align (sec
, size
);
583 x
= bfd_set_section_size (abfd
, sec
, newsize
);
586 /* If the size had to be rounded up, add some padding in the last
588 gas_assert (newsize
>= size
);
591 fragS
*last
= seginfo
->frchainP
->frch_last
;
592 fragp
= seginfo
->frchainP
->frch_root
;
593 while (fragp
->fr_next
!= last
)
594 fragp
= fragp
->fr_next
;
595 last
->fr_address
= size
;
596 if ((newsize
- size
) % fragp
->fr_var
== 0)
597 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
599 /* If we hit this abort, it's likely due to subsegs_finish not
600 providing sufficient alignment on the last frag, and the
601 machine dependent code using alignment frags with fr_var
606 #ifdef tc_frob_section
607 tc_frob_section (sec
);
609 #ifdef obj_frob_section
610 obj_frob_section (sec
);
616 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
618 segment_info_type
*seginfo
= seg_info (sec
);
619 fixS
*fixp
= seginfo
->fix_root
;
624 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
627 symbolS
*s
= fixp
->fx_addsy
;
629 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
630 (int) fixp
->fx_r_type
);
632 fprintf (stream
, "no sym\n");
635 print_symbol_value_1 (stream
, s
);
636 fprintf (stream
, "\n");
638 fixp
= fixp
->fx_next
;
642 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
645 #ifndef EMIT_SECTION_SYMBOLS
646 #define EMIT_SECTION_SYMBOLS 1
649 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
650 and check for validity. Convert RELOC_LIST from using U.A fields
653 resolve_reloc_expr_symbols (void)
655 bfd_vma addr_mask
= 1;
656 struct reloc_list
*r
;
658 /* Avoid a shift by the width of type. */
659 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
663 for (r
= reloc_list
; r
; r
= r
->next
)
665 reloc_howto_type
*howto
= r
->u
.a
.howto
;
668 bfd_vma offset
, addend
;
671 resolve_symbol_value (r
->u
.a
.offset_sym
);
672 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
676 if (symval
->X_op
== O_constant
)
677 sym
= r
->u
.a
.offset_sym
;
678 else if (symval
->X_op
== O_symbol
)
680 sym
= symval
->X_add_symbol
;
681 offset
= symval
->X_add_number
;
682 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
685 || symval
->X_op
!= O_constant
686 || (sec
= S_GET_SEGMENT (sym
)) == NULL
687 || !SEG_NORMAL (sec
))
689 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
693 offset
+= S_GET_VALUE (sym
);
696 addend
= r
->u
.a
.addend
;
697 if (r
->u
.a
.sym
!= NULL
)
699 resolve_symbol_value (r
->u
.a
.sym
);
700 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
701 if (symval
->X_op
== O_constant
)
703 else if (symval
->X_op
== O_symbol
)
705 sym
= symval
->X_add_symbol
;
706 addend
+= symval
->X_add_number
;
707 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
709 if (symval
->X_op
!= O_constant
)
711 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
714 else if (sym
!= NULL
)
716 /* Convert relocs against local symbols to refer to the
717 corresponding section symbol plus offset instead. Keep
718 PC-relative relocs of the REL variety intact though to
719 prevent the offset from overflowing the relocated field,
720 unless it has enough bits to cover the whole address
722 if (S_IS_LOCAL (sym
) && !symbol_section_p (sym
)
724 || (howto
->partial_inplace
725 && (!howto
->pc_relative
726 || howto
->src_mask
== addr_mask
))))
728 asection
*symsec
= S_GET_SEGMENT (sym
);
729 if (!(((symsec
->flags
& SEC_MERGE
) != 0
731 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
733 addend
+= S_GET_VALUE (sym
);
734 sym
= section_symbol (symsec
);
737 symbol_mark_used_in_reloc (sym
);
742 if (abs_section_sym
== NULL
)
743 abs_section_sym
= section_symbol (absolute_section
);
744 sym
= abs_section_sym
;
748 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
749 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
750 r
->u
.b
.r
.address
= offset
;
751 r
->u
.b
.r
.addend
= addend
;
752 r
->u
.b
.r
.howto
= howto
;
756 /* This pass over fixups decides whether symbols can be replaced with
760 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
762 void *xxx ATTRIBUTE_UNUSED
)
764 segment_info_type
*seginfo
= seg_info (sec
);
770 dump_section_relocs (abfd
, sec
, stderr
);
772 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
776 else if (fixp
->fx_addsy
)
782 fprintf (stderr
, "\n\nadjusting fixup:\n");
786 sym
= fixp
->fx_addsy
;
788 /* All symbols should have already been resolved at this
789 point. It is possible to see unresolved expression
790 symbols, though, since they are not in the regular symbol
792 resolve_symbol_value (sym
);
794 if (fixp
->fx_subsy
!= NULL
)
795 resolve_symbol_value (fixp
->fx_subsy
);
797 /* If this symbol is equated to an undefined or common symbol,
798 convert the fixup to being against that symbol. */
799 while (symbol_equated_reloc_p (sym
)
800 || S_IS_WEAKREFR (sym
))
802 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
805 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
806 fixp
->fx_addsy
= newsym
;
810 if (symbol_mri_common_p (sym
))
812 fixp
->fx_offset
+= S_GET_VALUE (sym
);
813 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
817 /* If the symbol is undefined, common, weak, or global (ELF
818 shared libs), we can't replace it with the section symbol. */
819 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
822 /* Is there some other (target cpu dependent) reason we can't adjust
823 this one? (E.g. relocations involving function addresses on
825 #ifdef tc_fix_adjustable
826 if (! tc_fix_adjustable (fixp
))
830 /* Since we're reducing to section symbols, don't attempt to reduce
831 anything that's already using one. */
832 if (symbol_section_p (sym
))
835 symsec
= S_GET_SEGMENT (sym
);
839 if (bfd_is_abs_section (symsec
))
841 /* The fixup_segment routine normally will not use this
842 symbol in a relocation. */
846 /* Don't try to reduce relocs which refer to non-local symbols
847 in .linkonce sections. It can lead to confusion when a
848 debugging section refers to a .linkonce section. I hope
849 this will always be correct. */
850 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
852 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
854 /* The GNU toolchain uses an extension for ELF: a
855 section beginning with the magic string
856 .gnu.linkonce is a linkonce section. */
857 && strncmp (segment_name (symsec
), ".gnu.linkonce",
858 sizeof ".gnu.linkonce" - 1) == 0))
862 /* Never adjust a reloc against local symbol in a merge section
863 with non-zero addend. */
864 if ((symsec
->flags
& SEC_MERGE
) != 0
865 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
868 /* Never adjust a reloc against TLS local symbol. */
869 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
872 /* We refetch the segment when calling section_symbol, rather
873 than using symsec, because S_GET_VALUE may wind up changing
874 the section when it calls resolve_symbol_value. */
875 fixp
->fx_offset
+= S_GET_VALUE (sym
);
876 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
878 fprintf (stderr
, "\nadjusted fixup:\n");
883 dump_section_relocs (abfd
, sec
, stderr
);
888 Go through all the fixS's in a segment and see which ones can be
889 handled now. (These consist of fixS where we have since discovered
890 the value of a symbol, or the address of the frag involved.)
891 For each one, call md_apply_fix to put the fix into the frag data.
892 Ones that we couldn't completely handle here will be output later
893 by emit_relocations. */
896 fixup_segment (fixS
*fixP
, segT this_segment
)
900 segT add_symbol_segment
= absolute_section
;
902 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
903 abs_section_sym
= section_symbol (absolute_section
);
905 /* If the linker is doing the relaxing, we must not do any fixups.
907 Well, strictly speaking that's not true -- we could do any that
908 are PC-relative and don't cross regions that could change size.
909 And for the i960 we might be able to turn callx/callj into bal
910 anyways in cases where we know the maximum displacement. */
911 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
913 for (; fixP
; fixP
= fixP
->fx_next
)
916 if (fixP
->fx_addsy
== NULL
)
918 /* There was no symbol required by this relocation.
919 However, BFD doesn't really handle relocations
920 without symbols well. So fake up a local symbol in
921 the absolute section. */
922 fixP
->fx_addsy
= abs_section_sym
;
924 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
925 if (fixP
->fx_subsy
!= NULL
)
926 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
931 for (; fixP
; fixP
= fixP
->fx_next
)
934 fprintf (stderr
, "\nprocessing fixup:\n");
938 fragP
= fixP
->fx_frag
;
940 #ifdef TC_VALIDATE_FIX
941 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
943 add_number
= fixP
->fx_offset
;
945 if (fixP
->fx_addsy
!= NULL
)
946 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
948 if (fixP
->fx_subsy
!= NULL
)
950 segT sub_symbol_segment
;
951 resolve_symbol_value (fixP
->fx_subsy
);
952 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
953 if (fixP
->fx_addsy
!= NULL
954 && sub_symbol_segment
== add_symbol_segment
955 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
956 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
957 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
959 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
960 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
961 fixP
->fx_offset
= add_number
;
962 fixP
->fx_addsy
= NULL
;
963 fixP
->fx_subsy
= NULL
;
965 /* See the comment below about 68k weirdness. */
969 else if (sub_symbol_segment
== absolute_section
970 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
971 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
973 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
974 fixP
->fx_offset
= add_number
;
975 fixP
->fx_subsy
= NULL
;
977 else if (sub_symbol_segment
== this_segment
978 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
979 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
981 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
982 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
983 + fixP
->fx_dot_frag
->fr_address
);
985 /* Make it pc-relative. If the back-end code has not
986 selected a pc-relative reloc, cancel the adjustment
987 we do later on all pc-relative relocs. */
990 /* Do this for m68k even if it's already described
991 as pc-relative. On the m68k, an operand of
992 "pc@(foo-.-2)" should address "foo" in a
997 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
998 fixP
->fx_subsy
= NULL
;
1001 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1003 if (!md_register_arithmetic
1004 && (add_symbol_segment
== reg_section
1005 || sub_symbol_segment
== reg_section
))
1006 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1007 _("register value used as expression"));
1009 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1010 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1011 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1012 segment_name (add_symbol_segment
),
1013 S_GET_NAME (fixP
->fx_subsy
),
1014 segment_name (sub_symbol_segment
));
1016 else if (sub_symbol_segment
!= undefined_section
1017 && ! bfd_is_com_section (sub_symbol_segment
)
1018 && MD_APPLY_SYM_VALUE (fixP
))
1019 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1024 if (add_symbol_segment
== this_segment
1025 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1026 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1028 /* This fixup was made when the symbol's segment was
1029 SEG_UNKNOWN, but it is now in the local segment.
1030 So we know how to do the address without relocation. */
1031 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1032 fixP
->fx_offset
= add_number
;
1034 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1035 fixP
->fx_addsy
= NULL
;
1038 else if (add_symbol_segment
== absolute_section
1039 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1040 && !TC_FORCE_RELOCATION_ABS (fixP
))
1042 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1043 fixP
->fx_offset
= add_number
;
1044 fixP
->fx_addsy
= NULL
;
1046 else if (add_symbol_segment
!= undefined_section
1047 && ! bfd_is_com_section (add_symbol_segment
)
1048 && MD_APPLY_SYM_VALUE (fixP
))
1049 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1054 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1055 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1057 /* There was no symbol required by this relocation.
1058 However, BFD doesn't really handle relocations
1059 without symbols well. So fake up a local symbol in
1060 the absolute section. */
1061 fixP
->fx_addsy
= abs_section_sym
;
1066 md_apply_fix (fixP
, &add_number
, this_segment
);
1070 if (fixP
->fx_addsy
== NULL
)
1071 fixP
->fx_addsy
= abs_section_sym
;
1072 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1073 if (fixP
->fx_subsy
!= NULL
)
1074 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1077 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1079 if (fixP
->fx_size
< sizeof (valueT
))
1084 mask
--; /* Set all bits to one. */
1085 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1086 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1088 char buf
[50], buf2
[50];
1089 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1090 if (add_number
> 1000)
1091 sprint_value (buf2
, add_number
);
1093 sprintf (buf2
, "%ld", (long) add_number
);
1094 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1095 _("value of %s too large for field of %d bytes at %s"),
1096 buf2
, fixP
->fx_size
, buf
);
1097 } /* Generic error checking. */
1099 #ifdef WARN_SIGNED_OVERFLOW_WORD
1100 /* Warn if a .word value is too large when treated as a signed
1101 number. We already know it is not too negative. This is to
1102 catch over-large switches generated by gcc on the 68k. */
1103 if (!flag_signed_overflow_ok
1104 && fixP
->fx_size
== 2
1105 && add_number
> 0x7fff)
1106 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1107 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1109 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1111 } /* Not a bit fix. */
1113 #ifdef TC_VALIDATE_FIX
1114 skip
: ATTRIBUTE_UNUSED_LABEL
1118 fprintf (stderr
, "result:\n");
1121 } /* For each fixS in this segment. */
1125 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1127 void *xxx ATTRIBUTE_UNUSED
)
1129 segment_info_type
*seginfo
= seg_info (sec
);
1131 fixup_segment (seginfo
->fix_root
, sec
);
1135 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1136 char *file
, unsigned int line
)
1139 bfd_reloc_status_type s
;
1142 if (reloc
->sym_ptr_ptr
!= NULL
1143 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1144 && (sym
->flags
& BSF_KEEP
) == 0
1145 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1146 || (EMIT_SECTION_SYMBOLS
1147 && !bfd_is_abs_section (sym
->section
))))
1148 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1150 s
= bfd_install_relocation (stdoutput
, reloc
,
1151 fragp
->fr_literal
, fragp
->fr_address
,
1157 case bfd_reloc_overflow
:
1158 as_bad_where (file
, line
, _("relocation overflow"));
1160 case bfd_reloc_outofrange
:
1161 as_bad_where (file
, line
, _("relocation out of range"));
1164 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1170 get_frag_for_reloc (fragS
*last_frag
,
1171 const segment_info_type
*seginfo
,
1172 const struct reloc_list
*r
)
1176 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1177 if (f
->fr_address
<= r
->u
.b
.r
.address
1178 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1181 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1182 if (f
->fr_address
<= r
->u
.b
.r
.address
1183 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1186 as_bad_where (r
->file
, r
->line
,
1187 _("reloc not within (fixed part of) section"));
1192 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1194 segment_info_type
*seginfo
= seg_info (sec
);
1196 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1201 /* If seginfo is NULL, we did not create this section; don't do
1202 anything with it. */
1203 if (seginfo
== NULL
)
1207 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1211 #ifdef RELOC_EXPANSION_POSSIBLE
1212 n
*= MAX_RELOC_EXPANSION
;
1215 /* Extract relocs for this section from reloc_list. */
1217 my_reloc_list
= NULL
;
1218 while ((r
= *rp
) != NULL
)
1220 if (r
->u
.b
.sec
== sec
)
1223 r
->next
= my_reloc_list
;
1231 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
1236 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1241 #ifndef RELOC_EXPANSION_POSSIBLE
1250 fx_size
= fixp
->fx_size
;
1251 slack
= TC_FX_SIZE_SLACK (fixp
);
1253 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1254 loc
= fixp
->fx_where
+ fx_size
;
1255 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1256 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1257 _("internal error: fixup not contained within frag"));
1259 #ifndef RELOC_EXPANSION_POSSIBLE
1260 *reloc
= tc_gen_reloc (sec
, fixp
);
1262 reloc
= tc_gen_reloc (sec
, fixp
);
1267 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1269 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1273 relocs
[n
++] = &r
->u
.b
.r
;
1274 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1278 relocs
[n
++] = *reloc
;
1279 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1280 fixp
->fx_file
, fixp
->fx_line
);
1281 #ifndef RELOC_EXPANSION_POSSIBLE
1291 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1295 relocs
[n
++] = &r
->u
.b
.r
;
1296 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1303 unsigned int k
, j
, nsyms
;
1305 sympp
= bfd_get_outsymbols (stdoutput
);
1306 nsyms
= bfd_get_symcount (stdoutput
);
1307 for (k
= 0; k
< n
; k
++)
1308 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1310 for (j
= 0; j
< nsyms
; j
++)
1311 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1321 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1323 bfd_set_section_flags (abfd
, sec
, flags
);
1324 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1327 #ifdef SET_SECTION_RELOCS
1328 SET_SECTION_RELOCS (sec
, relocs
, n
);
1335 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1336 for (k
= 0; k
< n
; k
++)
1338 arelent
*rel
= relocs
[k
];
1339 asymbol
*s
= *rel
->sym_ptr_ptr
;
1340 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1341 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1342 (unsigned long)rel
->addend
);
1349 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1350 fragS
**last_newf
, struct obstack
*ob
)
1353 int total_out_size
= 0;
1354 fragS
*f
= *last_newf
;
1358 /* Call the compression routine repeatedly until it has finished
1359 processing the frag. */
1362 /* Reserve all the space available in the current chunk.
1363 If none is available, start a new frag. */
1364 avail_out
= obstack_room (ob
);
1367 obstack_finish (ob
);
1368 f
= frag_alloc (ob
);
1369 f
->fr_type
= rs_fill
;
1370 (*last_newf
)->fr_next
= f
;
1372 avail_out
= obstack_room (ob
);
1375 as_fatal (_("can't extend frag"));
1376 next_out
= obstack_next_free (ob
);
1377 obstack_blank_fast (ob
, avail_out
);
1378 out_size
= compress_data (strm
, &contents
, &in_size
,
1379 &next_out
, &avail_out
);
1383 f
->fr_fix
+= out_size
;
1384 total_out_size
+= out_size
;
1386 /* Return unused space. */
1388 obstack_blank_fast (ob
, -avail_out
);
1391 return total_out_size
;
1395 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1397 segment_info_type
*seginfo
= seg_info (sec
);
1401 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1402 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1403 bfd_size_type compressed_size
;
1404 const char *section_name
;
1405 char *compressed_name
;
1407 struct z_stream_s
*strm
;
1409 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1413 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1416 section_name
= bfd_get_section_name (stdoutput
, sec
);
1417 if (strncmp (section_name
, ".debug_", 7) != 0)
1420 strm
= compress_init ();
1424 /* Create a new frag to contain the "ZLIB" header. */
1425 first_newf
= frag_alloc (ob
);
1426 if (obstack_room (ob
) < 12)
1427 first_newf
= frag_alloc (ob
);
1428 if (obstack_room (ob
) < 12)
1429 as_fatal (_("can't extend frag %u chars"), 12);
1430 last_newf
= first_newf
;
1431 obstack_blank_fast (ob
, 12);
1432 last_newf
->fr_type
= rs_fill
;
1433 last_newf
->fr_fix
= 12;
1434 header
= last_newf
->fr_literal
;
1435 memcpy (header
, "ZLIB", 4);
1436 header
[11] = uncompressed_size
; uncompressed_size
>>= 8;
1437 header
[10] = uncompressed_size
; uncompressed_size
>>= 8;
1438 header
[9] = uncompressed_size
; uncompressed_size
>>= 8;
1439 header
[8] = uncompressed_size
; uncompressed_size
>>= 8;
1440 header
[7] = uncompressed_size
; uncompressed_size
>>= 8;
1441 header
[6] = uncompressed_size
; uncompressed_size
>>= 8;
1442 header
[5] = uncompressed_size
; uncompressed_size
>>= 8;
1443 header
[4] = uncompressed_size
;
1444 compressed_size
= 12;
1446 /* Stream the frags through the compression engine, adding new frags
1447 as necessary to accomodate the compressed output. */
1448 for (f
= seginfo
->frchainP
->frch_root
;
1457 gas_assert (f
->fr_type
== rs_fill
);
1460 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1464 compressed_size
+= out_size
;
1466 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1467 fill_size
= f
->fr_var
;
1468 count
= f
->fr_offset
;
1469 gas_assert (count
>= 0);
1470 if (fill_size
&& count
)
1474 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1478 compressed_size
+= out_size
;
1483 /* Flush the compression state. */
1490 /* Reserve all the space available in the current chunk.
1491 If none is available, start a new frag. */
1492 avail_out
= obstack_room (ob
);
1497 obstack_finish (ob
);
1498 newf
= frag_alloc (ob
);
1499 newf
->fr_type
= rs_fill
;
1500 last_newf
->fr_next
= newf
;
1502 avail_out
= obstack_room (ob
);
1505 as_fatal (_("can't extend frag"));
1506 next_out
= obstack_next_free (ob
);
1507 obstack_blank_fast (ob
, avail_out
);
1508 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1512 last_newf
->fr_fix
+= out_size
;
1513 compressed_size
+= out_size
;
1515 /* Return unused space. */
1517 obstack_blank_fast (ob
, -avail_out
);
1523 /* Replace the uncompressed frag list with the compressed frag list. */
1524 seginfo
->frchainP
->frch_root
= first_newf
;
1525 seginfo
->frchainP
->frch_last
= last_newf
;
1527 /* Update the section size and its name. */
1528 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1530 compressed_name
= (char *) xmalloc (strlen (section_name
) + 2);
1531 compressed_name
[0] = '.';
1532 compressed_name
[1] = 'z';
1533 strcpy (compressed_name
+ 2, section_name
+ 1);
1534 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1538 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1540 void *xxx ATTRIBUTE_UNUSED
)
1542 segment_info_type
*seginfo
= seg_info (sec
);
1543 addressT offset
= 0;
1546 /* Write out the frags. */
1548 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1551 for (f
= seginfo
->frchainP
->frch_root
;
1560 gas_assert (f
->fr_type
== rs_fill
);
1563 x
= bfd_set_section_contents (stdoutput
, sec
,
1564 f
->fr_literal
, (file_ptr
) offset
,
1565 (bfd_size_type
) f
->fr_fix
);
1567 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1568 bfd_errmsg (bfd_get_error ()));
1569 offset
+= f
->fr_fix
;
1571 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1572 fill_size
= f
->fr_var
;
1573 count
= f
->fr_offset
;
1574 gas_assert (count
>= 0);
1575 if (fill_size
&& count
)
1578 if (fill_size
> sizeof (buf
))
1580 /* Do it the old way. Can this ever happen? */
1583 x
= bfd_set_section_contents (stdoutput
, sec
,
1586 (bfd_size_type
) fill_size
);
1588 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1589 bfd_errmsg (bfd_get_error ()));
1590 offset
+= fill_size
;
1595 /* Build a buffer full of fill objects and output it as
1596 often as necessary. This saves on the overhead of
1597 potentially lots of bfd_set_section_contents calls. */
1601 n_per_buf
= sizeof (buf
);
1602 memset (buf
, *fill_literal
, n_per_buf
);
1607 n_per_buf
= sizeof (buf
) / fill_size
;
1608 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1609 memcpy (bufp
, fill_literal
, fill_size
);
1611 for (; count
> 0; count
-= n_per_buf
)
1613 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1614 x
= bfd_set_section_contents
1615 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1616 (bfd_size_type
) n_per_buf
* fill_size
);
1618 as_fatal (_("cannot write to output file '%s': %s"),
1619 stdoutput
->filename
,
1620 bfd_errmsg (bfd_get_error ()));
1621 offset
+= n_per_buf
* fill_size
;
1629 merge_data_into_text (void)
1631 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1632 seg_info (data_section
)->frchainP
->frch_root
;
1633 seg_info (text_section
)->frchainP
->frch_last
=
1634 seg_info (data_section
)->frchainP
->frch_last
;
1635 seg_info (data_section
)->frchainP
= 0;
1646 /* Count symbols. We can't rely on a count made by the loop in
1647 write_object_file, because *_frob_file may add a new symbol or
1650 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1656 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1658 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1659 symp
= symbol_rootP
;
1660 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1662 asympp
[i
] = symbol_get_bfdsym (symp
);
1663 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1664 || !(bfd_is_const_section (asympp
[i
]->section
)
1665 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1666 asympp
[i
]->flags
|= BSF_KEEP
;
1667 symbol_mark_written (symp
);
1672 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1673 gas_assert (result
);
1674 symbol_table_frozen
= 1;
1677 /* Finish the subsegments. After every sub-segment, we fake an
1678 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1679 ".fill 0" because that is the kind of frag that requires least
1680 thought. ".align" frags like to have a following frag since that
1681 makes calculating their intended length trivial. */
1683 #ifndef SUB_SEGMENT_ALIGN
1685 /* The last subsegment gets an alignment corresponding to the alignment
1686 of the section. This allows proper nop-filling at the end of
1687 code-bearing sections. */
1688 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1689 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1691 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1696 subsegs_finish (void)
1698 struct frchain
*frchainP
;
1701 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1703 segment_info_type
*seginfo
= seg_info (s
);
1707 for (frchainP
= seginfo
->frchainP
;
1709 frchainP
= frchainP
->frch_next
)
1713 subseg_set (s
, frchainP
->frch_subseg
);
1715 /* This now gets called even if we had errors. In that case,
1716 any alignment is meaningless, and, moreover, will look weird
1717 if we are generating a listing. */
1720 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1721 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1722 && now_seg
->entsize
)
1724 unsigned int entsize
= now_seg
->entsize
;
1727 while ((entsize
& 1) == 0)
1732 if (entalign
> alignment
)
1733 alignment
= entalign
;
1737 if (subseg_text_p (now_seg
))
1738 frag_align_code (alignment
, 0);
1740 frag_align (alignment
, 0, 0);
1742 /* frag_align will have left a new frag.
1743 Use this last frag for an empty ".fill".
1745 For this segment ...
1746 Create a last frag. Do not leave a "being filled in frag". */
1747 frag_wane (frag_now
);
1748 frag_now
->fr_fix
= 0;
1749 know (frag_now
->fr_next
== NULL
);
1754 /* Write the object file. */
1757 write_object_file (void)
1759 struct relax_seg_info rsi
;
1760 #ifndef WORKING_DOT_WORD
1761 fragS
*fragP
; /* Track along all frags. */
1764 #ifdef md_pre_output_hook
1768 /* Do we really want to write it? */
1770 int n_warns
, n_errs
;
1771 n_warns
= had_warnings ();
1772 n_errs
= had_errors ();
1773 /* The -Z flag indicates that an object file should be generated,
1774 regardless of warnings and errors. */
1775 if (flag_always_generate_output
)
1777 if (n_warns
|| n_errs
)
1778 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1779 n_errs
, n_errs
== 1 ? "" : "s",
1780 n_warns
, n_warns
== 1 ? "" : "s");
1785 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1786 n_errs
, n_errs
== 1 ? "" : "s",
1787 n_warns
, n_warns
== 1 ? "" : "s");
1791 #ifdef md_pre_relax_hook
1795 /* From now on, we don't care about sub-segments. Build one frag chain
1796 for each segment. Linked thru fr_next. */
1798 /* Remove the sections created by gas for its own purposes. */
1802 bfd_section_list_remove (stdoutput
, reg_section
);
1803 bfd_section_list_remove (stdoutput
, expr_section
);
1804 stdoutput
->section_count
-= 2;
1806 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1809 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1811 /* We have two segments. If user gave -R flag, then we must put the
1812 data frags into the text segment. Do this before relaxing so
1813 we know to take advantage of -R and make shorter addresses. */
1814 if (flag_readonly_data_in_text
)
1816 merge_data_into_text ();
1822 #ifndef WORKING_DOT_WORD
1823 /* We need to reset the markers in the broken word list and
1824 associated frags between calls to relax_segment (via
1825 relax_seg). Since the broken word list is global, we do it
1826 once per round, rather than locally in relax_segment for each
1828 struct broken_word
*brokp
;
1830 for (brokp
= broken_words
;
1831 brokp
!= (struct broken_word
*) NULL
;
1832 brokp
= brokp
->next_broken_word
)
1836 if (brokp
->dispfrag
!= (fragS
*) NULL
1837 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1838 brokp
->dispfrag
->fr_subtype
= 0;
1843 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1849 /* Note - Most ports will use the default value of
1850 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1851 local symbols to be resolved, removing their frag information.
1852 Some ports however, will not have finished relaxing all of
1853 their frags and will still need the local symbol frag
1854 information. These ports can set
1855 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1856 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1858 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1860 /* Relaxation has completed. Freeze all syms. */
1863 #ifdef md_post_relax_hook
1867 #ifndef WORKING_DOT_WORD
1869 struct broken_word
*lie
;
1870 struct broken_word
**prevP
;
1872 prevP
= &broken_words
;
1873 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1878 subseg_change (lie
->seg
, lie
->subseg
);
1879 exp
.X_op
= O_subtract
;
1880 exp
.X_add_symbol
= lie
->add
;
1881 exp
.X_op_symbol
= lie
->sub
;
1882 exp
.X_add_number
= lie
->addnum
;
1883 #ifdef TC_CONS_FIX_NEW
1884 TC_CONS_FIX_NEW (lie
->frag
,
1885 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1888 fix_new_exp (lie
->frag
,
1889 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1890 2, &exp
, 0, BFD_RELOC_16
);
1892 *prevP
= lie
->next_broken_word
;
1895 prevP
= &(lie
->next_broken_word
);
1897 for (lie
= broken_words
; lie
;)
1899 struct broken_word
*untruth
;
1901 addressT table_addr
;
1902 addressT from_addr
, to_addr
;
1905 subseg_change (lie
->seg
, lie
->subseg
);
1906 fragP
= lie
->dispfrag
;
1908 /* Find out how many broken_words go here. */
1911 untruth
&& untruth
->dispfrag
== fragP
;
1912 untruth
= untruth
->next_broken_word
)
1913 if (untruth
->added
== 1)
1916 table_ptr
= lie
->dispfrag
->fr_opcode
;
1917 table_addr
= (lie
->dispfrag
->fr_address
1918 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1919 /* Create the jump around the long jumps. This is a short
1920 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1921 from_addr
= table_addr
;
1922 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1923 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1925 table_ptr
+= md_short_jump_size
;
1926 table_addr
+= md_short_jump_size
;
1929 lie
&& lie
->dispfrag
== fragP
;
1930 m
++, lie
= lie
->next_broken_word
)
1932 if (lie
->added
== 2)
1934 /* Patch the jump table. */
1935 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
1936 untruth
&& untruth
->dispfrag
== fragP
;
1937 untruth
= untruth
->next_broken_word
)
1939 if (untruth
->use_jump
== lie
)
1941 /* This is the offset from ??? to table_ptr+0.
1942 The target is the same for all users of this
1943 md_long_jump, but the "sub" bases (and hence the
1944 offsets) may be different. */
1945 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
1946 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1947 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
1949 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
1953 /* Install the long jump. */
1954 /* This is a long jump from table_ptr+0 to the final target. */
1955 from_addr
= table_addr
;
1956 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1957 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1959 table_ptr
+= md_long_jump_size
;
1960 table_addr
+= md_long_jump_size
;
1964 #endif /* not WORKING_DOT_WORD */
1966 /* Resolve symbol values. This needs to be done before processing
1972 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1973 resolve_symbol_value (symp
);
1975 resolve_local_symbol_values ();
1976 resolve_reloc_expr_symbols ();
1980 #ifdef tc_frob_file_before_adjust
1981 tc_frob_file_before_adjust ();
1983 #ifdef obj_frob_file_before_adjust
1984 obj_frob_file_before_adjust ();
1987 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1989 #ifdef tc_frob_file_before_fix
1990 tc_frob_file_before_fix ();
1992 #ifdef obj_frob_file_before_fix
1993 obj_frob_file_before_fix ();
1996 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1998 /* Set up symbol table, and write it out. */
2002 bfd_boolean skip_next_symbol
= FALSE
;
2004 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2009 if (skip_next_symbol
)
2011 /* Don't do anything besides moving the value of the
2012 symbol from the GAS value-field to the BFD value-field. */
2013 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2014 skip_next_symbol
= FALSE
;
2018 if (symbol_mri_common_p (symp
))
2020 if (S_IS_EXTERNAL (symp
))
2021 as_bad (_("%s: global symbols not supported in common sections"),
2023 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2027 name
= S_GET_NAME (symp
);
2031 decode_local_label_name ((char *) S_GET_NAME (symp
));
2032 /* They only differ if `name' is a fb or dollar local
2034 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2035 as_bad (_("local label `%s' is not defined"), name2
);
2038 /* Do it again, because adjust_reloc_syms might introduce
2039 more symbols. They'll probably only be section symbols,
2040 but they'll still need to have the values computed. */
2041 resolve_symbol_value (symp
);
2043 /* Skip symbols which were equated to undefined or common
2045 if (symbol_equated_reloc_p (symp
)
2046 || S_IS_WEAKREFR (symp
))
2048 const char *sname
= S_GET_NAME (symp
);
2050 if (S_IS_COMMON (symp
)
2051 && !TC_FAKE_LABEL (sname
)
2052 && !S_IS_WEAKREFR (symp
)
2053 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
2055 expressionS
*e
= symbol_get_value_expression (symp
);
2057 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2058 sname
, S_GET_NAME (e
->X_add_symbol
));
2060 if (S_GET_SEGMENT (symp
) == reg_section
)
2062 /* Report error only if we know the symbol name. */
2063 if (S_GET_NAME (symp
) != reg_section
->name
)
2064 as_bad (_("can't make global register symbol `%s'"),
2067 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2071 #ifdef obj_frob_symbol
2072 obj_frob_symbol (symp
, punt
);
2074 #ifdef tc_frob_symbol
2075 if (! punt
|| symbol_used_in_reloc_p (symp
))
2076 tc_frob_symbol (symp
, punt
);
2079 /* If we don't want to keep this symbol, splice it out of
2080 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2081 want section symbols. Otherwise, we skip local symbols
2082 and symbols that the frob_symbol macros told us to punt,
2083 but we keep such symbols if they are used in relocs. */
2084 if (symp
== abs_section_sym
2085 || (! EMIT_SECTION_SYMBOLS
2086 && symbol_section_p (symp
))
2087 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2088 opposites. Sometimes the former checks flags and the
2089 latter examines the name... */
2090 || (!S_IS_EXTERNAL (symp
)
2091 && (punt
|| S_IS_LOCAL (symp
) ||
2092 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2093 && ! symbol_used_in_reloc_p (symp
)))
2095 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2097 /* After symbol_remove, symbol_next(symp) still returns
2098 the one that came after it in the chain. So we don't
2099 need to do any extra cleanup work here. */
2103 /* Make sure we really got a value for the symbol. */
2104 if (! symbol_resolved_p (symp
))
2106 as_bad (_("can't resolve value for symbol `%s'"),
2108 symbol_mark_resolved (symp
);
2111 /* Set the value into the BFD symbol. Up til now the value
2112 has only been kept in the gas symbolS struct. */
2113 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2115 /* A warning construct is a warning symbol followed by the
2116 symbol warned about. Don't let anything object-format or
2117 target-specific muck with it; it's ready for output. */
2118 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2119 skip_next_symbol
= TRUE
;
2125 /* Now do any format-specific adjustments to the symbol table, such
2126 as adding file symbols. */
2127 #ifdef tc_adjust_symtab
2128 tc_adjust_symtab ();
2130 #ifdef obj_adjust_symtab
2131 obj_adjust_symtab ();
2134 /* Stop if there is an error. */
2138 /* Now that all the sizes are known, and contents correct, we can
2139 start writing to the file. */
2142 /* If *_frob_file changes the symbol value at this point, it is
2143 responsible for moving the changed value into symp->bsym->value
2144 as well. Hopefully all symbol value changing can be done in
2149 #ifdef obj_frob_file
2152 #ifdef obj_coff_generate_pdata
2153 obj_coff_generate_pdata ();
2155 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2157 #ifdef tc_frob_file_after_relocs
2158 tc_frob_file_after_relocs ();
2160 #ifdef obj_frob_file_after_relocs
2161 obj_frob_file_after_relocs ();
2164 /* Once all relocations have been written, we can compress the
2165 contents of the debug sections. This needs to be done before
2166 we start writing any sections, because it will affect the file
2167 layout, which is fixed once we start writing contents. */
2168 if (flag_compress_debug
)
2169 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2171 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2174 #ifdef TC_GENERIC_RELAX_TABLE
2175 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2178 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2180 const relax_typeS
*this_type
;
2181 const relax_typeS
*start_type
;
2182 relax_substateT next_state
;
2183 relax_substateT this_state
;
2189 const relax_typeS
*table
;
2191 target
= fragP
->fr_offset
;
2192 address
= fragP
->fr_address
;
2193 table
= TC_GENERIC_RELAX_TABLE
;
2194 this_state
= fragP
->fr_subtype
;
2195 start_type
= this_type
= table
+ this_state
;
2196 symbolP
= fragP
->fr_symbol
;
2202 sym_frag
= symbol_get_frag (symbolP
);
2204 #ifndef DIFF_EXPR_OK
2205 know (sym_frag
!= NULL
);
2207 know (S_GET_SEGMENT (symbolP
) != absolute_section
2208 || sym_frag
== &zero_address_frag
);
2209 target
+= S_GET_VALUE (symbolP
);
2211 /* If SYM_FRAG has yet to be reached on this pass, assume it
2212 will move by STRETCH just as we did, unless there is an
2213 alignment frag between here and SYM_FRAG. An alignment may
2214 well absorb any STRETCH, and we don't want to choose a larger
2215 branch insn by overestimating the needed reach of this
2216 branch. It isn't critical to calculate TARGET exactly; We
2217 know we'll be doing another pass if STRETCH is non-zero. */
2220 && sym_frag
->relax_marker
!= fragP
->relax_marker
2221 && S_GET_SEGMENT (symbolP
) == segment
)
2224 || sym_frag
->region
== fragP
->region
)
2226 /* If we get here we know we have a forward branch. This
2227 relax pass may have stretched previous instructions so
2228 far that omitting STRETCH would make the branch
2229 negative. Don't allow this in case the negative reach is
2230 large enough to require a larger branch instruction. */
2231 else if (target
< address
)
2232 target
= fragP
->fr_next
->fr_address
+ stretch
;
2236 aim
= target
- address
- fragP
->fr_fix
;
2237 #ifdef TC_PCREL_ADJUST
2238 /* Currently only the ns32k family needs this. */
2239 aim
+= TC_PCREL_ADJUST (fragP
);
2242 #ifdef md_prepare_relax_scan
2243 /* Formerly called M68K_AIM_KLUDGE. */
2244 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2249 /* Look backwards. */
2250 for (next_state
= this_type
->rlx_more
; next_state
;)
2251 if (aim
>= this_type
->rlx_backward
)
2255 /* Grow to next state. */
2256 this_state
= next_state
;
2257 this_type
= table
+ this_state
;
2258 next_state
= this_type
->rlx_more
;
2263 /* Look forwards. */
2264 for (next_state
= this_type
->rlx_more
; next_state
;)
2265 if (aim
<= this_type
->rlx_forward
)
2269 /* Grow to next state. */
2270 this_state
= next_state
;
2271 this_type
= table
+ this_state
;
2272 next_state
= this_type
->rlx_more
;
2276 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2278 fragP
->fr_subtype
= this_state
;
2282 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2284 /* Relax_align. Advance location counter to next address that has 'alignment'
2285 lowest order bits all 0s, return size of adjustment made. */
2286 static relax_addressT
2287 relax_align (register relax_addressT address
, /* Address now. */
2288 register int alignment
/* Alignment (binary). */)
2290 relax_addressT mask
;
2291 relax_addressT new_address
;
2293 mask
= ~((~0) << alignment
);
2294 new_address
= (address
+ mask
) & (~mask
);
2295 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2297 /* We must provide lots of padding, so the linker can discard it
2298 when needed. The linker will not add extra space, ever. */
2299 new_address
+= (1 << alignment
);
2301 return (new_address
- address
);
2304 /* Now we have a segment, not a crowd of sub-segments, we can make
2309 After this, all frags in this segment have addresses that are correct
2310 within the segment. Since segments live in different file addresses,
2311 these frag addresses may not be the same as final object-file
2315 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2317 unsigned long frag_count
;
2319 relax_addressT address
;
2323 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2324 subseg_change (segment
, 0);
2326 /* For each frag in segment: count and store (a 1st guess of)
2330 for (frag_count
= 0, fragP
= segment_frag_root
;
2332 fragP
= fragP
->fr_next
, frag_count
++)
2334 fragP
->region
= region
;
2335 fragP
->relax_marker
= 0;
2336 fragP
->fr_address
= address
;
2337 address
+= fragP
->fr_fix
;
2339 switch (fragP
->fr_type
)
2342 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2349 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2351 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2354 if (offset
% fragP
->fr_var
!= 0)
2356 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2357 _("alignment padding (%lu bytes) not a multiple of %ld"),
2358 (unsigned long) offset
, (long) fragP
->fr_var
);
2359 offset
-= (offset
% fragP
->fr_var
);
2368 /* Assume .org is nugatory. It will grow with 1st relax. */
2375 case rs_machine_dependent
:
2376 /* If fr_symbol is an expression, this call to
2377 resolve_symbol_value sets up the correct segment, which will
2378 likely be needed in md_estimate_size_before_relax. */
2379 if (fragP
->fr_symbol
)
2380 resolve_symbol_value (fragP
->fr_symbol
);
2382 address
+= md_estimate_size_before_relax (fragP
, segment
);
2385 #ifndef WORKING_DOT_WORD
2386 /* Broken words don't concern us yet. */
2387 case rs_broken_word
:
2392 /* Initial guess is always 1; doing otherwise can result in
2393 stable solutions that are larger than the minimum. */
2394 address
+= fragP
->fr_offset
= 1;
2398 address
+= eh_frame_estimate_size_before_relax (fragP
);
2402 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2406 BAD_CASE (fragP
->fr_type
);
2413 unsigned long max_iterations
;
2415 /* Cumulative address adjustment. */
2418 /* Have we made any adjustment this pass? We can't just test
2419 stretch because one piece of code may have grown and another
2423 /* Most horrible, but gcc may give us some exception data that
2424 is impossible to assemble, of the form
2428 .uleb128 end - start
2434 If the leb128 is two bytes in size, then end-start is 128*128,
2435 which requires a three byte leb128. If the leb128 is three
2436 bytes in size, then end-start is 128*128-1, which requires a
2437 two byte leb128. We work around this dilemma by inserting
2438 an extra 4 bytes of alignment just after the .align. This
2439 works because the data after the align is accessed relative to
2442 This counter is used in a tiny state machine to detect
2443 whether a leb128 followed by an align is impossible to
2445 int rs_leb128_fudge
= 0;
2447 /* We want to prevent going into an infinite loop where one frag grows
2448 depending upon the location of a symbol which is in turn moved by
2449 the growing frag. eg:
2455 So we dictate that this algorithm can be at most O2. */
2456 max_iterations
= frag_count
* frag_count
;
2457 /* Check for overflow. */
2458 if (max_iterations
< frag_count
)
2459 max_iterations
= frag_count
;
2467 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2470 addressT was_address
;
2474 fragP
->relax_marker
^= 1;
2475 was_address
= fragP
->fr_address
;
2476 address
= fragP
->fr_address
+= stretch
;
2477 symbolP
= fragP
->fr_symbol
;
2478 offset
= fragP
->fr_offset
;
2480 switch (fragP
->fr_type
)
2482 case rs_fill
: /* .fill never relaxes. */
2486 #ifndef WORKING_DOT_WORD
2487 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2488 for it I do not want to write it. I do not want to have
2489 anything to do with it. This is not the proper way to
2490 implement this misfeature. */
2491 case rs_broken_word
:
2493 struct broken_word
*lie
;
2494 struct broken_word
*untruth
;
2496 /* Yes this is ugly (storing the broken_word pointer
2497 in the symbol slot). Still, this whole chunk of
2498 code is ugly, and I don't feel like doing anything
2499 about it. Think of it as stubbornness in action. */
2501 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2502 lie
&& lie
->dispfrag
== fragP
;
2503 lie
= lie
->next_broken_word
)
2509 offset
= (S_GET_VALUE (lie
->add
)
2511 - S_GET_VALUE (lie
->sub
));
2512 if (offset
<= -32768 || offset
>= 32767)
2514 if (flag_warn_displacement
)
2517 sprint_value (buf
, (addressT
) lie
->addnum
);
2518 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2519 _(".word %s-%s+%s didn't fit"),
2520 S_GET_NAME (lie
->add
),
2521 S_GET_NAME (lie
->sub
),
2524 if (fragP
->fr_subtype
== 0)
2526 fragP
->fr_subtype
++;
2527 growth
+= md_short_jump_size
;
2530 /* Redirect *all* words of this table with the same
2531 target, lest we have to handle the case where the
2532 same target but with a offset that fits on this
2533 round overflows at the next relaxation round. */
2534 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2535 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2536 untruth
= untruth
->next_broken_word
)
2537 if ((symbol_get_frag (untruth
->add
)
2538 == symbol_get_frag (lie
->add
))
2539 && (S_GET_VALUE (untruth
->add
)
2540 == S_GET_VALUE (lie
->add
)))
2543 untruth
->use_jump
= lie
;
2547 growth
+= md_long_jump_size
;
2552 } /* case rs_broken_word */
2558 addressT oldoff
, newoff
;
2560 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2562 newoff
= relax_align (address
+ fragP
->fr_fix
,
2565 if (fragP
->fr_subtype
!= 0)
2567 if (oldoff
> fragP
->fr_subtype
)
2569 if (newoff
> fragP
->fr_subtype
)
2573 growth
= newoff
- oldoff
;
2575 /* If this align happens to follow a leb128 and
2576 we have determined that the leb128 is bouncing
2577 in size, then break the cycle by inserting an
2580 && (rs_leb128_fudge
& 16) != 0
2581 && (rs_leb128_fudge
& 15) >= 2)
2583 segment_info_type
*seginfo
= seg_info (segment
);
2584 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2587 newf
= frag_alloc (ob
);
2588 obstack_blank_fast (ob
, fragP
->fr_var
);
2589 obstack_finish (ob
);
2590 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2591 memcpy (newf
->fr_literal
,
2592 fragP
->fr_literal
+ fragP
->fr_fix
,
2594 newf
->fr_type
= rs_fill
;
2595 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2597 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2599 if (newf
->fr_offset
* newf
->fr_var
2600 != (offsetT
) 1 << fragP
->fr_offset
)
2602 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2605 /* Include size of new frag in GROWTH. */
2606 growth
+= newf
->fr_offset
* newf
->fr_var
;
2607 /* Adjust the new frag address for the amount
2608 we'll add when we process the new frag. */
2609 newf
->fr_address
-= stretch
+ growth
;
2610 newf
->relax_marker
^= 1;
2611 fragP
->fr_next
= newf
;
2613 as_warn (_("padding added"));
2621 addressT target
= offset
;
2626 /* Convert from an actual address to an octet offset
2627 into the section. Here it is assumed that the
2628 section's VMA is zero, and can omit subtracting it
2629 from the symbol's value to get the address offset. */
2630 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2631 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2634 know (fragP
->fr_next
);
2635 after
= fragP
->fr_next
->fr_address
+ stretch
;
2636 growth
= target
- after
;
2641 /* Don't error on first few frag relax passes.
2642 The symbol might be an expression involving
2643 symbol values from other sections. If those
2644 sections have not yet been processed their
2645 frags will all have zero addresses, so we
2646 will calculate incorrect values for them. The
2647 number of passes we allow before giving an
2648 error is somewhat arbitrary. It should be at
2649 least one, with larger values requiring
2650 increasingly contrived dependencies between
2651 frags to trigger a false error. */
2654 /* Force another pass. */
2659 /* Growth may be negative, but variable part of frag
2660 cannot have fewer than 0 chars. That is, we can't
2662 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2663 _("attempt to move .org backwards"));
2665 /* We've issued an error message. Change the
2666 frag to avoid cascading errors. */
2667 fragP
->fr_type
= rs_align
;
2668 fragP
->fr_subtype
= 0;
2669 fragP
->fr_offset
= 0;
2670 fragP
->fr_fix
= after
- address
;
2681 amount
= S_GET_VALUE (symbolP
);
2682 if (S_GET_SEGMENT (symbolP
) != absolute_section
2683 || S_IS_COMMON (symbolP
)
2684 || ! S_IS_DEFINED (symbolP
))
2686 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2687 _(".space specifies non-absolute value"));
2688 /* Prevent repeat of this error message. */
2689 fragP
->fr_symbol
= 0;
2691 else if (amount
< 0)
2693 /* Don't error on first few frag relax passes.
2694 See rs_org comment for a longer explanation. */
2701 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2702 _(".space or .fill with negative value, ignored"));
2703 fragP
->fr_symbol
= 0;
2706 growth
= (was_address
+ fragP
->fr_fix
+ amount
2707 - fragP
->fr_next
->fr_address
);
2711 case rs_machine_dependent
:
2712 #ifdef md_relax_frag
2713 growth
= md_relax_frag (segment
, fragP
, stretch
);
2715 #ifdef TC_GENERIC_RELAX_TABLE
2716 /* The default way to relax a frag is to look through
2717 TC_GENERIC_RELAX_TABLE. */
2718 growth
= relax_frag (segment
, fragP
, stretch
);
2719 #endif /* TC_GENERIC_RELAX_TABLE */
2728 value
= resolve_symbol_value (fragP
->fr_symbol
);
2729 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2730 growth
= size
- fragP
->fr_offset
;
2731 fragP
->fr_offset
= size
;
2736 growth
= eh_frame_relax_frag (fragP
);
2740 growth
= dwarf2dbg_relax_frag (fragP
);
2744 BAD_CASE (fragP
->fr_type
);
2751 if (fragP
->fr_type
== rs_leb128
)
2752 rs_leb128_fudge
+= 16;
2753 else if (fragP
->fr_type
== rs_align
2754 && (rs_leb128_fudge
& 16) != 0
2756 rs_leb128_fudge
+= 16;
2758 rs_leb128_fudge
= 0;
2763 && (rs_leb128_fudge
& 16) == 0
2764 && (rs_leb128_fudge
& -16) != 0)
2765 rs_leb128_fudge
+= 1;
2767 rs_leb128_fudge
= 0;
2769 /* Until nothing further to relax. */
2770 while (stretched
&& -- max_iterations
);
2773 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2774 segment_name (segment
));
2777 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2778 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2780 fragP
->last_fr_address
= fragP
->fr_address
;
2787 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2793 buf
[n
] = val
& 0xff;
2799 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2805 *buf
++ = val
& 0xff;
2811 write_print_statistics (FILE *file
)
2813 fprintf (file
, "fixups: %d\n", n_fixups
);
2816 /* For debugging. */
2817 extern int indent_level
;
2820 print_fixup (fixS
*fixp
)
2823 fprintf (stderr
, "fix ");
2824 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2825 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2827 fprintf (stderr
, " pcrel");
2828 if (fixp
->fx_pcrel_adjust
)
2829 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2830 if (fixp
->fx_im_disp
)
2833 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2835 fprintf (stderr
, " im_disp");
2839 fprintf (stderr
, " tcbit");
2841 fprintf (stderr
, " done");
2842 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2843 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2844 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2845 (long) fixp
->fx_where
,
2846 (unsigned long) fixp
->fx_offset
,
2847 (unsigned long) fixp
->fx_addnumber
);
2848 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2852 fprintf (stderr
, "\n +<");
2853 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2854 fprintf (stderr
, ">");
2858 fprintf (stderr
, "\n -<");
2859 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2860 fprintf (stderr
, ">");
2862 fprintf (stderr
, "\n");
2863 #ifdef TC_FIX_DATA_PRINT
2864 TC_FIX_DATA_PRINT (stderr
, fixp
);