1 /* write.c - emit .o file
2 Copyright (C) 1986-2017 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* This thing should be set up to do byte ordering correctly. But... */
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
28 #include "compress-debug.h"
30 #ifndef TC_FORCE_RELOCATION
31 #define TC_FORCE_RELOCATION(FIX) \
32 (generic_force_reloc (FIX))
35 #ifndef TC_FORCE_RELOCATION_ABS
36 #define TC_FORCE_RELOCATION_ABS(FIX) \
37 (TC_FORCE_RELOCATION (FIX))
40 #define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \
42 || TC_FORCE_RELOCATION (FIX))
43 #ifndef TC_FORCE_RELOCATION_LOCAL
44 #define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL
47 #define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
49 #ifndef TC_FORCE_RELOCATION_SUB_SAME
50 #define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME
53 #ifndef md_register_arithmetic
54 # define md_register_arithmetic 1
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
59 (!md_register_arithmetic && (SEG) == reg_section)
62 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
64 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
65 (!md_register_arithmetic && (SEG) == reg_section)
67 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
71 #ifndef TC_VALIDATE_FIX_SUB
72 #ifdef UNDEFINED_DIFFERENCE_OK
73 /* The PA needs this for PIC code generation. */
74 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
75 (md_register_arithmetic || (SEG) != reg_section)
77 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
78 ((md_register_arithmetic || (SEG) != reg_section) \
79 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
80 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
84 #ifndef TC_LINKRELAX_FIXUP
85 #define TC_LINKRELAX_FIXUP(SEG) 1
88 #ifndef MD_APPLY_SYM_VALUE
89 #define MD_APPLY_SYM_VALUE(FIX) 1
92 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
93 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
96 #ifndef MD_PCREL_FROM_SECTION
97 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #ifndef TC_FAKE_LABEL
101 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
104 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
105 fixups that far past the end of a frag. Having such fixups
106 is of course most most likely a bug in setting fx_size correctly.
107 A negative value disables the fixup check entirely, which is
108 appropriate for something like the Renesas / SuperH SH_COUNT
110 #ifndef TC_FX_SIZE_SLACK
111 #define TC_FX_SIZE_SLACK(FIX) 0
114 /* Used to control final evaluation of expressions. */
115 int finalize_syms
= 0;
117 int symbol_table_frozen
;
119 symbolS
*abs_section_sym
;
121 /* Remember the value of dot when parsing expressions. */
124 /* The frag that dot_value is based from. */
127 /* Relocs generated by ".reloc" pseudo. */
128 struct reloc_list
* reloc_list
;
130 void print_fixup (fixS
*);
132 /* We generally attach relocs to frag chains. However, after we have
133 chained these all together into a segment, any relocs we add after
134 that must be attached to a segment. This will include relocs added
135 in md_estimate_size_for_relax, for example. */
136 static int frags_chained
= 0;
140 #define RELOC_ENUM enum bfd_reloc_code_real
142 /* Create a fixS in obstack 'notes'. */
145 fix_new_internal (fragS
*frag
, /* Which frag? */
146 int where
, /* Where in that frag? */
147 int size
, /* 1, 2, or 4 usually. */
148 symbolS
*add_symbol
, /* X_add_symbol. */
149 symbolS
*sub_symbol
, /* X_op_symbol. */
150 offsetT offset
, /* X_add_number. */
151 int pcrel
, /* TRUE if PC-relative relocation. */
152 RELOC_ENUM r_type
/* Relocation type. */,
153 int at_beginning
) /* Add to the start of the list? */
159 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
161 fixP
->fx_frag
= frag
;
162 fixP
->fx_where
= where
;
163 fixP
->fx_size
= size
;
164 /* We've made fx_size a narrow field; check that it's wide enough. */
165 if (fixP
->fx_size
!= size
)
167 as_bad (_("field fx_size too small to hold %d"), size
);
170 fixP
->fx_addsy
= add_symbol
;
171 fixP
->fx_subsy
= sub_symbol
;
172 fixP
->fx_offset
= offset
;
173 fixP
->fx_dot_value
= dot_value
;
174 fixP
->fx_dot_frag
= dot_frag
;
175 fixP
->fx_pcrel
= pcrel
;
176 fixP
->fx_r_type
= r_type
;
177 fixP
->fx_im_disp
= 0;
178 fixP
->fx_pcrel_adjust
= 0;
179 fixP
->fx_bit_fixP
= 0;
180 fixP
->fx_addnumber
= 0;
184 fixP
->fx_no_overflow
= 0;
188 fixP
->fx_cgen
.insn
= NULL
;
189 fixP
->fx_cgen
.opinfo
= 0;
193 TC_INIT_FIX_DATA (fixP
);
196 fixP
->fx_file
= as_where (&fixP
->fx_line
);
200 fixS
**seg_fix_rootP
= (frags_chained
201 ? &seg_info (now_seg
)->fix_root
202 : &frchain_now
->fix_root
);
203 fixS
**seg_fix_tailP
= (frags_chained
204 ? &seg_info (now_seg
)->fix_tail
205 : &frchain_now
->fix_tail
);
209 fixP
->fx_next
= *seg_fix_rootP
;
210 *seg_fix_rootP
= fixP
;
211 if (fixP
->fx_next
== NULL
)
212 *seg_fix_tailP
= fixP
;
216 fixP
->fx_next
= NULL
;
218 (*seg_fix_tailP
)->fx_next
= fixP
;
220 *seg_fix_rootP
= fixP
;
221 *seg_fix_tailP
= fixP
;
228 /* Create a fixup relative to a symbol (plus a constant). */
231 fix_new (fragS
*frag
, /* Which frag? */
232 int where
, /* Where in that frag? */
233 int size
, /* 1, 2, or 4 usually. */
234 symbolS
*add_symbol
, /* X_add_symbol. */
235 offsetT offset
, /* X_add_number. */
236 int pcrel
, /* TRUE if PC-relative relocation. */
237 RELOC_ENUM r_type
/* Relocation type. */)
239 return fix_new_internal (frag
, where
, size
, add_symbol
,
240 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
243 /* Create a fixup for an expression. Currently we only support fixups
244 for difference expressions. That is itself more than most object
245 file formats support anyhow. */
248 fix_new_exp (fragS
*frag
, /* Which frag? */
249 int where
, /* Where in that frag? */
250 int size
, /* 1, 2, or 4 usually. */
251 expressionS
*exp
, /* Expression. */
252 int pcrel
, /* TRUE if PC-relative relocation. */
253 RELOC_ENUM r_type
/* Relocation type. */)
265 as_bad (_("register value used as expression"));
269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
270 the difference expression cannot immediately be reduced. */
272 symbolS
*stmp
= make_expr_symbol (exp
);
274 exp
->X_op
= O_symbol
;
275 exp
->X_op_symbol
= 0;
276 exp
->X_add_symbol
= stmp
;
277 exp
->X_add_number
= 0;
279 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
283 add
= exp
->X_add_symbol
;
284 off
= exp
->X_add_number
;
285 r_type
= BFD_RELOC_RVA
;
289 sub
= exp
->X_add_symbol
;
290 off
= exp
->X_add_number
;
294 sub
= exp
->X_op_symbol
;
297 add
= exp
->X_add_symbol
;
300 off
= exp
->X_add_number
;
304 add
= make_expr_symbol (exp
);
308 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
312 /* Create a fixup at the beginning of FRAG. The arguments are the same
313 as for fix_new, except that WHERE is implicitly 0. */
316 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
317 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
319 return fix_new_internal (frag
, 0, size
, add_symbol
,
320 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
323 /* Generic function to determine whether a fixup requires a relocation. */
325 generic_force_reloc (fixS
*fix
)
327 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
328 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
331 if (fix
->fx_addsy
== NULL
)
334 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
337 /* Append a string onto another string, bumping the pointer along. */
339 append (char **charPP
, char *fromP
, unsigned long length
)
341 /* Don't trust memcpy() of 0 chars. */
345 memcpy (*charPP
, fromP
, length
);
349 /* This routine records the largest alignment seen for each segment.
350 If the beginning of the segment is aligned on the worst-case
351 boundary, all of the other alignments within it will work. At
352 least one object format really uses this info. */
355 record_alignment (/* Segment to which alignment pertains. */
357 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
358 boundary, 2 => 4-byte boundary, etc.) */
361 if (seg
== absolute_section
)
364 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
365 bfd_set_section_alignment (stdoutput
, seg
, align
);
369 get_recorded_alignment (segT seg
)
371 if (seg
== absolute_section
)
374 return bfd_get_section_alignment (stdoutput
, seg
);
377 /* Reset the section indices after removing the gas created sections. */
380 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
382 int *countp
= (int *) countparg
;
384 sec
->index
= *countp
;
389 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
391 fragS dummy
, *prev_frag
= &dummy
;
392 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
394 for (; frchp
; frchp
= frchp
->frch_next
)
396 prev_frag
->fr_next
= frchp
->frch_root
;
397 prev_frag
= frchp
->frch_last
;
398 gas_assert (prev_frag
->fr_type
!= 0);
399 if (frchp
->fix_root
!= (fixS
*) NULL
)
401 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
402 seg_info (section
)->fix_root
= frchp
->fix_root
;
403 prev_fix
->fx_next
= frchp
->fix_root
;
404 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
405 prev_fix
= frchp
->fix_tail
;
408 gas_assert (prev_frag
!= &dummy
409 && prev_frag
->fr_type
!= 0);
410 prev_frag
->fr_next
= 0;
415 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
417 void *xxx ATTRIBUTE_UNUSED
)
419 segment_info_type
*info
;
421 /* BFD may have introduced its own sections without using
422 subseg_new, so it is possible that seg_info is NULL. */
423 info
= seg_info (section
);
424 if (info
!= (segment_info_type
*) NULL
)
425 info
->frchainP
->frch_last
426 = chain_frchains_together_1 (section
, info
->frchainP
);
428 /* Now that we've chained the frags together, we must add new fixups
429 to the segment, not to the frag chain. */
434 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
436 switch (fragP
->fr_type
)
444 HANDLE_ALIGN (fragP
);
446 know (fragP
->fr_next
!= NULL
);
447 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
449 - fragP
->fr_fix
) / fragP
->fr_var
;
450 if (fragP
->fr_offset
< 0)
452 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
453 _("attempt to .org/.space backwards? (%ld)"),
454 (long) fragP
->fr_offset
);
455 fragP
->fr_offset
= 0;
457 fragP
->fr_type
= rs_fill
;
465 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
468 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
471 fragP
->fr_fix
+= size
;
472 fragP
->fr_type
= rs_fill
;
474 fragP
->fr_offset
= 0;
475 fragP
->fr_symbol
= NULL
;
480 eh_frame_convert_frag (fragP
);
484 dwarf2dbg_convert_frag (fragP
);
487 case rs_machine_dependent
:
488 md_convert_frag (stdoutput
, sec
, fragP
);
490 gas_assert (fragP
->fr_next
== NULL
491 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
494 /* After md_convert_frag, we make the frag into a ".space 0".
495 md_convert_frag() should set up any fixSs and constants
500 #ifndef WORKING_DOT_WORD
503 struct broken_word
*lie
;
505 if (fragP
->fr_subtype
)
507 fragP
->fr_fix
+= md_short_jump_size
;
508 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
509 lie
&& lie
->dispfrag
== fragP
;
510 lie
= lie
->next_broken_word
)
512 fragP
->fr_fix
+= md_long_jump_size
;
520 BAD_CASE (fragP
->fr_type
);
524 md_frag_check (fragP
);
528 struct relax_seg_info
535 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
537 segment_info_type
*seginfo
= seg_info (sec
);
538 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
540 if (seginfo
&& seginfo
->frchainP
541 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
546 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
550 segment_info_type
*seginfo
;
552 valueT size
, newsize
;
554 subseg_change (sec
, 0);
556 seginfo
= seg_info (sec
);
557 if (seginfo
&& seginfo
->frchainP
)
559 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
560 cvt_frag_to_fill (sec
, fragp
);
561 for (fragp
= seginfo
->frchainP
->frch_root
;
563 fragp
= fragp
->fr_next
)
564 /* Walk to last elt. */
566 size
= fragp
->fr_address
+ fragp
->fr_fix
;
571 flags
= bfd_get_section_flags (abfd
, sec
);
572 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
573 (flags
& SEC_HAS_CONTENTS
) != 0)
576 if (size
> 0 && ! seginfo
->bss
)
577 flags
|= SEC_HAS_CONTENTS
;
580 x
= bfd_set_section_flags (abfd
, sec
, flags
);
583 /* If permitted, allow the backend to pad out the section
584 to some alignment boundary. */
585 if (do_not_pad_sections_to_alignment
)
588 newsize
= md_section_align (sec
, size
);
589 x
= bfd_set_section_size (abfd
, sec
, newsize
);
592 /* If the size had to be rounded up, add some padding in the last
594 gas_assert (newsize
>= size
);
597 fragS
*last
= seginfo
->frchainP
->frch_last
;
598 fragp
= seginfo
->frchainP
->frch_root
;
599 while (fragp
->fr_next
!= last
)
600 fragp
= fragp
->fr_next
;
601 last
->fr_address
= size
;
602 if ((newsize
- size
) % fragp
->fr_var
== 0)
603 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
605 /* If we hit this abort, it's likely due to subsegs_finish not
606 providing sufficient alignment on the last frag, and the
607 machine dependent code using alignment frags with fr_var
612 #ifdef tc_frob_section
613 tc_frob_section (sec
);
615 #ifdef obj_frob_section
616 obj_frob_section (sec
);
622 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
624 segment_info_type
*seginfo
= seg_info (sec
);
625 fixS
*fixp
= seginfo
->fix_root
;
630 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
633 symbolS
*s
= fixp
->fx_addsy
;
635 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
636 (int) fixp
->fx_r_type
);
638 fprintf (stream
, "no sym\n");
641 print_symbol_value_1 (stream
, s
);
642 fprintf (stream
, "\n");
644 fixp
= fixp
->fx_next
;
648 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
651 #ifndef EMIT_SECTION_SYMBOLS
652 #define EMIT_SECTION_SYMBOLS 1
655 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
656 and check for validity. Convert RELOC_LIST from using U.A fields
659 resolve_reloc_expr_symbols (void)
661 bfd_vma addr_mask
= 1;
662 struct reloc_list
*r
;
664 /* Avoid a shift by the width of type. */
665 addr_mask
<<= bfd_arch_bits_per_address (stdoutput
) - 1;
669 for (r
= reloc_list
; r
; r
= r
->next
)
671 reloc_howto_type
*howto
= r
->u
.a
.howto
;
674 bfd_vma offset
, addend
;
677 resolve_symbol_value (r
->u
.a
.offset_sym
);
678 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
682 if (symval
->X_op
== O_constant
)
683 sym
= r
->u
.a
.offset_sym
;
684 else if (symval
->X_op
== O_symbol
)
686 sym
= symval
->X_add_symbol
;
687 offset
= symval
->X_add_number
;
688 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
691 || symval
->X_op
!= O_constant
692 || (sec
= S_GET_SEGMENT (sym
)) == NULL
693 || !SEG_NORMAL (sec
))
695 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
699 offset
+= S_GET_VALUE (sym
);
702 addend
= r
->u
.a
.addend
;
703 if (r
->u
.a
.sym
!= NULL
)
705 resolve_symbol_value (r
->u
.a
.sym
);
706 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
707 if (symval
->X_op
== O_constant
)
709 else if (symval
->X_op
== O_symbol
)
711 sym
= symval
->X_add_symbol
;
712 addend
+= symval
->X_add_number
;
713 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
715 if (symval
->X_op
!= O_constant
)
717 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
720 else if (sym
!= NULL
)
722 /* Convert relocs against local symbols to refer to the
723 corresponding section symbol plus offset instead. Keep
724 PC-relative relocs of the REL variety intact though to
725 prevent the offset from overflowing the relocated field,
726 unless it has enough bits to cover the whole address
728 if (S_IS_LOCAL (sym
) && !symbol_section_p (sym
)
730 || (howto
->partial_inplace
731 && (!howto
->pc_relative
732 || howto
->src_mask
== addr_mask
))))
734 asection
*symsec
= S_GET_SEGMENT (sym
);
735 if (!(((symsec
->flags
& SEC_MERGE
) != 0
737 || (symsec
->flags
& SEC_THREAD_LOCAL
) != 0))
739 addend
+= S_GET_VALUE (sym
);
740 sym
= section_symbol (symsec
);
743 symbol_mark_used_in_reloc (sym
);
748 if (abs_section_sym
== NULL
)
749 abs_section_sym
= section_symbol (absolute_section
);
750 sym
= abs_section_sym
;
754 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
755 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
756 r
->u
.b
.r
.address
= offset
;
757 r
->u
.b
.r
.addend
= addend
;
758 r
->u
.b
.r
.howto
= howto
;
762 /* This pass over fixups decides whether symbols can be replaced with
766 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
768 void *xxx ATTRIBUTE_UNUSED
)
770 segment_info_type
*seginfo
= seg_info (sec
);
776 dump_section_relocs (abfd
, sec
, stderr
);
778 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
782 else if (fixp
->fx_addsy
)
788 fprintf (stderr
, "\n\nadjusting fixup:\n");
792 sym
= fixp
->fx_addsy
;
794 /* All symbols should have already been resolved at this
795 point. It is possible to see unresolved expression
796 symbols, though, since they are not in the regular symbol
798 resolve_symbol_value (sym
);
800 if (fixp
->fx_subsy
!= NULL
)
801 resolve_symbol_value (fixp
->fx_subsy
);
803 /* If this symbol is equated to an undefined or common symbol,
804 convert the fixup to being against that symbol. */
805 while (symbol_equated_reloc_p (sym
)
806 || S_IS_WEAKREFR (sym
))
808 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
811 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
812 fixp
->fx_addsy
= newsym
;
816 if (symbol_mri_common_p (sym
))
818 fixp
->fx_offset
+= S_GET_VALUE (sym
);
819 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
823 /* If the symbol is undefined, common, weak, or global (ELF
824 shared libs), we can't replace it with the section symbol. */
825 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
828 /* Is there some other (target cpu dependent) reason we can't adjust
829 this one? (E.g. relocations involving function addresses on
831 #ifdef tc_fix_adjustable
832 if (! tc_fix_adjustable (fixp
))
836 /* Since we're reducing to section symbols, don't attempt to reduce
837 anything that's already using one. */
838 if (symbol_section_p (sym
))
841 symsec
= S_GET_SEGMENT (sym
);
845 if (bfd_is_abs_section (symsec
)
846 || symsec
== reg_section
)
848 /* The fixup_segment routine normally will not use this
849 symbol in a relocation. */
853 /* Don't try to reduce relocs which refer to non-local symbols
854 in .linkonce sections. It can lead to confusion when a
855 debugging section refers to a .linkonce section. I hope
856 this will always be correct. */
857 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
859 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
861 /* The GNU toolchain uses an extension for ELF: a
862 section beginning with the magic string
863 .gnu.linkonce is a linkonce section. */
864 && strncmp (segment_name (symsec
), ".gnu.linkonce",
865 sizeof ".gnu.linkonce" - 1) == 0))
869 /* Never adjust a reloc against local symbol in a merge section
870 with non-zero addend. */
871 if ((symsec
->flags
& SEC_MERGE
) != 0
872 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
875 /* Never adjust a reloc against TLS local symbol. */
876 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
879 /* We refetch the segment when calling section_symbol, rather
880 than using symsec, because S_GET_VALUE may wind up changing
881 the section when it calls resolve_symbol_value. */
882 fixp
->fx_offset
+= S_GET_VALUE (sym
);
883 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
885 fprintf (stderr
, "\nadjusted fixup:\n");
890 dump_section_relocs (abfd
, sec
, stderr
);
895 Go through all the fixS's in a segment and see which ones can be
896 handled now. (These consist of fixS where we have since discovered
897 the value of a symbol, or the address of the frag involved.)
898 For each one, call md_apply_fix to put the fix into the frag data.
899 Ones that we couldn't completely handle here will be output later
900 by emit_relocations. */
903 fixup_segment (fixS
*fixP
, segT this_segment
)
907 segT add_symbol_segment
= absolute_section
;
909 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
910 abs_section_sym
= section_symbol (absolute_section
);
912 /* If the linker is doing the relaxing, we must not do any fixups.
914 Well, strictly speaking that's not true -- we could do any that
915 are PC-relative and don't cross regions that could change size.
916 And for the i960 we might be able to turn callx/callj into bal
917 anyways in cases where we know the maximum displacement. */
918 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
920 for (; fixP
; fixP
= fixP
->fx_next
)
923 if (fixP
->fx_addsy
== NULL
)
925 /* There was no symbol required by this relocation.
926 However, BFD doesn't really handle relocations
927 without symbols well. So fake up a local symbol in
928 the absolute section. */
929 fixP
->fx_addsy
= abs_section_sym
;
931 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
932 if (fixP
->fx_subsy
!= NULL
)
933 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
938 for (; fixP
; fixP
= fixP
->fx_next
)
941 fprintf (stderr
, "\nprocessing fixup:\n");
945 fragP
= fixP
->fx_frag
;
947 #ifdef TC_VALIDATE_FIX
948 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
950 add_number
= fixP
->fx_offset
;
952 if (fixP
->fx_addsy
!= NULL
)
953 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
955 if (fixP
->fx_subsy
!= NULL
)
957 segT sub_symbol_segment
;
958 resolve_symbol_value (fixP
->fx_subsy
);
959 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
960 if (fixP
->fx_addsy
!= NULL
961 && sub_symbol_segment
== add_symbol_segment
962 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
963 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
964 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
966 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
967 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
968 fixP
->fx_offset
= add_number
;
969 fixP
->fx_addsy
= NULL
;
970 fixP
->fx_subsy
= NULL
;
972 /* See the comment below about 68k weirdness. */
976 else if (sub_symbol_segment
== absolute_section
977 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
978 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
980 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
981 fixP
->fx_offset
= add_number
;
982 fixP
->fx_subsy
= NULL
;
984 else if (sub_symbol_segment
== this_segment
985 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
986 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
988 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
989 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
990 + fixP
->fx_dot_frag
->fr_address
);
992 /* Make it pc-relative. If the back-end code has not
993 selected a pc-relative reloc, cancel the adjustment
994 we do later on all pc-relative relocs. */
997 /* Do this for m68k even if it's already described
998 as pc-relative. On the m68k, an operand of
999 "pc@(foo-.-2)" should address "foo" in a
1000 pc-relative mode. */
1004 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1005 fixP
->fx_subsy
= NULL
;
1008 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
1010 if (!md_register_arithmetic
1011 && (add_symbol_segment
== reg_section
1012 || sub_symbol_segment
== reg_section
))
1013 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1014 _("register value used as expression"));
1016 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1017 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1018 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
1019 segment_name (add_symbol_segment
),
1020 S_GET_NAME (fixP
->fx_subsy
),
1021 segment_name (sub_symbol_segment
));
1023 else if (sub_symbol_segment
!= undefined_section
1024 && ! bfd_is_com_section (sub_symbol_segment
)
1025 && MD_APPLY_SYM_VALUE (fixP
))
1026 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
1031 if (add_symbol_segment
== this_segment
1032 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1033 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1035 /* This fixup was made when the symbol's segment was
1036 SEG_UNKNOWN, but it is now in the local segment.
1037 So we know how to do the address without relocation. */
1038 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1039 fixP
->fx_offset
= add_number
;
1041 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1042 fixP
->fx_addsy
= NULL
;
1045 else if (add_symbol_segment
== absolute_section
1046 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1047 && !TC_FORCE_RELOCATION_ABS (fixP
))
1049 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1050 fixP
->fx_offset
= add_number
;
1051 fixP
->fx_addsy
= NULL
;
1053 else if (add_symbol_segment
!= undefined_section
1054 && ! bfd_is_com_section (add_symbol_segment
)
1055 && MD_APPLY_SYM_VALUE (fixP
))
1056 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1061 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1062 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1064 /* There was no symbol required by this relocation.
1065 However, BFD doesn't really handle relocations
1066 without symbols well. So fake up a local symbol in
1067 the absolute section. */
1068 fixP
->fx_addsy
= abs_section_sym
;
1073 md_apply_fix (fixP
, &add_number
, this_segment
);
1077 if (fixP
->fx_addsy
== NULL
)
1078 fixP
->fx_addsy
= abs_section_sym
;
1079 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1080 if (fixP
->fx_subsy
!= NULL
)
1081 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1084 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1086 if (fixP
->fx_size
< sizeof (valueT
))
1091 mask
--; /* Set all bits to one. */
1092 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1093 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1095 char buf
[50], buf2
[50];
1096 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1097 if (add_number
> 1000)
1098 sprint_value (buf2
, add_number
);
1100 sprintf (buf2
, "%ld", (long) add_number
);
1101 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1102 _("value of %s too large for field of %d bytes at %s"),
1103 buf2
, fixP
->fx_size
, buf
);
1104 } /* Generic error checking. */
1106 #ifdef WARN_SIGNED_OVERFLOW_WORD
1107 /* Warn if a .word value is too large when treated as a signed
1108 number. We already know it is not too negative. This is to
1109 catch over-large switches generated by gcc on the 68k. */
1110 if (!flag_signed_overflow_ok
1111 && fixP
->fx_size
== 2
1112 && add_number
> 0x7fff)
1113 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1114 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1116 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1118 } /* Not a bit fix. */
1120 #ifdef TC_VALIDATE_FIX
1121 skip
: ATTRIBUTE_UNUSED_LABEL
1125 fprintf (stderr
, "result:\n");
1128 } /* For each fixS in this segment. */
1132 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1134 void *xxx ATTRIBUTE_UNUSED
)
1136 segment_info_type
*seginfo
= seg_info (sec
);
1138 fixup_segment (seginfo
->fix_root
, sec
);
1142 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1143 const char *file
, unsigned int line
)
1146 bfd_reloc_status_type s
;
1149 if (reloc
->sym_ptr_ptr
!= NULL
1150 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1151 && (sym
->flags
& BSF_KEEP
) == 0
1152 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1153 || (EMIT_SECTION_SYMBOLS
1154 && !bfd_is_abs_section (sym
->section
))))
1155 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1157 s
= bfd_install_relocation (stdoutput
, reloc
,
1158 fragp
->fr_literal
, fragp
->fr_address
,
1164 case bfd_reloc_overflow
:
1165 as_bad_where (file
, line
, _("relocation overflow"));
1167 case bfd_reloc_outofrange
:
1168 as_bad_where (file
, line
, _("relocation out of range"));
1171 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1177 get_frag_for_reloc (fragS
*last_frag
,
1178 const segment_info_type
*seginfo
,
1179 const struct reloc_list
*r
)
1183 for (f
= last_frag
; f
!= NULL
; f
= f
->fr_next
)
1184 if (f
->fr_address
<= r
->u
.b
.r
.address
1185 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1188 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1189 if (f
->fr_address
<= r
->u
.b
.r
.address
1190 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1193 for (f
= seginfo
->frchainP
->frch_root
; f
!= NULL
; f
= f
->fr_next
)
1194 if (f
->fr_address
<= r
->u
.b
.r
.address
1195 && r
->u
.b
.r
.address
<= f
->fr_address
+ f
->fr_fix
)
1198 as_bad_where (r
->file
, r
->line
,
1199 _("reloc not within (fixed part of) section"));
1204 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1206 segment_info_type
*seginfo
= seg_info (sec
);
1208 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1213 /* If seginfo is NULL, we did not create this section; don't do
1214 anything with it. */
1215 if (seginfo
== NULL
)
1219 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1223 #ifdef RELOC_EXPANSION_POSSIBLE
1224 n
*= MAX_RELOC_EXPANSION
;
1227 /* Extract relocs for this section from reloc_list. */
1229 my_reloc_list
= NULL
;
1230 while ((r
= *rp
) != NULL
)
1232 if (r
->u
.b
.sec
== sec
)
1235 r
->next
= my_reloc_list
;
1243 relocs
= XCNEWVEC (arelent
*, n
);
1248 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1253 #ifndef RELOC_EXPANSION_POSSIBLE
1262 fx_size
= fixp
->fx_size
;
1263 slack
= TC_FX_SIZE_SLACK (fixp
);
1265 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1266 loc
= fixp
->fx_where
+ fx_size
;
1267 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1268 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1269 _("internal error: fixup not contained within frag"));
1271 #ifndef RELOC_EXPANSION_POSSIBLE
1272 *reloc
= tc_gen_reloc (sec
, fixp
);
1274 reloc
= tc_gen_reloc (sec
, fixp
);
1279 while (r
!= NULL
&& r
->u
.b
.r
.address
< (*reloc
)->address
)
1281 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1285 relocs
[n
++] = &r
->u
.b
.r
;
1286 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1290 relocs
[n
++] = *reloc
;
1291 install_reloc (sec
, *reloc
, fixp
->fx_frag
,
1292 fixp
->fx_file
, fixp
->fx_line
);
1293 #ifndef RELOC_EXPANSION_POSSIBLE
1303 fragS
*f
= get_frag_for_reloc (last_frag
, seginfo
, r
);
1307 relocs
[n
++] = &r
->u
.b
.r
;
1308 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1315 unsigned int k
, j
, nsyms
;
1317 sympp
= bfd_get_outsymbols (stdoutput
);
1318 nsyms
= bfd_get_symcount (stdoutput
);
1319 for (k
= 0; k
< n
; k
++)
1320 if (((*relocs
[k
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1322 for (j
= 0; j
< nsyms
; j
++)
1323 if (sympp
[j
] == *relocs
[k
]->sym_ptr_ptr
)
1333 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1335 bfd_set_section_flags (abfd
, sec
, flags
);
1336 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1339 #ifdef SET_SECTION_RELOCS
1340 SET_SECTION_RELOCS (sec
, relocs
, n
);
1347 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1348 for (k
= 0; k
< n
; k
++)
1350 arelent
*rel
= relocs
[k
];
1351 asymbol
*s
= *rel
->sym_ptr_ptr
;
1352 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1353 k
, rel
, (unsigned long)rel
->address
, s
->name
,
1354 (unsigned long)rel
->addend
);
1361 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1362 fragS
**last_newf
, struct obstack
*ob
)
1365 int total_out_size
= 0;
1366 fragS
*f
= *last_newf
;
1370 /* Call the compression routine repeatedly until it has finished
1371 processing the frag. */
1374 /* Reserve all the space available in the current chunk.
1375 If none is available, start a new frag. */
1376 avail_out
= obstack_room (ob
);
1379 obstack_finish (ob
);
1380 f
= frag_alloc (ob
);
1381 f
->fr_type
= rs_fill
;
1382 (*last_newf
)->fr_next
= f
;
1384 avail_out
= obstack_room (ob
);
1387 as_fatal (_("can't extend frag"));
1388 next_out
= obstack_next_free (ob
);
1389 obstack_blank_fast (ob
, avail_out
);
1390 out_size
= compress_data (strm
, &contents
, &in_size
,
1391 &next_out
, &avail_out
);
1395 f
->fr_fix
+= out_size
;
1396 total_out_size
+= out_size
;
1398 /* Return unused space. */
1400 obstack_blank_fast (ob
, -avail_out
);
1403 return total_out_size
;
1407 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1409 segment_info_type
*seginfo
= seg_info (sec
);
1413 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1414 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1415 bfd_size_type compressed_size
;
1416 const char *section_name
;
1417 char *compressed_name
;
1419 struct z_stream_s
*strm
;
1421 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1422 unsigned int header_size
, compression_header_size
;
1426 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1429 section_name
= bfd_get_section_name (stdoutput
, sec
);
1430 if (strncmp (section_name
, ".debug_", 7) != 0)
1433 strm
= compress_init ();
1437 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
1439 compression_header_size
1440 = bfd_get_compression_header_size (stdoutput
, NULL
);
1441 header_size
= compression_header_size
;
1445 compression_header_size
= 0;
1449 /* Create a new frag to contain the compression header. */
1450 first_newf
= frag_alloc (ob
);
1451 if (obstack_room (ob
) < header_size
)
1452 first_newf
= frag_alloc (ob
);
1453 if (obstack_room (ob
) < header_size
)
1454 as_fatal (_("can't extend frag %u chars"), header_size
);
1455 last_newf
= first_newf
;
1456 obstack_blank_fast (ob
, header_size
);
1457 last_newf
->fr_type
= rs_fill
;
1458 last_newf
->fr_fix
= header_size
;
1459 header
= last_newf
->fr_literal
;
1460 compressed_size
= header_size
;
1462 /* Stream the frags through the compression engine, adding new frags
1463 as necessary to accommodate the compressed output. */
1464 for (f
= seginfo
->frchainP
->frch_root
;
1473 gas_assert (f
->fr_type
== rs_fill
);
1476 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1480 compressed_size
+= out_size
;
1482 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1483 fill_size
= f
->fr_var
;
1484 count
= f
->fr_offset
;
1485 gas_assert (count
>= 0);
1486 if (fill_size
&& count
)
1490 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1494 compressed_size
+= out_size
;
1499 /* Flush the compression state. */
1506 /* Reserve all the space available in the current chunk.
1507 If none is available, start a new frag. */
1508 avail_out
= obstack_room (ob
);
1513 obstack_finish (ob
);
1514 newf
= frag_alloc (ob
);
1515 newf
->fr_type
= rs_fill
;
1516 last_newf
->fr_next
= newf
;
1518 avail_out
= obstack_room (ob
);
1521 as_fatal (_("can't extend frag"));
1522 next_out
= obstack_next_free (ob
);
1523 obstack_blank_fast (ob
, avail_out
);
1524 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1528 last_newf
->fr_fix
+= out_size
;
1529 compressed_size
+= out_size
;
1531 /* Return unused space. */
1533 obstack_blank_fast (ob
, -avail_out
);
1539 /* PR binutils/18087: If compression didn't make the section smaller,
1540 just keep it uncompressed. */
1541 if (compressed_size
>= uncompressed_size
)
1544 /* Replace the uncompressed frag list with the compressed frag list. */
1545 seginfo
->frchainP
->frch_root
= first_newf
;
1546 seginfo
->frchainP
->frch_last
= last_newf
;
1548 /* Update the section size and its name. */
1549 bfd_update_compression_header (abfd
, (bfd_byte
*) header
, sec
);
1550 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1552 if (!compression_header_size
)
1554 compressed_name
= concat (".z", section_name
+ 1, (char *) NULL
);
1555 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1560 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1562 void *xxx ATTRIBUTE_UNUSED
)
1564 segment_info_type
*seginfo
= seg_info (sec
);
1565 addressT offset
= 0;
1568 /* Write out the frags. */
1570 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1573 for (f
= seginfo
->frchainP
->frch_root
;
1582 gas_assert (f
->fr_type
== rs_fill
);
1585 x
= bfd_set_section_contents (stdoutput
, sec
,
1586 f
->fr_literal
, (file_ptr
) offset
,
1587 (bfd_size_type
) f
->fr_fix
);
1589 as_fatal (_("can't write %ld bytes to section %s of %s because: '%s'"),
1590 (long) f
->fr_fix
, sec
->name
,
1591 stdoutput
->filename
,
1592 bfd_errmsg (bfd_get_error ()));
1593 offset
+= f
->fr_fix
;
1595 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1596 fill_size
= f
->fr_var
;
1597 count
= f
->fr_offset
;
1598 gas_assert (count
>= 0);
1599 if (fill_size
&& count
)
1602 if (fill_size
> sizeof (buf
))
1604 /* Do it the old way. Can this ever happen? */
1607 x
= bfd_set_section_contents (stdoutput
, sec
,
1610 (bfd_size_type
) fill_size
);
1612 as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
1613 (long) fill_size
, sec
->name
,
1614 stdoutput
->filename
,
1615 bfd_errmsg (bfd_get_error ()));
1616 offset
+= fill_size
;
1621 /* Build a buffer full of fill objects and output it as
1622 often as necessary. This saves on the overhead of
1623 potentially lots of bfd_set_section_contents calls. */
1627 n_per_buf
= sizeof (buf
);
1628 memset (buf
, *fill_literal
, n_per_buf
);
1633 n_per_buf
= sizeof (buf
) / fill_size
;
1634 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1635 memcpy (bufp
, fill_literal
, fill_size
);
1637 for (; count
> 0; count
-= n_per_buf
)
1639 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1640 x
= bfd_set_section_contents
1641 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1642 (bfd_size_type
) n_per_buf
* fill_size
);
1644 as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
1645 (long)(n_per_buf
* fill_size
), sec
->name
,
1646 stdoutput
->filename
,
1647 bfd_errmsg (bfd_get_error ()));
1648 offset
+= n_per_buf
* fill_size
;
1656 merge_data_into_text (void)
1658 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1659 seg_info (data_section
)->frchainP
->frch_root
;
1660 seg_info (text_section
)->frchainP
->frch_last
=
1661 seg_info (data_section
)->frchainP
->frch_last
;
1662 seg_info (data_section
)->frchainP
= 0;
1673 /* Count symbols. We can't rely on a count made by the loop in
1674 write_object_file, because *_frob_file may add a new symbol or
1677 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1683 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1685 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1686 symp
= symbol_rootP
;
1687 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1689 asympp
[i
] = symbol_get_bfdsym (symp
);
1690 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1691 || !(bfd_is_const_section (asympp
[i
]->section
)
1692 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1693 asympp
[i
]->flags
|= BSF_KEEP
;
1694 symbol_mark_written (symp
);
1699 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1700 gas_assert (result
);
1701 symbol_table_frozen
= 1;
1704 /* Finish the subsegments. After every sub-segment, we fake an
1705 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1706 ".fill 0" because that is the kind of frag that requires least
1707 thought. ".align" frags like to have a following frag since that
1708 makes calculating their intended length trivial. */
1710 #ifndef SUB_SEGMENT_ALIGN
1712 /* The last subsegment gets an alignment corresponding to the alignment
1713 of the section. This allows proper nop-filling at the end of
1714 code-bearing sections. */
1715 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1716 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1717 && !do_not_pad_sections_to_alignment \
1718 ? get_recorded_alignment (SEG) \
1721 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1726 subsegs_finish_section (asection
*s
)
1728 struct frchain
*frchainP
;
1729 segment_info_type
*seginfo
= seg_info (s
);
1733 for (frchainP
= seginfo
->frchainP
;
1735 frchainP
= frchainP
->frch_next
)
1739 subseg_set (s
, frchainP
->frch_subseg
);
1741 /* This now gets called even if we had errors. In that case,
1742 any alignment is meaningless, and, moreover, will look weird
1743 if we are generating a listing. */
1745 do_not_pad_sections_to_alignment
= 1;
1747 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1748 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1749 && now_seg
->entsize
)
1751 unsigned int entsize
= now_seg
->entsize
;
1754 while ((entsize
& 1) == 0)
1760 if (entalign
> alignment
)
1761 alignment
= entalign
;
1764 if (subseg_text_p (now_seg
))
1765 frag_align_code (alignment
, 0);
1767 frag_align (alignment
, 0, 0);
1769 /* frag_align will have left a new frag.
1770 Use this last frag for an empty ".fill".
1772 For this segment ...
1773 Create a last frag. Do not leave a "being filled in frag". */
1774 frag_wane (frag_now
);
1775 frag_now
->fr_fix
= 0;
1776 know (frag_now
->fr_next
== NULL
);
1781 subsegs_finish (void)
1785 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1786 subsegs_finish_section (s
);
1791 create_obj_attrs_section (void)
1798 size
= bfd_elf_obj_attr_size (stdoutput
);
1801 name
= get_elf_backend_data (stdoutput
)->obj_attrs_section
;
1803 name
= ".gnu.attributes";
1804 s
= subseg_new (name
, 0);
1805 elf_section_type (s
)
1806 = get_elf_backend_data (stdoutput
)->obj_attrs_section_type
;
1807 bfd_set_section_flags (stdoutput
, s
, SEC_READONLY
| SEC_DATA
);
1809 p
= frag_more (size
);
1810 bfd_elf_set_obj_attr_contents (stdoutput
, (bfd_byte
*)p
, size
);
1812 subsegs_finish_section (s
);
1813 relax_segment (seg_info (s
)->frchainP
->frch_root
, s
, 0);
1814 size_seg (stdoutput
, s
, NULL
);
1819 /* Write the object file. */
1822 write_object_file (void)
1824 struct relax_seg_info rsi
;
1825 #ifndef WORKING_DOT_WORD
1826 fragS
*fragP
; /* Track along all frags. */
1831 #ifdef md_pre_output_hook
1835 #ifdef md_pre_relax_hook
1839 /* From now on, we don't care about sub-segments. Build one frag chain
1840 for each segment. Linked through fr_next. */
1842 /* Remove the sections created by gas for its own purposes. */
1846 bfd_section_list_remove (stdoutput
, reg_section
);
1847 bfd_section_list_remove (stdoutput
, expr_section
);
1848 stdoutput
->section_count
-= 2;
1850 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1853 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1855 /* We have two segments. If user gave -R flag, then we must put the
1856 data frags into the text segment. Do this before relaxing so
1857 we know to take advantage of -R and make shorter addresses. */
1858 if (flag_readonly_data_in_text
)
1860 merge_data_into_text ();
1866 #ifndef WORKING_DOT_WORD
1867 /* We need to reset the markers in the broken word list and
1868 associated frags between calls to relax_segment (via
1869 relax_seg). Since the broken word list is global, we do it
1870 once per round, rather than locally in relax_segment for each
1872 struct broken_word
*brokp
;
1874 for (brokp
= broken_words
;
1875 brokp
!= (struct broken_word
*) NULL
;
1876 brokp
= brokp
->next_broken_word
)
1880 if (brokp
->dispfrag
!= (fragS
*) NULL
1881 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1882 brokp
->dispfrag
->fr_subtype
= 0;
1887 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1893 /* Note - Most ports will use the default value of
1894 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1895 local symbols to be resolved, removing their frag information.
1896 Some ports however, will not have finished relaxing all of
1897 their frags and will still need the local symbol frag
1898 information. These ports can set
1899 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1900 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1902 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1904 /* Relaxation has completed. Freeze all syms. */
1907 #ifdef md_post_relax_hook
1913 create_obj_attrs_section ();
1916 #ifndef WORKING_DOT_WORD
1918 struct broken_word
*lie
;
1919 struct broken_word
**prevP
;
1921 prevP
= &broken_words
;
1922 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1927 subseg_change (lie
->seg
, lie
->subseg
);
1928 exp
.X_op
= O_subtract
;
1929 exp
.X_add_symbol
= lie
->add
;
1930 exp
.X_op_symbol
= lie
->sub
;
1931 exp
.X_add_number
= lie
->addnum
;
1932 #ifdef TC_CONS_FIX_NEW
1933 TC_CONS_FIX_NEW (lie
->frag
,
1934 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1935 2, &exp
, TC_PARSE_CONS_RETURN_NONE
);
1937 fix_new_exp (lie
->frag
,
1938 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1939 2, &exp
, 0, BFD_RELOC_16
);
1941 *prevP
= lie
->next_broken_word
;
1944 prevP
= &(lie
->next_broken_word
);
1946 for (lie
= broken_words
; lie
;)
1948 struct broken_word
*untruth
;
1950 addressT table_addr
;
1951 addressT from_addr
, to_addr
;
1954 subseg_change (lie
->seg
, lie
->subseg
);
1955 fragP
= lie
->dispfrag
;
1957 /* Find out how many broken_words go here. */
1960 untruth
&& untruth
->dispfrag
== fragP
;
1961 untruth
= untruth
->next_broken_word
)
1962 if (untruth
->added
== 1)
1965 table_ptr
= lie
->dispfrag
->fr_opcode
;
1966 table_addr
= (lie
->dispfrag
->fr_address
1967 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1968 /* Create the jump around the long jumps. This is a short
1969 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1970 from_addr
= table_addr
;
1971 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1972 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1974 table_ptr
+= md_short_jump_size
;
1975 table_addr
+= md_short_jump_size
;
1978 lie
&& lie
->dispfrag
== fragP
;
1979 m
++, lie
= lie
->next_broken_word
)
1981 if (lie
->added
== 2)
1983 /* Patch the jump table. */
1984 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
1985 untruth
&& untruth
->dispfrag
== fragP
;
1986 untruth
= untruth
->next_broken_word
)
1988 if (untruth
->use_jump
== lie
)
1990 /* This is the offset from ??? to table_ptr+0.
1991 The target is the same for all users of this
1992 md_long_jump, but the "sub" bases (and hence the
1993 offsets) may be different. */
1994 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
1995 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1996 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
1998 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
2002 /* Install the long jump. */
2003 /* This is a long jump from table_ptr+0 to the final target. */
2004 from_addr
= table_addr
;
2005 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
2006 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
2008 table_ptr
+= md_long_jump_size
;
2009 table_addr
+= md_long_jump_size
;
2013 #endif /* not WORKING_DOT_WORD */
2015 /* Resolve symbol values. This needs to be done before processing
2021 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2022 resolve_symbol_value (symp
);
2024 resolve_local_symbol_values ();
2025 resolve_reloc_expr_symbols ();
2029 #ifdef tc_frob_file_before_adjust
2030 tc_frob_file_before_adjust ();
2032 #ifdef obj_frob_file_before_adjust
2033 obj_frob_file_before_adjust ();
2036 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
2038 #ifdef tc_frob_file_before_fix
2039 tc_frob_file_before_fix ();
2041 #ifdef obj_frob_file_before_fix
2042 obj_frob_file_before_fix ();
2045 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
2047 /* Set up symbol table, and write it out. */
2051 bfd_boolean skip_next_symbol
= FALSE
;
2053 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
2058 if (skip_next_symbol
)
2060 /* Don't do anything besides moving the value of the
2061 symbol from the GAS value-field to the BFD value-field. */
2062 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2063 skip_next_symbol
= FALSE
;
2067 if (symbol_mri_common_p (symp
))
2069 if (S_IS_EXTERNAL (symp
))
2070 as_bad (_("%s: global symbols not supported in common sections"),
2072 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2076 name
= S_GET_NAME (symp
);
2080 decode_local_label_name ((char *) S_GET_NAME (symp
));
2081 /* They only differ if `name' is a fb or dollar local
2083 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
2084 as_bad (_("local label `%s' is not defined"), name2
);
2087 /* Do it again, because adjust_reloc_syms might introduce
2088 more symbols. They'll probably only be section symbols,
2089 but they'll still need to have the values computed. */
2090 resolve_symbol_value (symp
);
2092 /* Skip symbols which were equated to undefined or common
2094 if (symbol_equated_reloc_p (symp
)
2095 || S_IS_WEAKREFR (symp
))
2097 const char *sname
= S_GET_NAME (symp
);
2099 if (S_IS_COMMON (symp
)
2100 && !TC_FAKE_LABEL (sname
)
2101 && !S_IS_WEAKREFR (symp
)
2102 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
2104 expressionS
*e
= symbol_get_value_expression (symp
);
2106 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2107 sname
, S_GET_NAME (e
->X_add_symbol
));
2109 if (S_GET_SEGMENT (symp
) == reg_section
)
2111 /* Report error only if we know the symbol name. */
2112 if (S_GET_NAME (symp
) != reg_section
->name
)
2113 as_bad (_("can't make global register symbol `%s'"),
2116 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2120 #ifdef obj_frob_symbol
2121 obj_frob_symbol (symp
, punt
);
2123 #ifdef tc_frob_symbol
2124 if (! punt
|| symbol_used_in_reloc_p (symp
))
2125 tc_frob_symbol (symp
, punt
);
2128 /* If we don't want to keep this symbol, splice it out of
2129 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2130 want section symbols. Otherwise, we skip local symbols
2131 and symbols that the frob_symbol macros told us to punt,
2132 but we keep such symbols if they are used in relocs. */
2133 if (symp
== abs_section_sym
2134 || (! EMIT_SECTION_SYMBOLS
2135 && symbol_section_p (symp
))
2136 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2137 opposites. Sometimes the former checks flags and the
2138 latter examines the name... */
2139 || (!S_IS_EXTERNAL (symp
)
2140 && (punt
|| S_IS_LOCAL (symp
) ||
2141 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2142 && ! symbol_used_in_reloc_p (symp
)))
2144 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2146 /* After symbol_remove, symbol_next(symp) still returns
2147 the one that came after it in the chain. So we don't
2148 need to do any extra cleanup work here. */
2152 /* Make sure we really got a value for the symbol. */
2153 if (! symbol_resolved_p (symp
))
2155 as_bad (_("can't resolve value for symbol `%s'"),
2157 symbol_mark_resolved (symp
);
2160 /* Set the value into the BFD symbol. Up til now the value
2161 has only been kept in the gas symbolS struct. */
2162 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2164 /* A warning construct is a warning symbol followed by the
2165 symbol warned about. Don't let anything object-format or
2166 target-specific muck with it; it's ready for output. */
2167 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2168 skip_next_symbol
= TRUE
;
2174 /* Now do any format-specific adjustments to the symbol table, such
2175 as adding file symbols. */
2176 #ifdef tc_adjust_symtab
2177 tc_adjust_symtab ();
2179 #ifdef obj_adjust_symtab
2180 obj_adjust_symtab ();
2183 /* Stop if there is an error. */
2187 /* Now that all the sizes are known, and contents correct, we can
2188 start writing to the file. */
2191 /* If *_frob_file changes the symbol value at this point, it is
2192 responsible for moving the changed value into symp->bsym->value
2193 as well. Hopefully all symbol value changing can be done in
2198 #ifdef obj_frob_file
2201 #ifdef obj_coff_generate_pdata
2202 obj_coff_generate_pdata ();
2204 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2206 #ifdef tc_frob_file_after_relocs
2207 tc_frob_file_after_relocs ();
2209 #ifdef obj_frob_file_after_relocs
2210 obj_frob_file_after_relocs ();
2213 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2214 if (IS_ELF
&& flag_use_elf_stt_common
)
2215 stdoutput
->flags
|= BFD_CONVERT_ELF_COMMON
| BFD_USE_ELF_STT_COMMON
;
2218 /* Once all relocations have been written, we can compress the
2219 contents of the debug sections. This needs to be done before
2220 we start writing any sections, because it will affect the file
2221 layout, which is fixed once we start writing contents. */
2222 if (flag_compress_debug
)
2224 if (flag_compress_debug
== COMPRESS_DEBUG_GABI_ZLIB
)
2225 stdoutput
->flags
|= BFD_COMPRESS
| BFD_COMPRESS_GABI
;
2227 stdoutput
->flags
|= BFD_COMPRESS
;
2228 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2231 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2234 #ifdef TC_GENERIC_RELAX_TABLE
2235 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2238 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2240 const relax_typeS
*this_type
;
2241 const relax_typeS
*start_type
;
2242 relax_substateT next_state
;
2243 relax_substateT this_state
;
2249 const relax_typeS
*table
;
2251 target
= fragP
->fr_offset
;
2252 address
= fragP
->fr_address
;
2253 table
= TC_GENERIC_RELAX_TABLE
;
2254 this_state
= fragP
->fr_subtype
;
2255 start_type
= this_type
= table
+ this_state
;
2256 symbolP
= fragP
->fr_symbol
;
2262 sym_frag
= symbol_get_frag (symbolP
);
2264 #ifndef DIFF_EXPR_OK
2265 know (sym_frag
!= NULL
);
2267 know (S_GET_SEGMENT (symbolP
) != absolute_section
2268 || sym_frag
== &zero_address_frag
);
2269 target
+= S_GET_VALUE (symbolP
);
2271 /* If SYM_FRAG has yet to be reached on this pass, assume it
2272 will move by STRETCH just as we did, unless there is an
2273 alignment frag between here and SYM_FRAG. An alignment may
2274 well absorb any STRETCH, and we don't want to choose a larger
2275 branch insn by overestimating the needed reach of this
2276 branch. It isn't critical to calculate TARGET exactly; We
2277 know we'll be doing another pass if STRETCH is non-zero. */
2280 && sym_frag
->relax_marker
!= fragP
->relax_marker
2281 && S_GET_SEGMENT (symbolP
) == segment
)
2284 || sym_frag
->region
== fragP
->region
)
2286 /* If we get here we know we have a forward branch. This
2287 relax pass may have stretched previous instructions so
2288 far that omitting STRETCH would make the branch
2289 negative. Don't allow this in case the negative reach is
2290 large enough to require a larger branch instruction. */
2291 else if (target
< address
)
2292 target
= fragP
->fr_next
->fr_address
+ stretch
;
2296 aim
= target
- address
- fragP
->fr_fix
;
2297 #ifdef TC_PCREL_ADJUST
2298 /* Currently only the ns32k family needs this. */
2299 aim
+= TC_PCREL_ADJUST (fragP
);
2302 #ifdef md_prepare_relax_scan
2303 /* Formerly called M68K_AIM_KLUDGE. */
2304 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2309 /* Look backwards. */
2310 for (next_state
= this_type
->rlx_more
; next_state
;)
2311 if (aim
>= this_type
->rlx_backward
)
2315 /* Grow to next state. */
2316 this_state
= next_state
;
2317 this_type
= table
+ this_state
;
2318 next_state
= this_type
->rlx_more
;
2323 /* Look forwards. */
2324 for (next_state
= this_type
->rlx_more
; next_state
;)
2325 if (aim
<= this_type
->rlx_forward
)
2329 /* Grow to next state. */
2330 this_state
= next_state
;
2331 this_type
= table
+ this_state
;
2332 next_state
= this_type
->rlx_more
;
2336 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2338 fragP
->fr_subtype
= this_state
;
2342 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2344 /* Relax_align. Advance location counter to next address that has 'alignment'
2345 lowest order bits all 0s, return size of adjustment made. */
2346 static relax_addressT
2347 relax_align (relax_addressT address
, /* Address now. */
2348 int alignment
/* Alignment (binary). */)
2350 relax_addressT mask
;
2351 relax_addressT new_address
;
2353 mask
= ~((relax_addressT
) ~0 << alignment
);
2354 new_address
= (address
+ mask
) & (~mask
);
2355 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2357 /* We must provide lots of padding, so the linker can discard it
2358 when needed. The linker will not add extra space, ever. */
2359 new_address
+= (1 << alignment
);
2361 return (new_address
- address
);
2364 /* Now we have a segment, not a crowd of sub-segments, we can make
2369 After this, all frags in this segment have addresses that are correct
2370 within the segment. Since segments live in different file addresses,
2371 these frag addresses may not be the same as final object-file
2375 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2377 unsigned long frag_count
;
2379 relax_addressT address
;
2383 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2384 subseg_change (segment
, 0);
2386 /* For each frag in segment: count and store (a 1st guess of)
2390 for (frag_count
= 0, fragP
= segment_frag_root
;
2392 fragP
= fragP
->fr_next
, frag_count
++)
2394 fragP
->region
= region
;
2395 fragP
->relax_marker
= 0;
2396 fragP
->fr_address
= address
;
2397 address
+= fragP
->fr_fix
;
2399 switch (fragP
->fr_type
)
2402 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2409 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2411 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2414 if (offset
% fragP
->fr_var
!= 0)
2416 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2417 _("alignment padding (%lu bytes) not a multiple of %ld"),
2418 (unsigned long) offset
, (long) fragP
->fr_var
);
2419 offset
-= (offset
% fragP
->fr_var
);
2428 /* Assume .org is nugatory. It will grow with 1st relax. */
2435 case rs_machine_dependent
:
2436 /* If fr_symbol is an expression, this call to
2437 resolve_symbol_value sets up the correct segment, which will
2438 likely be needed in md_estimate_size_before_relax. */
2439 if (fragP
->fr_symbol
)
2440 resolve_symbol_value (fragP
->fr_symbol
);
2442 address
+= md_estimate_size_before_relax (fragP
, segment
);
2445 #ifndef WORKING_DOT_WORD
2446 /* Broken words don't concern us yet. */
2447 case rs_broken_word
:
2452 /* Initial guess is always 1; doing otherwise can result in
2453 stable solutions that are larger than the minimum. */
2454 address
+= fragP
->fr_offset
= 1;
2458 address
+= eh_frame_estimate_size_before_relax (fragP
);
2462 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2466 BAD_CASE (fragP
->fr_type
);
2473 unsigned long max_iterations
;
2475 /* Cumulative address adjustment. */
2478 /* Have we made any adjustment this pass? We can't just test
2479 stretch because one piece of code may have grown and another
2483 /* Most horrible, but gcc may give us some exception data that
2484 is impossible to assemble, of the form
2488 .uleb128 end - start
2494 If the leb128 is two bytes in size, then end-start is 128*128,
2495 which requires a three byte leb128. If the leb128 is three
2496 bytes in size, then end-start is 128*128-1, which requires a
2497 two byte leb128. We work around this dilemma by inserting
2498 an extra 4 bytes of alignment just after the .align. This
2499 works because the data after the align is accessed relative to
2502 This counter is used in a tiny state machine to detect
2503 whether a leb128 followed by an align is impossible to
2505 int rs_leb128_fudge
= 0;
2507 /* We want to prevent going into an infinite loop where one frag grows
2508 depending upon the location of a symbol which is in turn moved by
2509 the growing frag. eg:
2515 So we dictate that this algorithm can be at most O2. */
2516 max_iterations
= frag_count
* frag_count
;
2517 /* Check for overflow. */
2518 if (max_iterations
< frag_count
)
2519 max_iterations
= frag_count
;
2527 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2530 addressT was_address
;
2534 fragP
->relax_marker
^= 1;
2535 was_address
= fragP
->fr_address
;
2536 address
= fragP
->fr_address
+= stretch
;
2537 symbolP
= fragP
->fr_symbol
;
2538 offset
= fragP
->fr_offset
;
2540 switch (fragP
->fr_type
)
2542 case rs_fill
: /* .fill never relaxes. */
2546 #ifndef WORKING_DOT_WORD
2547 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2548 for it I do not want to write it. I do not want to have
2549 anything to do with it. This is not the proper way to
2550 implement this misfeature. */
2551 case rs_broken_word
:
2553 struct broken_word
*lie
;
2554 struct broken_word
*untruth
;
2556 /* Yes this is ugly (storing the broken_word pointer
2557 in the symbol slot). Still, this whole chunk of
2558 code is ugly, and I don't feel like doing anything
2559 about it. Think of it as stubbornness in action. */
2561 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2562 lie
&& lie
->dispfrag
== fragP
;
2563 lie
= lie
->next_broken_word
)
2569 offset
= (S_GET_VALUE (lie
->add
)
2571 - S_GET_VALUE (lie
->sub
));
2572 if (offset
<= -32768 || offset
>= 32767)
2574 if (flag_warn_displacement
)
2577 sprint_value (buf
, (addressT
) lie
->addnum
);
2578 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2579 _(".word %s-%s+%s didn't fit"),
2580 S_GET_NAME (lie
->add
),
2581 S_GET_NAME (lie
->sub
),
2584 if (fragP
->fr_subtype
== 0)
2586 fragP
->fr_subtype
++;
2587 growth
+= md_short_jump_size
;
2590 /* Redirect *all* words of this table with the same
2591 target, lest we have to handle the case where the
2592 same target but with a offset that fits on this
2593 round overflows at the next relaxation round. */
2594 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2595 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2596 untruth
= untruth
->next_broken_word
)
2597 if ((symbol_get_frag (untruth
->add
)
2598 == symbol_get_frag (lie
->add
))
2599 && (S_GET_VALUE (untruth
->add
)
2600 == S_GET_VALUE (lie
->add
)))
2603 untruth
->use_jump
= lie
;
2607 growth
+= md_long_jump_size
;
2612 } /* case rs_broken_word */
2618 addressT oldoff
, newoff
;
2620 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2622 newoff
= relax_align (address
+ fragP
->fr_fix
,
2625 if (fragP
->fr_subtype
!= 0)
2627 if (oldoff
> fragP
->fr_subtype
)
2629 if (newoff
> fragP
->fr_subtype
)
2633 growth
= newoff
- oldoff
;
2635 /* If this align happens to follow a leb128 and
2636 we have determined that the leb128 is bouncing
2637 in size, then break the cycle by inserting an
2640 && (rs_leb128_fudge
& 16) != 0
2641 && (rs_leb128_fudge
& 15) >= 2)
2643 segment_info_type
*seginfo
= seg_info (segment
);
2644 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2647 newf
= frag_alloc (ob
);
2648 obstack_blank_fast (ob
, fragP
->fr_var
);
2649 obstack_finish (ob
);
2650 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2651 memcpy (newf
->fr_literal
,
2652 fragP
->fr_literal
+ fragP
->fr_fix
,
2654 newf
->fr_type
= rs_fill
;
2655 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2657 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2659 if (newf
->fr_offset
* newf
->fr_var
2660 != (offsetT
) 1 << fragP
->fr_offset
)
2662 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2665 /* Include size of new frag in GROWTH. */
2666 growth
+= newf
->fr_offset
* newf
->fr_var
;
2667 /* Adjust the new frag address for the amount
2668 we'll add when we process the new frag. */
2669 newf
->fr_address
-= stretch
+ growth
;
2670 newf
->relax_marker
^= 1;
2671 fragP
->fr_next
= newf
;
2673 as_warn (_("padding added"));
2681 addressT target
= offset
;
2686 /* Convert from an actual address to an octet offset
2687 into the section. Here it is assumed that the
2688 section's VMA is zero, and can omit subtracting it
2689 from the symbol's value to get the address offset. */
2690 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2691 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2694 know (fragP
->fr_next
);
2695 after
= fragP
->fr_next
->fr_address
+ stretch
;
2696 growth
= target
- after
;
2698 /* Growth may be negative, but variable part of frag
2699 cannot have fewer than 0 chars. That is, we can't
2701 if (address
+ fragP
->fr_fix
> target
)
2705 /* Don't error on first few frag relax passes.
2706 The symbol might be an expression involving
2707 symbol values from other sections. If those
2708 sections have not yet been processed their
2709 frags will all have zero addresses, so we
2710 will calculate incorrect values for them. The
2711 number of passes we allow before giving an
2712 error is somewhat arbitrary. It should be at
2713 least one, with larger values requiring
2714 increasingly contrived dependencies between
2715 frags to trigger a false error. */
2718 /* Force another pass. */
2723 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2724 _("attempt to move .org backwards"));
2726 /* We've issued an error message. Change the
2727 frag to avoid cascading errors. */
2728 fragP
->fr_type
= rs_align
;
2729 fragP
->fr_subtype
= 0;
2730 fragP
->fr_offset
= 0;
2731 fragP
->fr_fix
= after
- address
;
2742 amount
= S_GET_VALUE (symbolP
);
2743 if (S_GET_SEGMENT (symbolP
) != absolute_section
2744 || S_IS_COMMON (symbolP
)
2745 || ! S_IS_DEFINED (symbolP
))
2747 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2748 _(".space specifies non-absolute value"));
2749 /* Prevent repeat of this error message. */
2750 fragP
->fr_symbol
= 0;
2752 else if (amount
< 0)
2754 /* Don't error on first few frag relax passes.
2755 See rs_org comment for a longer explanation. */
2762 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2763 _(".space or .fill with negative value, ignored"));
2764 fragP
->fr_symbol
= 0;
2767 growth
= (was_address
+ fragP
->fr_fix
+ amount
2768 - fragP
->fr_next
->fr_address
);
2772 case rs_machine_dependent
:
2773 #ifdef md_relax_frag
2774 growth
= md_relax_frag (segment
, fragP
, stretch
);
2776 #ifdef TC_GENERIC_RELAX_TABLE
2777 /* The default way to relax a frag is to look through
2778 TC_GENERIC_RELAX_TABLE. */
2779 growth
= relax_frag (segment
, fragP
, stretch
);
2780 #endif /* TC_GENERIC_RELAX_TABLE */
2789 value
= resolve_symbol_value (fragP
->fr_symbol
);
2790 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2791 growth
= size
- fragP
->fr_offset
;
2792 fragP
->fr_offset
= size
;
2797 growth
= eh_frame_relax_frag (fragP
);
2801 growth
= dwarf2dbg_relax_frag (fragP
);
2805 BAD_CASE (fragP
->fr_type
);
2812 if (fragP
->fr_type
== rs_leb128
)
2813 rs_leb128_fudge
+= 16;
2814 else if (fragP
->fr_type
== rs_align
2815 && (rs_leb128_fudge
& 16) != 0
2817 rs_leb128_fudge
+= 16;
2819 rs_leb128_fudge
= 0;
2824 && (rs_leb128_fudge
& 16) == 0
2825 && (rs_leb128_fudge
& -16) != 0)
2826 rs_leb128_fudge
+= 1;
2828 rs_leb128_fudge
= 0;
2830 /* Until nothing further to relax. */
2831 while (stretched
&& -- max_iterations
);
2834 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2835 segment_name (segment
));
2838 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2839 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2841 fragP
->last_fr_address
= fragP
->fr_address
;
2848 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2854 buf
[n
] = val
& 0xff;
2860 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2866 *buf
++ = val
& 0xff;
2872 write_print_statistics (FILE *file
)
2874 fprintf (file
, "fixups: %d\n", n_fixups
);
2877 /* For debugging. */
2878 extern int indent_level
;
2881 print_fixup (fixS
*fixp
)
2884 fprintf (stderr
, "fix ");
2885 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2886 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2888 fprintf (stderr
, " pcrel");
2889 if (fixp
->fx_pcrel_adjust
)
2890 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2891 if (fixp
->fx_im_disp
)
2894 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2896 fprintf (stderr
, " im_disp");
2900 fprintf (stderr
, " tcbit");
2902 fprintf (stderr
, " done");
2903 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2904 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2905 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2906 (long) fixp
->fx_where
,
2907 (unsigned long) fixp
->fx_offset
,
2908 (unsigned long) fixp
->fx_addnumber
);
2909 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2913 fprintf (stderr
, "\n +<");
2914 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2915 fprintf (stderr
, ">");
2919 fprintf (stderr
, "\n -<");
2920 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2921 fprintf (stderr
, ">");
2923 fprintf (stderr
, "\n");
2924 #ifdef TC_FIX_DATA_PRINT
2925 TC_FIX_DATA_PRINT (stderr
, fixp
);