1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010, 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This thing should be set up to do byteordering correctly. But... */
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 #include "compress-debug.h"
33 #ifndef TC_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 /* 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 bfd_vma addr_mask = 1;
658 struct reloc_list *r;
660 /* Avoid a shift by the width of type. */
661 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
665 for (r = reloc_list; r; r = r->next)
667 reloc_howto_type *howto = r->u.a.howto;
670 bfd_vma offset, addend;
673 resolve_symbol_value (r->u.a.offset_sym);
674 symval = symbol_get_value_expression (r->u.a.offset_sym);
678 if (symval->X_op == O_constant)
679 sym = r->u.a.offset_sym;
680 else if (symval->X_op == O_symbol)
682 sym = symval->X_add_symbol;
683 offset = symval->X_add_number;
684 symval = symbol_get_value_expression (symval->X_add_symbol);
687 || symval->X_op != O_constant
688 || (sec = S_GET_SEGMENT (sym)) == NULL
689 || !SEG_NORMAL (sec))
691 as_bad_where (r->file, r->line, _("invalid offset expression"));
695 offset += S_GET_VALUE (sym);
698 addend = r->u.a.addend;
699 if (r->u.a.sym != NULL)
701 resolve_symbol_value (r->u.a.sym);
702 symval = symbol_get_value_expression (r->u.a.sym);
703 if (symval->X_op == O_constant)
705 else if (symval->X_op == O_symbol)
707 sym = symval->X_add_symbol;
708 addend += symval->X_add_number;
709 symval = symbol_get_value_expression (symval->X_add_symbol);
711 if (symval->X_op != O_constant)
713 as_bad_where (r->file, r->line, _("invalid reloc expression"));
716 else if (sym != NULL)
718 /* Convert relocs against local symbols to refer to the
719 corresponding section symbol plus offset instead. Keep
720 PC-relative relocs of the REL variety intact though to
721 prevent the offset from overflowing the relocated field,
722 unless it has enough bits to cover the whole address
724 if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
725 && !(howto->partial_inplace
726 && howto->pc_relative
727 && howto->src_mask != addr_mask))
729 asection *symsec = S_GET_SEGMENT (sym);
730 if (!(((symsec->flags & SEC_MERGE) != 0
732 || (symsec->flags & SEC_THREAD_LOCAL) != 0))
734 addend += S_GET_VALUE (sym);
735 sym = section_symbol (symsec);
738 symbol_mark_used_in_reloc (sym);
743 if (abs_section_sym == NULL)
744 abs_section_sym = section_symbol (absolute_section);
745 sym = abs_section_sym;
749 r->u.b.s = symbol_get_bfdsym (sym);
750 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
751 r->u.b.r.address = offset;
752 r->u.b.r.addend = addend;
753 r->u.b.r.howto = howto;
757 /* This pass over fixups decides whether symbols can be replaced with
761 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
763 void *xxx ATTRIBUTE_UNUSED)
765 segment_info_type *seginfo = seg_info (sec);
771 dump_section_relocs (abfd, sec, stderr);
773 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
777 else if (fixp->fx_addsy)
783 fprintf (stderr, "\n\nadjusting fixup:\n");
787 sym = fixp->fx_addsy;
789 /* All symbols should have already been resolved at this
790 point. It is possible to see unresolved expression
791 symbols, though, since they are not in the regular symbol
793 resolve_symbol_value (sym);
795 if (fixp->fx_subsy != NULL)
796 resolve_symbol_value (fixp->fx_subsy);
798 /* If this symbol is equated to an undefined or common symbol,
799 convert the fixup to being against that symbol. */
800 while (symbol_equated_reloc_p (sym)
801 || S_IS_WEAKREFR (sym))
803 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
806 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
807 fixp->fx_addsy = newsym;
811 if (symbol_mri_common_p (sym))
813 fixp->fx_offset += S_GET_VALUE (sym);
814 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
818 /* If the symbol is undefined, common, weak, or global (ELF
819 shared libs), we can't replace it with the section symbol. */
820 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
823 /* Is there some other (target cpu dependent) reason we can't adjust
824 this one? (E.g. relocations involving function addresses on
826 #ifdef tc_fix_adjustable
827 if (! tc_fix_adjustable (fixp))
831 /* Since we're reducing to section symbols, don't attempt to reduce
832 anything that's already using one. */
833 if (symbol_section_p (sym))
836 symsec = S_GET_SEGMENT (sym);
840 if (bfd_is_abs_section (symsec))
842 /* The fixup_segment routine normally will not use this
843 symbol in a relocation. */
847 /* Don't try to reduce relocs which refer to non-local symbols
848 in .linkonce sections. It can lead to confusion when a
849 debugging section refers to a .linkonce section. I hope
850 this will always be correct. */
851 if (symsec != sec && ! S_IS_LOCAL (sym))
853 if ((symsec->flags & SEC_LINK_ONCE) != 0
855 /* The GNU toolchain uses an extension for ELF: a
856 section beginning with the magic string
857 .gnu.linkonce is a linkonce section. */
858 && strncmp (segment_name (symsec), ".gnu.linkonce",
859 sizeof ".gnu.linkonce" - 1) == 0))
863 /* Never adjust a reloc against local symbol in a merge section
864 with non-zero addend. */
865 if ((symsec->flags & SEC_MERGE) != 0
866 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
869 /* Never adjust a reloc against TLS local symbol. */
870 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
873 /* We refetch the segment when calling section_symbol, rather
874 than using symsec, because S_GET_VALUE may wind up changing
875 the section when it calls resolve_symbol_value. */
876 fixp->fx_offset += S_GET_VALUE (sym);
877 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
879 fprintf (stderr, "\nadjusted fixup:\n");
884 dump_section_relocs (abfd, sec, stderr);
889 Go through all the fixS's in a segment and see which ones can be
890 handled now. (These consist of fixS where we have since discovered
891 the value of a symbol, or the address of the frag involved.)
892 For each one, call md_apply_fix to put the fix into the frag data.
894 Result is a count of how many relocation structs will be needed to
895 handle the remaining fixS's that we couldn't completely handle here.
896 These will be output later by emit_relocations(). */
899 fixup_segment (fixS *fixP, segT this_segment)
901 long seg_reloc_count = 0;
904 segT add_symbol_segment = absolute_section;
906 if (fixP != NULL && abs_section_sym == NULL)
907 abs_section_sym = section_symbol (absolute_section);
909 /* If the linker is doing the relaxing, we must not do any fixups.
911 Well, strictly speaking that's not true -- we could do any that
912 are PC-relative and don't cross regions that could change size.
913 And for the i960 we might be able to turn callx/callj into bal
914 anyways in cases where we know the maximum displacement. */
915 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
917 for (; fixP; fixP = fixP->fx_next)
920 if (fixP->fx_addsy == NULL)
922 /* There was no symbol required by this relocation.
923 However, BFD doesn't really handle relocations
924 without symbols well. So fake up a local symbol in
925 the absolute section. */
926 fixP->fx_addsy = abs_section_sym;
928 symbol_mark_used_in_reloc (fixP->fx_addsy);
929 if (fixP->fx_subsy != NULL)
930 symbol_mark_used_in_reloc (fixP->fx_subsy);
933 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
934 return seg_reloc_count;
937 for (; fixP; fixP = fixP->fx_next)
940 fprintf (stderr, "\nprocessing fixup:\n");
944 fragP = fixP->fx_frag;
946 #ifdef TC_VALIDATE_FIX
947 TC_VALIDATE_FIX (fixP, this_segment, skip);
949 add_number = fixP->fx_offset;
951 if (fixP->fx_addsy != NULL)
952 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
954 if (fixP->fx_subsy != NULL)
956 segT sub_symbol_segment;
957 resolve_symbol_value (fixP->fx_subsy);
958 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
959 if (fixP->fx_addsy != NULL
960 && sub_symbol_segment == add_symbol_segment
961 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
962 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
963 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
965 add_number += S_GET_VALUE (fixP->fx_addsy);
966 add_number -= S_GET_VALUE (fixP->fx_subsy);
967 fixP->fx_offset = add_number;
968 fixP->fx_addsy = NULL;
969 fixP->fx_subsy = NULL;
971 /* See the comment below about 68k weirdness. */
975 else if (sub_symbol_segment == absolute_section
976 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
977 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
979 add_number -= S_GET_VALUE (fixP->fx_subsy);
980 fixP->fx_offset = add_number;
981 fixP->fx_subsy = NULL;
983 else if (sub_symbol_segment == this_segment
984 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
985 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
987 add_number -= S_GET_VALUE (fixP->fx_subsy);
988 fixP->fx_offset = (add_number + fixP->fx_dot_value
989 + fixP->fx_frag->fr_address);
991 /* Make it pc-relative. If the back-end code has not
992 selected a pc-relative reloc, cancel the adjustment
993 we do later on all pc-relative relocs. */
996 /* Do this for m68k even if it's already described
997 as pc-relative. On the m68k, an operand of
998 "pc@(foo-.-2)" should address "foo" in a
1003 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1004 fixP->fx_subsy = NULL;
1007 else if (TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1008 /* If the fix is valid, subtract fx_subsy here. The addition of
1009 fx_addsy will be performed below. Doing this prevents bogus
1010 warnings from the range check below. */
1011 add_number -= S_GET_VALUE (fixP->fx_subsy);
1014 if (!md_register_arithmetic
1015 && (add_symbol_segment == reg_section
1016 || sub_symbol_segment == reg_section))
1017 as_bad_where (fixP->fx_file, fixP->fx_line,
1018 _("register value used as expression"));
1020 as_bad_where (fixP->fx_file, fixP->fx_line,
1021 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1022 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1023 segment_name (add_symbol_segment),
1024 S_GET_NAME (fixP->fx_subsy),
1025 segment_name (sub_symbol_segment));
1031 if (add_symbol_segment == this_segment
1032 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1033 && !TC_FORCE_RELOCATION_LOCAL (fixP))
1035 /* This fixup was made when the symbol's segment was
1036 SEG_UNKNOWN, but it is now in the local segment.
1037 So we know how to do the address without relocation. */
1038 add_number += S_GET_VALUE (fixP->fx_addsy);
1039 fixP->fx_offset = add_number;
1041 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1042 fixP->fx_addsy = NULL;
1045 else if (add_symbol_segment == absolute_section
1046 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1047 && !TC_FORCE_RELOCATION_ABS (fixP))
1049 add_number += S_GET_VALUE (fixP->fx_addsy);
1050 fixP->fx_offset = add_number;
1051 fixP->fx_addsy = NULL;
1053 else if (add_symbol_segment != undefined_section
1054 && ! bfd_is_com_section (add_symbol_segment)
1055 && MD_APPLY_SYM_VALUE (fixP))
1056 add_number += S_GET_VALUE (fixP->fx_addsy);
1061 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1062 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1064 /* There was no symbol required by this relocation.
1065 However, BFD doesn't really handle relocations
1066 without symbols well. So fake up a local symbol in
1067 the absolute section. */
1068 fixP->fx_addsy = abs_section_sym;
1073 md_apply_fix (fixP, &add_number, this_segment);
1078 if (fixP->fx_addsy == NULL)
1079 fixP->fx_addsy = abs_section_sym;
1080 symbol_mark_used_in_reloc (fixP->fx_addsy);
1081 if (fixP->fx_subsy != NULL)
1082 symbol_mark_used_in_reloc (fixP->fx_subsy);
1085 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1087 if (fixP->fx_size < sizeof (valueT))
1092 mask--; /* Set all bits to one. */
1093 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1094 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1096 char buf[50], buf2[50];
1097 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1098 if (add_number > 1000)
1099 sprint_value (buf2, add_number);
1101 sprintf (buf2, "%ld", (long) add_number);
1102 as_bad_where (fixP->fx_file, fixP->fx_line,
1103 _("value of %s too large for field of %d bytes at %s"),
1104 buf2, fixP->fx_size, buf);
1105 } /* Generic error checking. */
1107 #ifdef WARN_SIGNED_OVERFLOW_WORD
1108 /* Warn if a .word value is too large when treated as a signed
1109 number. We already know it is not too negative. This is to
1110 catch over-large switches generated by gcc on the 68k. */
1111 if (!flag_signed_overflow_ok
1112 && fixP->fx_size == 2
1113 && add_number > 0x7fff)
1114 as_bad_where (fixP->fx_file, fixP->fx_line,
1115 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1117 (long) (fragP->fr_address + fixP->fx_where));
1119 } /* Not a bit fix. */
1121 #ifdef TC_VALIDATE_FIX
1122 skip: ATTRIBUTE_UNUSED_LABEL
1126 fprintf (stderr, "result:\n");
1129 } /* For each fixS in this segment. */
1131 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1132 return seg_reloc_count;
1136 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1138 void *xxx ATTRIBUTE_UNUSED)
1140 segment_info_type *seginfo = seg_info (sec);
1142 fixup_segment (seginfo->fix_root, sec);
1146 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1147 char *file, unsigned int line)
1150 bfd_reloc_status_type s;
1153 if (reloc->sym_ptr_ptr != NULL
1154 && (sym = *reloc->sym_ptr_ptr) != NULL
1155 && (sym->flags & BSF_KEEP) == 0
1156 && ((sym->flags & BSF_SECTION_SYM) == 0
1157 || (EMIT_SECTION_SYMBOLS
1158 && !bfd_is_abs_section (sym->section))))
1159 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1161 s = bfd_install_relocation (stdoutput, reloc,
1162 fragp->fr_literal, fragp->fr_address,
1168 case bfd_reloc_overflow:
1169 as_bad_where (file, line, _("relocation overflow"));
1171 case bfd_reloc_outofrange:
1172 as_bad_where (file, line, _("relocation out of range"));
1175 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1181 get_frag_for_reloc (fragS *last_frag,
1182 const segment_info_type *seginfo,
1183 const struct reloc_list *r)
1187 for (f = last_frag; f != NULL; f = f->fr_next)
1188 if (f->fr_address <= r->u.b.r.address
1189 && r->u.b.r.address < f->fr_address + f->fr_fix)
1192 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1193 if (f->fr_address <= r->u.b.r.address
1194 && r->u.b.r.address < f->fr_address + f->fr_fix)
1197 as_bad_where (r->file, r->line,
1198 _("reloc not within (fixed part of) section"));
1203 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1205 segment_info_type *seginfo = seg_info (sec);
1207 struct reloc_list *my_reloc_list, **rp, *r;
1212 /* If seginfo is NULL, we did not create this section; don't do
1213 anything with it. */
1214 if (seginfo == NULL)
1218 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1222 #ifdef RELOC_EXPANSION_POSSIBLE
1223 n *= MAX_RELOC_EXPANSION;
1226 /* Extract relocs for this section from reloc_list. */
1228 my_reloc_list = NULL;
1229 while ((r = *rp) != NULL)
1231 if (r->u.b.sec == sec)
1234 r->next = my_reloc_list;
1242 relocs = (arelent **) xcalloc (n, sizeof (arelent *));
1247 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1252 #ifndef RELOC_EXPANSION_POSSIBLE
1261 fx_size = fixp->fx_size;
1262 slack = TC_FX_SIZE_SLACK (fixp);
1264 fx_size = fx_size > slack ? fx_size - slack : 0;
1265 loc = fixp->fx_where + fx_size;
1266 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1267 as_bad_where (fixp->fx_file, fixp->fx_line,
1268 _("internal error: fixup not contained within frag"));
1270 #ifndef RELOC_EXPANSION_POSSIBLE
1271 *reloc = tc_gen_reloc (sec, fixp);
1273 reloc = tc_gen_reloc (sec, fixp);
1278 while (r != NULL && r->u.b.r.address < (*reloc)->address)
1280 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1284 relocs[n++] = &r->u.b.r;
1285 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1289 relocs[n++] = *reloc;
1290 install_reloc (sec, *reloc, fixp->fx_frag,
1291 fixp->fx_file, fixp->fx_line);
1292 #ifndef RELOC_EXPANSION_POSSIBLE
1302 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1306 relocs[n++] = &r->u.b.r;
1307 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1314 unsigned int k, j, nsyms;
1316 sympp = bfd_get_outsymbols (stdoutput);
1317 nsyms = bfd_get_symcount (stdoutput);
1318 for (k = 0; k < n; k++)
1319 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1321 for (j = 0; j < nsyms; j++)
1322 if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1332 flagword flags = bfd_get_section_flags (abfd, sec);
1334 bfd_set_section_flags (abfd, sec, flags);
1335 bfd_set_reloc (stdoutput, sec, relocs, n);
1338 #ifdef SET_SECTION_RELOCS
1339 SET_SECTION_RELOCS (sec, relocs, n);
1346 fprintf (stderr, "relocs for sec %s\n", sec->name);
1347 for (k = 0; k < n; k++)
1349 arelent *rel = relocs[k];
1350 asymbol *s = *rel->sym_ptr_ptr;
1351 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1352 k, rel, (unsigned long)rel->address, s->name,
1353 (unsigned long)rel->addend);
1360 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1361 fragS **last_newf, struct obstack *ob)
1364 int total_out_size = 0;
1365 fragS *f = *last_newf;
1369 /* Call the compression routine repeatedly until it has finished
1370 processing the frag. */
1373 /* Reserve all the space available in the current chunk.
1374 If none is available, start a new frag. */
1375 avail_out = obstack_room (ob);
1378 obstack_finish (ob);
1379 f = frag_alloc (ob);
1380 f->fr_type = rs_fill;
1381 (*last_newf)->fr_next = f;
1383 avail_out = obstack_room (ob);
1386 as_fatal (_("can't extend frag"));
1387 next_out = obstack_next_free (ob);
1388 obstack_blank_fast (ob, avail_out);
1389 out_size = compress_data (strm, &contents, &in_size,
1390 &next_out, &avail_out);
1394 f->fr_fix += out_size;
1395 total_out_size += out_size;
1397 /* Return unused space. */
1399 obstack_blank_fast (ob, -avail_out);
1402 return total_out_size;
1406 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1408 segment_info_type *seginfo = seg_info (sec);
1412 struct obstack *ob = &seginfo->frchainP->frch_obstack;
1413 bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1414 bfd_size_type compressed_size;
1415 const char *section_name;
1416 char *compressed_name;
1418 struct z_stream_s *strm;
1420 flagword flags = bfd_get_section_flags (abfd, sec);
1424 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1427 section_name = bfd_get_section_name (stdoutput, sec);
1428 if (strncmp (section_name, ".debug_", 7) != 0)
1431 strm = compress_init ();
1435 /* Create a new frag to contain the "ZLIB" header. */
1436 first_newf = frag_alloc (ob);
1437 if (obstack_room (ob) < 12)
1438 first_newf = frag_alloc (ob);
1439 if (obstack_room (ob) < 12)
1440 as_fatal (_("can't extend frag %u chars"), 12);
1441 last_newf = first_newf;
1442 obstack_blank_fast (ob, 12);
1443 last_newf->fr_type = rs_fill;
1444 last_newf->fr_fix = 12;
1445 header = last_newf->fr_literal;
1446 memcpy (header, "ZLIB", 4);
1447 header[11] = uncompressed_size; uncompressed_size >>= 8;
1448 header[10] = uncompressed_size; uncompressed_size >>= 8;
1449 header[9] = uncompressed_size; uncompressed_size >>= 8;
1450 header[8] = uncompressed_size; uncompressed_size >>= 8;
1451 header[7] = uncompressed_size; uncompressed_size >>= 8;
1452 header[6] = uncompressed_size; uncompressed_size >>= 8;
1453 header[5] = uncompressed_size; uncompressed_size >>= 8;
1454 header[4] = uncompressed_size;
1455 compressed_size = 12;
1457 /* Stream the frags through the compression engine, adding new frags
1458 as necessary to accomodate the compressed output. */
1459 for (f = seginfo->frchainP->frch_root;
1468 gas_assert (f->fr_type == rs_fill);
1471 out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1475 compressed_size += out_size;
1477 fill_literal = f->fr_literal + f->fr_fix;
1478 fill_size = f->fr_var;
1479 count = f->fr_offset;
1480 gas_assert (count >= 0);
1481 if (fill_size && count)
1485 out_size = compress_frag (strm, fill_literal, (int) fill_size,
1489 compressed_size += out_size;
1494 /* Flush the compression state. */
1501 /* Reserve all the space available in the current chunk.
1502 If none is available, start a new frag. */
1503 avail_out = obstack_room (ob);
1508 obstack_finish (ob);
1509 newf = frag_alloc (ob);
1510 newf->fr_type = rs_fill;
1511 last_newf->fr_next = newf;
1513 avail_out = obstack_room (ob);
1516 as_fatal (_("can't extend frag"));
1517 next_out = obstack_next_free (ob);
1518 obstack_blank_fast (ob, avail_out);
1519 x = compress_finish (strm, &next_out, &avail_out, &out_size);
1523 last_newf->fr_fix += out_size;
1524 compressed_size += out_size;
1526 /* Return unused space. */
1528 obstack_blank_fast (ob, -avail_out);
1534 /* Replace the uncompressed frag list with the compressed frag list. */
1535 seginfo->frchainP->frch_root = first_newf;
1536 seginfo->frchainP->frch_last = last_newf;
1538 /* Update the section size and its name. */
1539 x = bfd_set_section_size (abfd, sec, compressed_size);
1541 compressed_name = (char *) xmalloc (strlen (section_name) + 2);
1542 compressed_name[0] = '.';
1543 compressed_name[1] = 'z';
1544 strcpy (compressed_name + 2, section_name + 1);
1545 bfd_section_name (stdoutput, sec) = compressed_name;
1549 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1551 void *xxx ATTRIBUTE_UNUSED)
1553 segment_info_type *seginfo = seg_info (sec);
1554 addressT offset = 0;
1557 /* Write out the frags. */
1559 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1562 for (f = seginfo->frchainP->frch_root;
1571 gas_assert (f->fr_type == rs_fill);
1574 x = bfd_set_section_contents (stdoutput, sec,
1575 f->fr_literal, (file_ptr) offset,
1576 (bfd_size_type) f->fr_fix);
1578 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1579 bfd_errmsg (bfd_get_error ()));
1580 offset += f->fr_fix;
1582 fill_literal = f->fr_literal + f->fr_fix;
1583 fill_size = f->fr_var;
1584 count = f->fr_offset;
1585 gas_assert (count >= 0);
1586 if (fill_size && count)
1589 if (fill_size > sizeof (buf))
1591 /* Do it the old way. Can this ever happen? */
1594 x = bfd_set_section_contents (stdoutput, sec,
1597 (bfd_size_type) fill_size);
1599 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1600 bfd_errmsg (bfd_get_error ()));
1601 offset += fill_size;
1606 /* Build a buffer full of fill objects and output it as
1607 often as necessary. This saves on the overhead of
1608 potentially lots of bfd_set_section_contents calls. */
1612 n_per_buf = sizeof (buf);
1613 memset (buf, *fill_literal, n_per_buf);
1618 n_per_buf = sizeof (buf) / fill_size;
1619 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1620 memcpy (bufp, fill_literal, fill_size);
1622 for (; count > 0; count -= n_per_buf)
1624 n_per_buf = n_per_buf > count ? count : n_per_buf;
1625 x = bfd_set_section_contents
1626 (stdoutput, sec, buf, (file_ptr) offset,
1627 (bfd_size_type) n_per_buf * fill_size);
1629 as_fatal (_("cannot write to output file '%s': %s"),
1630 stdoutput->filename,
1631 bfd_errmsg (bfd_get_error ()));
1632 offset += n_per_buf * fill_size;
1640 merge_data_into_text (void)
1642 seg_info (text_section)->frchainP->frch_last->fr_next =
1643 seg_info (data_section)->frchainP->frch_root;
1644 seg_info (text_section)->frchainP->frch_last =
1645 seg_info (data_section)->frchainP->frch_last;
1646 seg_info (data_section)->frchainP = 0;
1657 /* Count symbols. We can't rely on a count made by the loop in
1658 write_object_file, because *_frob_file may add a new symbol or
1661 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1667 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1669 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1670 symp = symbol_rootP;
1671 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1673 asympp[i] = symbol_get_bfdsym (symp);
1674 if (asympp[i]->flags != BSF_SECTION_SYM
1675 || !(bfd_is_const_section (asympp[i]->section)
1676 && asympp[i]->section->symbol == asympp[i]))
1677 asympp[i]->flags |= BSF_KEEP;
1678 symbol_mark_written (symp);
1683 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1684 gas_assert (result);
1685 symbol_table_frozen = 1;
1688 /* Finish the subsegments. After every sub-segment, we fake an
1689 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1690 ".fill 0" because that is the kind of frag that requires least
1691 thought. ".align" frags like to have a following frag since that
1692 makes calculating their intended length trivial. */
1694 #ifndef SUB_SEGMENT_ALIGN
1696 /* The last subsegment gets an alignment corresponding to the alignment
1697 of the section. This allows proper nop-filling at the end of
1698 code-bearing sections. */
1699 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1700 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1702 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1707 subsegs_finish (void)
1709 struct frchain *frchainP;
1712 for (s = stdoutput->sections; s; s = s->next)
1714 segment_info_type *seginfo = seg_info (s);
1718 for (frchainP = seginfo->frchainP;
1720 frchainP = frchainP->frch_next)
1724 subseg_set (s, frchainP->frch_subseg);
1726 /* This now gets called even if we had errors. In that case,
1727 any alignment is meaningless, and, moreover, will look weird
1728 if we are generating a listing. */
1731 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1732 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1733 && now_seg->entsize)
1735 unsigned int entsize = now_seg->entsize;
1738 while ((entsize & 1) == 0)
1743 if (entalign > alignment)
1744 alignment = entalign;
1748 if (subseg_text_p (now_seg))
1749 frag_align_code (alignment, 0);
1751 frag_align (alignment, 0, 0);
1753 /* frag_align will have left a new frag.
1754 Use this last frag for an empty ".fill".
1756 For this segment ...
1757 Create a last frag. Do not leave a "being filled in frag". */
1758 frag_wane (frag_now);
1759 frag_now->fr_fix = 0;
1760 know (frag_now->fr_next == NULL);
1765 /* Write the object file. */
1768 write_object_file (void)
1770 struct relax_seg_info rsi;
1771 #ifndef WORKING_DOT_WORD
1772 fragS *fragP; /* Track along all frags. */
1775 #ifdef md_pre_output_hook
1779 /* Do we really want to write it? */
1781 int n_warns, n_errs;
1782 n_warns = had_warnings ();
1783 n_errs = had_errors ();
1784 /* The -Z flag indicates that an object file should be generated,
1785 regardless of warnings and errors. */
1786 if (flag_always_generate_output)
1788 if (n_warns || n_errs)
1789 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1790 n_errs, n_errs == 1 ? "" : "s",
1791 n_warns, n_warns == 1 ? "" : "s");
1796 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1797 n_errs, n_errs == 1 ? "" : "s",
1798 n_warns, n_warns == 1 ? "" : "s");
1802 #ifdef md_pre_relax_hook
1806 /* From now on, we don't care about sub-segments. Build one frag chain
1807 for each segment. Linked thru fr_next. */
1809 /* Remove the sections created by gas for its own purposes. */
1813 bfd_section_list_remove (stdoutput, reg_section);
1814 bfd_section_list_remove (stdoutput, expr_section);
1815 stdoutput->section_count -= 2;
1817 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1820 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1822 /* We have two segments. If user gave -R flag, then we must put the
1823 data frags into the text segment. Do this before relaxing so
1824 we know to take advantage of -R and make shorter addresses. */
1825 if (flag_readonly_data_in_text)
1827 merge_data_into_text ();
1833 #ifndef WORKING_DOT_WORD
1834 /* We need to reset the markers in the broken word list and
1835 associated frags between calls to relax_segment (via
1836 relax_seg). Since the broken word list is global, we do it
1837 once per round, rather than locally in relax_segment for each
1839 struct broken_word *brokp;
1841 for (brokp = broken_words;
1842 brokp != (struct broken_word *) NULL;
1843 brokp = brokp->next_broken_word)
1847 if (brokp->dispfrag != (fragS *) NULL
1848 && brokp->dispfrag->fr_type == rs_broken_word)
1849 brokp->dispfrag->fr_subtype = 0;
1854 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1860 /* Note - Most ports will use the default value of
1861 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1862 local symbols to be resolved, removing their frag information.
1863 Some ports however, will not have finished relaxing all of
1864 their frags and will still need the local symbol frag
1865 information. These ports can set
1866 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1867 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1869 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1871 /* Relaxation has completed. Freeze all syms. */
1874 #ifdef md_post_relax_hook
1878 #ifndef WORKING_DOT_WORD
1880 struct broken_word *lie;
1881 struct broken_word **prevP;
1883 prevP = &broken_words;
1884 for (lie = broken_words; lie; lie = lie->next_broken_word)
1889 subseg_change (lie->seg, lie->subseg);
1890 exp.X_op = O_subtract;
1891 exp.X_add_symbol = lie->add;
1892 exp.X_op_symbol = lie->sub;
1893 exp.X_add_number = lie->addnum;
1894 #ifdef TC_CONS_FIX_NEW
1895 TC_CONS_FIX_NEW (lie->frag,
1896 lie->word_goes_here - lie->frag->fr_literal,
1899 fix_new_exp (lie->frag,
1900 lie->word_goes_here - lie->frag->fr_literal,
1901 2, &exp, 0, BFD_RELOC_16);
1903 *prevP = lie->next_broken_word;
1906 prevP = &(lie->next_broken_word);
1908 for (lie = broken_words; lie;)
1910 struct broken_word *untruth;
1912 addressT table_addr;
1913 addressT from_addr, to_addr;
1916 subseg_change (lie->seg, lie->subseg);
1917 fragP = lie->dispfrag;
1919 /* Find out how many broken_words go here. */
1922 untruth && untruth->dispfrag == fragP;
1923 untruth = untruth->next_broken_word)
1924 if (untruth->added == 1)
1927 table_ptr = lie->dispfrag->fr_opcode;
1928 table_addr = (lie->dispfrag->fr_address
1929 + (table_ptr - lie->dispfrag->fr_literal));
1930 /* Create the jump around the long jumps. This is a short
1931 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1932 from_addr = table_addr;
1933 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1934 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1936 table_ptr += md_short_jump_size;
1937 table_addr += md_short_jump_size;
1940 lie && lie->dispfrag == fragP;
1941 m++, lie = lie->next_broken_word)
1943 if (lie->added == 2)
1945 /* Patch the jump table. */
1946 for (untruth = (struct broken_word *) (fragP->fr_symbol);
1947 untruth && untruth->dispfrag == fragP;
1948 untruth = untruth->next_broken_word)
1950 if (untruth->use_jump == lie)
1952 /* This is the offset from ??? to table_ptr+0.
1953 The target is the same for all users of this
1954 md_long_jump, but the "sub" bases (and hence the
1955 offsets) may be different. */
1956 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1957 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1958 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1960 md_number_to_chars (untruth->word_goes_here, to_word, 2);
1964 /* Install the long jump. */
1965 /* This is a long jump from table_ptr+0 to the final target. */
1966 from_addr = table_addr;
1967 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1968 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1970 table_ptr += md_long_jump_size;
1971 table_addr += md_long_jump_size;
1975 #endif /* not WORKING_DOT_WORD */
1977 /* Resolve symbol values. This needs to be done before processing
1983 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1984 resolve_symbol_value (symp);
1986 resolve_local_symbol_values ();
1987 resolve_reloc_expr_symbols ();
1991 #ifdef tc_frob_file_before_adjust
1992 tc_frob_file_before_adjust ();
1994 #ifdef obj_frob_file_before_adjust
1995 obj_frob_file_before_adjust ();
1998 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2000 #ifdef tc_frob_file_before_fix
2001 tc_frob_file_before_fix ();
2003 #ifdef obj_frob_file_before_fix
2004 obj_frob_file_before_fix ();
2007 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2009 /* Set up symbol table, and write it out. */
2013 bfd_boolean skip_next_symbol = FALSE;
2015 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2020 if (skip_next_symbol)
2022 /* Don't do anything besides moving the value of the
2023 symbol from the GAS value-field to the BFD value-field. */
2024 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2025 skip_next_symbol = FALSE;
2029 if (symbol_mri_common_p (symp))
2031 if (S_IS_EXTERNAL (symp))
2032 as_bad (_("%s: global symbols not supported in common sections"),
2034 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2038 name = S_GET_NAME (symp);
2042 decode_local_label_name ((char *) S_GET_NAME (symp));
2043 /* They only differ if `name' is a fb or dollar local
2045 if (name2 != name && ! S_IS_DEFINED (symp))
2046 as_bad (_("local label `%s' is not defined"), name2);
2049 /* Do it again, because adjust_reloc_syms might introduce
2050 more symbols. They'll probably only be section symbols,
2051 but they'll still need to have the values computed. */
2052 resolve_symbol_value (symp);
2054 /* Skip symbols which were equated to undefined or common
2056 if (symbol_equated_reloc_p (symp)
2057 || S_IS_WEAKREFR (symp))
2059 const char *sname = S_GET_NAME (symp);
2061 if (S_IS_COMMON (symp)
2062 && !TC_FAKE_LABEL (sname)
2063 && !S_IS_WEAKREFR (symp)
2064 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2066 expressionS *e = symbol_get_value_expression (symp);
2068 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2069 sname, S_GET_NAME (e->X_add_symbol));
2071 if (S_GET_SEGMENT (symp) == reg_section)
2073 /* Report error only if we know the symbol name. */
2074 if (S_GET_NAME (symp) != reg_section->name)
2075 as_bad (_("can't make global register symbol `%s'"),
2078 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2082 #ifdef obj_frob_symbol
2083 obj_frob_symbol (symp, punt);
2085 #ifdef tc_frob_symbol
2086 if (! punt || symbol_used_in_reloc_p (symp))
2087 tc_frob_symbol (symp, punt);
2090 /* If we don't want to keep this symbol, splice it out of
2091 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2092 want section symbols. Otherwise, we skip local symbols
2093 and symbols that the frob_symbol macros told us to punt,
2094 but we keep such symbols if they are used in relocs. */
2095 if (symp == abs_section_sym
2096 || (! EMIT_SECTION_SYMBOLS
2097 && symbol_section_p (symp))
2098 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2099 opposites. Sometimes the former checks flags and the
2100 latter examines the name... */
2101 || (!S_IS_EXTERNAL (symp)
2102 && (punt || S_IS_LOCAL (symp) ||
2103 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2104 && ! symbol_used_in_reloc_p (symp)))
2106 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2108 /* After symbol_remove, symbol_next(symp) still returns
2109 the one that came after it in the chain. So we don't
2110 need to do any extra cleanup work here. */
2114 /* Make sure we really got a value for the symbol. */
2115 if (! symbol_resolved_p (symp))
2117 as_bad (_("can't resolve value for symbol `%s'"),
2119 symbol_mark_resolved (symp);
2122 /* Set the value into the BFD symbol. Up til now the value
2123 has only been kept in the gas symbolS struct. */
2124 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2126 /* A warning construct is a warning symbol followed by the
2127 symbol warned about. Don't let anything object-format or
2128 target-specific muck with it; it's ready for output. */
2129 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2130 skip_next_symbol = TRUE;
2136 /* Now do any format-specific adjustments to the symbol table, such
2137 as adding file symbols. */
2138 #ifdef tc_adjust_symtab
2139 tc_adjust_symtab ();
2141 #ifdef obj_adjust_symtab
2142 obj_adjust_symtab ();
2145 /* Stop if there is an error. */
2149 /* Now that all the sizes are known, and contents correct, we can
2150 start writing to the file. */
2153 /* If *_frob_file changes the symbol value at this point, it is
2154 responsible for moving the changed value into symp->bsym->value
2155 as well. Hopefully all symbol value changing can be done in
2160 #ifdef obj_frob_file
2163 #ifdef obj_coff_generate_pdata
2164 obj_coff_generate_pdata ();
2166 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2168 #ifdef tc_frob_file_after_relocs
2169 tc_frob_file_after_relocs ();
2171 #ifdef obj_frob_file_after_relocs
2172 obj_frob_file_after_relocs ();
2175 /* Once all relocations have been written, we can compress the
2176 contents of the debug sections. This needs to be done before
2177 we start writing any sections, because it will affect the file
2178 layout, which is fixed once we start writing contents. */
2179 if (flag_compress_debug)
2180 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2182 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2185 #ifdef TC_GENERIC_RELAX_TABLE
2186 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2189 relax_frag (segT segment, fragS *fragP, long stretch)
2191 const relax_typeS *this_type;
2192 const relax_typeS *start_type;
2193 relax_substateT next_state;
2194 relax_substateT this_state;
2200 const relax_typeS *table;
2202 target = fragP->fr_offset;
2203 address = fragP->fr_address;
2204 table = TC_GENERIC_RELAX_TABLE;
2205 this_state = fragP->fr_subtype;
2206 start_type = this_type = table + this_state;
2207 symbolP = fragP->fr_symbol;
2213 sym_frag = symbol_get_frag (symbolP);
2215 #ifndef DIFF_EXPR_OK
2216 know (sym_frag != NULL);
2218 know (S_GET_SEGMENT (symbolP) != absolute_section
2219 || sym_frag == &zero_address_frag);
2220 target += S_GET_VALUE (symbolP);
2222 /* If SYM_FRAG has yet to be reached on this pass, assume it
2223 will move by STRETCH just as we did, unless there is an
2224 alignment frag between here and SYM_FRAG. An alignment may
2225 well absorb any STRETCH, and we don't want to choose a larger
2226 branch insn by overestimating the needed reach of this
2227 branch. It isn't critical to calculate TARGET exactly; We
2228 know we'll be doing another pass if STRETCH is non-zero. */
2231 && sym_frag->relax_marker != fragP->relax_marker
2232 && S_GET_SEGMENT (symbolP) == segment)
2235 || sym_frag->region == fragP->region)
2237 /* If we get here we know we have a forward branch. This
2238 relax pass may have stretched previous instructions so
2239 far that omitting STRETCH would make the branch
2240 negative. Don't allow this in case the negative reach is
2241 large enough to require a larger branch instruction. */
2242 else if (target < address)
2243 target = fragP->fr_next->fr_address + stretch;
2247 aim = target - address - fragP->fr_fix;
2248 #ifdef TC_PCREL_ADJUST
2249 /* Currently only the ns32k family needs this. */
2250 aim += TC_PCREL_ADJUST (fragP);
2253 #ifdef md_prepare_relax_scan
2254 /* Formerly called M68K_AIM_KLUDGE. */
2255 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2260 /* Look backwards. */
2261 for (next_state = this_type->rlx_more; next_state;)
2262 if (aim >= this_type->rlx_backward)
2266 /* Grow to next state. */
2267 this_state = next_state;
2268 this_type = table + this_state;
2269 next_state = this_type->rlx_more;
2274 /* Look forwards. */
2275 for (next_state = this_type->rlx_more; next_state;)
2276 if (aim <= this_type->rlx_forward)
2280 /* Grow to next state. */
2281 this_state = next_state;
2282 this_type = table + this_state;
2283 next_state = this_type->rlx_more;
2287 growth = this_type->rlx_length - start_type->rlx_length;
2289 fragP->fr_subtype = this_state;
2293 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2295 /* Relax_align. Advance location counter to next address that has 'alignment'
2296 lowest order bits all 0s, return size of adjustment made. */
2297 static relax_addressT
2298 relax_align (register relax_addressT address, /* Address now. */
2299 register int alignment /* Alignment (binary). */)
2301 relax_addressT mask;
2302 relax_addressT new_address;
2304 mask = ~((~0) << alignment);
2305 new_address = (address + mask) & (~mask);
2306 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2308 /* We must provide lots of padding, so the linker can discard it
2309 when needed. The linker will not add extra space, ever. */
2310 new_address += (1 << alignment);
2312 return (new_address - address);
2315 /* Now we have a segment, not a crowd of sub-segments, we can make
2320 After this, all frags in this segment have addresses that are correct
2321 within the segment. Since segments live in different file addresses,
2322 these frag addresses may not be the same as final object-file
2326 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2328 unsigned long frag_count;
2330 relax_addressT address;
2334 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2335 subseg_change (segment, 0);
2337 /* For each frag in segment: count and store (a 1st guess of)
2341 for (frag_count = 0, fragP = segment_frag_root;
2343 fragP = fragP->fr_next, frag_count ++)
2345 fragP->region = region;
2346 fragP->relax_marker = 0;
2347 fragP->fr_address = address;
2348 address += fragP->fr_fix;
2350 switch (fragP->fr_type)
2353 address += fragP->fr_offset * fragP->fr_var;
2360 addressT offset = relax_align (address, (int) fragP->fr_offset);
2362 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2365 if (offset % fragP->fr_var != 0)
2367 as_bad_where (fragP->fr_file, fragP->fr_line,
2368 _("alignment padding (%lu bytes) not a multiple of %ld"),
2369 (unsigned long) offset, (long) fragP->fr_var);
2370 offset -= (offset % fragP->fr_var);
2379 /* Assume .org is nugatory. It will grow with 1st relax. */
2386 case rs_machine_dependent:
2387 /* If fr_symbol is an expression, this call to
2388 resolve_symbol_value sets up the correct segment, which will
2389 likely be needed in md_estimate_size_before_relax. */
2390 if (fragP->fr_symbol)
2391 resolve_symbol_value (fragP->fr_symbol);
2393 address += md_estimate_size_before_relax (fragP, segment);
2396 #ifndef WORKING_DOT_WORD
2397 /* Broken words don't concern us yet. */
2398 case rs_broken_word:
2403 /* Initial guess is always 1; doing otherwise can result in
2404 stable solutions that are larger than the minimum. */
2405 address += fragP->fr_offset = 1;
2409 address += eh_frame_estimate_size_before_relax (fragP);
2413 address += dwarf2dbg_estimate_size_before_relax (fragP);
2417 BAD_CASE (fragP->fr_type);
2424 unsigned long max_iterations;
2426 /* Cumulative address adjustment. */
2429 /* Have we made any adjustment this pass? We can't just test
2430 stretch because one piece of code may have grown and another
2434 /* Most horrible, but gcc may give us some exception data that
2435 is impossible to assemble, of the form
2439 .uleb128 end - start
2445 If the leb128 is two bytes in size, then end-start is 128*128,
2446 which requires a three byte leb128. If the leb128 is three
2447 bytes in size, then end-start is 128*128-1, which requires a
2448 two byte leb128. We work around this dilemma by inserting
2449 an extra 4 bytes of alignment just after the .align. This
2450 works because the data after the align is accessed relative to
2453 This counter is used in a tiny state machine to detect
2454 whether a leb128 followed by an align is impossible to
2456 int rs_leb128_fudge = 0;
2458 /* We want to prevent going into an infinite loop where one frag grows
2459 depending upon the location of a symbol which is in turn moved by
2460 the growing frag. eg:
2466 So we dictate that this algorithm can be at most O2. */
2467 max_iterations = frag_count * frag_count;
2468 /* Check for overflow. */
2469 if (max_iterations < frag_count)
2470 max_iterations = frag_count;
2478 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2481 addressT was_address;
2485 fragP->relax_marker ^= 1;
2486 was_address = fragP->fr_address;
2487 address = fragP->fr_address += stretch;
2488 symbolP = fragP->fr_symbol;
2489 offset = fragP->fr_offset;
2491 switch (fragP->fr_type)
2493 case rs_fill: /* .fill never relaxes. */
2497 #ifndef WORKING_DOT_WORD
2498 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2499 for it I do not want to write it. I do not want to have
2500 anything to do with it. This is not the proper way to
2501 implement this misfeature. */
2502 case rs_broken_word:
2504 struct broken_word *lie;
2505 struct broken_word *untruth;
2507 /* Yes this is ugly (storing the broken_word pointer
2508 in the symbol slot). Still, this whole chunk of
2509 code is ugly, and I don't feel like doing anything
2510 about it. Think of it as stubbornness in action. */
2512 for (lie = (struct broken_word *) (fragP->fr_symbol);
2513 lie && lie->dispfrag == fragP;
2514 lie = lie->next_broken_word)
2520 offset = (S_GET_VALUE (lie->add)
2522 - S_GET_VALUE (lie->sub));
2523 if (offset <= -32768 || offset >= 32767)
2525 if (flag_warn_displacement)
2528 sprint_value (buf, (addressT) lie->addnum);
2529 as_warn_where (fragP->fr_file, fragP->fr_line,
2530 _(".word %s-%s+%s didn't fit"),
2531 S_GET_NAME (lie->add),
2532 S_GET_NAME (lie->sub),
2535 if (fragP->fr_subtype == 0)
2537 fragP->fr_subtype++;
2538 growth += md_short_jump_size;
2541 /* Redirect *all* words of this table with the same
2542 target, lest we have to handle the case where the
2543 same target but with a offset that fits on this
2544 round overflows at the next relaxation round. */
2545 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2546 untruth && untruth->dispfrag == lie->dispfrag;
2547 untruth = untruth->next_broken_word)
2548 if ((symbol_get_frag (untruth->add)
2549 == symbol_get_frag (lie->add))
2550 && (S_GET_VALUE (untruth->add)
2551 == S_GET_VALUE (lie->add)))
2554 untruth->use_jump = lie;
2558 growth += md_long_jump_size;
2563 } /* case rs_broken_word */
2569 addressT oldoff, newoff;
2571 oldoff = relax_align (was_address + fragP->fr_fix,
2573 newoff = relax_align (address + fragP->fr_fix,
2576 if (fragP->fr_subtype != 0)
2578 if (oldoff > fragP->fr_subtype)
2580 if (newoff > fragP->fr_subtype)
2584 growth = newoff - oldoff;
2586 /* If this align happens to follow a leb128 and
2587 we have determined that the leb128 is bouncing
2588 in size, then break the cycle by inserting an
2591 && (rs_leb128_fudge & 16) != 0
2592 && (rs_leb128_fudge & 15) >= 2)
2594 segment_info_type *seginfo = seg_info (segment);
2595 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2598 newf = frag_alloc (ob);
2599 obstack_blank_fast (ob, fragP->fr_var);
2600 obstack_finish (ob);
2601 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2602 memcpy (newf->fr_literal,
2603 fragP->fr_literal + fragP->fr_fix,
2605 newf->fr_type = rs_fill;
2606 newf->fr_address = address + fragP->fr_fix + newoff;
2608 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2610 if (newf->fr_offset * newf->fr_var
2611 != (offsetT) 1 << fragP->fr_offset)
2613 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2616 /* Include size of new frag in GROWTH. */
2617 growth += newf->fr_offset * newf->fr_var;
2618 /* Adjust the new frag address for the amount
2619 we'll add when we process the new frag. */
2620 newf->fr_address -= stretch + growth;
2621 newf->relax_marker ^= 1;
2622 fragP->fr_next = newf;
2624 as_warn (_("padding added"));
2632 addressT target = offset;
2637 /* Convert from an actual address to an octet offset
2638 into the section. Here it is assumed that the
2639 section's VMA is zero, and can omit subtracting it
2640 from the symbol's value to get the address offset. */
2641 know (S_GET_SEGMENT (symbolP)->vma == 0);
2642 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2645 know (fragP->fr_next);
2646 after = fragP->fr_next->fr_address + stretch;
2647 growth = target - after;
2652 /* Don't error on first few frag relax passes.
2653 The symbol might be an expression involving
2654 symbol values from other sections. If those
2655 sections have not yet been processed their
2656 frags will all have zero addresses, so we
2657 will calculate incorrect values for them. The
2658 number of passes we allow before giving an
2659 error is somewhat arbitrary. It should be at
2660 least one, with larger values requiring
2661 increasingly contrived dependencies between
2662 frags to trigger a false error. */
2665 /* Force another pass. */
2670 /* Growth may be negative, but variable part of frag
2671 cannot have fewer than 0 chars. That is, we can't
2673 as_bad_where (fragP->fr_file, fragP->fr_line,
2674 _("attempt to move .org backwards"));
2676 /* We've issued an error message. Change the
2677 frag to avoid cascading errors. */
2678 fragP->fr_type = rs_align;
2679 fragP->fr_subtype = 0;
2680 fragP->fr_offset = 0;
2681 fragP->fr_fix = after - address;
2692 amount = S_GET_VALUE (symbolP);
2693 if (S_GET_SEGMENT (symbolP) != absolute_section
2694 || S_IS_COMMON (symbolP)
2695 || ! S_IS_DEFINED (symbolP))
2697 as_bad_where (fragP->fr_file, fragP->fr_line,
2698 _(".space specifies non-absolute value"));
2699 /* Prevent repeat of this error message. */
2700 fragP->fr_symbol = 0;
2702 else if (amount < 0)
2704 /* Don't error on first few frag relax passes.
2705 See rs_org comment for a longer explanation. */
2712 as_warn_where (fragP->fr_file, fragP->fr_line,
2713 _(".space or .fill with negative value, ignored"));
2714 fragP->fr_symbol = 0;
2717 growth = (was_address + fragP->fr_fix + amount
2718 - fragP->fr_next->fr_address);
2722 case rs_machine_dependent:
2723 #ifdef md_relax_frag
2724 growth = md_relax_frag (segment, fragP, stretch);
2726 #ifdef TC_GENERIC_RELAX_TABLE
2727 /* The default way to relax a frag is to look through
2728 TC_GENERIC_RELAX_TABLE. */
2729 growth = relax_frag (segment, fragP, stretch);
2730 #endif /* TC_GENERIC_RELAX_TABLE */
2739 value = resolve_symbol_value (fragP->fr_symbol);
2740 size = sizeof_leb128 (value, fragP->fr_subtype);
2741 growth = size - fragP->fr_offset;
2742 fragP->fr_offset = size;
2747 growth = eh_frame_relax_frag (fragP);
2751 growth = dwarf2dbg_relax_frag (fragP);
2755 BAD_CASE (fragP->fr_type);
2762 if (fragP->fr_type == rs_leb128)
2763 rs_leb128_fudge += 16;
2764 else if (fragP->fr_type == rs_align
2765 && (rs_leb128_fudge & 16) != 0
2767 rs_leb128_fudge += 16;
2769 rs_leb128_fudge = 0;
2774 && (rs_leb128_fudge & 16) == 0
2775 && (rs_leb128_fudge & -16) != 0)
2776 rs_leb128_fudge += 1;
2778 rs_leb128_fudge = 0;
2780 /* Until nothing further to relax. */
2781 while (stretched && -- max_iterations);
2784 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2785 segment_name (segment));
2788 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2789 if (fragP->last_fr_address != fragP->fr_address)
2791 fragP->last_fr_address = fragP->fr_address;
2798 number_to_chars_bigendian (char *buf, valueT val, int n)
2804 buf[n] = val & 0xff;
2810 number_to_chars_littleendian (char *buf, valueT val, int n)
2816 *buf++ = val & 0xff;
2822 write_print_statistics (FILE *file)
2824 fprintf (file, "fixups: %d\n", n_fixups);
2827 /* For debugging. */
2828 extern int indent_level;
2831 print_fixup (fixS *fixp)
2834 fprintf (stderr, "fix ");
2835 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2836 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2838 fprintf (stderr, " pcrel");
2839 if (fixp->fx_pcrel_adjust)
2840 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2841 if (fixp->fx_im_disp)
2844 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2846 fprintf (stderr, " im_disp");
2850 fprintf (stderr, " tcbit");
2852 fprintf (stderr, " done");
2853 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2854 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2855 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2856 (long) fixp->fx_where,
2857 (unsigned long) fixp->fx_offset,
2858 (unsigned long) fixp->fx_addnumber);
2859 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2863 fprintf (stderr, "\n +<");
2864 print_symbol_value_1 (stderr, fixp->fx_addsy);
2865 fprintf (stderr, ">");
2869 fprintf (stderr, "\n -<");
2870 print_symbol_value_1 (stderr, fixp->fx_subsy);
2871 fprintf (stderr, ">");
2873 fprintf (stderr, "\n");
2874 #ifdef TC_FIX_DATA_PRINT
2875 TC_FIX_DATA_PRINT (stderr, fixp);