1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010, 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This thing should be set up to do byteordering correctly. But... */
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 #include "compress-debug.h"
33 #ifndef TC_FORCE_RELOCATION
34 #define TC_FORCE_RELOCATION(FIX) \
35 (generic_force_reloc (FIX))
38 #ifndef TC_FORCE_RELOCATION_ABS
39 #define TC_FORCE_RELOCATION_ABS(FIX) \
40 (TC_FORCE_RELOCATION (FIX))
43 #ifndef TC_FORCE_RELOCATION_LOCAL
44 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
46 || TC_FORCE_RELOCATION (FIX))
49 #ifndef TC_FORCE_RELOCATION_SUB_SAME
50 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
54 #ifndef md_register_arithmetic
55 # define md_register_arithmetic 1
58 #ifndef TC_FORCE_RELOCATION_SUB_ABS
59 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
60 (!md_register_arithmetic && (SEG) == reg_section)
63 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
65 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
66 (!md_register_arithmetic && (SEG) == reg_section)
68 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
72 #ifndef TC_VALIDATE_FIX_SUB
73 #ifdef UNDEFINED_DIFFERENCE_OK
74 /* The PA needs this for PIC code generation. */
75 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
76 (md_register_arithmetic || (SEG) != reg_section)
78 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
79 ((md_register_arithmetic || (SEG) != reg_section) \
80 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
81 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
85 #ifndef TC_LINKRELAX_FIXUP
86 #define TC_LINKRELAX_FIXUP(SEG) 1
89 #ifndef MD_APPLY_SYM_VALUE
90 #define MD_APPLY_SYM_VALUE(FIX) 1
93 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
94 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
97 #ifndef MD_PCREL_FROM_SECTION
98 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
101 #ifndef TC_FAKE_LABEL
102 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
105 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
106 fixups that far past the end of a frag. Having such fixups
107 is of course most most likely a bug in setting fx_size correctly.
108 A negative value disables the fixup check entirely, which is
109 appropriate for something like the Renesas / SuperH SH_COUNT
111 #ifndef TC_FX_SIZE_SLACK
112 #define TC_FX_SIZE_SLACK(FIX) 0
115 /* Used to control final evaluation of expressions. */
116 int finalize_syms
= 0;
118 int symbol_table_frozen
;
120 symbolS
*abs_section_sym
;
122 /* Remember the value of dot when parsing expressions. */
125 /* Relocs generated by ".reloc" pseudo. */
126 struct reloc_list
* reloc_list
;
128 void print_fixup (fixS
*);
130 /* We generally attach relocs to frag chains. However, after we have
131 chained these all together into a segment, any relocs we add after
132 that must be attached to a segment. This will include relocs added
133 in md_estimate_size_for_relax, for example. */
134 static int frags_chained
= 0;
138 #define RELOC_ENUM enum bfd_reloc_code_real
140 /* Create a fixS in obstack 'notes'. */
143 fix_new_internal (fragS
*frag
, /* Which frag? */
144 int where
, /* Where in that frag? */
145 int size
, /* 1, 2, or 4 usually. */
146 symbolS
*add_symbol
, /* X_add_symbol. */
147 symbolS
*sub_symbol
, /* X_op_symbol. */
148 offsetT offset
, /* X_add_number. */
149 int pcrel
, /* TRUE if PC-relative relocation. */
150 RELOC_ENUM r_type
/* Relocation type. */,
151 int at_beginning
) /* Add to the start of the list? */
157 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
159 fixP
->fx_frag
= frag
;
160 fixP
->fx_where
= where
;
161 fixP
->fx_size
= size
;
162 /* We've made fx_size a narrow field; check that it's wide enough. */
163 if (fixP
->fx_size
!= size
)
165 as_bad (_("field fx_size too small to hold %d"), size
);
168 fixP
->fx_addsy
= add_symbol
;
169 fixP
->fx_subsy
= sub_symbol
;
170 fixP
->fx_offset
= offset
;
171 fixP
->fx_dot_value
= dot_value
;
172 fixP
->fx_pcrel
= pcrel
;
173 fixP
->fx_r_type
= r_type
;
174 fixP
->fx_im_disp
= 0;
175 fixP
->fx_pcrel_adjust
= 0;
176 fixP
->fx_bit_fixP
= 0;
177 fixP
->fx_addnumber
= 0;
181 fixP
->fx_no_overflow
= 0;
185 fixP
->fx_cgen
.insn
= NULL
;
186 fixP
->fx_cgen
.opinfo
= 0;
190 TC_INIT_FIX_DATA (fixP
);
193 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
197 fixS
**seg_fix_rootP
= (frags_chained
198 ? &seg_info (now_seg
)->fix_root
199 : &frchain_now
->fix_root
);
200 fixS
**seg_fix_tailP
= (frags_chained
201 ? &seg_info (now_seg
)->fix_tail
202 : &frchain_now
->fix_tail
);
206 fixP
->fx_next
= *seg_fix_rootP
;
207 *seg_fix_rootP
= fixP
;
208 if (fixP
->fx_next
== NULL
)
209 *seg_fix_tailP
= fixP
;
213 fixP
->fx_next
= NULL
;
215 (*seg_fix_tailP
)->fx_next
= fixP
;
217 *seg_fix_rootP
= fixP
;
218 *seg_fix_tailP
= fixP
;
225 /* Create a fixup relative to a symbol (plus a constant). */
228 fix_new (fragS
*frag
, /* Which frag? */
229 int where
, /* Where in that frag? */
230 int size
, /* 1, 2, or 4 usually. */
231 symbolS
*add_symbol
, /* X_add_symbol. */
232 offsetT offset
, /* X_add_number. */
233 int pcrel
, /* TRUE if PC-relative relocation. */
234 RELOC_ENUM r_type
/* Relocation type. */)
236 return fix_new_internal (frag
, where
, size
, add_symbol
,
237 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
240 /* Create a fixup for an expression. Currently we only support fixups
241 for difference expressions. That is itself more than most object
242 file formats support anyhow. */
245 fix_new_exp (fragS
*frag
, /* Which frag? */
246 int where
, /* Where in that frag? */
247 int size
, /* 1, 2, or 4 usually. */
248 expressionS
*exp
, /* Expression. */
249 int pcrel
, /* TRUE if PC-relative relocation. */
250 RELOC_ENUM r_type
/* Relocation type. */)
262 as_bad (_("register value used as expression"));
266 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
267 the difference expression cannot immediately be reduced. */
269 symbolS
*stmp
= make_expr_symbol (exp
);
271 exp
->X_op
= O_symbol
;
272 exp
->X_op_symbol
= 0;
273 exp
->X_add_symbol
= stmp
;
274 exp
->X_add_number
= 0;
276 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
280 add
= exp
->X_add_symbol
;
281 off
= exp
->X_add_number
;
282 r_type
= BFD_RELOC_RVA
;
286 sub
= exp
->X_add_symbol
;
287 off
= exp
->X_add_number
;
291 sub
= exp
->X_op_symbol
;
294 add
= exp
->X_add_symbol
;
297 off
= exp
->X_add_number
;
301 add
= make_expr_symbol (exp
);
305 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
309 /* Create a fixup at the beginning of FRAG. The arguments are the same
310 as for fix_new, except that WHERE is implicitly 0. */
313 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
314 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
316 return fix_new_internal (frag
, 0, size
, add_symbol
,
317 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
320 /* Generic function to determine whether a fixup requires a relocation. */
322 generic_force_reloc (fixS
*fix
)
324 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
325 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
328 if (fix
->fx_addsy
== NULL
)
331 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
334 /* Append a string onto another string, bumping the pointer along. */
336 append (char **charPP
, char *fromP
, unsigned long length
)
338 /* Don't trust memcpy() of 0 chars. */
342 memcpy (*charPP
, fromP
, length
);
346 /* This routine records the largest alignment seen for each segment.
347 If the beginning of the segment is aligned on the worst-case
348 boundary, all of the other alignments within it will work. At
349 least one object format really uses this info. */
352 record_alignment (/* Segment to which alignment pertains. */
354 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
355 boundary, 2 => 4-byte boundary, etc.) */
358 if (seg
== absolute_section
)
361 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
362 bfd_set_section_alignment (stdoutput
, seg
, align
);
366 get_recorded_alignment (segT seg
)
368 if (seg
== absolute_section
)
371 return bfd_get_section_alignment (stdoutput
, seg
);
374 /* Reset the section indices after removing the gas created sections. */
377 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
379 int *countp
= (int *) countparg
;
381 sec
->index
= *countp
;
386 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
388 fragS dummy
, *prev_frag
= &dummy
;
389 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
391 for (; frchp
; frchp
= frchp
->frch_next
)
393 prev_frag
->fr_next
= frchp
->frch_root
;
394 prev_frag
= frchp
->frch_last
;
395 gas_assert (prev_frag
->fr_type
!= 0);
396 if (frchp
->fix_root
!= (fixS
*) NULL
)
398 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
399 seg_info (section
)->fix_root
= frchp
->fix_root
;
400 prev_fix
->fx_next
= frchp
->fix_root
;
401 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
402 prev_fix
= frchp
->fix_tail
;
405 gas_assert (prev_frag
!= &dummy
406 && prev_frag
->fr_type
!= 0);
407 prev_frag
->fr_next
= 0;
412 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
414 void *xxx ATTRIBUTE_UNUSED
)
416 segment_info_type
*info
;
418 /* BFD may have introduced its own sections without using
419 subseg_new, so it is possible that seg_info is NULL. */
420 info
= seg_info (section
);
421 if (info
!= (segment_info_type
*) NULL
)
422 info
->frchainP
->frch_last
423 = chain_frchains_together_1 (section
, info
->frchainP
);
425 /* Now that we've chained the frags together, we must add new fixups
426 to the segment, not to the frag chain. */
431 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
433 switch (fragP
->fr_type
)
441 HANDLE_ALIGN (fragP
);
443 know (fragP
->fr_next
!= NULL
);
444 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
446 - fragP
->fr_fix
) / fragP
->fr_var
;
447 if (fragP
->fr_offset
< 0)
449 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
450 _("attempt to .org/.space backwards? (%ld)"),
451 (long) fragP
->fr_offset
);
452 fragP
->fr_offset
= 0;
454 fragP
->fr_type
= rs_fill
;
462 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
465 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
468 fragP
->fr_fix
+= size
;
469 fragP
->fr_type
= rs_fill
;
471 fragP
->fr_offset
= 0;
472 fragP
->fr_symbol
= NULL
;
477 eh_frame_convert_frag (fragP
);
481 dwarf2dbg_convert_frag (fragP
);
484 case rs_machine_dependent
:
485 md_convert_frag (stdoutput
, sec
, fragP
);
487 gas_assert (fragP
->fr_next
== NULL
488 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
491 /* After md_convert_frag, we make the frag into a ".space 0".
492 md_convert_frag() should set up any fixSs and constants
497 #ifndef WORKING_DOT_WORD
500 struct broken_word
*lie
;
502 if (fragP
->fr_subtype
)
504 fragP
->fr_fix
+= md_short_jump_size
;
505 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
506 lie
&& lie
->dispfrag
== fragP
;
507 lie
= lie
->next_broken_word
)
509 fragP
->fr_fix
+= md_long_jump_size
;
517 BAD_CASE (fragP
->fr_type
);
521 md_frag_check (fragP
);
525 struct relax_seg_info
532 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
534 segment_info_type
*seginfo
= seg_info (sec
);
535 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
537 if (seginfo
&& seginfo
->frchainP
538 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
543 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
547 segment_info_type
*seginfo
;
549 valueT size
, newsize
;
551 subseg_change (sec
, 0);
553 seginfo
= seg_info (sec
);
554 if (seginfo
&& seginfo
->frchainP
)
556 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
557 cvt_frag_to_fill (sec
, fragp
);
558 for (fragp
= seginfo
->frchainP
->frch_root
;
560 fragp
= fragp
->fr_next
)
561 /* Walk to last elt. */
563 size
= fragp
->fr_address
+ fragp
->fr_fix
;
568 flags
= bfd_get_section_flags (abfd
, sec
);
569 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
570 (flags
& SEC_HAS_CONTENTS
) != 0)
573 if (size
> 0 && ! seginfo
->bss
)
574 flags
|= SEC_HAS_CONTENTS
;
577 x
= bfd_set_section_flags (abfd
, sec
, flags
);
580 newsize
= md_section_align (sec
, size
);
581 x
= bfd_set_section_size (abfd
, sec
, newsize
);
584 /* If the size had to be rounded up, add some padding in the last
586 gas_assert (newsize
>= size
);
589 fragS
*last
= seginfo
->frchainP
->frch_last
;
590 fragp
= seginfo
->frchainP
->frch_root
;
591 while (fragp
->fr_next
!= last
)
592 fragp
= fragp
->fr_next
;
593 last
->fr_address
= size
;
594 if ((newsize
- size
) % fragp
->fr_var
== 0)
595 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
597 /* If we hit this abort, it's likely due to subsegs_finish not
598 providing sufficient alignment on the last frag, and the
599 machine dependent code using alignment frags with fr_var
604 #ifdef tc_frob_section
605 tc_frob_section (sec
);
607 #ifdef obj_frob_section
608 obj_frob_section (sec
);
614 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
616 segment_info_type
*seginfo
= seg_info (sec
);
617 fixS
*fixp
= seginfo
->fix_root
;
622 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
625 symbolS
*s
= fixp
->fx_addsy
;
627 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
628 (int) fixp
->fx_r_type
);
630 fprintf (stream
, "no sym\n");
633 print_symbol_value_1 (stream
, s
);
634 fprintf (stream
, "\n");
636 fixp
= fixp
->fx_next
;
640 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
643 #ifndef EMIT_SECTION_SYMBOLS
644 #define EMIT_SECTION_SYMBOLS 1
647 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
648 and check for validity. Convert RELOC_LIST from using U.A fields
651 resolve_reloc_expr_symbols (void)
653 bfd_vma addr_mask
= 1;
654 struct reloc_list
*r
;
656 /* Avoid a shift by the width of type. */
657 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
661 for (r
= reloc_list
; r
; r
= r
->next
)
663 reloc_howto_type
*howto
= r
->u
.a
.howto
;
666 bfd_vma offset
, addend
;
669 resolve_symbol_value (r
->u
.a
.offset_sym
);
670 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
674 if (symval
->X_op
== O_constant
)
675 sym
= r
->u
.a
.offset_sym
;
676 else if (symval
->X_op
== O_symbol
)
678 sym
= symval
->X_add_symbol
;
679 offset
= symval
->X_add_number
;
680 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
683 || symval
->X_op
!= O_constant
684 || (sec
= S_GET_SEGMENT (sym
)) == NULL
685 || !SEG_NORMAL (sec
))
687 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
691 offset
+= S_GET_VALUE (sym
);
694 addend
= r
->u
.a
.addend
;
695 if (r
->u
.a
.sym
!= NULL
)
697 resolve_symbol_value (r
->u
.a
.sym
);
698 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
699 if (symval
->X_op
== O_constant
)
701 else if (symval
->X_op
== O_symbol
)
703 sym
= symval
->X_add_symbol
;
704 addend
+= symval
->X_add_number
;
705 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
707 if (symval
->X_op
!= O_constant
)
709 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
712 else if (sym
!= NULL
)
714 /* Convert relocs against local symbols to refer to the
715 corresponding section symbol plus offset instead. Keep
716 PC-relative relocs of the REL variety intact though to
717 prevent the offset from overflowing the relocated field,
718 unless it has enough bits to cover the whole address
720 if (S_IS_LOCAL (sym
) && !symbol_section_p (sym
)
721 && !(howto
->partial_inplace
722 && howto
->pc_relative
723 && howto
->src_mask
!= addr_mask
))
725 asection
*symsec
= S_GET_SEGMENT (sym
);
726 if (!(((symsec
->flags
& SEC_MERGE
) != 0
728 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
730 addend
+= S_GET_VALUE (sym
);
731 sym
= section_symbol (symsec
);
734 symbol_mark_used_in_reloc (sym
);
739 if (abs_section_sym
== NULL
)
740 abs_section_sym
= section_symbol (absolute_section
);
741 sym
= abs_section_sym
;
745 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
746 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
747 r
->u
.b
.r
.address
= offset
;
748 r
->u
.b
.r
.addend
= addend
;
749 r
->u
.b
.r
.howto
= howto
;
753 /* This pass over fixups decides whether symbols can be replaced with
757 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
759 void *xxx ATTRIBUTE_UNUSED
)
761 segment_info_type
*seginfo
= seg_info (sec
);
767 dump_section_relocs (abfd
, sec
, stderr
);
769 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
773 else if (fixp
->fx_addsy
)
779 fprintf (stderr
, "\n\nadjusting fixup:\n");
783 sym
= fixp
->fx_addsy
;
785 /* All symbols should have already been resolved at this
786 point. It is possible to see unresolved expression
787 symbols, though, since they are not in the regular symbol
789 resolve_symbol_value (sym
);
791 if (fixp
->fx_subsy
!= NULL
)
792 resolve_symbol_value (fixp
->fx_subsy
);
794 /* If this symbol is equated to an undefined or common symbol,
795 convert the fixup to being against that symbol. */
796 while (symbol_equated_reloc_p (sym
)
797 || S_IS_WEAKREFR (sym
))
799 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
802 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
803 fixp
->fx_addsy
= newsym
;
807 if (symbol_mri_common_p (sym
))
809 fixp
->fx_offset
+= S_GET_VALUE (sym
);
810 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
814 /* If the symbol is undefined, common, weak, or global (ELF
815 shared libs), we can't replace it with the section symbol. */
816 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
819 /* Is there some other (target cpu dependent) reason we can't adjust
820 this one? (E.g. relocations involving function addresses on
822 #ifdef tc_fix_adjustable
823 if (! tc_fix_adjustable (fixp
))
827 /* Since we're reducing to section symbols, don't attempt to reduce
828 anything that's already using one. */
829 if (symbol_section_p (sym
))
832 symsec
= S_GET_SEGMENT (sym
);
836 if (bfd_is_abs_section (symsec
))
838 /* The fixup_segment routine normally will not use this
839 symbol in a relocation. */
843 /* Don't try to reduce relocs which refer to non-local symbols
844 in .linkonce sections. It can lead to confusion when a
845 debugging section refers to a .linkonce section. I hope
846 this will always be correct. */
847 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
849 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
851 /* The GNU toolchain uses an extension for ELF: a
852 section beginning with the magic string
853 .gnu.linkonce is a linkonce section. */
854 && strncmp (segment_name (symsec
), ".gnu.linkonce",
855 sizeof ".gnu.linkonce" - 1) == 0))
859 /* Never adjust a reloc against local symbol in a merge section
860 with non-zero addend. */
861 if ((symsec
->flags
& SEC_MERGE
) != 0
862 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
865 /* Never adjust a reloc against TLS local symbol. */
866 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
869 /* We refetch the segment when calling section_symbol, rather
870 than using symsec, because S_GET_VALUE may wind up changing
871 the section when it calls resolve_symbol_value. */
872 fixp
->fx_offset
+= S_GET_VALUE (sym
);
873 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
875 fprintf (stderr
, "\nadjusted fixup:\n");
880 dump_section_relocs (abfd
, sec
, stderr
);
885 Go through all the fixS's in a segment and see which ones can be
886 handled now. (These consist of fixS where we have since discovered
887 the value of a symbol, or the address of the frag involved.)
888 For each one, call md_apply_fix to put the fix into the frag data.
889 Ones that we couldn't completely handle here will be output later
890 by emit_relocations. */
893 fixup_segment (fixS
*fixP
, segT this_segment
)
897 segT add_symbol_segment
= absolute_section
;
899 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
900 abs_section_sym
= section_symbol (absolute_section
);
902 /* If the linker is doing the relaxing, we must not do any fixups.
904 Well, strictly speaking that's not true -- we could do any that
905 are PC-relative and don't cross regions that could change size.
906 And for the i960 we might be able to turn callx/callj into bal
907 anyways in cases where we know the maximum displacement. */
908 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
910 for (; fixP
; fixP
= fixP
->fx_next
)
913 if (fixP
->fx_addsy
== NULL
)
915 /* There was no symbol required by this relocation.
916 However, BFD doesn't really handle relocations
917 without symbols well. So fake up a local symbol in
918 the absolute section. */
919 fixP
->fx_addsy
= abs_section_sym
;
921 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
922 if (fixP
->fx_subsy
!= NULL
)
923 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
928 for (; fixP
; fixP
= fixP
->fx_next
)
931 fprintf (stderr
, "\nprocessing fixup:\n");
935 fragP
= fixP
->fx_frag
;
937 #ifdef TC_VALIDATE_FIX
938 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
940 add_number
= fixP
->fx_offset
;
942 if (fixP
->fx_addsy
!= NULL
)
943 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
945 if (fixP
->fx_subsy
!= NULL
)
947 segT sub_symbol_segment
;
948 resolve_symbol_value (fixP
->fx_subsy
);
949 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
950 if (fixP
->fx_addsy
!= NULL
951 && sub_symbol_segment
== add_symbol_segment
952 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
953 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
954 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
956 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
957 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
958 fixP
->fx_offset
= add_number
;
959 fixP
->fx_addsy
= NULL
;
960 fixP
->fx_subsy
= NULL
;
962 /* See the comment below about 68k weirdness. */
966 else if (sub_symbol_segment
== absolute_section
967 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
968 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
970 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
971 fixP
->fx_offset
= add_number
;
972 fixP
->fx_subsy
= NULL
;
974 else if (sub_symbol_segment
== this_segment
975 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
976 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
978 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
979 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
980 + fixP
->fx_frag
->fr_address
);
982 /* Make it pc-relative. If the back-end code has not
983 selected a pc-relative reloc, cancel the adjustment
984 we do later on all pc-relative relocs. */
987 /* Do this for m68k even if it's already described
988 as pc-relative. On the m68k, an operand of
989 "pc@(foo-.-2)" should address "foo" in a
994 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
995 fixP
->fx_subsy
= NULL
;
998 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1000 if (!md_register_arithmetic
1001 && (add_symbol_segment
== reg_section
1002 || sub_symbol_segment
== reg_section
))
1003 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1004 _("register value used as expression"));
1006 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1007 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1008 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1009 segment_name (add_symbol_segment
),
1010 S_GET_NAME (fixP
->fx_subsy
),
1011 segment_name (sub_symbol_segment
));
1013 else if (sub_symbol_segment
!= undefined_section
1014 && ! bfd_is_com_section (sub_symbol_segment
)
1015 && MD_APPLY_SYM_VALUE (fixP
))
1016 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1021 if (add_symbol_segment
== this_segment
1022 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1023 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1025 /* This fixup was made when the symbol's segment was
1026 SEG_UNKNOWN, but it is now in the local segment.
1027 So we know how to do the address without relocation. */
1028 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1029 fixP
->fx_offset
= add_number
;
1031 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1032 fixP
->fx_addsy
= NULL
;
1035 else if (add_symbol_segment
== absolute_section
1036 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1037 && !TC_FORCE_RELOCATION_ABS (fixP
))
1039 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1040 fixP
->fx_offset
= add_number
;
1041 fixP
->fx_addsy
= NULL
;
1043 else if (add_symbol_segment
!= undefined_section
1044 && ! bfd_is_com_section (add_symbol_segment
)
1045 && MD_APPLY_SYM_VALUE (fixP
))
1046 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1051 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1052 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1054 /* There was no symbol required by this relocation.
1055 However, BFD doesn't really handle relocations
1056 without symbols well. So fake up a local symbol in
1057 the absolute section. */
1058 fixP
->fx_addsy
= abs_section_sym
;
1063 md_apply_fix (fixP
, &add_number
, this_segment
);
1067 if (fixP
->fx_addsy
== NULL
)
1068 fixP
->fx_addsy
= abs_section_sym
;
1069 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1070 if (fixP
->fx_subsy
!= NULL
)
1071 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1074 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1076 if (fixP
->fx_size
< sizeof (valueT
))
1081 mask
--; /* Set all bits to one. */
1082 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1083 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1085 char buf
[50], buf2
[50];
1086 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1087 if (add_number
> 1000)
1088 sprint_value (buf2
, add_number
);
1090 sprintf (buf2
, "%ld", (long) add_number
);
1091 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1092 _("value of %s too large for field of %d bytes at %s"),
1093 buf2
, fixP
->fx_size
, buf
);
1094 } /* Generic error checking. */
1096 #ifdef WARN_SIGNED_OVERFLOW_WORD
1097 /* Warn if a .word value is too large when treated as a signed
1098 number. We already know it is not too negative. This is to
1099 catch over-large switches generated by gcc on the 68k. */
1100 if (!flag_signed_overflow_ok
1101 && fixP
->fx_size
== 2
1102 && add_number
> 0x7fff)
1103 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1104 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1106 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1108 } /* Not a bit fix. */
1110 #ifdef TC_VALIDATE_FIX
1111 skip
: ATTRIBUTE_UNUSED_LABEL
1115 fprintf (stderr
, "result:\n");
1118 } /* For each fixS in this segment. */
1122 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1124 void *xxx ATTRIBUTE_UNUSED
)
1126 segment_info_type
*seginfo
= seg_info (sec
);
1128 fixup_segment (seginfo
->fix_root
, sec
);
1132 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1133 char *file
, unsigned int line
)
1136 bfd_reloc_status_type s
;
1139 if (reloc
->sym_ptr_ptr
!= NULL
1140 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1141 && (sym
->flags
& BSF_KEEP
) == 0
1142 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1143 || (EMIT_SECTION_SYMBOLS
1144 && !bfd_is_abs_section (sym
->section
))))
1145 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1147 s
= bfd_install_relocation (stdoutput
, reloc
,
1148 fragp
->fr_literal
, fragp
->fr_address
,
1154 case bfd_reloc_overflow
:
1155 as_bad_where (file
, line
, _("relocation overflow"));
1157 case bfd_reloc_outofrange
:
1158 as_bad_where (file
, line
, _("relocation out of range"));
1161 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1167 get_frag_for_reloc (fragS
*last_frag
,
1168 const segment_info_type
*seginfo
,
1169 const struct reloc_list
*r
)
1173 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1174 if (f
->fr_address
<= r
->u
.b
.r
.address
1175 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1178 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1179 if (f
->fr_address
<= r
->u
.b
.r
.address
1180 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1183 as_bad_where (r
->file
, r
->line
,
1184 _("reloc not within (fixed part of) section"));
1189 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1191 segment_info_type
*seginfo
= seg_info (sec
);
1193 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1198 /* If seginfo is NULL, we did not create this section; don't do
1199 anything with it. */
1200 if (seginfo
== NULL
)
1204 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1208 #ifdef RELOC_EXPANSION_POSSIBLE
1209 n
*= MAX_RELOC_EXPANSION
;
1212 /* Extract relocs for this section from reloc_list. */
1214 my_reloc_list
= NULL
;
1215 while ((r
= *rp
) != NULL
)
1217 if (r
->u
.b
.sec
== sec
)
1220 r
->next
= my_reloc_list
;
1228 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
1233 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1238 #ifndef RELOC_EXPANSION_POSSIBLE
1247 fx_size
= fixp
->fx_size
;
1248 slack
= TC_FX_SIZE_SLACK (fixp
);
1250 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1251 loc
= fixp
->fx_where
+ fx_size
;
1252 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1253 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1254 _("internal error: fixup not contained within frag"));
1256 #ifndef RELOC_EXPANSION_POSSIBLE
1257 *reloc
= tc_gen_reloc (sec
, fixp
);
1259 reloc
= tc_gen_reloc (sec
, fixp
);
1264 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1266 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1270 relocs
[n
++] = &r
->u
.b
.r
;
1271 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1275 relocs
[n
++] = *reloc
;
1276 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1277 fixp
->fx_file
, fixp
->fx_line
);
1278 #ifndef RELOC_EXPANSION_POSSIBLE
1288 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1292 relocs
[n
++] = &r
->u
.b
.r
;
1293 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1300 unsigned int k
, j
, nsyms
;
1302 sympp
= bfd_get_outsymbols (stdoutput
);
1303 nsyms
= bfd_get_symcount (stdoutput
);
1304 for (k
= 0; k
< n
; k
++)
1305 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1307 for (j
= 0; j
< nsyms
; j
++)
1308 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1318 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1320 bfd_set_section_flags (abfd
, sec
, flags
);
1321 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1324 #ifdef SET_SECTION_RELOCS
1325 SET_SECTION_RELOCS (sec
, relocs
, n
);
1332 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1333 for (k
= 0; k
< n
; k
++)
1335 arelent
*rel
= relocs
[k
];
1336 asymbol
*s
= *rel
->sym_ptr_ptr
;
1337 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1338 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1339 (unsigned long)rel
->addend
);
1346 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1347 fragS
**last_newf
, struct obstack
*ob
)
1350 int total_out_size
= 0;
1351 fragS
*f
= *last_newf
;
1355 /* Call the compression routine repeatedly until it has finished
1356 processing the frag. */
1359 /* Reserve all the space available in the current chunk.
1360 If none is available, start a new frag. */
1361 avail_out
= obstack_room (ob
);
1364 obstack_finish (ob
);
1365 f
= frag_alloc (ob
);
1366 f
->fr_type
= rs_fill
;
1367 (*last_newf
)->fr_next
= f
;
1369 avail_out
= obstack_room (ob
);
1372 as_fatal (_("can't extend frag"));
1373 next_out
= obstack_next_free (ob
);
1374 obstack_blank_fast (ob
, avail_out
);
1375 out_size
= compress_data (strm
, &contents
, &in_size
,
1376 &next_out
, &avail_out
);
1380 f
->fr_fix
+= out_size
;
1381 total_out_size
+= out_size
;
1383 /* Return unused space. */
1385 obstack_blank_fast (ob
, -avail_out
);
1388 return total_out_size
;
1392 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1394 segment_info_type
*seginfo
= seg_info (sec
);
1398 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1399 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1400 bfd_size_type compressed_size
;
1401 const char *section_name
;
1402 char *compressed_name
;
1404 struct z_stream_s
*strm
;
1406 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1410 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1413 section_name
= bfd_get_section_name (stdoutput
, sec
);
1414 if (strncmp (section_name
, ".debug_", 7) != 0)
1417 strm
= compress_init ();
1421 /* Create a new frag to contain the "ZLIB" header. */
1422 first_newf
= frag_alloc (ob
);
1423 if (obstack_room (ob
) < 12)
1424 first_newf
= frag_alloc (ob
);
1425 if (obstack_room (ob
) < 12)
1426 as_fatal (_("can't extend frag %u chars"), 12);
1427 last_newf
= first_newf
;
1428 obstack_blank_fast (ob
, 12);
1429 last_newf
->fr_type
= rs_fill
;
1430 last_newf
->fr_fix
= 12;
1431 header
= last_newf
->fr_literal
;
1432 memcpy (header
, "ZLIB", 4);
1433 header
[11] = uncompressed_size
; uncompressed_size
>>= 8;
1434 header
[10] = uncompressed_size
; uncompressed_size
>>= 8;
1435 header
[9] = uncompressed_size
; uncompressed_size
>>= 8;
1436 header
[8] = uncompressed_size
; uncompressed_size
>>= 8;
1437 header
[7] = uncompressed_size
; uncompressed_size
>>= 8;
1438 header
[6] = uncompressed_size
; uncompressed_size
>>= 8;
1439 header
[5] = uncompressed_size
; uncompressed_size
>>= 8;
1440 header
[4] = uncompressed_size
;
1441 compressed_size
= 12;
1443 /* Stream the frags through the compression engine, adding new frags
1444 as necessary to accomodate the compressed output. */
1445 for (f
= seginfo
->frchainP
->frch_root
;
1454 gas_assert (f
->fr_type
== rs_fill
);
1457 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1461 compressed_size
+= out_size
;
1463 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1464 fill_size
= f
->fr_var
;
1465 count
= f
->fr_offset
;
1466 gas_assert (count
>= 0);
1467 if (fill_size
&& count
)
1471 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1475 compressed_size
+= out_size
;
1480 /* Flush the compression state. */
1487 /* Reserve all the space available in the current chunk.
1488 If none is available, start a new frag. */
1489 avail_out
= obstack_room (ob
);
1494 obstack_finish (ob
);
1495 newf
= frag_alloc (ob
);
1496 newf
->fr_type
= rs_fill
;
1497 last_newf
->fr_next
= newf
;
1499 avail_out
= obstack_room (ob
);
1502 as_fatal (_("can't extend frag"));
1503 next_out
= obstack_next_free (ob
);
1504 obstack_blank_fast (ob
, avail_out
);
1505 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1509 last_newf
->fr_fix
+= out_size
;
1510 compressed_size
+= out_size
;
1512 /* Return unused space. */
1514 obstack_blank_fast (ob
, -avail_out
);
1520 /* Replace the uncompressed frag list with the compressed frag list. */
1521 seginfo
->frchainP
->frch_root
= first_newf
;
1522 seginfo
->frchainP
->frch_last
= last_newf
;
1524 /* Update the section size and its name. */
1525 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1527 compressed_name
= (char *) xmalloc (strlen (section_name
) + 2);
1528 compressed_name
[0] = '.';
1529 compressed_name
[1] = 'z';
1530 strcpy (compressed_name
+ 2, section_name
+ 1);
1531 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1535 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1537 void *xxx ATTRIBUTE_UNUSED
)
1539 segment_info_type
*seginfo
= seg_info (sec
);
1540 addressT offset
= 0;
1543 /* Write out the frags. */
1545 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1548 for (f
= seginfo
->frchainP
->frch_root
;
1557 gas_assert (f
->fr_type
== rs_fill
);
1560 x
= bfd_set_section_contents (stdoutput
, sec
,
1561 f
->fr_literal
, (file_ptr
) offset
,
1562 (bfd_size_type
) f
->fr_fix
);
1564 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1565 bfd_errmsg (bfd_get_error ()));
1566 offset
+= f
->fr_fix
;
1568 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1569 fill_size
= f
->fr_var
;
1570 count
= f
->fr_offset
;
1571 gas_assert (count
>= 0);
1572 if (fill_size
&& count
)
1575 if (fill_size
> sizeof (buf
))
1577 /* Do it the old way. Can this ever happen? */
1580 x
= bfd_set_section_contents (stdoutput
, sec
,
1583 (bfd_size_type
) fill_size
);
1585 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1586 bfd_errmsg (bfd_get_error ()));
1587 offset
+= fill_size
;
1592 /* Build a buffer full of fill objects and output it as
1593 often as necessary. This saves on the overhead of
1594 potentially lots of bfd_set_section_contents calls. */
1598 n_per_buf
= sizeof (buf
);
1599 memset (buf
, *fill_literal
, n_per_buf
);
1604 n_per_buf
= sizeof (buf
) / fill_size
;
1605 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1606 memcpy (bufp
, fill_literal
, fill_size
);
1608 for (; count
> 0; count
-= n_per_buf
)
1610 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1611 x
= bfd_set_section_contents
1612 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1613 (bfd_size_type
) n_per_buf
* fill_size
);
1615 as_fatal (_("cannot write to output file '%s': %s"),
1616 stdoutput
->filename
,
1617 bfd_errmsg (bfd_get_error ()));
1618 offset
+= n_per_buf
* fill_size
;
1626 merge_data_into_text (void)
1628 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1629 seg_info (data_section
)->frchainP
->frch_root
;
1630 seg_info (text_section
)->frchainP
->frch_last
=
1631 seg_info (data_section
)->frchainP
->frch_last
;
1632 seg_info (data_section
)->frchainP
= 0;
1643 /* Count symbols. We can't rely on a count made by the loop in
1644 write_object_file, because *_frob_file may add a new symbol or
1647 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1653 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1655 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1656 symp
= symbol_rootP
;
1657 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1659 asympp
[i
] = symbol_get_bfdsym (symp
);
1660 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1661 || !(bfd_is_const_section (asympp
[i
]->section
)
1662 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1663 asympp
[i
]->flags
|= BSF_KEEP
;
1664 symbol_mark_written (symp
);
1669 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1670 gas_assert (result
);
1671 symbol_table_frozen
= 1;
1674 /* Finish the subsegments. After every sub-segment, we fake an
1675 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1676 ".fill 0" because that is the kind of frag that requires least
1677 thought. ".align" frags like to have a following frag since that
1678 makes calculating their intended length trivial. */
1680 #ifndef SUB_SEGMENT_ALIGN
1682 /* The last subsegment gets an alignment corresponding to the alignment
1683 of the section. This allows proper nop-filling at the end of
1684 code-bearing sections. */
1685 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1686 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1688 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1693 subsegs_finish (void)
1695 struct frchain
*frchainP
;
1698 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1700 segment_info_type
*seginfo
= seg_info (s
);
1704 for (frchainP
= seginfo
->frchainP
;
1706 frchainP
= frchainP
->frch_next
)
1710 subseg_set (s
, frchainP
->frch_subseg
);
1712 /* This now gets called even if we had errors. In that case,
1713 any alignment is meaningless, and, moreover, will look weird
1714 if we are generating a listing. */
1717 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1718 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1719 && now_seg
->entsize
)
1721 unsigned int entsize
= now_seg
->entsize
;
1724 while ((entsize
& 1) == 0)
1729 if (entalign
> alignment
)
1730 alignment
= entalign
;
1734 if (subseg_text_p (now_seg
))
1735 frag_align_code (alignment
, 0);
1737 frag_align (alignment
, 0, 0);
1739 /* frag_align will have left a new frag.
1740 Use this last frag for an empty ".fill".
1742 For this segment ...
1743 Create a last frag. Do not leave a "being filled in frag". */
1744 frag_wane (frag_now
);
1745 frag_now
->fr_fix
= 0;
1746 know (frag_now
->fr_next
== NULL
);
1751 /* Write the object file. */
1754 write_object_file (void)
1756 struct relax_seg_info rsi
;
1757 #ifndef WORKING_DOT_WORD
1758 fragS
*fragP
; /* Track along all frags. */
1761 #ifdef md_pre_output_hook
1765 /* Do we really want to write it? */
1767 int n_warns
, n_errs
;
1768 n_warns
= had_warnings ();
1769 n_errs
= had_errors ();
1770 /* The -Z flag indicates that an object file should be generated,
1771 regardless of warnings and errors. */
1772 if (flag_always_generate_output
)
1774 if (n_warns
|| n_errs
)
1775 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1776 n_errs
, n_errs
== 1 ? "" : "s",
1777 n_warns
, n_warns
== 1 ? "" : "s");
1782 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1783 n_errs
, n_errs
== 1 ? "" : "s",
1784 n_warns
, n_warns
== 1 ? "" : "s");
1788 #ifdef md_pre_relax_hook
1792 /* From now on, we don't care about sub-segments. Build one frag chain
1793 for each segment. Linked thru fr_next. */
1795 /* Remove the sections created by gas for its own purposes. */
1799 bfd_section_list_remove (stdoutput
, reg_section
);
1800 bfd_section_list_remove (stdoutput
, expr_section
);
1801 stdoutput
->section_count
-= 2;
1803 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1806 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1808 /* We have two segments. If user gave -R flag, then we must put the
1809 data frags into the text segment. Do this before relaxing so
1810 we know to take advantage of -R and make shorter addresses. */
1811 if (flag_readonly_data_in_text
)
1813 merge_data_into_text ();
1819 #ifndef WORKING_DOT_WORD
1820 /* We need to reset the markers in the broken word list and
1821 associated frags between calls to relax_segment (via
1822 relax_seg). Since the broken word list is global, we do it
1823 once per round, rather than locally in relax_segment for each
1825 struct broken_word
*brokp
;
1827 for (brokp
= broken_words
;
1828 brokp
!= (struct broken_word
*) NULL
;
1829 brokp
= brokp
->next_broken_word
)
1833 if (brokp
->dispfrag
!= (fragS
*) NULL
1834 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1835 brokp
->dispfrag
->fr_subtype
= 0;
1840 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1846 /* Note - Most ports will use the default value of
1847 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1848 local symbols to be resolved, removing their frag information.
1849 Some ports however, will not have finished relaxing all of
1850 their frags and will still need the local symbol frag
1851 information. These ports can set
1852 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1853 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1855 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1857 /* Relaxation has completed. Freeze all syms. */
1860 #ifdef md_post_relax_hook
1864 #ifndef WORKING_DOT_WORD
1866 struct broken_word
*lie
;
1867 struct broken_word
**prevP
;
1869 prevP
= &broken_words
;
1870 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1875 subseg_change (lie
->seg
, lie
->subseg
);
1876 exp
.X_op
= O_subtract
;
1877 exp
.X_add_symbol
= lie
->add
;
1878 exp
.X_op_symbol
= lie
->sub
;
1879 exp
.X_add_number
= lie
->addnum
;
1880 #ifdef TC_CONS_FIX_NEW
1881 TC_CONS_FIX_NEW (lie
->frag
,
1882 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1885 fix_new_exp (lie
->frag
,
1886 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1887 2, &exp
, 0, BFD_RELOC_16
);
1889 *prevP
= lie
->next_broken_word
;
1892 prevP
= &(lie
->next_broken_word
);
1894 for (lie
= broken_words
; lie
;)
1896 struct broken_word
*untruth
;
1898 addressT table_addr
;
1899 addressT from_addr
, to_addr
;
1902 subseg_change (lie
->seg
, lie
->subseg
);
1903 fragP
= lie
->dispfrag
;
1905 /* Find out how many broken_words go here. */
1908 untruth
&& untruth
->dispfrag
== fragP
;
1909 untruth
= untruth
->next_broken_word
)
1910 if (untruth
->added
== 1)
1913 table_ptr
= lie
->dispfrag
->fr_opcode
;
1914 table_addr
= (lie
->dispfrag
->fr_address
1915 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1916 /* Create the jump around the long jumps. This is a short
1917 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1918 from_addr
= table_addr
;
1919 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1920 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1922 table_ptr
+= md_short_jump_size
;
1923 table_addr
+= md_short_jump_size
;
1926 lie
&& lie
->dispfrag
== fragP
;
1927 m
++, lie
= lie
->next_broken_word
)
1929 if (lie
->added
== 2)
1931 /* Patch the jump table. */
1932 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
1933 untruth
&& untruth
->dispfrag
== fragP
;
1934 untruth
= untruth
->next_broken_word
)
1936 if (untruth
->use_jump
== lie
)
1938 /* This is the offset from ??? to table_ptr+0.
1939 The target is the same for all users of this
1940 md_long_jump, but the "sub" bases (and hence the
1941 offsets) may be different. */
1942 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
1943 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1944 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
1946 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
1950 /* Install the long jump. */
1951 /* This is a long jump from table_ptr+0 to the final target. */
1952 from_addr
= table_addr
;
1953 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1954 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1956 table_ptr
+= md_long_jump_size
;
1957 table_addr
+= md_long_jump_size
;
1961 #endif /* not WORKING_DOT_WORD */
1963 /* Resolve symbol values. This needs to be done before processing
1969 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1970 resolve_symbol_value (symp
);
1972 resolve_local_symbol_values ();
1973 resolve_reloc_expr_symbols ();
1977 #ifdef tc_frob_file_before_adjust
1978 tc_frob_file_before_adjust ();
1980 #ifdef obj_frob_file_before_adjust
1981 obj_frob_file_before_adjust ();
1984 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1986 #ifdef tc_frob_file_before_fix
1987 tc_frob_file_before_fix ();
1989 #ifdef obj_frob_file_before_fix
1990 obj_frob_file_before_fix ();
1993 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1995 /* Set up symbol table, and write it out. */
1999 bfd_boolean skip_next_symbol
= FALSE
;
2001 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2006 if (skip_next_symbol
)
2008 /* Don't do anything besides moving the value of the
2009 symbol from the GAS value-field to the BFD value-field. */
2010 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2011 skip_next_symbol
= FALSE
;
2015 if (symbol_mri_common_p (symp
))
2017 if (S_IS_EXTERNAL (symp
))
2018 as_bad (_("%s: global symbols not supported in common sections"),
2020 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2024 name
= S_GET_NAME (symp
);
2028 decode_local_label_name ((char *) S_GET_NAME (symp
));
2029 /* They only differ if `name' is a fb or dollar local
2031 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2032 as_bad (_("local label `%s' is not defined"), name2
);
2035 /* Do it again, because adjust_reloc_syms might introduce
2036 more symbols. They'll probably only be section symbols,
2037 but they'll still need to have the values computed. */
2038 resolve_symbol_value (symp
);
2040 /* Skip symbols which were equated to undefined or common
2042 if (symbol_equated_reloc_p (symp
)
2043 || S_IS_WEAKREFR (symp
))
2045 const char *sname
= S_GET_NAME (symp
);
2047 if (S_IS_COMMON (symp
)
2048 && !TC_FAKE_LABEL (sname
)
2049 && !S_IS_WEAKREFR (symp
)
2050 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
2052 expressionS
*e
= symbol_get_value_expression (symp
);
2054 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2055 sname
, S_GET_NAME (e
->X_add_symbol
));
2057 if (S_GET_SEGMENT (symp
) == reg_section
)
2059 /* Report error only if we know the symbol name. */
2060 if (S_GET_NAME (symp
) != reg_section
->name
)
2061 as_bad (_("can't make global register symbol `%s'"),
2064 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2068 #ifdef obj_frob_symbol
2069 obj_frob_symbol (symp
, punt
);
2071 #ifdef tc_frob_symbol
2072 if (! punt
|| symbol_used_in_reloc_p (symp
))
2073 tc_frob_symbol (symp
, punt
);
2076 /* If we don't want to keep this symbol, splice it out of
2077 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2078 want section symbols. Otherwise, we skip local symbols
2079 and symbols that the frob_symbol macros told us to punt,
2080 but we keep such symbols if they are used in relocs. */
2081 if (symp
== abs_section_sym
2082 || (! EMIT_SECTION_SYMBOLS
2083 && symbol_section_p (symp
))
2084 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2085 opposites. Sometimes the former checks flags and the
2086 latter examines the name... */
2087 || (!S_IS_EXTERNAL (symp
)
2088 && (punt
|| S_IS_LOCAL (symp
) ||
2089 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2090 && ! symbol_used_in_reloc_p (symp
)))
2092 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2094 /* After symbol_remove, symbol_next(symp) still returns
2095 the one that came after it in the chain. So we don't
2096 need to do any extra cleanup work here. */
2100 /* Make sure we really got a value for the symbol. */
2101 if (! symbol_resolved_p (symp
))
2103 as_bad (_("can't resolve value for symbol `%s'"),
2105 symbol_mark_resolved (symp
);
2108 /* Set the value into the BFD symbol. Up til now the value
2109 has only been kept in the gas symbolS struct. */
2110 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2112 /* A warning construct is a warning symbol followed by the
2113 symbol warned about. Don't let anything object-format or
2114 target-specific muck with it; it's ready for output. */
2115 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2116 skip_next_symbol
= TRUE
;
2122 /* Now do any format-specific adjustments to the symbol table, such
2123 as adding file symbols. */
2124 #ifdef tc_adjust_symtab
2125 tc_adjust_symtab ();
2127 #ifdef obj_adjust_symtab
2128 obj_adjust_symtab ();
2131 /* Stop if there is an error. */
2135 /* Now that all the sizes are known, and contents correct, we can
2136 start writing to the file. */
2139 /* If *_frob_file changes the symbol value at this point, it is
2140 responsible for moving the changed value into symp->bsym->value
2141 as well. Hopefully all symbol value changing can be done in
2146 #ifdef obj_frob_file
2149 #ifdef obj_coff_generate_pdata
2150 obj_coff_generate_pdata ();
2152 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2154 #ifdef tc_frob_file_after_relocs
2155 tc_frob_file_after_relocs ();
2157 #ifdef obj_frob_file_after_relocs
2158 obj_frob_file_after_relocs ();
2161 /* Once all relocations have been written, we can compress the
2162 contents of the debug sections. This needs to be done before
2163 we start writing any sections, because it will affect the file
2164 layout, which is fixed once we start writing contents. */
2165 if (flag_compress_debug
)
2166 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2168 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2171 #ifdef TC_GENERIC_RELAX_TABLE
2172 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2175 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2177 const relax_typeS
*this_type
;
2178 const relax_typeS
*start_type
;
2179 relax_substateT next_state
;
2180 relax_substateT this_state
;
2186 const relax_typeS
*table
;
2188 target
= fragP
->fr_offset
;
2189 address
= fragP
->fr_address
;
2190 table
= TC_GENERIC_RELAX_TABLE
;
2191 this_state
= fragP
->fr_subtype
;
2192 start_type
= this_type
= table
+ this_state
;
2193 symbolP
= fragP
->fr_symbol
;
2199 sym_frag
= symbol_get_frag (symbolP
);
2201 #ifndef DIFF_EXPR_OK
2202 know (sym_frag
!= NULL
);
2204 know (S_GET_SEGMENT (symbolP
) != absolute_section
2205 || sym_frag
== &zero_address_frag
);
2206 target
+= S_GET_VALUE (symbolP
);
2208 /* If SYM_FRAG has yet to be reached on this pass, assume it
2209 will move by STRETCH just as we did, unless there is an
2210 alignment frag between here and SYM_FRAG. An alignment may
2211 well absorb any STRETCH, and we don't want to choose a larger
2212 branch insn by overestimating the needed reach of this
2213 branch. It isn't critical to calculate TARGET exactly; We
2214 know we'll be doing another pass if STRETCH is non-zero. */
2217 && sym_frag
->relax_marker
!= fragP
->relax_marker
2218 && S_GET_SEGMENT (symbolP
) == segment
)
2221 || sym_frag
->region
== fragP
->region
)
2223 /* If we get here we know we have a forward branch. This
2224 relax pass may have stretched previous instructions so
2225 far that omitting STRETCH would make the branch
2226 negative. Don't allow this in case the negative reach is
2227 large enough to require a larger branch instruction. */
2228 else if (target
< address
)
2229 target
= fragP
->fr_next
->fr_address
+ stretch
;
2233 aim
= target
- address
- fragP
->fr_fix
;
2234 #ifdef TC_PCREL_ADJUST
2235 /* Currently only the ns32k family needs this. */
2236 aim
+= TC_PCREL_ADJUST (fragP
);
2239 #ifdef md_prepare_relax_scan
2240 /* Formerly called M68K_AIM_KLUDGE. */
2241 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2246 /* Look backwards. */
2247 for (next_state
= this_type
->rlx_more
; next_state
;)
2248 if (aim
>= this_type
->rlx_backward
)
2252 /* Grow to next state. */
2253 this_state
= next_state
;
2254 this_type
= table
+ this_state
;
2255 next_state
= this_type
->rlx_more
;
2260 /* Look forwards. */
2261 for (next_state
= this_type
->rlx_more
; next_state
;)
2262 if (aim
<= this_type
->rlx_forward
)
2266 /* Grow to next state. */
2267 this_state
= next_state
;
2268 this_type
= table
+ this_state
;
2269 next_state
= this_type
->rlx_more
;
2273 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2275 fragP
->fr_subtype
= this_state
;
2279 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2281 /* Relax_align. Advance location counter to next address that has 'alignment'
2282 lowest order bits all 0s, return size of adjustment made. */
2283 static relax_addressT
2284 relax_align (register relax_addressT address
, /* Address now. */
2285 register int alignment
/* Alignment (binary). */)
2287 relax_addressT mask
;
2288 relax_addressT new_address
;
2290 mask
= ~((~0) << alignment
);
2291 new_address
= (address
+ mask
) & (~mask
);
2292 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2294 /* We must provide lots of padding, so the linker can discard it
2295 when needed. The linker will not add extra space, ever. */
2296 new_address
+= (1 << alignment
);
2298 return (new_address
- address
);
2301 /* Now we have a segment, not a crowd of sub-segments, we can make
2306 After this, all frags in this segment have addresses that are correct
2307 within the segment. Since segments live in different file addresses,
2308 these frag addresses may not be the same as final object-file
2312 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2314 unsigned long frag_count
;
2316 relax_addressT address
;
2320 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2321 subseg_change (segment
, 0);
2323 /* For each frag in segment: count and store (a 1st guess of)
2327 for (frag_count
= 0, fragP
= segment_frag_root
;
2329 fragP
= fragP
->fr_next
, frag_count
++)
2331 fragP
->region
= region
;
2332 fragP
->relax_marker
= 0;
2333 fragP
->fr_address
= address
;
2334 address
+= fragP
->fr_fix
;
2336 switch (fragP
->fr_type
)
2339 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2346 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2348 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2351 if (offset
% fragP
->fr_var
!= 0)
2353 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2354 _("alignment padding (%lu bytes) not a multiple of %ld"),
2355 (unsigned long) offset
, (long) fragP
->fr_var
);
2356 offset
-= (offset
% fragP
->fr_var
);
2365 /* Assume .org is nugatory. It will grow with 1st relax. */
2372 case rs_machine_dependent
:
2373 /* If fr_symbol is an expression, this call to
2374 resolve_symbol_value sets up the correct segment, which will
2375 likely be needed in md_estimate_size_before_relax. */
2376 if (fragP
->fr_symbol
)
2377 resolve_symbol_value (fragP
->fr_symbol
);
2379 address
+= md_estimate_size_before_relax (fragP
, segment
);
2382 #ifndef WORKING_DOT_WORD
2383 /* Broken words don't concern us yet. */
2384 case rs_broken_word
:
2389 /* Initial guess is always 1; doing otherwise can result in
2390 stable solutions that are larger than the minimum. */
2391 address
+= fragP
->fr_offset
= 1;
2395 address
+= eh_frame_estimate_size_before_relax (fragP
);
2399 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2403 BAD_CASE (fragP
->fr_type
);
2410 unsigned long max_iterations
;
2412 /* Cumulative address adjustment. */
2415 /* Have we made any adjustment this pass? We can't just test
2416 stretch because one piece of code may have grown and another
2420 /* Most horrible, but gcc may give us some exception data that
2421 is impossible to assemble, of the form
2425 .uleb128 end - start
2431 If the leb128 is two bytes in size, then end-start is 128*128,
2432 which requires a three byte leb128. If the leb128 is three
2433 bytes in size, then end-start is 128*128-1, which requires a
2434 two byte leb128. We work around this dilemma by inserting
2435 an extra 4 bytes of alignment just after the .align. This
2436 works because the data after the align is accessed relative to
2439 This counter is used in a tiny state machine to detect
2440 whether a leb128 followed by an align is impossible to
2442 int rs_leb128_fudge
= 0;
2444 /* We want to prevent going into an infinite loop where one frag grows
2445 depending upon the location of a symbol which is in turn moved by
2446 the growing frag. eg:
2452 So we dictate that this algorithm can be at most O2. */
2453 max_iterations
= frag_count
* frag_count
;
2454 /* Check for overflow. */
2455 if (max_iterations
< frag_count
)
2456 max_iterations
= frag_count
;
2464 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2467 addressT was_address
;
2471 fragP
->relax_marker
^= 1;
2472 was_address
= fragP
->fr_address
;
2473 address
= fragP
->fr_address
+= stretch
;
2474 symbolP
= fragP
->fr_symbol
;
2475 offset
= fragP
->fr_offset
;
2477 switch (fragP
->fr_type
)
2479 case rs_fill
: /* .fill never relaxes. */
2483 #ifndef WORKING_DOT_WORD
2484 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2485 for it I do not want to write it. I do not want to have
2486 anything to do with it. This is not the proper way to
2487 implement this misfeature. */
2488 case rs_broken_word
:
2490 struct broken_word
*lie
;
2491 struct broken_word
*untruth
;
2493 /* Yes this is ugly (storing the broken_word pointer
2494 in the symbol slot). Still, this whole chunk of
2495 code is ugly, and I don't feel like doing anything
2496 about it. Think of it as stubbornness in action. */
2498 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2499 lie
&& lie
->dispfrag
== fragP
;
2500 lie
= lie
->next_broken_word
)
2506 offset
= (S_GET_VALUE (lie
->add
)
2508 - S_GET_VALUE (lie
->sub
));
2509 if (offset
<= -32768 || offset
>= 32767)
2511 if (flag_warn_displacement
)
2514 sprint_value (buf
, (addressT
) lie
->addnum
);
2515 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2516 _(".word %s-%s+%s didn't fit"),
2517 S_GET_NAME (lie
->add
),
2518 S_GET_NAME (lie
->sub
),
2521 if (fragP
->fr_subtype
== 0)
2523 fragP
->fr_subtype
++;
2524 growth
+= md_short_jump_size
;
2527 /* Redirect *all* words of this table with the same
2528 target, lest we have to handle the case where the
2529 same target but with a offset that fits on this
2530 round overflows at the next relaxation round. */
2531 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2532 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2533 untruth
= untruth
->next_broken_word
)
2534 if ((symbol_get_frag (untruth
->add
)
2535 == symbol_get_frag (lie
->add
))
2536 && (S_GET_VALUE (untruth
->add
)
2537 == S_GET_VALUE (lie
->add
)))
2540 untruth
->use_jump
= lie
;
2544 growth
+= md_long_jump_size
;
2549 } /* case rs_broken_word */
2555 addressT oldoff
, newoff
;
2557 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2559 newoff
= relax_align (address
+ fragP
->fr_fix
,
2562 if (fragP
->fr_subtype
!= 0)
2564 if (oldoff
> fragP
->fr_subtype
)
2566 if (newoff
> fragP
->fr_subtype
)
2570 growth
= newoff
- oldoff
;
2572 /* If this align happens to follow a leb128 and
2573 we have determined that the leb128 is bouncing
2574 in size, then break the cycle by inserting an
2577 && (rs_leb128_fudge
& 16) != 0
2578 && (rs_leb128_fudge
& 15) >= 2)
2580 segment_info_type
*seginfo
= seg_info (segment
);
2581 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2584 newf
= frag_alloc (ob
);
2585 obstack_blank_fast (ob
, fragP
->fr_var
);
2586 obstack_finish (ob
);
2587 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2588 memcpy (newf
->fr_literal
,
2589 fragP
->fr_literal
+ fragP
->fr_fix
,
2591 newf
->fr_type
= rs_fill
;
2592 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2594 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2596 if (newf
->fr_offset
* newf
->fr_var
2597 != (offsetT
) 1 << fragP
->fr_offset
)
2599 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2602 /* Include size of new frag in GROWTH. */
2603 growth
+= newf
->fr_offset
* newf
->fr_var
;
2604 /* Adjust the new frag address for the amount
2605 we'll add when we process the new frag. */
2606 newf
->fr_address
-= stretch
+ growth
;
2607 newf
->relax_marker
^= 1;
2608 fragP
->fr_next
= newf
;
2610 as_warn (_("padding added"));
2618 addressT target
= offset
;
2623 /* Convert from an actual address to an octet offset
2624 into the section. Here it is assumed that the
2625 section's VMA is zero, and can omit subtracting it
2626 from the symbol's value to get the address offset. */
2627 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2628 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2631 know (fragP
->fr_next
);
2632 after
= fragP
->fr_next
->fr_address
+ stretch
;
2633 growth
= target
- after
;
2638 /* Don't error on first few frag relax passes.
2639 The symbol might be an expression involving
2640 symbol values from other sections. If those
2641 sections have not yet been processed their
2642 frags will all have zero addresses, so we
2643 will calculate incorrect values for them. The
2644 number of passes we allow before giving an
2645 error is somewhat arbitrary. It should be at
2646 least one, with larger values requiring
2647 increasingly contrived dependencies between
2648 frags to trigger a false error. */
2651 /* Force another pass. */
2656 /* Growth may be negative, but variable part of frag
2657 cannot have fewer than 0 chars. That is, we can't
2659 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2660 _("attempt to move .org backwards"));
2662 /* We've issued an error message. Change the
2663 frag to avoid cascading errors. */
2664 fragP
->fr_type
= rs_align
;
2665 fragP
->fr_subtype
= 0;
2666 fragP
->fr_offset
= 0;
2667 fragP
->fr_fix
= after
- address
;
2678 amount
= S_GET_VALUE (symbolP
);
2679 if (S_GET_SEGMENT (symbolP
) != absolute_section
2680 || S_IS_COMMON (symbolP
)
2681 || ! S_IS_DEFINED (symbolP
))
2683 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2684 _(".space specifies non-absolute value"));
2685 /* Prevent repeat of this error message. */
2686 fragP
->fr_symbol
= 0;
2688 else if (amount
< 0)
2690 /* Don't error on first few frag relax passes.
2691 See rs_org comment for a longer explanation. */
2698 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2699 _(".space or .fill with negative value, ignored"));
2700 fragP
->fr_symbol
= 0;
2703 growth
= (was_address
+ fragP
->fr_fix
+ amount
2704 - fragP
->fr_next
->fr_address
);
2708 case rs_machine_dependent
:
2709 #ifdef md_relax_frag
2710 growth
= md_relax_frag (segment
, fragP
, stretch
);
2712 #ifdef TC_GENERIC_RELAX_TABLE
2713 /* The default way to relax a frag is to look through
2714 TC_GENERIC_RELAX_TABLE. */
2715 growth
= relax_frag (segment
, fragP
, stretch
);
2716 #endif /* TC_GENERIC_RELAX_TABLE */
2725 value
= resolve_symbol_value (fragP
->fr_symbol
);
2726 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2727 growth
= size
- fragP
->fr_offset
;
2728 fragP
->fr_offset
= size
;
2733 growth
= eh_frame_relax_frag (fragP
);
2737 growth
= dwarf2dbg_relax_frag (fragP
);
2741 BAD_CASE (fragP
->fr_type
);
2748 if (fragP
->fr_type
== rs_leb128
)
2749 rs_leb128_fudge
+= 16;
2750 else if (fragP
->fr_type
== rs_align
2751 && (rs_leb128_fudge
& 16) != 0
2753 rs_leb128_fudge
+= 16;
2755 rs_leb128_fudge
= 0;
2760 && (rs_leb128_fudge
& 16) == 0
2761 && (rs_leb128_fudge
& -16) != 0)
2762 rs_leb128_fudge
+= 1;
2764 rs_leb128_fudge
= 0;
2766 /* Until nothing further to relax. */
2767 while (stretched
&& -- max_iterations
);
2770 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2771 segment_name (segment
));
2774 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2775 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2777 fragP
->last_fr_address
= fragP
->fr_address
;
2784 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2790 buf
[n
] = val
& 0xff;
2796 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2802 *buf
++ = val
& 0xff;
2808 write_print_statistics (FILE *file
)
2810 fprintf (file
, "fixups: %d\n", n_fixups
);
2813 /* For debugging. */
2814 extern int indent_level
;
2817 print_fixup (fixS
*fixp
)
2820 fprintf (stderr
, "fix ");
2821 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2822 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2824 fprintf (stderr
, " pcrel");
2825 if (fixp
->fx_pcrel_adjust
)
2826 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2827 if (fixp
->fx_im_disp
)
2830 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2832 fprintf (stderr
, " im_disp");
2836 fprintf (stderr
, " tcbit");
2838 fprintf (stderr
, " done");
2839 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2840 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2841 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2842 (long) fixp
->fx_where
,
2843 (unsigned long) fixp
->fx_offset
,
2844 (unsigned long) fixp
->fx_addnumber
);
2845 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2849 fprintf (stderr
, "\n +<");
2850 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2851 fprintf (stderr
, ">");
2855 fprintf (stderr
, "\n -<");
2856 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2857 fprintf (stderr
, ">");
2859 fprintf (stderr
, "\n");
2860 #ifdef TC_FIX_DATA_PRINT
2861 TC_FIX_DATA_PRINT (stderr
, fixp
);