1 /* write.c - emit .o file
2 Copyright (C) 1986-2019 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 unsigned long where, /* Where in that frag? */
147 unsigned long 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 %lu"), 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_pcrel_adjust = 0;
178 fixP->fx_addnumber = 0;
182 fixP->fx_no_overflow = 0;
186 fixP->fx_cgen.insn = NULL;
187 fixP->fx_cgen.opinfo = 0;
191 TC_INIT_FIX_DATA (fixP);
194 fixP->fx_file = as_where (&fixP->fx_line);
198 fixS **seg_fix_rootP = (frags_chained
199 ? &seg_info (now_seg)->fix_root
200 : &frchain_now->fix_root);
201 fixS **seg_fix_tailP = (frags_chained
202 ? &seg_info (now_seg)->fix_tail
203 : &frchain_now->fix_tail);
207 fixP->fx_next = *seg_fix_rootP;
208 *seg_fix_rootP = fixP;
209 if (fixP->fx_next == NULL)
210 *seg_fix_tailP = fixP;
214 fixP->fx_next = NULL;
216 (*seg_fix_tailP)->fx_next = fixP;
218 *seg_fix_rootP = fixP;
219 *seg_fix_tailP = fixP;
226 /* Create a fixup relative to a symbol (plus a constant). */
229 fix_new (fragS *frag, /* Which frag? */
230 unsigned long where, /* Where in that frag? */
231 unsigned long size, /* 1, 2, or 4 usually. */
232 symbolS *add_symbol, /* X_add_symbol. */
233 offsetT offset, /* X_add_number. */
234 int pcrel, /* TRUE if PC-relative relocation. */
235 RELOC_ENUM r_type /* Relocation type. */)
237 return fix_new_internal (frag, where, size, add_symbol,
238 (symbolS *) NULL, offset, pcrel, r_type, FALSE);
241 /* Create a fixup for an expression. Currently we only support fixups
242 for difference expressions. That is itself more than most object
243 file formats support anyhow. */
246 fix_new_exp (fragS *frag, /* Which frag? */
247 unsigned long where, /* Where in that frag? */
248 unsigned long size, /* 1, 2, or 4 usually. */
249 expressionS *exp, /* Expression. */
250 int pcrel, /* TRUE if PC-relative relocation. */
251 RELOC_ENUM r_type /* Relocation type. */)
263 as_bad (_("register value used as expression"));
267 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
268 the difference expression cannot immediately be reduced. */
270 symbolS *stmp = make_expr_symbol (exp);
272 exp->X_op = O_symbol;
273 exp->X_op_symbol = 0;
274 exp->X_add_symbol = stmp;
275 exp->X_add_number = 0;
277 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
281 add = exp->X_add_symbol;
282 off = exp->X_add_number;
283 r_type = BFD_RELOC_RVA;
287 sub = exp->X_add_symbol;
288 off = exp->X_add_number;
292 sub = exp->X_op_symbol;
295 add = exp->X_add_symbol;
298 off = exp->X_add_number;
302 add = make_expr_symbol (exp);
306 return fix_new_internal (frag, where, size, add, sub, off, pcrel,
310 /* Create a fixup at the beginning of FRAG. The arguments are the same
311 as for fix_new, except that WHERE is implicitly 0. */
314 fix_at_start (fragS *frag, unsigned long size, symbolS *add_symbol,
315 offsetT offset, int pcrel, RELOC_ENUM r_type)
317 return fix_new_internal (frag, 0, size, add_symbol,
318 (symbolS *) NULL, offset, pcrel, r_type, TRUE);
321 /* Generic function to determine whether a fixup requires a relocation. */
323 generic_force_reloc (fixS *fix)
325 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
326 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
329 if (fix->fx_addsy == NULL)
332 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
335 /* Append a string onto another string, bumping the pointer along. */
337 append (char **charPP, char *fromP, unsigned long length)
339 /* Don't trust memcpy() of 0 chars. */
343 memcpy (*charPP, fromP, length);
347 /* This routine records the largest alignment seen for each segment.
348 If the beginning of the segment is aligned on the worst-case
349 boundary, all of the other alignments within it will work. At
350 least one object format really uses this info. */
353 record_alignment (/* Segment to which alignment pertains. */
355 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
356 boundary, 2 => 4-byte boundary, etc.) */
359 if (seg == absolute_section)
362 if (align > bfd_get_section_alignment (stdoutput, seg))
363 bfd_set_section_alignment (stdoutput, seg, align);
367 get_recorded_alignment (segT seg)
369 if (seg == absolute_section)
372 return bfd_get_section_alignment (stdoutput, seg);
375 /* Reset the section indices after removing the gas created sections. */
378 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
380 int *countp = (int *) countparg;
382 sec->index = *countp;
387 chain_frchains_together_1 (segT section, struct frchain *frchp)
389 fragS dummy, *prev_frag = &dummy;
390 fixS fix_dummy, *prev_fix = &fix_dummy;
392 for (; frchp; frchp = frchp->frch_next)
394 prev_frag->fr_next = frchp->frch_root;
395 prev_frag = frchp->frch_last;
396 gas_assert (prev_frag->fr_type != 0);
397 if (frchp->fix_root != (fixS *) NULL)
399 if (seg_info (section)->fix_root == (fixS *) NULL)
400 seg_info (section)->fix_root = frchp->fix_root;
401 prev_fix->fx_next = frchp->fix_root;
402 seg_info (section)->fix_tail = frchp->fix_tail;
403 prev_fix = frchp->fix_tail;
406 gas_assert (prev_frag != &dummy
407 && prev_frag->fr_type != 0);
408 prev_frag->fr_next = 0;
413 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
415 void *xxx ATTRIBUTE_UNUSED)
417 segment_info_type *info;
419 /* BFD may have introduced its own sections without using
420 subseg_new, so it is possible that seg_info is NULL. */
421 info = seg_info (section);
422 if (info != (segment_info_type *) NULL)
423 info->frchainP->frch_last
424 = chain_frchains_together_1 (section, info->frchainP);
426 /* Now that we've chained the frags together, we must add new fixups
427 to the segment, not to the frag chain. */
432 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
434 switch (fragP->fr_type)
444 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/.nops backwards? (%ld)"),
455 (long) fragP->fr_offset);
456 fragP->fr_offset = 0;
458 if (fragP->fr_type == rs_space_nop)
459 fragP->fr_type = rs_fill_nop;
461 fragP->fr_type = rs_fill;
470 valueT value = S_GET_VALUE (fragP->fr_symbol);
473 if (!S_IS_DEFINED (fragP->fr_symbol))
475 as_bad_where (fragP->fr_file, fragP->fr_line,
476 _("leb128 operand is an undefined symbol: %s"),
477 S_GET_NAME (fragP->fr_symbol));
480 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
483 fragP->fr_fix += size;
484 fragP->fr_type = rs_fill;
486 fragP->fr_offset = 0;
487 fragP->fr_symbol = NULL;
492 eh_frame_convert_frag (fragP);
496 dwarf2dbg_convert_frag (fragP);
499 case rs_machine_dependent:
500 md_convert_frag (stdoutput, sec, fragP);
502 gas_assert (fragP->fr_next == NULL
503 || (fragP->fr_next->fr_address - fragP->fr_address
506 /* After md_convert_frag, we make the frag into a ".space 0".
507 md_convert_frag() should set up any fixSs and constants
512 #ifndef WORKING_DOT_WORD
515 struct broken_word *lie;
517 if (fragP->fr_subtype)
519 fragP->fr_fix += md_short_jump_size;
520 for (lie = (struct broken_word *) (fragP->fr_symbol);
521 lie && lie->dispfrag == fragP;
522 lie = lie->next_broken_word)
524 fragP->fr_fix += md_long_jump_size;
532 BAD_CASE (fragP->fr_type);
536 md_frag_check (fragP);
540 struct relax_seg_info
547 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
549 segment_info_type *seginfo = seg_info (sec);
550 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
552 if (seginfo && seginfo->frchainP
553 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
558 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
562 segment_info_type *seginfo;
564 valueT size, newsize;
566 subseg_change (sec, 0);
568 seginfo = seg_info (sec);
569 if (seginfo && seginfo->frchainP)
571 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
572 cvt_frag_to_fill (sec, fragp);
573 for (fragp = seginfo->frchainP->frch_root;
575 fragp = fragp->fr_next)
576 /* Walk to last elt. */
578 size = fragp->fr_address + fragp->fr_fix;
583 flags = bfd_get_section_flags (abfd, sec);
584 if (size == 0 && bfd_get_section_size (sec) != 0 &&
585 (flags & SEC_HAS_CONTENTS) != 0)
588 if (size > 0 && ! seginfo->bss)
589 flags |= SEC_HAS_CONTENTS;
592 x = bfd_set_section_flags (abfd, sec, flags);
595 /* If permitted, allow the backend to pad out the section
596 to some alignment boundary. */
597 if (do_not_pad_sections_to_alignment)
600 newsize = md_section_align (sec, size);
601 x = bfd_set_section_size (abfd, sec, newsize);
604 /* If the size had to be rounded up, add some padding in the last
606 gas_assert (newsize >= size);
609 fragS *last = seginfo->frchainP->frch_last;
610 fragp = seginfo->frchainP->frch_root;
611 while (fragp->fr_next != last)
612 fragp = fragp->fr_next;
613 last->fr_address = size;
614 if ((newsize - size) % fragp->fr_var == 0)
615 fragp->fr_offset += (newsize - size) / fragp->fr_var;
617 /* If we hit this abort, it's likely due to subsegs_finish not
618 providing sufficient alignment on the last frag, and the
619 machine dependent code using alignment frags with fr_var
624 #ifdef tc_frob_section
625 tc_frob_section (sec);
627 #ifdef obj_frob_section
628 obj_frob_section (sec);
634 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
636 segment_info_type *seginfo = seg_info (sec);
637 fixS *fixp = seginfo->fix_root;
642 fprintf (stream, "sec %s relocs:\n", sec->name);
645 symbolS *s = fixp->fx_addsy;
647 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
648 (int) fixp->fx_r_type);
650 fprintf (stream, "no sym\n");
653 print_symbol_value_1 (stream, s);
654 fprintf (stream, "\n");
656 fixp = fixp->fx_next;
660 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
663 #ifndef EMIT_SECTION_SYMBOLS
664 #define EMIT_SECTION_SYMBOLS 1
667 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
668 and check for validity. Convert RELOC_LIST from using U.A fields
671 resolve_reloc_expr_symbols (void)
673 bfd_vma addr_mask = 1;
674 struct reloc_list *r;
676 /* Avoid a shift by the width of type. */
677 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
681 for (r = reloc_list; r; r = r->next)
683 reloc_howto_type *howto = r->u.a.howto;
686 bfd_vma offset, addend;
689 resolve_symbol_value (r->u.a.offset_sym);
690 symval = symbol_get_value_expression (r->u.a.offset_sym);
694 if (symval->X_op == O_constant)
695 sym = r->u.a.offset_sym;
696 else if (symval->X_op == O_symbol)
698 sym = symval->X_add_symbol;
699 offset = symval->X_add_number;
700 symval = symbol_get_value_expression (symval->X_add_symbol);
703 || symval->X_op != O_constant
704 || (sec = S_GET_SEGMENT (sym)) == NULL
705 || !SEG_NORMAL (sec))
707 as_bad_where (r->file, r->line, _("invalid offset expression"));
711 offset += S_GET_VALUE (sym);
714 addend = r->u.a.addend;
715 if (r->u.a.sym != NULL)
717 resolve_symbol_value (r->u.a.sym);
718 symval = symbol_get_value_expression (r->u.a.sym);
719 if (symval->X_op == O_constant)
721 else if (symval->X_op == O_symbol)
723 sym = symval->X_add_symbol;
724 addend += symval->X_add_number;
725 symval = symbol_get_value_expression (symval->X_add_symbol);
727 if (symval->X_op != O_constant)
729 as_bad_where (r->file, r->line, _("invalid reloc expression"));
732 else if (sym != NULL && sec != NULL)
734 /* Convert relocs against local symbols to refer to the
735 corresponding section symbol plus offset instead. Keep
736 PC-relative relocs of the REL variety intact though to
737 prevent the offset from overflowing the relocated field,
738 unless it has enough bits to cover the whole address
740 if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
742 || (howto->partial_inplace
743 && (!howto->pc_relative
744 || howto->src_mask == addr_mask))))
746 asection *symsec = S_GET_SEGMENT (sym);
747 if (!(((symsec->flags & SEC_MERGE) != 0
749 || (symsec->flags & SEC_THREAD_LOCAL) != 0))
751 addend += S_GET_VALUE (sym);
752 sym = section_symbol (symsec);
755 symbol_mark_used_in_reloc (sym);
760 if (abs_section_sym == NULL)
761 abs_section_sym = section_symbol (absolute_section);
762 sym = abs_section_sym;
766 r->u.b.s = symbol_get_bfdsym (sym);
767 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
768 r->u.b.r.address = offset;
769 r->u.b.r.addend = addend;
770 r->u.b.r.howto = howto;
774 /* This pass over fixups decides whether symbols can be replaced with
778 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
780 void *xxx ATTRIBUTE_UNUSED)
782 segment_info_type *seginfo = seg_info (sec);
788 dump_section_relocs (abfd, sec, stderr);
790 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
794 else if (fixp->fx_addsy)
800 fprintf (stderr, "\n\nadjusting fixup:\n");
804 sym = fixp->fx_addsy;
806 /* All symbols should have already been resolved at this
807 point. It is possible to see unresolved expression
808 symbols, though, since they are not in the regular symbol
810 resolve_symbol_value (sym);
812 if (fixp->fx_subsy != NULL)
813 resolve_symbol_value (fixp->fx_subsy);
815 /* If this symbol is equated to an undefined or common symbol,
816 convert the fixup to being against that symbol. */
817 while (symbol_equated_reloc_p (sym)
818 || S_IS_WEAKREFR (sym))
820 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
823 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
824 fixp->fx_addsy = newsym;
828 if (symbol_mri_common_p (sym))
830 fixp->fx_offset += S_GET_VALUE (sym);
831 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
835 /* If the symbol is undefined, common, weak, or global (ELF
836 shared libs), we can't replace it with the section symbol. */
837 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
840 /* Is there some other (target cpu dependent) reason we can't adjust
841 this one? (E.g. relocations involving function addresses on
843 #ifdef tc_fix_adjustable
844 if (! tc_fix_adjustable (fixp))
848 /* Since we're reducing to section symbols, don't attempt to reduce
849 anything that's already using one. */
850 if (symbol_section_p (sym))
853 symsec = S_GET_SEGMENT (sym);
857 if (bfd_is_abs_section (symsec)
858 || symsec == reg_section)
860 /* The fixup_segment routine normally will not use this
861 symbol in a relocation. */
865 /* Don't try to reduce relocs which refer to non-local symbols
866 in .linkonce sections. It can lead to confusion when a
867 debugging section refers to a .linkonce section. I hope
868 this will always be correct. */
869 if (symsec != sec && ! S_IS_LOCAL (sym))
871 if ((symsec->flags & SEC_LINK_ONCE) != 0
873 /* The GNU toolchain uses an extension for ELF: a
874 section beginning with the magic string
875 .gnu.linkonce is a linkonce section. */
876 && strncmp (segment_name (symsec), ".gnu.linkonce",
877 sizeof ".gnu.linkonce" - 1) == 0))
881 /* Never adjust a reloc against local symbol in a merge section
882 with non-zero addend. */
883 if ((symsec->flags & SEC_MERGE) != 0
884 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
887 /* Never adjust a reloc against TLS local symbol. */
888 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
891 /* We refetch the segment when calling section_symbol, rather
892 than using symsec, because S_GET_VALUE may wind up changing
893 the section when it calls resolve_symbol_value. */
894 fixp->fx_offset += S_GET_VALUE (sym);
895 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
897 fprintf (stderr, "\nadjusted fixup:\n");
902 dump_section_relocs (abfd, sec, stderr);
907 Go through all the fixS's in a segment and see which ones can be
908 handled now. (These consist of fixS where we have since discovered
909 the value of a symbol, or the address of the frag involved.)
910 For each one, call md_apply_fix to put the fix into the frag data.
911 Ones that we couldn't completely handle here will be output later
912 by emit_relocations. */
915 fixup_segment (fixS *fixP, segT this_segment)
919 segT add_symbol_segment = absolute_section;
921 if (fixP != NULL && abs_section_sym == NULL)
922 abs_section_sym = section_symbol (absolute_section);
924 /* If the linker is doing the relaxing, we must not do any fixups.
926 Well, strictly speaking that's not true -- we could do any that
927 are PC-relative and don't cross regions that could change size. */
928 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
930 for (; fixP; fixP = fixP->fx_next)
933 if (fixP->fx_addsy == NULL)
935 /* There was no symbol required by this relocation.
936 However, BFD doesn't really handle relocations
937 without symbols well. So fake up a local symbol in
938 the absolute section. */
939 fixP->fx_addsy = abs_section_sym;
941 symbol_mark_used_in_reloc (fixP->fx_addsy);
942 if (fixP->fx_subsy != NULL)
943 symbol_mark_used_in_reloc (fixP->fx_subsy);
948 for (; fixP; fixP = fixP->fx_next)
951 fprintf (stderr, "\nprocessing fixup:\n");
955 fragP = fixP->fx_frag;
957 #ifdef TC_VALIDATE_FIX
958 TC_VALIDATE_FIX (fixP, this_segment, skip);
960 add_number = fixP->fx_offset;
962 if (fixP->fx_addsy != NULL)
963 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
965 if (fixP->fx_subsy != NULL)
967 segT sub_symbol_segment;
968 resolve_symbol_value (fixP->fx_subsy);
969 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
970 if (fixP->fx_addsy != NULL
971 && sub_symbol_segment == add_symbol_segment
972 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
973 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
974 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
976 add_number += S_GET_VALUE (fixP->fx_addsy);
977 add_number -= S_GET_VALUE (fixP->fx_subsy);
978 fixP->fx_offset = add_number;
979 fixP->fx_addsy = NULL;
980 fixP->fx_subsy = NULL;
982 /* See the comment below about 68k weirdness. */
986 else if (sub_symbol_segment == absolute_section
987 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
988 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
990 add_number -= S_GET_VALUE (fixP->fx_subsy);
991 fixP->fx_offset = add_number;
992 fixP->fx_subsy = NULL;
994 else if (sub_symbol_segment == this_segment
995 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
996 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
998 add_number -= S_GET_VALUE (fixP->fx_subsy);
999 fixP->fx_offset = (add_number + fixP->fx_dot_value
1000 + fixP->fx_dot_frag->fr_address);
1002 /* Make it pc-relative. If the back-end code has not
1003 selected a pc-relative reloc, cancel the adjustment
1004 we do later on all pc-relative relocs. */
1007 /* Do this for m68k even if it's already described
1008 as pc-relative. On the m68k, an operand of
1009 "pc@(foo-.-2)" should address "foo" in a
1010 pc-relative mode. */
1014 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1015 fixP->fx_subsy = NULL;
1018 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1020 if (!md_register_arithmetic
1021 && (add_symbol_segment == reg_section
1022 || sub_symbol_segment == reg_section))
1023 as_bad_where (fixP->fx_file, fixP->fx_line,
1024 _("register value used as expression"));
1026 as_bad_where (fixP->fx_file, fixP->fx_line,
1027 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1028 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1029 segment_name (add_symbol_segment),
1030 S_GET_NAME (fixP->fx_subsy),
1031 segment_name (sub_symbol_segment));
1033 else if (sub_symbol_segment != undefined_section
1034 && ! bfd_is_com_section (sub_symbol_segment)
1035 && MD_APPLY_SYM_VALUE (fixP))
1036 add_number -= S_GET_VALUE (fixP->fx_subsy);
1041 if (add_symbol_segment == this_segment
1042 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1043 && !TC_FORCE_RELOCATION_LOCAL (fixP))
1045 /* This fixup was made when the symbol's segment was
1046 SEG_UNKNOWN, but it is now in the local segment.
1047 So we know how to do the address without relocation. */
1048 add_number += S_GET_VALUE (fixP->fx_addsy);
1049 fixP->fx_offset = add_number;
1051 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1052 fixP->fx_addsy = NULL;
1055 else if (add_symbol_segment == absolute_section
1056 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1057 && !TC_FORCE_RELOCATION_ABS (fixP))
1059 add_number += S_GET_VALUE (fixP->fx_addsy);
1060 fixP->fx_offset = add_number;
1061 fixP->fx_addsy = NULL;
1063 else if (add_symbol_segment != undefined_section
1064 && ! bfd_is_com_section (add_symbol_segment)
1065 && MD_APPLY_SYM_VALUE (fixP))
1066 add_number += S_GET_VALUE (fixP->fx_addsy);
1071 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1072 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1074 /* There was no symbol required by this relocation.
1075 However, BFD doesn't really handle relocations
1076 without symbols well. So fake up a local symbol in
1077 the absolute section. */
1078 fixP->fx_addsy = abs_section_sym;
1083 md_apply_fix (fixP, &add_number, this_segment);
1087 if (fixP->fx_addsy == NULL)
1088 fixP->fx_addsy = abs_section_sym;
1089 symbol_mark_used_in_reloc (fixP->fx_addsy);
1090 if (fixP->fx_subsy != NULL)
1091 symbol_mark_used_in_reloc (fixP->fx_subsy);
1094 if (!fixP->fx_no_overflow && fixP->fx_size != 0)
1096 if (fixP->fx_size < sizeof (valueT))
1101 mask--; /* Set all bits to one. */
1102 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1103 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1105 char buf[50], buf2[50];
1106 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1107 if (add_number > 1000)
1108 sprint_value (buf2, add_number);
1110 sprintf (buf2, "%ld", (long) add_number);
1111 as_bad_where (fixP->fx_file, fixP->fx_line,
1112 ngettext ("value of %s too large for field "
1114 "value of %s too large for field "
1115 "of %d bytes at %s",
1117 buf2, fixP->fx_size, buf);
1118 } /* Generic error checking. */
1120 #ifdef WARN_SIGNED_OVERFLOW_WORD
1121 /* Warn if a .word value is too large when treated as a signed
1122 number. We already know it is not too negative. This is to
1123 catch over-large switches generated by gcc on the 68k. */
1124 if (!flag_signed_overflow_ok
1125 && fixP->fx_size == 2
1126 && add_number > 0x7fff)
1127 as_bad_where (fixP->fx_file, fixP->fx_line,
1128 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1130 (long) (fragP->fr_address + fixP->fx_where));
1134 #ifdef TC_VALIDATE_FIX
1135 skip: ATTRIBUTE_UNUSED_LABEL
1139 fprintf (stderr, "result:\n");
1142 } /* For each fixS in this segment. */
1146 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1148 void *xxx ATTRIBUTE_UNUSED)
1150 segment_info_type *seginfo = seg_info (sec);
1152 fixup_segment (seginfo->fix_root, sec);
1156 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1157 const char *file, unsigned int line)
1160 bfd_reloc_status_type s;
1163 if (reloc->sym_ptr_ptr != NULL
1164 && (sym = *reloc->sym_ptr_ptr) != NULL
1165 && (sym->flags & BSF_KEEP) == 0
1166 && ((sym->flags & BSF_SECTION_SYM) == 0
1167 || (EMIT_SECTION_SYMBOLS
1168 && !bfd_is_abs_section (sym->section))))
1169 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1171 s = bfd_install_relocation (stdoutput, reloc,
1172 fragp->fr_literal, fragp->fr_address,
1178 case bfd_reloc_overflow:
1179 as_bad_where (file, line, _("relocation overflow"));
1181 case bfd_reloc_outofrange:
1182 as_bad_where (file, line, _("relocation out of range"));
1185 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1191 get_frag_for_reloc (fragS *last_frag,
1192 const segment_info_type *seginfo,
1193 const struct reloc_list *r)
1197 for (f = last_frag; f != NULL; f = f->fr_next)
1198 if (f->fr_address <= r->u.b.r.address
1199 && r->u.b.r.address < f->fr_address + f->fr_fix)
1202 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1203 if (f->fr_address <= r->u.b.r.address
1204 && r->u.b.r.address < f->fr_address + f->fr_fix)
1207 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1208 if (f->fr_address <= r->u.b.r.address
1209 && r->u.b.r.address <= f->fr_address + f->fr_fix)
1212 as_bad_where (r->file, r->line,
1213 _("reloc not within (fixed part of) section"));
1218 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1220 segment_info_type *seginfo = seg_info (sec);
1222 struct reloc_list *my_reloc_list, **rp, *r;
1227 /* If seginfo is NULL, we did not create this section; don't do
1228 anything with it. */
1229 if (seginfo == NULL)
1233 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1237 #ifdef RELOC_EXPANSION_POSSIBLE
1238 n *= MAX_RELOC_EXPANSION;
1241 /* Extract relocs for this section from reloc_list. */
1244 my_reloc_list = NULL;
1245 while ((r = *rp) != NULL)
1247 if (r->u.b.sec == sec)
1250 r->next = my_reloc_list;
1258 relocs = XCNEWVEC (arelent *, n);
1263 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1268 #ifndef RELOC_EXPANSION_POSSIBLE
1277 fx_size = fixp->fx_size;
1278 slack = TC_FX_SIZE_SLACK (fixp);
1280 fx_size = fx_size > slack ? fx_size - slack : 0;
1281 loc = fixp->fx_where + fx_size;
1282 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1283 as_bad_where (fixp->fx_file, fixp->fx_line,
1284 _("internal error: fixup not contained within frag"));
1286 #ifndef RELOC_EXPANSION_POSSIBLE
1287 *reloc = tc_gen_reloc (sec, fixp);
1289 reloc = tc_gen_reloc (sec, fixp);
1294 while (r != NULL && r->u.b.r.address < (*reloc)->address)
1296 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1300 relocs[n++] = &r->u.b.r;
1301 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1305 relocs[n++] = *reloc;
1306 install_reloc (sec, *reloc, fixp->fx_frag,
1307 fixp->fx_file, fixp->fx_line);
1308 #ifndef RELOC_EXPANSION_POSSIBLE
1318 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1322 relocs[n++] = &r->u.b.r;
1323 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1330 unsigned int k, j, nsyms;
1332 sympp = bfd_get_outsymbols (stdoutput);
1333 nsyms = bfd_get_symcount (stdoutput);
1334 for (k = 0; k < n; k++)
1335 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1337 for (j = 0; j < nsyms; j++)
1338 if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1348 flagword flags = bfd_get_section_flags (abfd, sec);
1350 bfd_set_section_flags (abfd, sec, flags);
1351 bfd_set_reloc (stdoutput, sec, relocs, n);
1354 #ifdef SET_SECTION_RELOCS
1355 SET_SECTION_RELOCS (sec, relocs, n);
1362 fprintf (stderr, "relocs for sec %s\n", sec->name);
1363 for (k = 0; k < n; k++)
1365 arelent *rel = relocs[k];
1366 asymbol *s = *rel->sym_ptr_ptr;
1367 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1368 k, rel, (unsigned long)rel->address, s->name,
1369 (unsigned long)rel->addend);
1376 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1377 fragS **last_newf, struct obstack *ob)
1380 int total_out_size = 0;
1381 fragS *f = *last_newf;
1385 /* Call the compression routine repeatedly until it has finished
1386 processing the frag. */
1389 /* Reserve all the space available in the current chunk.
1390 If none is available, start a new frag. */
1391 avail_out = obstack_room (ob);
1394 obstack_finish (ob);
1395 f = frag_alloc (ob);
1396 f->fr_type = rs_fill;
1397 (*last_newf)->fr_next = f;
1399 avail_out = obstack_room (ob);
1402 as_fatal (_("can't extend frag"));
1403 next_out = obstack_next_free (ob);
1404 obstack_blank_fast (ob, avail_out);
1405 out_size = compress_data (strm, &contents, &in_size,
1406 &next_out, &avail_out);
1410 f->fr_fix += out_size;
1411 total_out_size += out_size;
1413 /* Return unused space. */
1415 obstack_blank_fast (ob, -avail_out);
1418 return total_out_size;
1422 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1424 segment_info_type *seginfo = seg_info (sec);
1428 struct obstack *ob = &seginfo->frchainP->frch_obstack;
1429 bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1430 bfd_size_type compressed_size;
1431 const char *section_name;
1432 char *compressed_name;
1434 struct z_stream_s *strm;
1436 flagword flags = bfd_get_section_flags (abfd, sec);
1437 unsigned int header_size, compression_header_size;
1441 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1444 section_name = bfd_get_section_name (stdoutput, sec);
1445 if (strncmp (section_name, ".debug_", 7) != 0)
1448 strm = compress_init ();
1452 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
1454 compression_header_size
1455 = bfd_get_compression_header_size (stdoutput, NULL);
1456 header_size = compression_header_size;
1460 compression_header_size = 0;
1464 /* Create a new frag to contain the compression header. */
1465 first_newf = frag_alloc (ob);
1466 if (obstack_room (ob) < header_size)
1467 first_newf = frag_alloc (ob);
1468 if (obstack_room (ob) < header_size)
1469 as_fatal (ngettext ("can't extend frag %lu char",
1470 "can't extend frag %lu chars",
1471 (unsigned long) header_size),
1472 (unsigned long) header_size);
1473 last_newf = first_newf;
1474 obstack_blank_fast (ob, header_size);
1475 last_newf->fr_type = rs_fill;
1476 last_newf->fr_fix = header_size;
1477 header = last_newf->fr_literal;
1478 compressed_size = header_size;
1480 /* Stream the frags through the compression engine, adding new frags
1481 as necessary to accommodate the compressed output. */
1482 for (f = seginfo->frchainP->frch_root;
1491 gas_assert (f->fr_type == rs_fill);
1494 out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1498 compressed_size += out_size;
1500 fill_literal = f->fr_literal + f->fr_fix;
1501 fill_size = f->fr_var;
1502 count = f->fr_offset;
1503 gas_assert (count >= 0);
1504 if (fill_size && count)
1508 out_size = compress_frag (strm, fill_literal, (int) fill_size,
1512 compressed_size += out_size;
1517 /* Flush the compression state. */
1524 /* Reserve all the space available in the current chunk.
1525 If none is available, start a new frag. */
1526 avail_out = obstack_room (ob);
1531 obstack_finish (ob);
1532 newf = frag_alloc (ob);
1533 newf->fr_type = rs_fill;
1534 last_newf->fr_next = newf;
1536 avail_out = obstack_room (ob);
1539 as_fatal (_("can't extend frag"));
1540 next_out = obstack_next_free (ob);
1541 obstack_blank_fast (ob, avail_out);
1542 x = compress_finish (strm, &next_out, &avail_out, &out_size);
1546 last_newf->fr_fix += out_size;
1547 compressed_size += out_size;
1549 /* Return unused space. */
1551 obstack_blank_fast (ob, -avail_out);
1557 /* PR binutils/18087: If compression didn't make the section smaller,
1558 just keep it uncompressed. */
1559 if (compressed_size >= uncompressed_size)
1562 /* Replace the uncompressed frag list with the compressed frag list. */
1563 seginfo->frchainP->frch_root = first_newf;
1564 seginfo->frchainP->frch_last = last_newf;
1566 /* Update the section size and its name. */
1567 bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
1568 x = bfd_set_section_size (abfd, sec, compressed_size);
1570 if (!compression_header_size)
1572 compressed_name = concat (".z", section_name + 1, (char *) NULL);
1573 bfd_section_name (stdoutput, sec) = compressed_name;
1577 #ifndef md_generate_nops
1578 /* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1579 backend must override this with proper no-op instructions. */
1582 md_generate_nops (fragS *f ATTRIBUTE_UNUSED,
1583 char *where ATTRIBUTE_UNUSED,
1584 offsetT count ATTRIBUTE_UNUSED,
1585 int control ATTRIBUTE_UNUSED)
1587 as_bad (_("unimplemented .nops directive"));
1592 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1594 void *xxx ATTRIBUTE_UNUSED)
1596 segment_info_type *seginfo = seg_info (sec);
1597 addressT offset = 0;
1600 /* Write out the frags. */
1602 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1605 for (f = seginfo->frchainP->frch_root;
1614 gas_assert (f->fr_type == rs_fill || f->fr_type == rs_fill_nop);
1617 x = bfd_set_section_contents (stdoutput, sec,
1618 f->fr_literal, (file_ptr) offset,
1619 (bfd_size_type) f->fr_fix);
1621 as_fatal (ngettext ("can't write %ld byte "
1622 "to section %s of %s: '%s'",
1623 "can't write %ld bytes "
1624 "to section %s of %s: '%s'",
1627 sec->name, stdoutput->filename,
1628 bfd_errmsg (bfd_get_error ()));
1629 offset += f->fr_fix;
1632 fill_size = f->fr_var;
1633 count = f->fr_offset;
1634 fill_literal = f->fr_literal + f->fr_fix;
1636 if (f->fr_type == rs_fill_nop)
1638 gas_assert (count >= 0 && fill_size == 1);
1641 char *buf = xmalloc (count);
1642 md_generate_nops (f, buf, count, *fill_literal);
1643 x = bfd_set_section_contents
1644 (stdoutput, sec, buf, (file_ptr) offset,
1645 (bfd_size_type) count);
1647 as_fatal (ngettext ("can't fill %ld byte "
1648 "in section %s of %s: '%s'",
1649 "can't fill %ld bytes "
1650 "in section %s of %s: '%s'",
1651 (long) count), (long) count,
1652 sec->name, stdoutput->filename,
1653 bfd_errmsg (bfd_get_error ()));
1660 gas_assert (count >= 0);
1661 if (fill_size && count)
1664 if (fill_size > sizeof (buf))
1666 /* Do it the old way. Can this ever happen? */
1669 x = bfd_set_section_contents (stdoutput, sec,
1672 (bfd_size_type) fill_size);
1674 as_fatal (ngettext ("can't fill %ld byte "
1675 "in section %s of %s: '%s'",
1676 "can't fill %ld bytes "
1677 "in section %s of %s: '%s'",
1680 sec->name, stdoutput->filename,
1681 bfd_errmsg (bfd_get_error ()));
1682 offset += fill_size;
1687 /* Build a buffer full of fill objects and output it as
1688 often as necessary. This saves on the overhead of
1689 potentially lots of bfd_set_section_contents calls. */
1693 n_per_buf = sizeof (buf);
1694 memset (buf, *fill_literal, n_per_buf);
1699 n_per_buf = sizeof (buf) / fill_size;
1700 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1701 memcpy (bufp, fill_literal, fill_size);
1703 for (; count > 0; count -= n_per_buf)
1705 n_per_buf = n_per_buf > count ? count : n_per_buf;
1706 x = bfd_set_section_contents
1707 (stdoutput, sec, buf, (file_ptr) offset,
1708 (bfd_size_type) n_per_buf * fill_size);
1710 as_fatal (ngettext ("can't fill %ld byte "
1711 "in section %s of %s: '%s'",
1712 "can't fill %ld bytes "
1713 "in section %s of %s: '%s'",
1714 (long) (n_per_buf * fill_size)),
1715 (long) (n_per_buf * fill_size),
1716 sec->name, stdoutput->filename,
1717 bfd_errmsg (bfd_get_error ()));
1718 offset += n_per_buf * fill_size;
1726 merge_data_into_text (void)
1728 seg_info (text_section)->frchainP->frch_last->fr_next =
1729 seg_info (data_section)->frchainP->frch_root;
1730 seg_info (text_section)->frchainP->frch_last =
1731 seg_info (data_section)->frchainP->frch_last;
1732 seg_info (data_section)->frchainP = 0;
1743 /* Count symbols. We can't rely on a count made by the loop in
1744 write_object_file, because *_frob_file may add a new symbol or
1747 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1753 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1755 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1756 symp = symbol_rootP;
1757 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1759 asympp[i] = symbol_get_bfdsym (symp);
1760 if (asympp[i]->flags != BSF_SECTION_SYM
1761 || !(bfd_is_const_section (asympp[i]->section)
1762 && asympp[i]->section->symbol == asympp[i]))
1763 asympp[i]->flags |= BSF_KEEP;
1764 symbol_mark_written (symp);
1769 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1770 gas_assert (result);
1771 symbol_table_frozen = 1;
1774 /* Finish the subsegments. After every sub-segment, we fake an
1775 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1776 ".fill 0" because that is the kind of frag that requires least
1777 thought. ".align" frags like to have a following frag since that
1778 makes calculating their intended length trivial. */
1780 #ifndef SUB_SEGMENT_ALIGN
1782 /* The last subsegment gets an alignment corresponding to the alignment
1783 of the section. This allows proper nop-filling at the end of
1784 code-bearing sections. */
1785 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1786 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1787 && !do_not_pad_sections_to_alignment \
1788 ? get_recorded_alignment (SEG) \
1791 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1796 subsegs_finish_section (asection *s)
1798 struct frchain *frchainP;
1799 segment_info_type *seginfo = seg_info (s);
1803 for (frchainP = seginfo->frchainP;
1805 frchainP = frchainP->frch_next)
1809 subseg_set (s, frchainP->frch_subseg);
1811 /* This now gets called even if we had errors. In that case,
1812 any alignment is meaningless, and, moreover, will look weird
1813 if we are generating a listing. */
1815 do_not_pad_sections_to_alignment = 1;
1817 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1818 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1819 && now_seg->entsize)
1821 unsigned int entsize = now_seg->entsize;
1824 while ((entsize & 1) == 0)
1830 if (entalign > alignment)
1831 alignment = entalign;
1834 if (subseg_text_p (now_seg))
1835 frag_align_code (alignment, 0);
1837 frag_align (alignment, 0, 0);
1839 /* frag_align will have left a new frag.
1840 Use this last frag for an empty ".fill".
1842 For this segment ...
1843 Create a last frag. Do not leave a "being filled in frag". */
1844 frag_wane (frag_now);
1845 frag_now->fr_fix = 0;
1846 know (frag_now->fr_next == NULL);
1851 subsegs_finish (void)
1855 for (s = stdoutput->sections; s; s = s->next)
1856 subsegs_finish_section (s);
1861 create_obj_attrs_section (void)
1868 size = bfd_elf_obj_attr_size (stdoutput);
1872 name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1874 name = ".gnu.attributes";
1875 s = subseg_new (name, 0);
1876 elf_section_type (s)
1877 = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1878 bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1880 p = frag_more (size);
1881 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1883 subsegs_finish_section (s);
1884 relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1885 size_seg (stdoutput, s, NULL);
1888 /* Create a relocation against an entry in a GNU Build attribute section. */
1891 create_note_reloc (segT sec,
1893 bfd_size_type note_offset,
1894 bfd_size_type desc2_offset,
1899 struct reloc_list * reloc;
1901 reloc = XNEW (struct reloc_list);
1903 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
1904 reloc->u.b.sec = sec;
1905 reloc->u.b.s = symbol_get_bfdsym (sym);
1906 reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s;
1907 reloc->u.b.r.address = note_offset + desc2_offset;
1908 reloc->u.b.r.addend = addend;
1909 reloc->u.b.r.howto = bfd_reloc_type_lookup (stdoutput, reloc_type);
1911 if (reloc->u.b.r.howto == NULL)
1913 as_bad (_("unable to create reloc for build note"));
1917 reloc->file = N_("<gnu build note>");
1920 reloc->next = reloc_list;
1923 /* For REL relocs, store the addend in the section. */
1924 if (! sec->use_rela_p
1925 /* The SH target is a special case that uses RELA relocs
1926 but still stores the addend in the word being relocated. */
1927 || strstr (bfd_get_target (stdoutput), "-sh") != NULL)
1929 if (target_big_endian)
1931 if (bfd_arch_bits_per_address (stdoutput) <= 32)
1932 note[desc2_offset + 3] = addend;
1934 note[desc2_offset + 7] = addend;
1937 note[desc2_offset] = addend;
1942 maybe_generate_build_notes (void)
1949 offsetT desc2_offset;
1954 if (! flag_generate_build_notes
1955 || bfd_get_section_by_name (stdoutput,
1956 GNU_BUILD_ATTRS_SECTION_NAME) != NULL)
1959 /* Create a GNU Build Attribute section. */
1960 sec = subseg_new (GNU_BUILD_ATTRS_SECTION_NAME, FALSE);
1961 elf_section_type (sec) = SHT_NOTE;
1962 bfd_set_section_flags (stdoutput, sec,
1963 SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA);
1964 bfd_set_section_alignment (stdoutput, sec, 2);
1966 /* Work out the size of the notes that we will create,
1967 and the relocation we should use. */
1968 if (bfd_arch_bits_per_address (stdoutput) <= 32)
1971 desc_size = 8; /* Two 4-byte offsets. */
1974 /* FIXME: The BFD backend for the CRX target does not support the
1975 BFD_RELOC_32, even though it really should. Likewise for the
1976 CR16 target. So we have special case code here... */
1977 if (strstr (bfd_get_target (stdoutput), "-crx") != NULL)
1978 desc_reloc = BFD_RELOC_CRX_NUM32;
1979 else if (strstr (bfd_get_target (stdoutput), "-cr16") != NULL)
1980 desc_reloc = BFD_RELOC_CR16_NUM32;
1982 desc_reloc = BFD_RELOC_32;
1987 desc_size = 16; /* Two 8-byte offsets. */
1989 /* FIXME: The BFD backend for the IA64 target does not support the
1990 BFD_RELOC_64, even though it really should. The HPPA backend
1991 has a similar issue, although it does not support BFD_RELOCs at
1992 all! So we have special case code to handle these targets. */
1993 if (strstr (bfd_get_target (stdoutput), "-ia64") != NULL)
1994 desc_reloc = target_big_endian ? BFD_RELOC_IA64_DIR32MSB : BFD_RELOC_IA64_DIR32LSB;
1995 else if (strstr (bfd_get_target (stdoutput), "-hppa") != NULL)
1996 desc_reloc = 80; /* R_PARISC_DIR64. */
1998 desc_reloc = BFD_RELOC_64;
2001 /* We have to create a note for *each* code section.
2002 Linker garbage collection might discard some. */
2006 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
2007 if ((bsym = symbol_get_bfdsym (sym)) != NULL
2008 && bsym->flags & BSF_SECTION_SYM
2009 && bsym->section != NULL
2010 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
2011 && (bsym->section->flags & (SEC_CODE | SEC_LINK_ONCE)) == SEC_CODE
2012 /* Not all linkonce sections are flagged... */
2013 && strncmp (S_GET_NAME (sym), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0)
2015 /* Create a version note. */
2017 note = frag_more (note_size);
2018 memset (note, 0, note_size);
2020 if (target_big_endian)
2022 note[3] = 8; /* strlen (name) + 1. */
2023 note[7] = desc_size; /* Two 8-byte offsets. */
2024 note[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
2025 note[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2029 note[0] = 8; /* strlen (name) + 1. */
2030 note[4] = desc_size; /* Two 8-byte offsets. */
2031 note[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2032 note[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
2035 /* The a1 version number indicates that this note was
2036 generated by the assembler and not the gcc annobin plugin. */
2037 memcpy (note + 12, "GA$
\ 13a1", 8);
2039 /* Create a relocation to install the start address of the note... */
2040 create_note_reloc (sec, sym, total_size, 20, desc_reloc, 0, note);
2042 /* ...and another one to install the end address. */
2043 create_note_reloc (sec, sym, total_size, desc2_offset, desc_reloc,
2044 bfd_get_section_size (bsym->section),
2047 total_size += note_size;
2048 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2051 /* Install the note(s) into the section. */
2053 bfd_set_section_contents (stdoutput, sec, (bfd_byte *) note, 0, total_size);
2054 subsegs_finish_section (sec);
2055 relax_segment (seg_info (sec)->frchainP->frch_root, sec, 0);
2056 size_seg (stdoutput, sec, NULL);
2058 #endif /* OBJ_ELF */
2060 /* Write the object file. */
2063 write_object_file (void)
2065 struct relax_seg_info rsi;
2066 #ifndef WORKING_DOT_WORD
2067 fragS *fragP; /* Track along all frags. */
2072 #ifdef md_pre_output_hook
2076 #ifdef md_pre_relax_hook
2080 /* From now on, we don't care about sub-segments. Build one frag chain
2081 for each segment. Linked through fr_next. */
2083 /* Remove the sections created by gas for its own purposes. */
2087 bfd_section_list_remove (stdoutput, reg_section);
2088 bfd_section_list_remove (stdoutput, expr_section);
2089 stdoutput->section_count -= 2;
2091 bfd_map_over_sections (stdoutput, renumber_sections, &i);
2094 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
2096 /* We have two segments. If user gave -R flag, then we must put the
2097 data frags into the text segment. Do this before relaxing so
2098 we know to take advantage of -R and make shorter addresses. */
2099 if (flag_readonly_data_in_text)
2101 merge_data_into_text ();
2107 #ifndef WORKING_DOT_WORD
2108 /* We need to reset the markers in the broken word list and
2109 associated frags between calls to relax_segment (via
2110 relax_seg). Since the broken word list is global, we do it
2111 once per round, rather than locally in relax_segment for each
2113 struct broken_word *brokp;
2115 for (brokp = broken_words;
2116 brokp != (struct broken_word *) NULL;
2117 brokp = brokp->next_broken_word)
2121 if (brokp->dispfrag != (fragS *) NULL
2122 && brokp->dispfrag->fr_type == rs_broken_word)
2123 brokp->dispfrag->fr_subtype = 0;
2128 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
2134 /* Note - Most ports will use the default value of
2135 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2136 local symbols to be resolved, removing their frag information.
2137 Some ports however, will not have finished relaxing all of
2138 their frags and will still need the local symbol frag
2139 information. These ports can set
2140 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2141 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
2143 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
2145 /* Relaxation has completed. Freeze all syms. */
2148 dwarf2dbg_final_check ();
2150 #ifdef md_post_relax_hook
2156 create_obj_attrs_section ();
2159 #ifndef WORKING_DOT_WORD
2161 struct broken_word *lie;
2162 struct broken_word **prevP;
2164 prevP = &broken_words;
2165 for (lie = broken_words; lie; lie = lie->next_broken_word)
2170 subseg_change (lie->seg, lie->subseg);
2171 exp.X_op = O_subtract;
2172 exp.X_add_symbol = lie->add;
2173 exp.X_op_symbol = lie->sub;
2174 exp.X_add_number = lie->addnum;
2175 #ifdef TC_CONS_FIX_NEW
2176 TC_CONS_FIX_NEW (lie->frag,
2177 lie->word_goes_here - lie->frag->fr_literal,
2178 2, &exp, TC_PARSE_CONS_RETURN_NONE);
2180 fix_new_exp (lie->frag,
2181 lie->word_goes_here - lie->frag->fr_literal,
2182 2, &exp, 0, BFD_RELOC_16);
2184 *prevP = lie->next_broken_word;
2187 prevP = &(lie->next_broken_word);
2189 for (lie = broken_words; lie;)
2191 struct broken_word *untruth;
2193 addressT table_addr;
2194 addressT from_addr, to_addr;
2197 subseg_change (lie->seg, lie->subseg);
2198 fragP = lie->dispfrag;
2200 /* Find out how many broken_words go here. */
2203 untruth && untruth->dispfrag == fragP;
2204 untruth = untruth->next_broken_word)
2205 if (untruth->added == 1)
2208 table_ptr = lie->dispfrag->fr_opcode;
2209 table_addr = (lie->dispfrag->fr_address
2210 + (table_ptr - lie->dispfrag->fr_literal));
2211 /* Create the jump around the long jumps. This is a short
2212 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2213 from_addr = table_addr;
2214 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
2215 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2217 table_ptr += md_short_jump_size;
2218 table_addr += md_short_jump_size;
2221 lie && lie->dispfrag == fragP;
2222 m++, lie = lie->next_broken_word)
2224 if (lie->added == 2)
2226 /* Patch the jump table. */
2227 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2228 untruth && untruth->dispfrag == fragP;
2229 untruth = untruth->next_broken_word)
2231 if (untruth->use_jump == lie)
2233 /* This is the offset from ??? to table_ptr+0.
2234 The target is the same for all users of this
2235 md_long_jump, but the "sub" bases (and hence the
2236 offsets) may be different. */
2237 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
2238 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2239 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
2241 md_number_to_chars (untruth->word_goes_here, to_word, 2);
2245 /* Install the long jump. */
2246 /* This is a long jump from table_ptr+0 to the final target. */
2247 from_addr = table_addr;
2248 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
2249 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2251 table_ptr += md_long_jump_size;
2252 table_addr += md_long_jump_size;
2256 #endif /* not WORKING_DOT_WORD */
2258 /* Resolve symbol values. This needs to be done before processing
2264 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2265 resolve_symbol_value (symp);
2267 resolve_local_symbol_values ();
2268 resolve_reloc_expr_symbols ();
2272 maybe_generate_build_notes ();
2277 #ifdef tc_frob_file_before_adjust
2278 tc_frob_file_before_adjust ();
2280 #ifdef obj_frob_file_before_adjust
2281 obj_frob_file_before_adjust ();
2284 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2286 #ifdef tc_frob_file_before_fix
2287 tc_frob_file_before_fix ();
2289 #ifdef obj_frob_file_before_fix
2290 obj_frob_file_before_fix ();
2293 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2295 /* Set up symbol table, and write it out. */
2299 bfd_boolean skip_next_symbol = FALSE;
2301 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2306 if (skip_next_symbol)
2308 /* Don't do anything besides moving the value of the
2309 symbol from the GAS value-field to the BFD value-field. */
2310 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2311 skip_next_symbol = FALSE;
2315 if (symbol_mri_common_p (symp))
2317 if (S_IS_EXTERNAL (symp))
2318 as_bad (_("%s: global symbols not supported in common sections"),
2320 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2324 name = S_GET_NAME (symp);
2328 decode_local_label_name ((char *) S_GET_NAME (symp));
2329 /* They only differ if `name' is a fb or dollar local
2331 if (name2 != name && ! S_IS_DEFINED (symp))
2332 as_bad (_("local label `%s' is not defined"), name2);
2335 /* Do it again, because adjust_reloc_syms might introduce
2336 more symbols. They'll probably only be section symbols,
2337 but they'll still need to have the values computed. */
2338 resolve_symbol_value (symp);
2340 /* Skip symbols which were equated to undefined or common
2342 if (symbol_equated_reloc_p (symp)
2343 || S_IS_WEAKREFR (symp))
2345 const char *sname = S_GET_NAME (symp);
2347 if (S_IS_COMMON (symp)
2348 && !TC_FAKE_LABEL (sname)
2349 && !S_IS_WEAKREFR (symp))
2351 expressionS *e = symbol_get_value_expression (symp);
2353 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2354 sname, S_GET_NAME (e->X_add_symbol));
2356 if (S_GET_SEGMENT (symp) == reg_section)
2358 /* Report error only if we know the symbol name. */
2359 if (S_GET_NAME (symp) != reg_section->name)
2360 as_bad (_("can't make global register symbol `%s'"),
2363 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2367 #ifdef obj_frob_symbol
2368 obj_frob_symbol (symp, punt);
2370 #ifdef tc_frob_symbol
2371 if (! punt || symbol_used_in_reloc_p (symp))
2372 tc_frob_symbol (symp, punt);
2375 /* If we don't want to keep this symbol, splice it out of
2376 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2377 want section symbols. Otherwise, we skip local symbols
2378 and symbols that the frob_symbol macros told us to punt,
2379 but we keep such symbols if they are used in relocs. */
2380 if (symp == abs_section_sym
2381 || (! EMIT_SECTION_SYMBOLS
2382 && symbol_section_p (symp))
2383 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2384 opposites. Sometimes the former checks flags and the
2385 latter examines the name... */
2386 || (!S_IS_EXTERNAL (symp)
2387 && (punt || S_IS_LOCAL (symp) ||
2388 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2389 && ! symbol_used_in_reloc_p (symp)))
2391 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2393 /* After symbol_remove, symbol_next(symp) still returns
2394 the one that came after it in the chain. So we don't
2395 need to do any extra cleanup work here. */
2399 /* Make sure we really got a value for the symbol. */
2400 if (! symbol_resolved_p (symp))
2402 as_bad (_("can't resolve value for symbol `%s'"),
2404 symbol_mark_resolved (symp);
2407 /* Set the value into the BFD symbol. Up til now the value
2408 has only been kept in the gas symbolS struct. */
2409 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2411 /* A warning construct is a warning symbol followed by the
2412 symbol warned about. Don't let anything object-format or
2413 target-specific muck with it; it's ready for output. */
2414 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2415 skip_next_symbol = TRUE;
2421 /* Now do any format-specific adjustments to the symbol table, such
2422 as adding file symbols. */
2423 #ifdef tc_adjust_symtab
2424 tc_adjust_symtab ();
2426 #ifdef obj_adjust_symtab
2427 obj_adjust_symtab ();
2430 /* Stop if there is an error. */
2434 /* Now that all the sizes are known, and contents correct, we can
2435 start writing to the file. */
2438 /* If *_frob_file changes the symbol value at this point, it is
2439 responsible for moving the changed value into symp->bsym->value
2440 as well. Hopefully all symbol value changing can be done in
2445 #ifdef obj_frob_file
2448 #ifdef obj_coff_generate_pdata
2449 obj_coff_generate_pdata ();
2452 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2454 #ifdef tc_frob_file_after_relocs
2455 tc_frob_file_after_relocs ();
2457 #ifdef obj_frob_file_after_relocs
2458 obj_frob_file_after_relocs ();
2461 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2462 if (IS_ELF && flag_use_elf_stt_common)
2463 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
2466 /* Once all relocations have been written, we can compress the
2467 contents of the debug sections. This needs to be done before
2468 we start writing any sections, because it will affect the file
2469 layout, which is fixed once we start writing contents. */
2470 if (flag_compress_debug)
2472 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
2473 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
2475 stdoutput->flags |= BFD_COMPRESS;
2476 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2479 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2482 #ifdef TC_GENERIC_RELAX_TABLE
2483 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2486 relax_frag (segT segment, fragS *fragP, long stretch)
2488 const relax_typeS *this_type;
2489 const relax_typeS *start_type;
2490 relax_substateT next_state;
2491 relax_substateT this_state;
2497 const relax_typeS *table;
2499 target = fragP->fr_offset;
2500 address = fragP->fr_address;
2501 table = TC_GENERIC_RELAX_TABLE;
2502 this_state = fragP->fr_subtype;
2503 start_type = this_type = table + this_state;
2504 symbolP = fragP->fr_symbol;
2510 sym_frag = symbol_get_frag (symbolP);
2512 #ifndef DIFF_EXPR_OK
2513 know (sym_frag != NULL);
2515 know (S_GET_SEGMENT (symbolP) != absolute_section
2516 || sym_frag == &zero_address_frag);
2517 target += S_GET_VALUE (symbolP);
2519 /* If SYM_FRAG has yet to be reached on this pass, assume it
2520 will move by STRETCH just as we did, unless there is an
2521 alignment frag between here and SYM_FRAG. An alignment may
2522 well absorb any STRETCH, and we don't want to choose a larger
2523 branch insn by overestimating the needed reach of this
2524 branch. It isn't critical to calculate TARGET exactly; We
2525 know we'll be doing another pass if STRETCH is non-zero. */
2528 && sym_frag->relax_marker != fragP->relax_marker
2529 && S_GET_SEGMENT (symbolP) == segment)
2532 || sym_frag->region == fragP->region)
2534 /* If we get here we know we have a forward branch. This
2535 relax pass may have stretched previous instructions so
2536 far that omitting STRETCH would make the branch
2537 negative. Don't allow this in case the negative reach is
2538 large enough to require a larger branch instruction. */
2539 else if (target < address)
2540 target = fragP->fr_next->fr_address + stretch;
2544 aim = target - address - fragP->fr_fix;
2545 #ifdef TC_PCREL_ADJUST
2546 /* Currently only the ns32k family needs this. */
2547 aim += TC_PCREL_ADJUST (fragP);
2550 #ifdef md_prepare_relax_scan
2551 /* Formerly called M68K_AIM_KLUDGE. */
2552 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2557 /* Look backwards. */
2558 for (next_state = this_type->rlx_more; next_state;)
2559 if (aim >= this_type->rlx_backward)
2563 /* Grow to next state. */
2564 this_state = next_state;
2565 this_type = table + this_state;
2566 next_state = this_type->rlx_more;
2571 /* Look forwards. */
2572 for (next_state = this_type->rlx_more; next_state;)
2573 if (aim <= this_type->rlx_forward)
2577 /* Grow to next state. */
2578 this_state = next_state;
2579 this_type = table + this_state;
2580 next_state = this_type->rlx_more;
2584 growth = this_type->rlx_length - start_type->rlx_length;
2586 fragP->fr_subtype = this_state;
2590 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2592 /* Relax_align. Advance location counter to next address that has 'alignment'
2593 lowest order bits all 0s, return size of adjustment made. */
2594 static relax_addressT
2595 relax_align (relax_addressT address, /* Address now. */
2596 int alignment /* Alignment (binary). */)
2598 relax_addressT mask;
2599 relax_addressT new_address;
2601 mask = ~((relax_addressT) ~0 << alignment);
2602 new_address = (address + mask) & (~mask);
2603 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2605 /* We must provide lots of padding, so the linker can discard it
2606 when needed. The linker will not add extra space, ever. */
2607 new_address += (1 << alignment);
2609 return (new_address - address);
2612 /* Now we have a segment, not a crowd of sub-segments, we can make
2617 After this, all frags in this segment have addresses that are correct
2618 within the segment. Since segments live in different file addresses,
2619 these frag addresses may not be the same as final object-file
2623 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2625 unsigned long frag_count;
2627 relax_addressT address;
2631 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2632 subseg_change (segment, 0);
2634 /* For each frag in segment: count and store (a 1st guess of)
2638 for (frag_count = 0, fragP = segment_frag_root;
2640 fragP = fragP->fr_next, frag_count ++)
2642 fragP->region = region;
2643 fragP->relax_marker = 0;
2644 fragP->fr_address = address;
2645 address += fragP->fr_fix;
2647 switch (fragP->fr_type)
2650 address += fragP->fr_offset * fragP->fr_var;
2657 addressT offset = relax_align (address, (int) fragP->fr_offset);
2659 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2662 if (offset % fragP->fr_var != 0)
2664 as_bad_where (fragP->fr_file, fragP->fr_line,
2665 ngettext ("alignment padding (%lu byte) "
2666 "not a multiple of %ld",
2667 "alignment padding (%lu bytes) "
2668 "not a multiple of %ld",
2669 (unsigned long) offset),
2670 (unsigned long) offset, (long) fragP->fr_var);
2671 offset -= (offset % fragP->fr_var);
2680 /* Assume .org is nugatory. It will grow with 1st relax. */
2688 case rs_machine_dependent:
2689 /* If fr_symbol is an expression, this call to
2690 resolve_symbol_value sets up the correct segment, which will
2691 likely be needed in md_estimate_size_before_relax. */
2692 if (fragP->fr_symbol)
2693 resolve_symbol_value (fragP->fr_symbol);
2695 address += md_estimate_size_before_relax (fragP, segment);
2698 #ifndef WORKING_DOT_WORD
2699 /* Broken words don't concern us yet. */
2700 case rs_broken_word:
2705 /* Initial guess is always 1; doing otherwise can result in
2706 stable solutions that are larger than the minimum. */
2707 address += fragP->fr_offset = 1;
2711 address += eh_frame_estimate_size_before_relax (fragP);
2715 address += dwarf2dbg_estimate_size_before_relax (fragP);
2719 BAD_CASE (fragP->fr_type);
2726 unsigned long max_iterations;
2728 /* Cumulative address adjustment. */
2731 /* Have we made any adjustment this pass? We can't just test
2732 stretch because one piece of code may have grown and another
2736 /* Most horrible, but gcc may give us some exception data that
2737 is impossible to assemble, of the form
2741 .uleb128 end - start
2747 If the leb128 is two bytes in size, then end-start is 128*128,
2748 which requires a three byte leb128. If the leb128 is three
2749 bytes in size, then end-start is 128*128-1, which requires a
2750 two byte leb128. We work around this dilemma by inserting
2751 an extra 4 bytes of alignment just after the .align. This
2752 works because the data after the align is accessed relative to
2755 This counter is used in a tiny state machine to detect
2756 whether a leb128 followed by an align is impossible to
2758 int rs_leb128_fudge = 0;
2760 /* We want to prevent going into an infinite loop where one frag grows
2761 depending upon the location of a symbol which is in turn moved by
2762 the growing frag. eg:
2768 So we dictate that this algorithm can be at most O2. */
2769 max_iterations = frag_count * frag_count;
2770 /* Check for overflow. */
2771 if (max_iterations < frag_count)
2772 max_iterations = frag_count;
2780 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2783 addressT was_address;
2787 fragP->relax_marker ^= 1;
2788 was_address = fragP->fr_address;
2789 address = fragP->fr_address += stretch;
2790 symbolP = fragP->fr_symbol;
2791 offset = fragP->fr_offset;
2793 switch (fragP->fr_type)
2795 case rs_fill: /* .fill never relaxes. */
2799 #ifndef WORKING_DOT_WORD
2800 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2801 for it I do not want to write it. I do not want to have
2802 anything to do with it. This is not the proper way to
2803 implement this misfeature. */
2804 case rs_broken_word:
2806 struct broken_word *lie;
2807 struct broken_word *untruth;
2809 /* Yes this is ugly (storing the broken_word pointer
2810 in the symbol slot). Still, this whole chunk of
2811 code is ugly, and I don't feel like doing anything
2812 about it. Think of it as stubbornness in action. */
2814 for (lie = (struct broken_word *) (fragP->fr_symbol);
2815 lie && lie->dispfrag == fragP;
2816 lie = lie->next_broken_word)
2822 offset = (S_GET_VALUE (lie->add)
2824 - S_GET_VALUE (lie->sub));
2825 if (offset <= -32768 || offset >= 32767)
2827 if (flag_warn_displacement)
2830 sprint_value (buf, (addressT) lie->addnum);
2831 as_warn_where (fragP->fr_file, fragP->fr_line,
2832 _(".word %s-%s+%s didn't fit"),
2833 S_GET_NAME (lie->add),
2834 S_GET_NAME (lie->sub),
2837 if (fragP->fr_subtype == 0)
2839 fragP->fr_subtype++;
2840 growth += md_short_jump_size;
2843 /* Redirect *all* words of this table with the same
2844 target, lest we have to handle the case where the
2845 same target but with a offset that fits on this
2846 round overflows at the next relaxation round. */
2847 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2848 untruth && untruth->dispfrag == lie->dispfrag;
2849 untruth = untruth->next_broken_word)
2850 if ((symbol_get_frag (untruth->add)
2851 == symbol_get_frag (lie->add))
2852 && (S_GET_VALUE (untruth->add)
2853 == S_GET_VALUE (lie->add)))
2856 untruth->use_jump = lie;
2860 growth += md_long_jump_size;
2865 } /* case rs_broken_word */
2871 addressT oldoff, newoff;
2873 oldoff = relax_align (was_address + fragP->fr_fix,
2875 newoff = relax_align (address + fragP->fr_fix,
2878 if (fragP->fr_subtype != 0)
2880 if (oldoff > fragP->fr_subtype)
2882 if (newoff > fragP->fr_subtype)
2886 growth = newoff - oldoff;
2888 /* If this align happens to follow a leb128 and
2889 we have determined that the leb128 is bouncing
2890 in size, then break the cycle by inserting an
2893 && (rs_leb128_fudge & 16) != 0
2894 && (rs_leb128_fudge & 15) >= 2)
2896 segment_info_type *seginfo = seg_info (segment);
2897 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2900 newf = frag_alloc (ob);
2901 obstack_blank_fast (ob, fragP->fr_var);
2902 obstack_finish (ob);
2903 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2904 memcpy (newf->fr_literal,
2905 fragP->fr_literal + fragP->fr_fix,
2907 newf->fr_type = rs_fill;
2908 newf->fr_address = address + fragP->fr_fix + newoff;
2910 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2912 if (newf->fr_offset * newf->fr_var
2913 != (offsetT) 1 << fragP->fr_offset)
2915 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2918 /* Include size of new frag in GROWTH. */
2919 growth += newf->fr_offset * newf->fr_var;
2920 /* Adjust the new frag address for the amount
2921 we'll add when we process the new frag. */
2922 newf->fr_address -= stretch + growth;
2923 newf->relax_marker ^= 1;
2924 fragP->fr_next = newf;
2926 as_warn (_("padding added"));
2934 addressT target = offset;
2939 /* Convert from an actual address to an octet offset
2940 into the section. Here it is assumed that the
2941 section's VMA is zero, and can omit subtracting it
2942 from the symbol's value to get the address offset. */
2943 know (S_GET_SEGMENT (symbolP)->vma == 0);
2944 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2947 know (fragP->fr_next);
2948 after = fragP->fr_next->fr_address + stretch;
2949 growth = target - after;
2951 /* Growth may be negative, but variable part of frag
2952 cannot have fewer than 0 chars. That is, we can't
2954 if (address + fragP->fr_fix > target)
2958 /* Don't error on first few frag relax passes.
2959 The symbol might be an expression involving
2960 symbol values from other sections. If those
2961 sections have not yet been processed their
2962 frags will all have zero addresses, so we
2963 will calculate incorrect values for them. The
2964 number of passes we allow before giving an
2965 error is somewhat arbitrary. It should be at
2966 least one, with larger values requiring
2967 increasingly contrived dependencies between
2968 frags to trigger a false error. */
2971 /* Force another pass. */
2976 as_bad_where (fragP->fr_file, fragP->fr_line,
2977 _("attempt to move .org backwards"));
2979 /* We've issued an error message. Change the
2980 frag to avoid cascading errors. */
2981 fragP->fr_type = rs_align;
2982 fragP->fr_subtype = 0;
2983 fragP->fr_offset = 0;
2984 fragP->fr_fix = after - address;
2996 amount = S_GET_VALUE (symbolP);
2997 if (S_GET_SEGMENT (symbolP) != absolute_section
2998 || S_IS_COMMON (symbolP)
2999 || ! S_IS_DEFINED (symbolP))
3001 as_bad_where (fragP->fr_file, fragP->fr_line,
3002 _(".space specifies non-absolute value"));
3003 /* Prevent repeat of this error message. */
3004 fragP->fr_symbol = 0;
3006 else if (amount < 0)
3008 /* Don't error on first few frag relax passes.
3009 See rs_org comment for a longer explanation. */
3016 as_warn_where (fragP->fr_file, fragP->fr_line,
3017 _(".space, .nops or .fill with negative value, ignored"));
3018 fragP->fr_symbol = 0;
3021 growth = (was_address + fragP->fr_fix + amount
3022 - fragP->fr_next->fr_address);
3026 case rs_machine_dependent:
3027 #ifdef md_relax_frag
3028 growth = md_relax_frag (segment, fragP, stretch);
3030 #ifdef TC_GENERIC_RELAX_TABLE
3031 /* The default way to relax a frag is to look through
3032 TC_GENERIC_RELAX_TABLE. */
3033 growth = relax_frag (segment, fragP, stretch);
3034 #endif /* TC_GENERIC_RELAX_TABLE */
3043 value = resolve_symbol_value (fragP->fr_symbol);
3044 size = sizeof_leb128 (value, fragP->fr_subtype);
3045 growth = size - fragP->fr_offset;
3046 fragP->fr_offset = size;
3051 growth = eh_frame_relax_frag (fragP);
3055 growth = dwarf2dbg_relax_frag (fragP);
3059 BAD_CASE (fragP->fr_type);
3066 if (fragP->fr_type == rs_leb128)
3067 rs_leb128_fudge += 16;
3068 else if (fragP->fr_type == rs_align
3069 && (rs_leb128_fudge & 16) != 0
3071 rs_leb128_fudge += 16;
3073 rs_leb128_fudge = 0;
3078 && (rs_leb128_fudge & 16) == 0
3079 && (rs_leb128_fudge & -16) != 0)
3080 rs_leb128_fudge += 1;
3082 rs_leb128_fudge = 0;
3084 /* Until nothing further to relax. */
3085 while (stretched && -- max_iterations);
3088 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3089 segment_name (segment));
3092 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
3093 if (fragP->last_fr_address != fragP->fr_address)
3095 fragP->last_fr_address = fragP->fr_address;
3102 number_to_chars_bigendian (char *buf, valueT val, int n)
3108 buf[n] = val & 0xff;
3114 number_to_chars_littleendian (char *buf, valueT val, int n)
3120 *buf++ = val & 0xff;
3126 write_print_statistics (FILE *file)
3128 fprintf (file, "fixups: %d\n", n_fixups);
3131 /* For debugging. */
3132 extern int indent_level;
3135 print_fixup (fixS *fixp)
3138 fprintf (stderr, "fix ");
3139 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
3140 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
3142 fprintf (stderr, " pcrel");
3143 if (fixp->fx_pcrel_adjust)
3144 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
3146 fprintf (stderr, " tcbit");
3148 fprintf (stderr, " done");
3149 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
3150 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
3151 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
3152 (long) fixp->fx_where,
3153 (unsigned long) fixp->fx_offset,
3154 (unsigned long) fixp->fx_addnumber);
3155 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3159 fprintf (stderr, "\n +<");
3160 print_symbol_value_1 (stderr, fixp->fx_addsy);
3161 fprintf (stderr, ">");
3165 fprintf (stderr, "\n -<");
3166 print_symbol_value_1 (stderr, fixp->fx_subsy);
3167 fprintf (stderr, ">");
3169 fprintf (stderr, "\n");
3170 #ifdef TC_FIX_DATA_PRINT
3171 TC_FIX_DATA_PRINT (stderr, fixp);