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 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_ADJUST_RELOC_COUNT
34 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
37 #ifndef TC_FORCE_RELOCATION
38 #define TC_FORCE_RELOCATION(FIX) \
39 (generic_force_reloc (FIX))
42 #ifndef TC_FORCE_RELOCATION_ABS
43 #define TC_FORCE_RELOCATION_ABS(FIX) \
44 (TC_FORCE_RELOCATION (FIX))
47 #ifndef TC_FORCE_RELOCATION_LOCAL
48 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
50 || TC_FORCE_RELOCATION (FIX))
53 #ifndef TC_FORCE_RELOCATION_SUB_SAME
54 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
58 #ifndef md_register_arithmetic
59 # define md_register_arithmetic 1
62 #ifndef TC_FORCE_RELOCATION_SUB_ABS
63 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
64 (!md_register_arithmetic && (SEG) == reg_section)
67 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
69 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
70 (!md_register_arithmetic && (SEG) == reg_section)
72 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
76 #ifndef TC_VALIDATE_FIX_SUB
77 #ifdef UNDEFINED_DIFFERENCE_OK
78 /* The PA needs this for PIC code generation. */
79 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
80 (md_register_arithmetic || (SEG) != reg_section)
82 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
83 ((md_register_arithmetic || (SEG) != reg_section) \
84 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
85 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
89 #ifndef TC_LINKRELAX_FIXUP
90 #define TC_LINKRELAX_FIXUP(SEG) 1
93 #ifndef MD_APPLY_SYM_VALUE
94 #define MD_APPLY_SYM_VALUE(FIX) 1
97 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
98 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
101 #ifndef MD_PCREL_FROM_SECTION
102 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
105 #ifndef TC_FAKE_LABEL
106 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
109 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
110 fixups that far past the end of a frag. Having such fixups
111 is of course most most likely a bug in setting fx_size correctly.
112 A negative value disables the fixup check entirely, which is
113 appropriate for something like the Renesas / SuperH SH_COUNT
115 #ifndef TC_FX_SIZE_SLACK
116 #define TC_FX_SIZE_SLACK(FIX) 0
119 /* Used to control final evaluation of expressions. */
120 int finalize_syms
= 0;
122 int symbol_table_frozen
;
124 symbolS
*abs_section_sym
;
126 /* Remember the value of dot when parsing expressions. */
129 /* Relocs generated by ".reloc" pseudo. */
130 struct reloc_list
* reloc_list
;
132 void print_fixup (fixS
*);
134 /* We generally attach relocs to frag chains. However, after we have
135 chained these all together into a segment, any relocs we add after
136 that must be attached to a segment. This will include relocs added
137 in md_estimate_size_for_relax, for example. */
138 static int frags_chained
= 0;
142 #define RELOC_ENUM enum bfd_reloc_code_real
144 /* Create a fixS in obstack 'notes'. */
147 fix_new_internal (fragS
*frag
, /* Which frag? */
148 int where
, /* Where in that frag? */
149 int size
, /* 1, 2, or 4 usually. */
150 symbolS
*add_symbol
, /* X_add_symbol. */
151 symbolS
*sub_symbol
, /* X_op_symbol. */
152 offsetT offset
, /* X_add_number. */
153 int pcrel
, /* TRUE if PC-relative relocation. */
154 RELOC_ENUM r_type ATTRIBUTE_UNUSED
/* Relocation type. */,
155 int at_beginning
) /* Add to the start of the list? */
161 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
163 fixP
->fx_frag
= frag
;
164 fixP
->fx_where
= where
;
165 fixP
->fx_size
= size
;
166 /* We've made fx_size a narrow field; check that it's wide enough. */
167 if (fixP
->fx_size
!= size
)
169 as_bad (_("field fx_size too small to hold %d"), size
);
172 fixP
->fx_addsy
= add_symbol
;
173 fixP
->fx_subsy
= sub_symbol
;
174 fixP
->fx_offset
= offset
;
175 fixP
->fx_dot_value
= dot_value
;
176 fixP
->fx_pcrel
= pcrel
;
177 fixP
->fx_r_type
= r_type
;
178 fixP
->fx_im_disp
= 0;
179 fixP
->fx_pcrel_adjust
= 0;
180 fixP
->fx_bit_fixP
= 0;
181 fixP
->fx_addnumber
= 0;
185 fixP
->fx_no_overflow
= 0;
189 fixP
->fx_cgen
.insn
= NULL
;
190 fixP
->fx_cgen
.opinfo
= 0;
194 TC_INIT_FIX_DATA (fixP
);
197 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
201 fixS
**seg_fix_rootP
= (frags_chained
202 ? &seg_info (now_seg
)->fix_root
203 : &frchain_now
->fix_root
);
204 fixS
**seg_fix_tailP
= (frags_chained
205 ? &seg_info (now_seg
)->fix_tail
206 : &frchain_now
->fix_tail
);
210 fixP
->fx_next
= *seg_fix_rootP
;
211 *seg_fix_rootP
= fixP
;
212 if (fixP
->fx_next
== NULL
)
213 *seg_fix_tailP
= fixP
;
217 fixP
->fx_next
= NULL
;
219 (*seg_fix_tailP
)->fx_next
= fixP
;
221 *seg_fix_rootP
= fixP
;
222 *seg_fix_tailP
= fixP
;
229 /* Create a fixup relative to a symbol (plus a constant). */
232 fix_new (fragS
*frag
, /* Which frag? */
233 int where
, /* Where in that frag? */
234 int size
, /* 1, 2, or 4 usually. */
235 symbolS
*add_symbol
, /* X_add_symbol. */
236 offsetT offset
, /* X_add_number. */
237 int pcrel
, /* TRUE if PC-relative relocation. */
238 RELOC_ENUM r_type
/* Relocation type. */)
240 return fix_new_internal (frag
, where
, size
, add_symbol
,
241 (symbolS
*) NULL
, offset
, pcrel
, r_type
, FALSE
);
244 /* Create a fixup for an expression. Currently we only support fixups
245 for difference expressions. That is itself more than most object
246 file formats support anyhow. */
249 fix_new_exp (fragS
*frag
, /* Which frag? */
250 int where
, /* Where in that frag? */
251 int size
, /* 1, 2, or 4 usually. */
252 expressionS
*exp
, /* Expression. */
253 int pcrel
, /* TRUE if PC-relative relocation. */
254 RELOC_ENUM r_type
/* Relocation type. */)
266 as_bad (_("register value used as expression"));
270 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
271 the difference expression cannot immediately be reduced. */
273 symbolS
*stmp
= make_expr_symbol (exp
);
275 exp
->X_op
= O_symbol
;
276 exp
->X_op_symbol
= 0;
277 exp
->X_add_symbol
= stmp
;
278 exp
->X_add_number
= 0;
280 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
284 add
= exp
->X_add_symbol
;
285 off
= exp
->X_add_number
;
286 r_type
= BFD_RELOC_RVA
;
290 sub
= exp
->X_add_symbol
;
291 off
= exp
->X_add_number
;
295 sub
= exp
->X_op_symbol
;
298 add
= exp
->X_add_symbol
;
301 off
= exp
->X_add_number
;
305 add
= make_expr_symbol (exp
);
309 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
,
313 /* Create a fixup at the beginning of FRAG. The arguments are the same
314 as for fix_new, except that WHERE is implicitly 0. */
317 fix_at_start (fragS
*frag
, int size
, symbolS
*add_symbol
,
318 offsetT offset
, int pcrel
, RELOC_ENUM r_type
)
320 return fix_new_internal (frag
, 0, size
, add_symbol
,
321 (symbolS
*) NULL
, offset
, pcrel
, r_type
, TRUE
);
324 /* Generic function to determine whether a fixup requires a relocation. */
326 generic_force_reloc (fixS
*fix
)
328 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
329 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
332 if (fix
->fx_addsy
== NULL
)
335 return S_FORCE_RELOC (fix
->fx_addsy
, fix
->fx_subsy
== NULL
);
338 /* Append a string onto another string, bumping the pointer along. */
340 append (char **charPP
, char *fromP
, unsigned long length
)
342 /* Don't trust memcpy() of 0 chars. */
346 memcpy (*charPP
, fromP
, length
);
350 /* This routine records the largest alignment seen for each segment.
351 If the beginning of the segment is aligned on the worst-case
352 boundary, all of the other alignments within it will work. At
353 least one object format really uses this info. */
356 record_alignment (/* Segment to which alignment pertains. */
358 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
359 boundary, 2 => 4-byte boundary, etc.) */
362 if (seg
== absolute_section
)
365 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
366 bfd_set_section_alignment (stdoutput
, seg
, align
);
370 get_recorded_alignment (segT seg
)
372 if (seg
== absolute_section
)
375 return bfd_get_section_alignment (stdoutput
, seg
);
378 /* Reset the section indices after removing the gas created sections. */
381 renumber_sections (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *countparg
)
383 int *countp
= (int *) countparg
;
385 sec
->index
= *countp
;
390 chain_frchains_together_1 (segT section
, struct frchain
*frchp
)
392 fragS dummy
, *prev_frag
= &dummy
;
393 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
395 for (; frchp
; frchp
= frchp
->frch_next
)
397 prev_frag
->fr_next
= frchp
->frch_root
;
398 prev_frag
= frchp
->frch_last
;
399 gas_assert (prev_frag
->fr_type
!= 0);
400 if (frchp
->fix_root
!= (fixS
*) NULL
)
402 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
403 seg_info (section
)->fix_root
= frchp
->fix_root
;
404 prev_fix
->fx_next
= frchp
->fix_root
;
405 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
406 prev_fix
= frchp
->fix_tail
;
409 gas_assert (prev_frag
->fr_type
!= 0);
410 gas_assert (prev_frag
!= &dummy
);
411 prev_frag
->fr_next
= 0;
416 chain_frchains_together (bfd
*abfd ATTRIBUTE_UNUSED
,
418 void *xxx ATTRIBUTE_UNUSED
)
420 segment_info_type
*info
;
422 /* BFD may have introduced its own sections without using
423 subseg_new, so it is possible that seg_info is NULL. */
424 info
= seg_info (section
);
425 if (info
!= (segment_info_type
*) NULL
)
426 info
->frchainP
->frch_last
427 = chain_frchains_together_1 (section
, info
->frchainP
);
429 /* Now that we've chained the frags together, we must add new fixups
430 to the segment, not to the frag chain. */
435 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED
, fragS
*fragP
)
437 switch (fragP
->fr_type
)
445 HANDLE_ALIGN (fragP
);
447 know (fragP
->fr_next
!= NULL
);
448 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
450 - fragP
->fr_fix
) / fragP
->fr_var
;
451 if (fragP
->fr_offset
< 0)
453 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
454 _("attempt to .org/.space backwards? (%ld)"),
455 (long) fragP
->fr_offset
);
456 fragP
->fr_offset
= 0;
458 fragP
->fr_type
= rs_fill
;
466 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
469 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
472 fragP
->fr_fix
+= size
;
473 fragP
->fr_type
= rs_fill
;
475 fragP
->fr_offset
= 0;
476 fragP
->fr_symbol
= NULL
;
481 eh_frame_convert_frag (fragP
);
485 dwarf2dbg_convert_frag (fragP
);
488 case rs_machine_dependent
:
489 md_convert_frag (stdoutput
, sec
, fragP
);
491 gas_assert (fragP
->fr_next
== NULL
492 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
495 /* After md_convert_frag, we make the frag into a ".space 0".
496 md_convert_frag() should set up any fixSs and constants
501 #ifndef WORKING_DOT_WORD
504 struct broken_word
*lie
;
506 if (fragP
->fr_subtype
)
508 fragP
->fr_fix
+= md_short_jump_size
;
509 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
510 lie
&& lie
->dispfrag
== fragP
;
511 lie
= lie
->next_broken_word
)
513 fragP
->fr_fix
+= md_long_jump_size
;
521 BAD_CASE (fragP
->fr_type
);
525 md_frag_check (fragP
);
529 struct relax_seg_info
536 relax_seg (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, void *xxx
)
538 segment_info_type
*seginfo
= seg_info (sec
);
539 struct relax_seg_info
*info
= (struct relax_seg_info
*) xxx
;
541 if (seginfo
&& seginfo
->frchainP
542 && relax_segment (seginfo
->frchainP
->frch_root
, sec
, info
->pass
))
547 size_seg (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
551 segment_info_type
*seginfo
;
553 valueT size
, newsize
;
555 subseg_change (sec
, 0);
557 seginfo
= seg_info (sec
);
558 if (seginfo
&& seginfo
->frchainP
)
560 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
561 cvt_frag_to_fill (sec
, fragp
);
562 for (fragp
= seginfo
->frchainP
->frch_root
;
564 fragp
= fragp
->fr_next
)
565 /* Walk to last elt. */
567 size
= fragp
->fr_address
+ fragp
->fr_fix
;
572 flags
= bfd_get_section_flags (abfd
, sec
);
573 if (size
== 0 && bfd_get_section_size (sec
) != 0 &&
574 (flags
& SEC_HAS_CONTENTS
) != 0)
577 if (size
> 0 && ! seginfo
->bss
)
578 flags
|= SEC_HAS_CONTENTS
;
581 x
= bfd_set_section_flags (abfd
, sec
, flags
);
584 newsize
= md_section_align (sec
, size
);
585 x
= bfd_set_section_size (abfd
, sec
, newsize
);
588 /* If the size had to be rounded up, add some padding in the last
590 gas_assert (newsize
>= size
);
593 fragS
*last
= seginfo
->frchainP
->frch_last
;
594 fragp
= seginfo
->frchainP
->frch_root
;
595 while (fragp
->fr_next
!= last
)
596 fragp
= fragp
->fr_next
;
597 last
->fr_address
= size
;
598 if ((newsize
- size
) % fragp
->fr_var
== 0)
599 fragp
->fr_offset
+= (newsize
- size
) / fragp
->fr_var
;
601 /* If we hit this abort, it's likely due to subsegs_finish not
602 providing sufficient alignment on the last frag, and the
603 machine dependent code using alignment frags with fr_var
608 #ifdef tc_frob_section
609 tc_frob_section (sec
);
611 #ifdef obj_frob_section
612 obj_frob_section (sec
);
618 dump_section_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
, FILE *stream
)
620 segment_info_type
*seginfo
= seg_info (sec
);
621 fixS
*fixp
= seginfo
->fix_root
;
626 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
629 symbolS
*s
= fixp
->fx_addsy
;
631 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
632 (int) fixp
->fx_r_type
);
634 fprintf (stream
, "no sym\n");
637 print_symbol_value_1 (stream
, s
);
638 fprintf (stream
, "\n");
640 fixp
= fixp
->fx_next
;
644 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
647 #ifndef EMIT_SECTION_SYMBOLS
648 #define EMIT_SECTION_SYMBOLS 1
651 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
652 and check for validity. Convert RELOC_LIST from using U.A fields
655 resolve_reloc_expr_symbols (void)
657 struct reloc_list
*r
;
659 for (r
= reloc_list
; r
; r
= r
->next
)
663 bfd_vma offset
, addend
;
665 reloc_howto_type
*howto
;
667 resolve_symbol_value (r
->u
.a
.offset_sym
);
668 symval
= symbol_get_value_expression (r
->u
.a
.offset_sym
);
672 if (symval
->X_op
== O_constant
)
673 sym
= r
->u
.a
.offset_sym
;
674 else if (symval
->X_op
== O_symbol
)
676 sym
= symval
->X_add_symbol
;
677 offset
= symval
->X_add_number
;
678 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
681 || symval
->X_op
!= O_constant
682 || (sec
= S_GET_SEGMENT (sym
)) == NULL
683 || !SEG_NORMAL (sec
))
685 as_bad_where (r
->file
, r
->line
, _("invalid offset expression"));
689 offset
+= S_GET_VALUE (sym
);
692 addend
= r
->u
.a
.addend
;
693 if (r
->u
.a
.sym
!= NULL
)
695 resolve_symbol_value (r
->u
.a
.sym
);
696 symval
= symbol_get_value_expression (r
->u
.a
.sym
);
697 if (symval
->X_op
== O_constant
)
699 else if (symval
->X_op
== O_symbol
)
701 sym
= symval
->X_add_symbol
;
702 addend
+= symval
->X_add_number
;
703 symval
= symbol_get_value_expression (symval
->X_add_symbol
);
705 if (symval
->X_op
!= O_constant
)
707 as_bad_where (r
->file
, r
->line
, _("invalid reloc expression"));
710 else if (sym
!= NULL
)
711 symbol_mark_used_in_reloc (sym
);
715 if (abs_section_sym
== NULL
)
716 abs_section_sym
= section_symbol (absolute_section
);
717 sym
= abs_section_sym
;
720 howto
= r
->u
.a
.howto
;
723 r
->u
.b
.s
= symbol_get_bfdsym (sym
);
724 r
->u
.b
.r
.sym_ptr_ptr
= &r
->u
.b
.s
;
725 r
->u
.b
.r
.address
= offset
;
726 r
->u
.b
.r
.addend
= addend
;
727 r
->u
.b
.r
.howto
= howto
;
731 /* This pass over fixups decides whether symbols can be replaced with
735 adjust_reloc_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
737 void *xxx ATTRIBUTE_UNUSED
)
739 segment_info_type
*seginfo
= seg_info (sec
);
745 dump_section_relocs (abfd
, sec
, stderr
);
747 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
751 else if (fixp
->fx_addsy
)
757 fprintf (stderr
, "\n\nadjusting fixup:\n");
761 sym
= fixp
->fx_addsy
;
763 /* All symbols should have already been resolved at this
764 point. It is possible to see unresolved expression
765 symbols, though, since they are not in the regular symbol
767 resolve_symbol_value (sym
);
769 if (fixp
->fx_subsy
!= NULL
)
770 resolve_symbol_value (fixp
->fx_subsy
);
772 /* If this symbol is equated to an undefined or common symbol,
773 convert the fixup to being against that symbol. */
774 while (symbol_equated_reloc_p (sym
)
775 || S_IS_WEAKREFR (sym
))
777 symbolS
*newsym
= symbol_get_value_expression (sym
)->X_add_symbol
;
780 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
781 fixp
->fx_addsy
= newsym
;
785 if (symbol_mri_common_p (sym
))
787 fixp
->fx_offset
+= S_GET_VALUE (sym
);
788 fixp
->fx_addsy
= symbol_get_value_expression (sym
)->X_add_symbol
;
792 /* If the symbol is undefined, common, weak, or global (ELF
793 shared libs), we can't replace it with the section symbol. */
794 if (S_FORCE_RELOC (fixp
->fx_addsy
, 1))
797 /* Is there some other (target cpu dependent) reason we can't adjust
798 this one? (E.g. relocations involving function addresses on
800 #ifdef tc_fix_adjustable
801 if (! tc_fix_adjustable (fixp
))
805 /* Since we're reducing to section symbols, don't attempt to reduce
806 anything that's already using one. */
807 if (symbol_section_p (sym
))
810 symsec
= S_GET_SEGMENT (sym
);
814 if (bfd_is_abs_section (symsec
))
816 /* The fixup_segment routine normally will not use this
817 symbol in a relocation. */
821 /* Don't try to reduce relocs which refer to non-local symbols
822 in .linkonce sections. It can lead to confusion when a
823 debugging section refers to a .linkonce section. I hope
824 this will always be correct. */
825 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
827 if ((symsec
->flags
& SEC_LINK_ONCE
) != 0
829 /* The GNU toolchain uses an extension for ELF: a
830 section beginning with the magic string
831 .gnu.linkonce is a linkonce section. */
832 && strncmp (segment_name (symsec
), ".gnu.linkonce",
833 sizeof ".gnu.linkonce" - 1) == 0))
837 /* Never adjust a reloc against local symbol in a merge section
838 with non-zero addend. */
839 if ((symsec
->flags
& SEC_MERGE
) != 0
840 && (fixp
->fx_offset
!= 0 || fixp
->fx_subsy
!= NULL
))
843 /* Never adjust a reloc against TLS local symbol. */
844 if ((symsec
->flags
& SEC_THREAD_LOCAL
) != 0)
847 /* We refetch the segment when calling section_symbol, rather
848 than using symsec, because S_GET_VALUE may wind up changing
849 the section when it calls resolve_symbol_value. */
850 fixp
->fx_offset
+= S_GET_VALUE (sym
);
851 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
853 fprintf (stderr
, "\nadjusted fixup:\n");
858 dump_section_relocs (abfd
, sec
, stderr
);
863 Go through all the fixS's in a segment and see which ones can be
864 handled now. (These consist of fixS where we have since discovered
865 the value of a symbol, or the address of the frag involved.)
866 For each one, call md_apply_fix to put the fix into the frag data.
868 Result is a count of how many relocation structs will be needed to
869 handle the remaining fixS's that we couldn't completely handle here.
870 These will be output later by emit_relocations(). */
873 fixup_segment (fixS
*fixP
, segT this_segment
)
875 long seg_reloc_count
= 0;
878 segT add_symbol_segment
= absolute_section
;
880 if (fixP
!= NULL
&& abs_section_sym
== NULL
)
881 abs_section_sym
= section_symbol (absolute_section
);
883 /* If the linker is doing the relaxing, we must not do any fixups.
885 Well, strictly speaking that's not true -- we could do any that
886 are PC-relative and don't cross regions that could change size.
887 And for the i960 we might be able to turn callx/callj into bal
888 anyways in cases where we know the maximum displacement. */
889 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment
))
891 for (; fixP
; fixP
= fixP
->fx_next
)
894 if (fixP
->fx_addsy
== NULL
)
896 /* There was no symbol required by this relocation.
897 However, BFD doesn't really handle relocations
898 without symbols well. So fake up a local symbol in
899 the absolute section. */
900 fixP
->fx_addsy
= abs_section_sym
;
902 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
903 if (fixP
->fx_subsy
!= NULL
)
904 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
907 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
908 return seg_reloc_count
;
911 for (; fixP
; fixP
= fixP
->fx_next
)
914 fprintf (stderr
, "\nprocessing fixup:\n");
918 fragP
= fixP
->fx_frag
;
920 #ifdef TC_VALIDATE_FIX
921 TC_VALIDATE_FIX (fixP
, this_segment
, skip
);
923 add_number
= fixP
->fx_offset
;
925 if (fixP
->fx_addsy
!= NULL
)
926 add_symbol_segment
= S_GET_SEGMENT (fixP
->fx_addsy
);
928 if (fixP
->fx_subsy
!= NULL
)
930 segT sub_symbol_segment
;
931 resolve_symbol_value (fixP
->fx_subsy
);
932 sub_symbol_segment
= S_GET_SEGMENT (fixP
->fx_subsy
);
933 if (fixP
->fx_addsy
!= NULL
934 && sub_symbol_segment
== add_symbol_segment
935 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
936 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
937 && !TC_FORCE_RELOCATION_SUB_SAME (fixP
, add_symbol_segment
))
939 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
940 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
941 fixP
->fx_offset
= add_number
;
942 fixP
->fx_addsy
= NULL
;
943 fixP
->fx_subsy
= NULL
;
945 /* See the comment below about 68k weirdness. */
949 else if (sub_symbol_segment
== absolute_section
950 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
951 && !TC_FORCE_RELOCATION_SUB_ABS (fixP
, add_symbol_segment
))
953 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
954 fixP
->fx_offset
= add_number
;
955 fixP
->fx_subsy
= NULL
;
957 else if (sub_symbol_segment
== this_segment
958 && !S_FORCE_RELOC (fixP
->fx_subsy
, 0)
959 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP
, add_symbol_segment
))
961 add_number
-= S_GET_VALUE (fixP
->fx_subsy
);
962 fixP
->fx_offset
= (add_number
+ fixP
->fx_dot_value
963 + fixP
->fx_frag
->fr_address
);
965 /* Make it pc-relative. If the back-end code has not
966 selected a pc-relative reloc, cancel the adjustment
967 we do later on all pc-relative relocs. */
970 /* Do this for m68k even if it's already described
971 as pc-relative. On the m68k, an operand of
972 "pc@(foo-.-2)" should address "foo" in a
977 add_number
+= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
978 fixP
->fx_subsy
= NULL
;
981 else if (!TC_VALIDATE_FIX_SUB (fixP
, add_symbol_segment
))
983 if (!md_register_arithmetic
984 && (add_symbol_segment
== reg_section
985 || sub_symbol_segment
== reg_section
))
986 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
987 _("register value used as expression"));
989 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
990 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
991 fixP
->fx_addsy
? S_GET_NAME (fixP
->fx_addsy
) : "0",
992 segment_name (add_symbol_segment
),
993 S_GET_NAME (fixP
->fx_subsy
),
994 segment_name (sub_symbol_segment
));
1000 if (add_symbol_segment
== this_segment
1001 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1002 && !TC_FORCE_RELOCATION_LOCAL (fixP
))
1004 /* This fixup was made when the symbol's segment was
1005 SEG_UNKNOWN, but it is now in the local segment.
1006 So we know how to do the address without relocation. */
1007 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1008 fixP
->fx_offset
= add_number
;
1010 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1011 fixP
->fx_addsy
= NULL
;
1014 else if (add_symbol_segment
== absolute_section
1015 && !S_FORCE_RELOC (fixP
->fx_addsy
, 0)
1016 && !TC_FORCE_RELOCATION_ABS (fixP
))
1018 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1019 fixP
->fx_offset
= add_number
;
1020 fixP
->fx_addsy
= NULL
;
1022 else if (add_symbol_segment
!= undefined_section
1023 && ! bfd_is_com_section (add_symbol_segment
)
1024 && MD_APPLY_SYM_VALUE (fixP
))
1025 add_number
+= S_GET_VALUE (fixP
->fx_addsy
);
1030 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment
);
1031 if (!fixP
->fx_done
&& fixP
->fx_addsy
== NULL
)
1033 /* There was no symbol required by this relocation.
1034 However, BFD doesn't really handle relocations
1035 without symbols well. So fake up a local symbol in
1036 the absolute section. */
1037 fixP
->fx_addsy
= abs_section_sym
;
1042 md_apply_fix (fixP
, &add_number
, this_segment
);
1047 if (fixP
->fx_addsy
== NULL
)
1048 fixP
->fx_addsy
= abs_section_sym
;
1049 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
1050 if (fixP
->fx_subsy
!= NULL
)
1051 symbol_mark_used_in_reloc (fixP
->fx_subsy
);
1054 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& fixP
->fx_size
!= 0)
1056 if (fixP
->fx_size
< sizeof (valueT
))
1061 mask
--; /* Set all bits to one. */
1062 mask
<<= fixP
->fx_size
* 8 - (fixP
->fx_signed
? 1 : 0);
1063 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
1065 char buf
[50], buf2
[50];
1066 sprint_value (buf
, fragP
->fr_address
+ fixP
->fx_where
);
1067 if (add_number
> 1000)
1068 sprint_value (buf2
, add_number
);
1070 sprintf (buf2
, "%ld", (long) add_number
);
1071 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1072 _("value of %s too large for field of %d bytes at %s"),
1073 buf2
, fixP
->fx_size
, buf
);
1074 } /* Generic error checking. */
1076 #ifdef WARN_SIGNED_OVERFLOW_WORD
1077 /* Warn if a .word value is too large when treated as a signed
1078 number. We already know it is not too negative. This is to
1079 catch over-large switches generated by gcc on the 68k. */
1080 if (!flag_signed_overflow_ok
1081 && fixP
->fx_size
== 2
1082 && add_number
> 0x7fff)
1083 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1084 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1086 (long) (fragP
->fr_address
+ fixP
->fx_where
));
1088 } /* Not a bit fix. */
1090 #ifdef TC_VALIDATE_FIX
1091 skip
: ATTRIBUTE_UNUSED_LABEL
1095 fprintf (stderr
, "result:\n");
1098 } /* For each fixS in this segment. */
1100 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
1101 return seg_reloc_count
;
1105 fix_segment (bfd
*abfd ATTRIBUTE_UNUSED
,
1107 void *xxx ATTRIBUTE_UNUSED
)
1109 segment_info_type
*seginfo
= seg_info (sec
);
1111 fixup_segment (seginfo
->fix_root
, sec
);
1115 install_reloc (asection
*sec
, arelent
*reloc
, fragS
*fragp
,
1116 char *file
, unsigned int line
)
1119 bfd_reloc_status_type s
;
1122 if (reloc
->sym_ptr_ptr
!= NULL
1123 && (sym
= *reloc
->sym_ptr_ptr
) != NULL
1124 && (sym
->flags
& BSF_KEEP
) == 0
1125 && ((sym
->flags
& BSF_SECTION_SYM
) == 0
1126 || (EMIT_SECTION_SYMBOLS
1127 && !bfd_is_abs_section (sym
->section
))))
1128 as_bad_where (file
, line
, _("redefined symbol cannot be used on reloc"));
1130 s
= bfd_install_relocation (stdoutput
, reloc
,
1131 fragp
->fr_literal
, fragp
->fr_address
,
1137 case bfd_reloc_overflow
:
1138 as_bad_where (file
, line
, _("relocation overflow"));
1140 case bfd_reloc_outofrange
:
1141 as_bad_where (file
, line
, _("relocation out of range"));
1144 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1150 write_relocs (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1152 segment_info_type
*seginfo
= seg_info (sec
);
1155 struct reloc_list
*my_reloc_list
, **rp
, *r
;
1159 /* If seginfo is NULL, we did not create this section; don't do
1160 anything with it. */
1161 if (seginfo
== NULL
)
1165 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
1169 #ifdef RELOC_EXPANSION_POSSIBLE
1170 n
*= MAX_RELOC_EXPANSION
;
1173 /* Extract relocs for this section from reloc_list. */
1175 my_reloc_list
= NULL
;
1176 while ((r
= *rp
) != NULL
)
1178 if (r
->u
.b
.sec
== sec
)
1181 r
->next
= my_reloc_list
;
1189 relocs
= (arelent
**) xcalloc (n
, sizeof (arelent
*));
1192 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1201 fx_size
= fixp
->fx_size
;
1202 slack
= TC_FX_SIZE_SLACK (fixp
);
1204 fx_size
= fx_size
> slack
? fx_size
- slack
: 0;
1205 loc
= fixp
->fx_where
+ fx_size
;
1206 if (slack
>= 0 && loc
> fixp
->fx_frag
->fr_fix
)
1207 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1208 _("internal error: fixup not contained within frag"));
1210 #ifndef RELOC_EXPANSION_POSSIBLE
1212 arelent
*reloc
= tc_gen_reloc (sec
, fixp
);
1216 relocs
[i
++] = reloc
;
1221 arelent
**reloc
= tc_gen_reloc (sec
, fixp
);
1223 for (j
= 0; reloc
[j
]; j
++)
1224 relocs
[i
++] = reloc
[j
];
1228 for ( ; j
!= 0; --j
)
1229 install_reloc (sec
, relocs
[i
- j
], fixp
->fx_frag
,
1230 fixp
->fx_file
, fixp
->fx_line
);
1236 unsigned int i
, j
, nsyms
;
1238 sympp
= bfd_get_outsymbols (stdoutput
);
1239 nsyms
= bfd_get_symcount (stdoutput
);
1240 for (i
= 0; i
< n
; i
++)
1241 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1243 for (j
= 0; j
< nsyms
; j
++)
1244 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
1252 for (r
= my_reloc_list
; r
!= NULL
; r
= r
->next
)
1255 for (f
= seginfo
->frchainP
->frch_root
; f
; f
= f
->fr_next
)
1256 if (f
->fr_address
<= r
->u
.b
.r
.address
1257 && r
->u
.b
.r
.address
< f
->fr_address
+ f
->fr_fix
)
1260 as_bad_where (r
->file
, r
->line
,
1261 _("reloc not within (fixed part of) section"));
1264 relocs
[n
++] = &r
->u
.b
.r
;
1265 install_reloc (sec
, &r
->u
.b
.r
, f
, r
->file
, r
->line
);
1271 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1273 bfd_set_section_flags (abfd
, sec
, flags
);
1274 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1277 #ifdef SET_SECTION_RELOCS
1278 SET_SECTION_RELOCS (sec
, relocs
, n
);
1286 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1287 for (i
= 0; i
< n
; i
++)
1290 s
= *r
->sym_ptr_ptr
;
1291 fprintf (stderr
, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1292 i
, r
, (unsigned long)r
->address
, s
->name
, (unsigned long)r
->addend
);
1299 compress_frag (struct z_stream_s
*strm
, const char *contents
, int in_size
,
1300 fragS
**last_newf
, struct obstack
*ob
)
1303 int total_out_size
= 0;
1304 fragS
*f
= *last_newf
;
1308 /* Call the compression routine repeatedly until it has finished
1309 processing the frag. */
1312 /* Reserve all the space available in the current chunk.
1313 If none is available, start a new frag. */
1314 avail_out
= obstack_room (ob
);
1317 obstack_finish (ob
);
1318 f
= frag_alloc (ob
);
1319 f
->fr_type
= rs_fill
;
1320 (*last_newf
)->fr_next
= f
;
1322 avail_out
= obstack_room (ob
);
1325 as_fatal (_("can't extend frag"));
1326 next_out
= obstack_next_free (ob
);
1327 obstack_blank_fast (ob
, avail_out
);
1328 out_size
= compress_data (strm
, &contents
, &in_size
,
1329 &next_out
, &avail_out
);
1333 f
->fr_fix
+= out_size
;
1334 total_out_size
+= out_size
;
1336 /* Return unused space. */
1338 obstack_blank_fast (ob
, -avail_out
);
1341 return total_out_size
;
1345 compress_debug (bfd
*abfd
, asection
*sec
, void *xxx ATTRIBUTE_UNUSED
)
1347 segment_info_type
*seginfo
= seg_info (sec
);
1351 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
1352 bfd_size_type uncompressed_size
= (bfd_size_type
) sec
->size
;
1353 bfd_size_type compressed_size
;
1354 const char *section_name
;
1355 char *compressed_name
;
1357 struct z_stream_s
*strm
;
1359 flagword flags
= bfd_get_section_flags (abfd
, sec
);
1362 || (flags
& (SEC_ALLOC
| SEC_HAS_CONTENTS
)) == SEC_ALLOC
)
1365 section_name
= bfd_get_section_name (stdoutput
, sec
);
1366 if (strncmp (section_name
, ".debug_", 7) != 0)
1369 strm
= compress_init ();
1373 /* Create a new frag to contain the "ZLIB" header. */
1374 first_newf
= frag_alloc (ob
);
1375 if (obstack_room (ob
) < 12)
1376 first_newf
= frag_alloc (ob
);
1377 if (obstack_room (ob
) < 12)
1378 as_fatal (_("can't extend frag %u chars"), 12);
1379 last_newf
= first_newf
;
1380 obstack_blank_fast (ob
, 12);
1381 last_newf
->fr_type
= rs_fill
;
1382 last_newf
->fr_fix
= 12;
1383 header
= last_newf
->fr_literal
;
1384 memcpy (header
, "ZLIB", 4);
1385 header
[11] = uncompressed_size
; uncompressed_size
>>= 8;
1386 header
[10] = uncompressed_size
; uncompressed_size
>>= 8;
1387 header
[9] = uncompressed_size
; uncompressed_size
>>= 8;
1388 header
[8] = uncompressed_size
; uncompressed_size
>>= 8;
1389 header
[7] = uncompressed_size
; uncompressed_size
>>= 8;
1390 header
[6] = uncompressed_size
; uncompressed_size
>>= 8;
1391 header
[5] = uncompressed_size
; uncompressed_size
>>= 8;
1392 header
[4] = uncompressed_size
;
1393 compressed_size
= 12;
1395 /* Stream the frags through the compression engine, adding new frags
1396 as necessary to accomodate the compressed output. */
1397 for (f
= seginfo
->frchainP
->frch_root
;
1406 gas_assert (f
->fr_type
== rs_fill
);
1409 out_size
= compress_frag (strm
, f
->fr_literal
, f
->fr_fix
,
1413 compressed_size
+= out_size
;
1415 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1416 fill_size
= f
->fr_var
;
1417 count
= f
->fr_offset
;
1418 gas_assert (count
>= 0);
1419 if (fill_size
&& count
)
1423 out_size
= compress_frag (strm
, fill_literal
, (int) fill_size
,
1427 compressed_size
+= out_size
;
1432 /* Flush the compression state. */
1439 /* Reserve all the space available in the current chunk.
1440 If none is available, start a new frag. */
1441 avail_out
= obstack_room (ob
);
1446 obstack_finish (ob
);
1447 newf
= frag_alloc (ob
);
1448 newf
->fr_type
= rs_fill
;
1449 last_newf
->fr_next
= newf
;
1451 avail_out
= obstack_room (ob
);
1454 as_fatal (_("can't extend frag"));
1455 next_out
= obstack_next_free (ob
);
1456 obstack_blank_fast (ob
, avail_out
);
1457 x
= compress_finish (strm
, &next_out
, &avail_out
, &out_size
);
1461 last_newf
->fr_fix
+= out_size
;
1462 compressed_size
+= out_size
;
1464 /* Return unused space. */
1466 obstack_blank_fast (ob
, -avail_out
);
1472 /* Replace the uncompressed frag list with the compressed frag list. */
1473 seginfo
->frchainP
->frch_root
= first_newf
;
1474 seginfo
->frchainP
->frch_last
= last_newf
;
1476 /* Update the section size and its name. */
1477 x
= bfd_set_section_size (abfd
, sec
, compressed_size
);
1479 compressed_name
= (char *) xmalloc (strlen (section_name
) + 2);
1480 compressed_name
[0] = '.';
1481 compressed_name
[1] = 'z';
1482 strcpy (compressed_name
+ 2, section_name
+ 1);
1483 bfd_section_name (stdoutput
, sec
) = compressed_name
;
1487 write_contents (bfd
*abfd ATTRIBUTE_UNUSED
,
1489 void *xxx ATTRIBUTE_UNUSED
)
1491 segment_info_type
*seginfo
= seg_info (sec
);
1492 addressT offset
= 0;
1495 /* Write out the frags. */
1497 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1500 for (f
= seginfo
->frchainP
->frch_root
;
1509 gas_assert (f
->fr_type
== rs_fill
);
1512 x
= bfd_set_section_contents (stdoutput
, sec
,
1513 f
->fr_literal
, (file_ptr
) offset
,
1514 (bfd_size_type
) f
->fr_fix
);
1516 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1517 bfd_errmsg (bfd_get_error ()));
1518 offset
+= f
->fr_fix
;
1520 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1521 fill_size
= f
->fr_var
;
1522 count
= f
->fr_offset
;
1523 gas_assert (count
>= 0);
1524 if (fill_size
&& count
)
1527 if (fill_size
> sizeof (buf
))
1529 /* Do it the old way. Can this ever happen? */
1532 x
= bfd_set_section_contents (stdoutput
, sec
,
1535 (bfd_size_type
) fill_size
);
1537 as_fatal (_("can't write %s: %s"), stdoutput
->filename
,
1538 bfd_errmsg (bfd_get_error ()));
1539 offset
+= fill_size
;
1544 /* Build a buffer full of fill objects and output it as
1545 often as necessary. This saves on the overhead of
1546 potentially lots of bfd_set_section_contents calls. */
1550 n_per_buf
= sizeof (buf
);
1551 memset (buf
, *fill_literal
, n_per_buf
);
1556 n_per_buf
= sizeof (buf
) / fill_size
;
1557 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1558 memcpy (bufp
, fill_literal
, fill_size
);
1560 for (; count
> 0; count
-= n_per_buf
)
1562 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1563 x
= bfd_set_section_contents
1564 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1565 (bfd_size_type
) n_per_buf
* fill_size
);
1567 as_fatal (_("cannot write to output file"));
1568 offset
+= n_per_buf
* fill_size
;
1576 merge_data_into_text (void)
1578 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1579 seg_info (data_section
)->frchainP
->frch_root
;
1580 seg_info (text_section
)->frchainP
->frch_last
=
1581 seg_info (data_section
)->frchainP
->frch_last
;
1582 seg_info (data_section
)->frchainP
= 0;
1593 /* Count symbols. We can't rely on a count made by the loop in
1594 write_object_file, because *_frob_file may add a new symbol or
1597 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1603 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1605 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1606 symp
= symbol_rootP
;
1607 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1609 asympp
[i
] = symbol_get_bfdsym (symp
);
1610 if (asympp
[i
]->flags
!= BSF_SECTION_SYM
1611 || !(bfd_is_const_section (asympp
[i
]->section
)
1612 && asympp
[i
]->section
->symbol
== asympp
[i
]))
1613 asympp
[i
]->flags
|= BSF_KEEP
;
1614 symbol_mark_written (symp
);
1619 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1620 gas_assert (result
);
1621 symbol_table_frozen
= 1;
1624 /* Finish the subsegments. After every sub-segment, we fake an
1625 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1626 ".fill 0" because that is the kind of frag that requires least
1627 thought. ".align" frags like to have a following frag since that
1628 makes calculating their intended length trivial. */
1630 #ifndef SUB_SEGMENT_ALIGN
1632 /* The last subsegment gets an alignment corresponding to the alignment
1633 of the section. This allows proper nop-filling at the end of
1634 code-bearing sections. */
1635 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1636 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1638 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1643 subsegs_finish (void)
1645 struct frchain
*frchainP
;
1648 for (s
= stdoutput
->sections
; s
; s
= s
->next
)
1650 segment_info_type
*seginfo
= seg_info (s
);
1654 for (frchainP
= seginfo
->frchainP
;
1656 frchainP
= frchainP
->frch_next
)
1660 subseg_set (s
, frchainP
->frch_subseg
);
1662 /* This now gets called even if we had errors. In that case,
1663 any alignment is meaningless, and, moreover, will look weird
1664 if we are generating a listing. */
1667 alignment
= SUB_SEGMENT_ALIGN (now_seg
, frchainP
);
1668 if ((bfd_get_section_flags (now_seg
->owner
, now_seg
) & SEC_MERGE
)
1669 && now_seg
->entsize
)
1671 unsigned int entsize
= now_seg
->entsize
;
1674 while ((entsize
& 1) == 0)
1679 if (entalign
> alignment
)
1680 alignment
= entalign
;
1684 if (subseg_text_p (now_seg
))
1685 frag_align_code (alignment
, 0);
1687 frag_align (alignment
, 0, 0);
1689 /* frag_align will have left a new frag.
1690 Use this last frag for an empty ".fill".
1692 For this segment ...
1693 Create a last frag. Do not leave a "being filled in frag". */
1694 frag_wane (frag_now
);
1695 frag_now
->fr_fix
= 0;
1696 know (frag_now
->fr_next
== NULL
);
1701 /* Write the object file. */
1704 write_object_file (void)
1706 struct relax_seg_info rsi
;
1707 #ifndef WORKING_DOT_WORD
1708 fragS
*fragP
; /* Track along all frags. */
1711 /* Do we really want to write it? */
1713 int n_warns
, n_errs
;
1714 n_warns
= had_warnings ();
1715 n_errs
= had_errors ();
1716 /* The -Z flag indicates that an object file should be generated,
1717 regardless of warnings and errors. */
1718 if (flag_always_generate_output
)
1720 if (n_warns
|| n_errs
)
1721 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1722 n_errs
, n_errs
== 1 ? "" : "s",
1723 n_warns
, n_warns
== 1 ? "" : "s");
1728 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1729 n_errs
, n_errs
== 1 ? "" : "s",
1730 n_warns
, n_warns
== 1 ? "" : "s");
1735 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1736 a routine to check for the definition of the procedure "_main",
1737 and if so -- fix it up so that it can be program entry point. */
1738 vms_check_for_main ();
1739 #endif /* OBJ_VMS */
1741 /* From now on, we don't care about sub-segments. Build one frag chain
1742 for each segment. Linked thru fr_next. */
1744 /* Remove the sections created by gas for its own purposes. */
1748 bfd_section_list_remove (stdoutput
, reg_section
);
1749 bfd_section_list_remove (stdoutput
, expr_section
);
1750 stdoutput
->section_count
-= 2;
1752 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1755 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1757 /* We have two segments. If user gave -R flag, then we must put the
1758 data frags into the text segment. Do this before relaxing so
1759 we know to take advantage of -R and make shorter addresses. */
1760 if (flag_readonly_data_in_text
)
1762 merge_data_into_text ();
1768 #ifndef WORKING_DOT_WORD
1769 /* We need to reset the markers in the broken word list and
1770 associated frags between calls to relax_segment (via
1771 relax_seg). Since the broken word list is global, we do it
1772 once per round, rather than locally in relax_segment for each
1774 struct broken_word
*brokp
;
1776 for (brokp
= broken_words
;
1777 brokp
!= (struct broken_word
*) NULL
;
1778 brokp
= brokp
->next_broken_word
)
1782 if (brokp
->dispfrag
!= (fragS
*) NULL
1783 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1784 brokp
->dispfrag
->fr_subtype
= 0;
1789 bfd_map_over_sections (stdoutput
, relax_seg
, &rsi
);
1795 /* Note - Most ports will use the default value of
1796 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1797 local symbols to be resolved, removing their frag information.
1798 Some ports however, will not have finished relaxing all of
1799 their frags and will still need the local symbol frag
1800 information. These ports can set
1801 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1802 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1804 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1806 /* Relaxation has completed. Freeze all syms. */
1809 #ifdef md_post_relax_hook
1813 #ifndef WORKING_DOT_WORD
1815 struct broken_word
*lie
;
1816 struct broken_word
**prevP
;
1818 prevP
= &broken_words
;
1819 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1824 subseg_change (lie
->seg
, lie
->subseg
);
1825 exp
.X_op
= O_subtract
;
1826 exp
.X_add_symbol
= lie
->add
;
1827 exp
.X_op_symbol
= lie
->sub
;
1828 exp
.X_add_number
= lie
->addnum
;
1829 #ifdef TC_CONS_FIX_NEW
1830 TC_CONS_FIX_NEW (lie
->frag
,
1831 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1834 fix_new_exp (lie
->frag
,
1835 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1836 2, &exp
, 0, BFD_RELOC_16
);
1838 *prevP
= lie
->next_broken_word
;
1841 prevP
= &(lie
->next_broken_word
);
1843 for (lie
= broken_words
; lie
;)
1845 struct broken_word
*untruth
;
1847 addressT table_addr
;
1848 addressT from_addr
, to_addr
;
1851 subseg_change (lie
->seg
, lie
->subseg
);
1852 fragP
= lie
->dispfrag
;
1854 /* Find out how many broken_words go here. */
1857 untruth
&& untruth
->dispfrag
== fragP
;
1858 untruth
= untruth
->next_broken_word
)
1859 if (untruth
->added
== 1)
1862 table_ptr
= lie
->dispfrag
->fr_opcode
;
1863 table_addr
= (lie
->dispfrag
->fr_address
1864 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1865 /* Create the jump around the long jumps. This is a short
1866 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1867 from_addr
= table_addr
;
1868 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1869 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1871 table_ptr
+= md_short_jump_size
;
1872 table_addr
+= md_short_jump_size
;
1875 lie
&& lie
->dispfrag
== fragP
;
1876 m
++, lie
= lie
->next_broken_word
)
1878 if (lie
->added
== 2)
1880 /* Patch the jump table. */
1881 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
1882 untruth
&& untruth
->dispfrag
== fragP
;
1883 untruth
= untruth
->next_broken_word
)
1885 if (untruth
->use_jump
== lie
)
1887 /* This is the offset from ??? to table_ptr+0.
1888 The target is the same for all users of this
1889 md_long_jump, but the "sub" bases (and hence the
1890 offsets) may be different. */
1891 addressT to_word
= table_addr
- S_GET_VALUE (untruth
->sub
);
1892 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1893 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word
, untruth
);
1895 md_number_to_chars (untruth
->word_goes_here
, to_word
, 2);
1899 /* Install the long jump. */
1900 /* This is a long jump from table_ptr+0 to the final target. */
1901 from_addr
= table_addr
;
1902 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1903 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1905 table_ptr
+= md_long_jump_size
;
1906 table_addr
+= md_long_jump_size
;
1910 #endif /* not WORKING_DOT_WORD */
1912 /* Resolve symbol values. This needs to be done before processing
1918 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1919 resolve_symbol_value (symp
);
1921 resolve_local_symbol_values ();
1922 resolve_reloc_expr_symbols ();
1926 #ifdef tc_frob_file_before_adjust
1927 tc_frob_file_before_adjust ();
1929 #ifdef obj_frob_file_before_adjust
1930 obj_frob_file_before_adjust ();
1933 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1935 #ifdef tc_frob_file_before_fix
1936 tc_frob_file_before_fix ();
1938 #ifdef obj_frob_file_before_fix
1939 obj_frob_file_before_fix ();
1942 bfd_map_over_sections (stdoutput
, fix_segment
, (char *) 0);
1944 /* Set up symbol table, and write it out. */
1948 bfd_boolean skip_next_symbol
= FALSE
;
1950 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1955 if (skip_next_symbol
)
1957 /* Don't do anything besides moving the value of the
1958 symbol from the GAS value-field to the BFD value-field. */
1959 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1960 skip_next_symbol
= FALSE
;
1964 if (symbol_mri_common_p (symp
))
1966 if (S_IS_EXTERNAL (symp
))
1967 as_bad (_("%s: global symbols not supported in common sections"),
1969 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1973 name
= S_GET_NAME (symp
);
1977 decode_local_label_name ((char *) S_GET_NAME (symp
));
1978 /* They only differ if `name' is a fb or dollar local
1980 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1981 as_bad (_("local label `%s' is not defined"), name2
);
1984 /* Do it again, because adjust_reloc_syms might introduce
1985 more symbols. They'll probably only be section symbols,
1986 but they'll still need to have the values computed. */
1987 resolve_symbol_value (symp
);
1989 /* Skip symbols which were equated to undefined or common
1991 if (symbol_equated_reloc_p (symp
)
1992 || S_IS_WEAKREFR (symp
))
1994 const char *sname
= S_GET_NAME (symp
);
1996 if (S_IS_COMMON (symp
)
1997 && !TC_FAKE_LABEL (sname
)
1998 && !S_IS_WEAKREFR (symp
)
1999 && (!S_IS_EXTERNAL (symp
) || S_IS_LOCAL (symp
)))
2001 expressionS
*e
= symbol_get_value_expression (symp
);
2003 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2004 sname
, S_GET_NAME (e
->X_add_symbol
));
2006 if (S_GET_SEGMENT (symp
) == reg_section
)
2008 /* Report error only if we know the symbol name. */
2009 if (S_GET_NAME (symp
) != reg_section
->name
)
2010 as_bad (_("can't make global register symbol `%s'"),
2013 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2017 #ifdef obj_frob_symbol
2018 obj_frob_symbol (symp
, punt
);
2020 #ifdef tc_frob_symbol
2021 if (! punt
|| symbol_used_in_reloc_p (symp
))
2022 tc_frob_symbol (symp
, punt
);
2025 /* If we don't want to keep this symbol, splice it out of
2026 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2027 want section symbols. Otherwise, we skip local symbols
2028 and symbols that the frob_symbol macros told us to punt,
2029 but we keep such symbols if they are used in relocs. */
2030 if (symp
== abs_section_sym
2031 || (! EMIT_SECTION_SYMBOLS
2032 && symbol_section_p (symp
))
2033 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2034 opposites. Sometimes the former checks flags and the
2035 latter examines the name... */
2036 || (!S_IS_EXTERNAL (symp
)
2037 && (punt
|| S_IS_LOCAL (symp
) ||
2038 (S_IS_WEAKREFD (symp
) && ! symbol_used_p (symp
)))
2039 && ! symbol_used_in_reloc_p (symp
)))
2041 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2043 /* After symbol_remove, symbol_next(symp) still returns
2044 the one that came after it in the chain. So we don't
2045 need to do any extra cleanup work here. */
2049 /* Make sure we really got a value for the symbol. */
2050 if (! symbol_resolved_p (symp
))
2052 as_bad (_("can't resolve value for symbol `%s'"),
2054 symbol_mark_resolved (symp
);
2057 /* Set the value into the BFD symbol. Up til now the value
2058 has only been kept in the gas symbolS struct. */
2059 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2061 /* A warning construct is a warning symbol followed by the
2062 symbol warned about. Don't let anything object-format or
2063 target-specific muck with it; it's ready for output. */
2064 if (symbol_get_bfdsym (symp
)->flags
& BSF_WARNING
)
2065 skip_next_symbol
= TRUE
;
2071 /* Now do any format-specific adjustments to the symbol table, such
2072 as adding file symbols. */
2073 #ifdef tc_adjust_symtab
2074 tc_adjust_symtab ();
2076 #ifdef obj_adjust_symtab
2077 obj_adjust_symtab ();
2080 /* Stop if there is an error. */
2084 /* Now that all the sizes are known, and contents correct, we can
2085 start writing to the file. */
2088 /* If *_frob_file changes the symbol value at this point, it is
2089 responsible for moving the changed value into symp->bsym->value
2090 as well. Hopefully all symbol value changing can be done in
2095 #ifdef obj_frob_file
2098 #ifdef obj_coff_generate_pdata
2099 obj_coff_generate_pdata ();
2101 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2103 #ifdef tc_frob_file_after_relocs
2104 tc_frob_file_after_relocs ();
2106 #ifdef obj_frob_file_after_relocs
2107 obj_frob_file_after_relocs ();
2110 /* Once all relocations have been written, we can compress the
2111 contents of the debug sections. This needs to be done before
2112 we start writing any sections, because it will affect the file
2113 layout, which is fixed once we start writing contents. */
2114 if (flag_compress_debug
)
2115 bfd_map_over_sections (stdoutput
, compress_debug
, (char *) 0);
2117 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2120 #ifdef TC_GENERIC_RELAX_TABLE
2121 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2124 relax_frag (segT segment
, fragS
*fragP
, long stretch
)
2126 const relax_typeS
*this_type
;
2127 const relax_typeS
*start_type
;
2128 relax_substateT next_state
;
2129 relax_substateT this_state
;
2135 const relax_typeS
*table
;
2137 target
= fragP
->fr_offset
;
2138 address
= fragP
->fr_address
;
2139 table
= TC_GENERIC_RELAX_TABLE
;
2140 this_state
= fragP
->fr_subtype
;
2141 start_type
= this_type
= table
+ this_state
;
2142 symbolP
= fragP
->fr_symbol
;
2148 sym_frag
= symbol_get_frag (symbolP
);
2150 #ifndef DIFF_EXPR_OK
2151 know (sym_frag
!= NULL
);
2153 know (S_GET_SEGMENT (symbolP
) != absolute_section
2154 || sym_frag
== &zero_address_frag
);
2155 target
+= S_GET_VALUE (symbolP
);
2157 /* If SYM_FRAG has yet to be reached on this pass, assume it
2158 will move by STRETCH just as we did, unless there is an
2159 alignment frag between here and SYM_FRAG. An alignment may
2160 well absorb any STRETCH, and we don't want to choose a larger
2161 branch insn by overestimating the needed reach of this
2162 branch. It isn't critical to calculate TARGET exactly; We
2163 know we'll be doing another pass if STRETCH is non-zero. */
2166 && sym_frag
->relax_marker
!= fragP
->relax_marker
2167 && S_GET_SEGMENT (symbolP
) == segment
)
2170 || sym_frag
->region
== fragP
->region
)
2172 /* If we get here we know we have a forward branch. This
2173 relax pass may have stretched previous instructions so
2174 far that omitting STRETCH would make the branch
2175 negative. Don't allow this in case the negative reach is
2176 large enough to require a larger branch instruction. */
2177 else if (target
< address
)
2178 target
= fragP
->fr_next
->fr_address
+ stretch
;
2182 aim
= target
- address
- fragP
->fr_fix
;
2183 #ifdef TC_PCREL_ADJUST
2184 /* Currently only the ns32k family needs this. */
2185 aim
+= TC_PCREL_ADJUST (fragP
);
2188 #ifdef md_prepare_relax_scan
2189 /* Formerly called M68K_AIM_KLUDGE. */
2190 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2195 /* Look backwards. */
2196 for (next_state
= this_type
->rlx_more
; next_state
;)
2197 if (aim
>= this_type
->rlx_backward
)
2201 /* Grow to next state. */
2202 this_state
= next_state
;
2203 this_type
= table
+ this_state
;
2204 next_state
= this_type
->rlx_more
;
2209 /* Look forwards. */
2210 for (next_state
= this_type
->rlx_more
; next_state
;)
2211 if (aim
<= this_type
->rlx_forward
)
2215 /* Grow to next state. */
2216 this_state
= next_state
;
2217 this_type
= table
+ this_state
;
2218 next_state
= this_type
->rlx_more
;
2222 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2224 fragP
->fr_subtype
= this_state
;
2228 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2230 /* Relax_align. Advance location counter to next address that has 'alignment'
2231 lowest order bits all 0s, return size of adjustment made. */
2232 static relax_addressT
2233 relax_align (register relax_addressT address
, /* Address now. */
2234 register int alignment
/* Alignment (binary). */)
2236 relax_addressT mask
;
2237 relax_addressT new_address
;
2239 mask
= ~((~0) << alignment
);
2240 new_address
= (address
+ mask
) & (~mask
);
2241 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2243 /* We must provide lots of padding, so the linker can discard it
2244 when needed. The linker will not add extra space, ever. */
2245 new_address
+= (1 << alignment
);
2247 return (new_address
- address
);
2250 /* Now we have a segment, not a crowd of sub-segments, we can make
2255 After this, all frags in this segment have addresses that are correct
2256 within the segment. Since segments live in different file addresses,
2257 these frag addresses may not be the same as final object-file
2261 relax_segment (struct frag
*segment_frag_root
, segT segment
, int pass
)
2263 unsigned long frag_count
;
2265 relax_addressT address
;
2269 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2270 subseg_change (segment
, 0);
2272 /* For each frag in segment: count and store (a 1st guess of)
2276 for (frag_count
= 0, fragP
= segment_frag_root
;
2278 fragP
= fragP
->fr_next
, frag_count
++)
2280 fragP
->region
= region
;
2281 fragP
->relax_marker
= 0;
2282 fragP
->fr_address
= address
;
2283 address
+= fragP
->fr_fix
;
2285 switch (fragP
->fr_type
)
2288 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2295 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2297 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2300 if (offset
% fragP
->fr_var
!= 0)
2302 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2303 _("alignment padding (%lu bytes) not a multiple of %ld"),
2304 (unsigned long) offset
, (long) fragP
->fr_var
);
2305 offset
-= (offset
% fragP
->fr_var
);
2314 /* Assume .org is nugatory. It will grow with 1st relax. */
2321 case rs_machine_dependent
:
2322 /* If fr_symbol is an expression, this call to
2323 resolve_symbol_value sets up the correct segment, which will
2324 likely be needed in md_estimate_size_before_relax. */
2325 if (fragP
->fr_symbol
)
2326 resolve_symbol_value (fragP
->fr_symbol
);
2328 address
+= md_estimate_size_before_relax (fragP
, segment
);
2331 #ifndef WORKING_DOT_WORD
2332 /* Broken words don't concern us yet. */
2333 case rs_broken_word
:
2338 /* Initial guess is always 1; doing otherwise can result in
2339 stable solutions that are larger than the minimum. */
2340 address
+= fragP
->fr_offset
= 1;
2344 address
+= eh_frame_estimate_size_before_relax (fragP
);
2348 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2352 BAD_CASE (fragP
->fr_type
);
2359 unsigned long max_iterations
;
2361 /* Cumulative address adjustment. */
2364 /* Have we made any adjustment this pass? We can't just test
2365 stretch because one piece of code may have grown and another
2369 /* Most horrible, but gcc may give us some exception data that
2370 is impossible to assemble, of the form
2374 .uleb128 end - start
2380 If the leb128 is two bytes in size, then end-start is 128*128,
2381 which requires a three byte leb128. If the leb128 is three
2382 bytes in size, then end-start is 128*128-1, which requires a
2383 two byte leb128. We work around this dilemma by inserting
2384 an extra 4 bytes of alignment just after the .align. This
2385 works because the data after the align is accessed relative to
2388 This counter is used in a tiny state machine to detect
2389 whether a leb128 followed by an align is impossible to
2391 int rs_leb128_fudge
= 0;
2393 /* We want to prevent going into an infinite loop where one frag grows
2394 depending upon the location of a symbol which is in turn moved by
2395 the growing frag. eg:
2401 So we dictate that this algorithm can be at most O2. */
2402 max_iterations
= frag_count
* frag_count
;
2403 /* Check for overflow. */
2404 if (max_iterations
< frag_count
)
2405 max_iterations
= frag_count
;
2413 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2416 addressT was_address
;
2420 fragP
->relax_marker
^= 1;
2421 was_address
= fragP
->fr_address
;
2422 address
= fragP
->fr_address
+= stretch
;
2423 symbolP
= fragP
->fr_symbol
;
2424 offset
= fragP
->fr_offset
;
2426 switch (fragP
->fr_type
)
2428 case rs_fill
: /* .fill never relaxes. */
2432 #ifndef WORKING_DOT_WORD
2433 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2434 for it I do not want to write it. I do not want to have
2435 anything to do with it. This is not the proper way to
2436 implement this misfeature. */
2437 case rs_broken_word
:
2439 struct broken_word
*lie
;
2440 struct broken_word
*untruth
;
2442 /* Yes this is ugly (storing the broken_word pointer
2443 in the symbol slot). Still, this whole chunk of
2444 code is ugly, and I don't feel like doing anything
2445 about it. Think of it as stubbornness in action. */
2447 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2448 lie
&& lie
->dispfrag
== fragP
;
2449 lie
= lie
->next_broken_word
)
2455 offset
= (S_GET_VALUE (lie
->add
)
2457 - S_GET_VALUE (lie
->sub
));
2458 if (offset
<= -32768 || offset
>= 32767)
2460 if (flag_warn_displacement
)
2463 sprint_value (buf
, (addressT
) lie
->addnum
);
2464 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2465 _(".word %s-%s+%s didn't fit"),
2466 S_GET_NAME (lie
->add
),
2467 S_GET_NAME (lie
->sub
),
2470 if (fragP
->fr_subtype
== 0)
2472 fragP
->fr_subtype
++;
2473 growth
+= md_short_jump_size
;
2476 /* Redirect *all* words of this table with the same
2477 target, lest we have to handle the case where the
2478 same target but with a offset that fits on this
2479 round overflows at the next relaxation round. */
2480 for (untruth
= (struct broken_word
*) (fragP
->fr_symbol
);
2481 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2482 untruth
= untruth
->next_broken_word
)
2483 if ((symbol_get_frag (untruth
->add
)
2484 == symbol_get_frag (lie
->add
))
2485 && (S_GET_VALUE (untruth
->add
)
2486 == S_GET_VALUE (lie
->add
)))
2489 untruth
->use_jump
= lie
;
2493 growth
+= md_long_jump_size
;
2498 } /* case rs_broken_word */
2504 addressT oldoff
, newoff
;
2506 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2508 newoff
= relax_align (address
+ fragP
->fr_fix
,
2511 if (fragP
->fr_subtype
!= 0)
2513 if (oldoff
> fragP
->fr_subtype
)
2515 if (newoff
> fragP
->fr_subtype
)
2519 growth
= newoff
- oldoff
;
2521 /* If this align happens to follow a leb128 and
2522 we have determined that the leb128 is bouncing
2523 in size, then break the cycle by inserting an
2526 && (rs_leb128_fudge
& 16) != 0
2527 && (rs_leb128_fudge
& 15) >= 2)
2529 segment_info_type
*seginfo
= seg_info (segment
);
2530 struct obstack
*ob
= &seginfo
->frchainP
->frch_obstack
;
2533 newf
= frag_alloc (ob
);
2534 obstack_blank_fast (ob
, fragP
->fr_var
);
2535 obstack_finish (ob
);
2536 memcpy (newf
, fragP
, SIZEOF_STRUCT_FRAG
);
2537 memcpy (newf
->fr_literal
,
2538 fragP
->fr_literal
+ fragP
->fr_fix
,
2540 newf
->fr_type
= rs_fill
;
2541 newf
->fr_address
= address
+ fragP
->fr_fix
+ newoff
;
2543 newf
->fr_offset
= (((offsetT
) 1 << fragP
->fr_offset
)
2545 if (newf
->fr_offset
* newf
->fr_var
2546 != (offsetT
) 1 << fragP
->fr_offset
)
2548 newf
->fr_offset
= (offsetT
) 1 << fragP
->fr_offset
;
2551 /* Include size of new frag in GROWTH. */
2552 growth
+= newf
->fr_offset
* newf
->fr_var
;
2553 /* Adjust the new frag address for the amount
2554 we'll add when we process the new frag. */
2555 newf
->fr_address
-= stretch
+ growth
;
2556 newf
->relax_marker
^= 1;
2557 fragP
->fr_next
= newf
;
2559 as_warn (_("padding added"));
2567 addressT target
= offset
;
2572 /* Convert from an actual address to an octet offset
2573 into the section. Here it is assumed that the
2574 section's VMA is zero, and can omit subtracting it
2575 from the symbol's value to get the address offset. */
2576 know (S_GET_SEGMENT (symbolP
)->vma
== 0);
2577 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2580 know (fragP
->fr_next
);
2581 after
= fragP
->fr_next
->fr_address
+ stretch
;
2582 growth
= target
- after
;
2587 /* Don't error on first few frag relax passes.
2588 The symbol might be an expression involving
2589 symbol values from other sections. If those
2590 sections have not yet been processed their
2591 frags will all have zero addresses, so we
2592 will calculate incorrect values for them. The
2593 number of passes we allow before giving an
2594 error is somewhat arbitrary. It should be at
2595 least one, with larger values requiring
2596 increasingly contrived dependencies between
2597 frags to trigger a false error. */
2600 /* Force another pass. */
2605 /* Growth may be negative, but variable part of frag
2606 cannot have fewer than 0 chars. That is, we can't
2608 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2609 _("attempt to move .org backwards"));
2611 /* We've issued an error message. Change the
2612 frag to avoid cascading errors. */
2613 fragP
->fr_type
= rs_align
;
2614 fragP
->fr_subtype
= 0;
2615 fragP
->fr_offset
= 0;
2616 fragP
->fr_fix
= after
- address
;
2627 amount
= S_GET_VALUE (symbolP
);
2628 if (S_GET_SEGMENT (symbolP
) != absolute_section
2629 || S_IS_COMMON (symbolP
)
2630 || ! S_IS_DEFINED (symbolP
))
2632 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2633 _(".space specifies non-absolute value"));
2634 /* Prevent repeat of this error message. */
2635 fragP
->fr_symbol
= 0;
2637 else if (amount
< 0)
2639 /* Don't error on first few frag relax passes.
2640 See rs_org comment for a longer explanation. */
2647 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2648 _(".space or .fill with negative value, ignored"));
2649 fragP
->fr_symbol
= 0;
2652 growth
= (was_address
+ fragP
->fr_fix
+ amount
2653 - fragP
->fr_next
->fr_address
);
2657 case rs_machine_dependent
:
2658 #ifdef md_relax_frag
2659 growth
= md_relax_frag (segment
, fragP
, stretch
);
2661 #ifdef TC_GENERIC_RELAX_TABLE
2662 /* The default way to relax a frag is to look through
2663 TC_GENERIC_RELAX_TABLE. */
2664 growth
= relax_frag (segment
, fragP
, stretch
);
2665 #endif /* TC_GENERIC_RELAX_TABLE */
2674 value
= resolve_symbol_value (fragP
->fr_symbol
);
2675 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2676 growth
= size
- fragP
->fr_offset
;
2677 fragP
->fr_offset
= size
;
2682 growth
= eh_frame_relax_frag (fragP
);
2686 growth
= dwarf2dbg_relax_frag (fragP
);
2690 BAD_CASE (fragP
->fr_type
);
2697 if (fragP
->fr_type
== rs_leb128
)
2698 rs_leb128_fudge
+= 16;
2699 else if (fragP
->fr_type
== rs_align
2700 && (rs_leb128_fudge
& 16) != 0
2702 rs_leb128_fudge
+= 16;
2704 rs_leb128_fudge
= 0;
2709 && (rs_leb128_fudge
& 16) == 0
2710 && (rs_leb128_fudge
& -16) != 0)
2711 rs_leb128_fudge
+= 1;
2713 rs_leb128_fudge
= 0;
2715 /* Until nothing further to relax. */
2716 while (stretched
&& -- max_iterations
);
2719 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2720 segment_name (segment
));
2723 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2724 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2726 fragP
->last_fr_address
= fragP
->fr_address
;
2733 number_to_chars_bigendian (char *buf
, valueT val
, int n
)
2739 buf
[n
] = val
& 0xff;
2745 number_to_chars_littleendian (char *buf
, valueT val
, int n
)
2751 *buf
++ = val
& 0xff;
2757 write_print_statistics (FILE *file
)
2759 fprintf (file
, "fixups: %d\n", n_fixups
);
2762 /* For debugging. */
2763 extern int indent_level
;
2766 print_fixup (fixS
*fixp
)
2769 fprintf (stderr
, "fix ");
2770 fprintf_vma (stderr
, (bfd_vma
)((bfd_hostptr_t
) fixp
));
2771 fprintf (stderr
, " %s:%d",fixp
->fx_file
, fixp
->fx_line
);
2773 fprintf (stderr
, " pcrel");
2774 if (fixp
->fx_pcrel_adjust
)
2775 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2776 if (fixp
->fx_im_disp
)
2779 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2781 fprintf (stderr
, " im_disp");
2785 fprintf (stderr
, " tcbit");
2787 fprintf (stderr
, " done");
2788 fprintf (stderr
, "\n size=%d frag=", fixp
->fx_size
);
2789 fprintf_vma (stderr
, (bfd_vma
) ((bfd_hostptr_t
) fixp
->fx_frag
));
2790 fprintf (stderr
, " where=%ld offset=%lx addnumber=%lx",
2791 (long) fixp
->fx_where
,
2792 (unsigned long) fixp
->fx_offset
,
2793 (unsigned long) fixp
->fx_addnumber
);
2794 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2798 fprintf (stderr
, "\n +<");
2799 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2800 fprintf (stderr
, ">");
2804 fprintf (stderr
, "\n -<");
2805 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2806 fprintf (stderr
, ">");
2808 fprintf (stderr
, "\n");
2809 #ifdef TC_FIX_DATA_PRINT
2810 TC_FIX_DATA_PRINT (stderr
, fixp
);