1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010, 2011, 2012 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This thing should be set up to do byteordering correctly. But... */
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 #include "compress-debug.h"
33 #ifndef TC_FORCE_RELOCATION
34 #define TC_FORCE_RELOCATION(FIX) \
35 (generic_force_reloc (FIX))
38 #ifndef TC_FORCE_RELOCATION_ABS
39 #define TC_FORCE_RELOCATION_ABS(FIX) \
40 (TC_FORCE_RELOCATION (FIX))
43 #ifndef TC_FORCE_RELOCATION_LOCAL
44 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
46 || TC_FORCE_RELOCATION (FIX))
49 #ifndef TC_FORCE_RELOCATION_SUB_SAME
50 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
54 #ifndef md_register_arithmetic
55 # define md_register_arithmetic 1
58 #ifndef TC_FORCE_RELOCATION_SUB_ABS
59 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
60 (!md_register_arithmetic && (SEG) == reg_section)
63 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
65 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
66 (!md_register_arithmetic && (SEG) == reg_section)
68 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
72 #ifndef TC_VALIDATE_FIX_SUB
73 #ifdef UNDEFINED_DIFFERENCE_OK
74 /* The PA needs this for PIC code generation. */
75 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
76 (md_register_arithmetic || (SEG) != reg_section)
78 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
79 ((md_register_arithmetic || (SEG) != reg_section) \
80 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
81 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
85 #ifndef TC_LINKRELAX_FIXUP
86 #define TC_LINKRELAX_FIXUP(SEG) 1
89 #ifndef MD_APPLY_SYM_VALUE
90 #define MD_APPLY_SYM_VALUE(FIX) 1
93 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
94 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
97 #ifndef MD_PCREL_FROM_SECTION
98 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
101 #ifndef TC_FAKE_LABEL
102 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
105 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
106 fixups that far past the end of a frag. Having such fixups
107 is of course most most likely a bug in setting fx_size correctly.
108 A negative value disables the fixup check entirely, which is
109 appropriate for something like the Renesas / SuperH SH_COUNT
111 #ifndef TC_FX_SIZE_SLACK
112 #define TC_FX_SIZE_SLACK(FIX) 0
115 /* Used to control final evaluation of expressions. */
116 int finalize_syms = 0;
118 int symbol_table_frozen;
120 symbolS *abs_section_sym;
122 /* Remember the value of dot when parsing expressions. */
125 /* The frag that dot_value is based from. */
128 /* Relocs generated by ".reloc" pseudo. */
129 struct reloc_list* reloc_list;
131 void print_fixup (fixS *);
133 /* We generally attach relocs to frag chains. However, after we have
134 chained these all together into a segment, any relocs we add after
135 that must be attached to a segment. This will include relocs added
136 in md_estimate_size_for_relax, for example. */
137 static int frags_chained = 0;
141 #define RELOC_ENUM enum bfd_reloc_code_real
143 /* Create a fixS in obstack 'notes'. */
146 fix_new_internal (fragS *frag, /* Which frag? */
147 int where, /* Where in that frag? */
148 int size, /* 1, 2, or 4 usually. */
149 symbolS *add_symbol, /* X_add_symbol. */
150 symbolS *sub_symbol, /* X_op_symbol. */
151 offsetT offset, /* X_add_number. */
152 int pcrel, /* TRUE if PC-relative relocation. */
153 RELOC_ENUM r_type /* Relocation type. */,
154 int at_beginning) /* Add to the start of the list? */
160 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
162 fixP->fx_frag = frag;
163 fixP->fx_where = where;
164 fixP->fx_size = size;
165 /* We've made fx_size a narrow field; check that it's wide enough. */
166 if (fixP->fx_size != size)
168 as_bad (_("field fx_size too small to hold %d"), size);
171 fixP->fx_addsy = add_symbol;
172 fixP->fx_subsy = sub_symbol;
173 fixP->fx_offset = offset;
174 fixP->fx_dot_value = dot_value;
175 fixP->fx_dot_frag = dot_frag;
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 != &dummy
410 && prev_frag->fr_type != 0);
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.
893 Ones that we couldn't completely handle here will be output later
894 by emit_relocations. */
897 fixup_segment (fixS *fixP, segT this_segment)
901 segT add_symbol_segment = absolute_section;
903 if (fixP != NULL && abs_section_sym == NULL)
904 abs_section_sym = section_symbol (absolute_section);
906 /* If the linker is doing the relaxing, we must not do any fixups.
908 Well, strictly speaking that's not true -- we could do any that
909 are PC-relative and don't cross regions that could change size.
910 And for the i960 we might be able to turn callx/callj into bal
911 anyways in cases where we know the maximum displacement. */
912 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
914 for (; fixP; fixP = fixP->fx_next)
917 if (fixP->fx_addsy == NULL)
919 /* There was no symbol required by this relocation.
920 However, BFD doesn't really handle relocations
921 without symbols well. So fake up a local symbol in
922 the absolute section. */
923 fixP->fx_addsy = abs_section_sym;
925 symbol_mark_used_in_reloc (fixP->fx_addsy);
926 if (fixP->fx_subsy != NULL)
927 symbol_mark_used_in_reloc (fixP->fx_subsy);
932 for (; fixP; fixP = fixP->fx_next)
935 fprintf (stderr, "\nprocessing fixup:\n");
939 fragP = fixP->fx_frag;
941 #ifdef TC_VALIDATE_FIX
942 TC_VALIDATE_FIX (fixP, this_segment, skip);
944 add_number = fixP->fx_offset;
946 if (fixP->fx_addsy != NULL)
947 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
949 if (fixP->fx_subsy != NULL)
951 segT sub_symbol_segment;
952 resolve_symbol_value (fixP->fx_subsy);
953 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
954 if (fixP->fx_addsy != NULL
955 && sub_symbol_segment == add_symbol_segment
956 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
957 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
958 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
960 add_number += S_GET_VALUE (fixP->fx_addsy);
961 add_number -= S_GET_VALUE (fixP->fx_subsy);
962 fixP->fx_offset = add_number;
963 fixP->fx_addsy = NULL;
964 fixP->fx_subsy = NULL;
966 /* See the comment below about 68k weirdness. */
970 else if (sub_symbol_segment == absolute_section
971 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
972 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
974 add_number -= S_GET_VALUE (fixP->fx_subsy);
975 fixP->fx_offset = add_number;
976 fixP->fx_subsy = NULL;
978 else if (sub_symbol_segment == this_segment
979 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
980 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
982 add_number -= S_GET_VALUE (fixP->fx_subsy);
983 fixP->fx_offset = (add_number + fixP->fx_dot_value
984 + fixP->fx_dot_frag->fr_address);
986 /* Make it pc-relative. If the back-end code has not
987 selected a pc-relative reloc, cancel the adjustment
988 we do later on all pc-relative relocs. */
991 /* Do this for m68k even if it's already described
992 as pc-relative. On the m68k, an operand of
993 "pc@(foo-.-2)" should address "foo" in a
998 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
999 fixP->fx_subsy = NULL;
1002 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1004 if (!md_register_arithmetic
1005 && (add_symbol_segment == reg_section
1006 || sub_symbol_segment == reg_section))
1007 as_bad_where (fixP->fx_file, fixP->fx_line,
1008 _("register value used as expression"));
1010 as_bad_where (fixP->fx_file, fixP->fx_line,
1011 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1012 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1013 segment_name (add_symbol_segment),
1014 S_GET_NAME (fixP->fx_subsy),
1015 segment_name (sub_symbol_segment));
1017 else if (sub_symbol_segment != undefined_section
1018 && ! bfd_is_com_section (sub_symbol_segment)
1019 && MD_APPLY_SYM_VALUE (fixP))
1020 add_number -= S_GET_VALUE (fixP->fx_subsy);
1025 if (add_symbol_segment == this_segment
1026 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1027 && !TC_FORCE_RELOCATION_LOCAL (fixP))
1029 /* This fixup was made when the symbol's segment was
1030 SEG_UNKNOWN, but it is now in the local segment.
1031 So we know how to do the address without relocation. */
1032 add_number += S_GET_VALUE (fixP->fx_addsy);
1033 fixP->fx_offset = add_number;
1035 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1036 fixP->fx_addsy = NULL;
1039 else if (add_symbol_segment == absolute_section
1040 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1041 && !TC_FORCE_RELOCATION_ABS (fixP))
1043 add_number += S_GET_VALUE (fixP->fx_addsy);
1044 fixP->fx_offset = add_number;
1045 fixP->fx_addsy = NULL;
1047 else if (add_symbol_segment != undefined_section
1048 && ! bfd_is_com_section (add_symbol_segment)
1049 && MD_APPLY_SYM_VALUE (fixP))
1050 add_number += S_GET_VALUE (fixP->fx_addsy);
1055 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1056 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1058 /* There was no symbol required by this relocation.
1059 However, BFD doesn't really handle relocations
1060 without symbols well. So fake up a local symbol in
1061 the absolute section. */
1062 fixP->fx_addsy = abs_section_sym;
1067 md_apply_fix (fixP, &add_number, this_segment);
1071 if (fixP->fx_addsy == NULL)
1072 fixP->fx_addsy = abs_section_sym;
1073 symbol_mark_used_in_reloc (fixP->fx_addsy);
1074 if (fixP->fx_subsy != NULL)
1075 symbol_mark_used_in_reloc (fixP->fx_subsy);
1078 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1080 if (fixP->fx_size < sizeof (valueT))
1085 mask--; /* Set all bits to one. */
1086 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1087 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1089 char buf[50], buf2[50];
1090 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1091 if (add_number > 1000)
1092 sprint_value (buf2, add_number);
1094 sprintf (buf2, "%ld", (long) add_number);
1095 as_bad_where (fixP->fx_file, fixP->fx_line,
1096 _("value of %s too large for field of %d bytes at %s"),
1097 buf2, fixP->fx_size, buf);
1098 } /* Generic error checking. */
1100 #ifdef WARN_SIGNED_OVERFLOW_WORD
1101 /* Warn if a .word value is too large when treated as a signed
1102 number. We already know it is not too negative. This is to
1103 catch over-large switches generated by gcc on the 68k. */
1104 if (!flag_signed_overflow_ok
1105 && fixP->fx_size == 2
1106 && add_number > 0x7fff)
1107 as_bad_where (fixP->fx_file, fixP->fx_line,
1108 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1110 (long) (fragP->fr_address + fixP->fx_where));
1112 } /* Not a bit fix. */
1114 #ifdef TC_VALIDATE_FIX
1115 skip: ATTRIBUTE_UNUSED_LABEL
1119 fprintf (stderr, "result:\n");
1122 } /* For each fixS in this segment. */
1126 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1128 void *xxx ATTRIBUTE_UNUSED)
1130 segment_info_type *seginfo = seg_info (sec);
1132 fixup_segment (seginfo->fix_root, sec);
1136 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1137 char *file, unsigned int line)
1140 bfd_reloc_status_type s;
1143 if (reloc->sym_ptr_ptr != NULL
1144 && (sym = *reloc->sym_ptr_ptr) != NULL
1145 && (sym->flags & BSF_KEEP) == 0
1146 && ((sym->flags & BSF_SECTION_SYM) == 0
1147 || (EMIT_SECTION_SYMBOLS
1148 && !bfd_is_abs_section (sym->section))))
1149 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1151 s = bfd_install_relocation (stdoutput, reloc,
1152 fragp->fr_literal, fragp->fr_address,
1158 case bfd_reloc_overflow:
1159 as_bad_where (file, line, _("relocation overflow"));
1161 case bfd_reloc_outofrange:
1162 as_bad_where (file, line, _("relocation out of range"));
1165 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1171 get_frag_for_reloc (fragS *last_frag,
1172 const segment_info_type *seginfo,
1173 const struct reloc_list *r)
1177 for (f = last_frag; f != NULL; f = f->fr_next)
1178 if (f->fr_address <= r->u.b.r.address
1179 && r->u.b.r.address < f->fr_address + f->fr_fix)
1182 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1183 if (f->fr_address <= r->u.b.r.address
1184 && r->u.b.r.address < f->fr_address + f->fr_fix)
1187 as_bad_where (r->file, r->line,
1188 _("reloc not within (fixed part of) section"));
1193 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1195 segment_info_type *seginfo = seg_info (sec);
1197 struct reloc_list *my_reloc_list, **rp, *r;
1202 /* If seginfo is NULL, we did not create this section; don't do
1203 anything with it. */
1204 if (seginfo == NULL)
1208 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1212 #ifdef RELOC_EXPANSION_POSSIBLE
1213 n *= MAX_RELOC_EXPANSION;
1216 /* Extract relocs for this section from reloc_list. */
1218 my_reloc_list = NULL;
1219 while ((r = *rp) != NULL)
1221 if (r->u.b.sec == sec)
1224 r->next = my_reloc_list;
1232 relocs = (arelent **) xcalloc (n, sizeof (arelent *));
1237 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1242 #ifndef RELOC_EXPANSION_POSSIBLE
1251 fx_size = fixp->fx_size;
1252 slack = TC_FX_SIZE_SLACK (fixp);
1254 fx_size = fx_size > slack ? fx_size - slack : 0;
1255 loc = fixp->fx_where + fx_size;
1256 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1257 as_bad_where (fixp->fx_file, fixp->fx_line,
1258 _("internal error: fixup not contained within frag"));
1260 #ifndef RELOC_EXPANSION_POSSIBLE
1261 *reloc = tc_gen_reloc (sec, fixp);
1263 reloc = tc_gen_reloc (sec, fixp);
1268 while (r != NULL && r->u.b.r.address < (*reloc)->address)
1270 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1274 relocs[n++] = &r->u.b.r;
1275 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1279 relocs[n++] = *reloc;
1280 install_reloc (sec, *reloc, fixp->fx_frag,
1281 fixp->fx_file, fixp->fx_line);
1282 #ifndef RELOC_EXPANSION_POSSIBLE
1292 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1296 relocs[n++] = &r->u.b.r;
1297 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1304 unsigned int k, j, nsyms;
1306 sympp = bfd_get_outsymbols (stdoutput);
1307 nsyms = bfd_get_symcount (stdoutput);
1308 for (k = 0; k < n; k++)
1309 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1311 for (j = 0; j < nsyms; j++)
1312 if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1322 flagword flags = bfd_get_section_flags (abfd, sec);
1324 bfd_set_section_flags (abfd, sec, flags);
1325 bfd_set_reloc (stdoutput, sec, relocs, n);
1328 #ifdef SET_SECTION_RELOCS
1329 SET_SECTION_RELOCS (sec, relocs, n);
1336 fprintf (stderr, "relocs for sec %s\n", sec->name);
1337 for (k = 0; k < n; k++)
1339 arelent *rel = relocs[k];
1340 asymbol *s = *rel->sym_ptr_ptr;
1341 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1342 k, rel, (unsigned long)rel->address, s->name,
1343 (unsigned long)rel->addend);
1350 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1351 fragS **last_newf, struct obstack *ob)
1354 int total_out_size = 0;
1355 fragS *f = *last_newf;
1359 /* Call the compression routine repeatedly until it has finished
1360 processing the frag. */
1363 /* Reserve all the space available in the current chunk.
1364 If none is available, start a new frag. */
1365 avail_out = obstack_room (ob);
1368 obstack_finish (ob);
1369 f = frag_alloc (ob);
1370 f->fr_type = rs_fill;
1371 (*last_newf)->fr_next = f;
1373 avail_out = obstack_room (ob);
1376 as_fatal (_("can't extend frag"));
1377 next_out = obstack_next_free (ob);
1378 obstack_blank_fast (ob, avail_out);
1379 out_size = compress_data (strm, &contents, &in_size,
1380 &next_out, &avail_out);
1384 f->fr_fix += out_size;
1385 total_out_size += out_size;
1387 /* Return unused space. */
1389 obstack_blank_fast (ob, -avail_out);
1392 return total_out_size;
1396 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1398 segment_info_type *seginfo = seg_info (sec);
1402 struct obstack *ob = &seginfo->frchainP->frch_obstack;
1403 bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1404 bfd_size_type compressed_size;
1405 const char *section_name;
1406 char *compressed_name;
1408 struct z_stream_s *strm;
1410 flagword flags = bfd_get_section_flags (abfd, sec);
1414 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1417 section_name = bfd_get_section_name (stdoutput, sec);
1418 if (strncmp (section_name, ".debug_", 7) != 0)
1421 strm = compress_init ();
1425 /* Create a new frag to contain the "ZLIB" header. */
1426 first_newf = frag_alloc (ob);
1427 if (obstack_room (ob) < 12)
1428 first_newf = frag_alloc (ob);
1429 if (obstack_room (ob) < 12)
1430 as_fatal (_("can't extend frag %u chars"), 12);
1431 last_newf = first_newf;
1432 obstack_blank_fast (ob, 12);
1433 last_newf->fr_type = rs_fill;
1434 last_newf->fr_fix = 12;
1435 header = last_newf->fr_literal;
1436 memcpy (header, "ZLIB", 4);
1437 header[11] = uncompressed_size; uncompressed_size >>= 8;
1438 header[10] = uncompressed_size; uncompressed_size >>= 8;
1439 header[9] = uncompressed_size; uncompressed_size >>= 8;
1440 header[8] = uncompressed_size; uncompressed_size >>= 8;
1441 header[7] = uncompressed_size; uncompressed_size >>= 8;
1442 header[6] = uncompressed_size; uncompressed_size >>= 8;
1443 header[5] = uncompressed_size; uncompressed_size >>= 8;
1444 header[4] = uncompressed_size;
1445 compressed_size = 12;
1447 /* Stream the frags through the compression engine, adding new frags
1448 as necessary to accomodate the compressed output. */
1449 for (f = seginfo->frchainP->frch_root;
1458 gas_assert (f->fr_type == rs_fill);
1461 out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1465 compressed_size += out_size;
1467 fill_literal = f->fr_literal + f->fr_fix;
1468 fill_size = f->fr_var;
1469 count = f->fr_offset;
1470 gas_assert (count >= 0);
1471 if (fill_size && count)
1475 out_size = compress_frag (strm, fill_literal, (int) fill_size,
1479 compressed_size += out_size;
1484 /* Flush the compression state. */
1491 /* Reserve all the space available in the current chunk.
1492 If none is available, start a new frag. */
1493 avail_out = obstack_room (ob);
1498 obstack_finish (ob);
1499 newf = frag_alloc (ob);
1500 newf->fr_type = rs_fill;
1501 last_newf->fr_next = newf;
1503 avail_out = obstack_room (ob);
1506 as_fatal (_("can't extend frag"));
1507 next_out = obstack_next_free (ob);
1508 obstack_blank_fast (ob, avail_out);
1509 x = compress_finish (strm, &next_out, &avail_out, &out_size);
1513 last_newf->fr_fix += out_size;
1514 compressed_size += out_size;
1516 /* Return unused space. */
1518 obstack_blank_fast (ob, -avail_out);
1524 /* Replace the uncompressed frag list with the compressed frag list. */
1525 seginfo->frchainP->frch_root = first_newf;
1526 seginfo->frchainP->frch_last = last_newf;
1528 /* Update the section size and its name. */
1529 x = bfd_set_section_size (abfd, sec, compressed_size);
1531 compressed_name = (char *) xmalloc (strlen (section_name) + 2);
1532 compressed_name[0] = '.';
1533 compressed_name[1] = 'z';
1534 strcpy (compressed_name + 2, section_name + 1);
1535 bfd_section_name (stdoutput, sec) = compressed_name;
1539 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1541 void *xxx ATTRIBUTE_UNUSED)
1543 segment_info_type *seginfo = seg_info (sec);
1544 addressT offset = 0;
1547 /* Write out the frags. */
1549 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1552 for (f = seginfo->frchainP->frch_root;
1561 gas_assert (f->fr_type == rs_fill);
1564 x = bfd_set_section_contents (stdoutput, sec,
1565 f->fr_literal, (file_ptr) offset,
1566 (bfd_size_type) f->fr_fix);
1568 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1569 bfd_errmsg (bfd_get_error ()));
1570 offset += f->fr_fix;
1572 fill_literal = f->fr_literal + f->fr_fix;
1573 fill_size = f->fr_var;
1574 count = f->fr_offset;
1575 gas_assert (count >= 0);
1576 if (fill_size && count)
1579 if (fill_size > sizeof (buf))
1581 /* Do it the old way. Can this ever happen? */
1584 x = bfd_set_section_contents (stdoutput, sec,
1587 (bfd_size_type) fill_size);
1589 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1590 bfd_errmsg (bfd_get_error ()));
1591 offset += fill_size;
1596 /* Build a buffer full of fill objects and output it as
1597 often as necessary. This saves on the overhead of
1598 potentially lots of bfd_set_section_contents calls. */
1602 n_per_buf = sizeof (buf);
1603 memset (buf, *fill_literal, n_per_buf);
1608 n_per_buf = sizeof (buf) / fill_size;
1609 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1610 memcpy (bufp, fill_literal, fill_size);
1612 for (; count > 0; count -= n_per_buf)
1614 n_per_buf = n_per_buf > count ? count : n_per_buf;
1615 x = bfd_set_section_contents
1616 (stdoutput, sec, buf, (file_ptr) offset,
1617 (bfd_size_type) n_per_buf * fill_size);
1619 as_fatal (_("cannot write to output file '%s': %s"),
1620 stdoutput->filename,
1621 bfd_errmsg (bfd_get_error ()));
1622 offset += n_per_buf * fill_size;
1630 merge_data_into_text (void)
1632 seg_info (text_section)->frchainP->frch_last->fr_next =
1633 seg_info (data_section)->frchainP->frch_root;
1634 seg_info (text_section)->frchainP->frch_last =
1635 seg_info (data_section)->frchainP->frch_last;
1636 seg_info (data_section)->frchainP = 0;
1647 /* Count symbols. We can't rely on a count made by the loop in
1648 write_object_file, because *_frob_file may add a new symbol or
1651 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1657 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1659 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1660 symp = symbol_rootP;
1661 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1663 asympp[i] = symbol_get_bfdsym (symp);
1664 if (asympp[i]->flags != BSF_SECTION_SYM
1665 || !(bfd_is_const_section (asympp[i]->section)
1666 && asympp[i]->section->symbol == asympp[i]))
1667 asympp[i]->flags |= BSF_KEEP;
1668 symbol_mark_written (symp);
1673 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1674 gas_assert (result);
1675 symbol_table_frozen = 1;
1678 /* Finish the subsegments. After every sub-segment, we fake an
1679 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1680 ".fill 0" because that is the kind of frag that requires least
1681 thought. ".align" frags like to have a following frag since that
1682 makes calculating their intended length trivial. */
1684 #ifndef SUB_SEGMENT_ALIGN
1686 /* The last subsegment gets an alignment corresponding to the alignment
1687 of the section. This allows proper nop-filling at the end of
1688 code-bearing sections. */
1689 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1690 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1692 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1697 subsegs_finish (void)
1699 struct frchain *frchainP;
1702 for (s = stdoutput->sections; s; s = s->next)
1704 segment_info_type *seginfo = seg_info (s);
1708 for (frchainP = seginfo->frchainP;
1710 frchainP = frchainP->frch_next)
1714 subseg_set (s, frchainP->frch_subseg);
1716 /* This now gets called even if we had errors. In that case,
1717 any alignment is meaningless, and, moreover, will look weird
1718 if we are generating a listing. */
1721 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1722 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1723 && now_seg->entsize)
1725 unsigned int entsize = now_seg->entsize;
1728 while ((entsize & 1) == 0)
1733 if (entalign > alignment)
1734 alignment = entalign;
1738 if (subseg_text_p (now_seg))
1739 frag_align_code (alignment, 0);
1741 frag_align (alignment, 0, 0);
1743 /* frag_align will have left a new frag.
1744 Use this last frag for an empty ".fill".
1746 For this segment ...
1747 Create a last frag. Do not leave a "being filled in frag". */
1748 frag_wane (frag_now);
1749 frag_now->fr_fix = 0;
1750 know (frag_now->fr_next == NULL);
1755 /* Write the object file. */
1758 write_object_file (void)
1760 struct relax_seg_info rsi;
1761 #ifndef WORKING_DOT_WORD
1762 fragS *fragP; /* Track along all frags. */
1765 #ifdef md_pre_output_hook
1769 /* Do we really want to write it? */
1771 int n_warns, n_errs;
1772 n_warns = had_warnings ();
1773 n_errs = had_errors ();
1774 /* The -Z flag indicates that an object file should be generated,
1775 regardless of warnings and errors. */
1776 if (flag_always_generate_output)
1778 if (n_warns || n_errs)
1779 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1780 n_errs, n_errs == 1 ? "" : "s",
1781 n_warns, n_warns == 1 ? "" : "s");
1786 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1787 n_errs, n_errs == 1 ? "" : "s",
1788 n_warns, n_warns == 1 ? "" : "s");
1792 #ifdef md_pre_relax_hook
1796 /* From now on, we don't care about sub-segments. Build one frag chain
1797 for each segment. Linked thru fr_next. */
1799 /* Remove the sections created by gas for its own purposes. */
1803 bfd_section_list_remove (stdoutput, reg_section);
1804 bfd_section_list_remove (stdoutput, expr_section);
1805 stdoutput->section_count -= 2;
1807 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1810 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1812 /* We have two segments. If user gave -R flag, then we must put the
1813 data frags into the text segment. Do this before relaxing so
1814 we know to take advantage of -R and make shorter addresses. */
1815 if (flag_readonly_data_in_text)
1817 merge_data_into_text ();
1823 #ifndef WORKING_DOT_WORD
1824 /* We need to reset the markers in the broken word list and
1825 associated frags between calls to relax_segment (via
1826 relax_seg). Since the broken word list is global, we do it
1827 once per round, rather than locally in relax_segment for each
1829 struct broken_word *brokp;
1831 for (brokp = broken_words;
1832 brokp != (struct broken_word *) NULL;
1833 brokp = brokp->next_broken_word)
1837 if (brokp->dispfrag != (fragS *) NULL
1838 && brokp->dispfrag->fr_type == rs_broken_word)
1839 brokp->dispfrag->fr_subtype = 0;
1844 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1850 /* Note - Most ports will use the default value of
1851 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1852 local symbols to be resolved, removing their frag information.
1853 Some ports however, will not have finished relaxing all of
1854 their frags and will still need the local symbol frag
1855 information. These ports can set
1856 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1857 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1859 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1861 /* Relaxation has completed. Freeze all syms. */
1864 #ifdef md_post_relax_hook
1868 #ifndef WORKING_DOT_WORD
1870 struct broken_word *lie;
1871 struct broken_word **prevP;
1873 prevP = &broken_words;
1874 for (lie = broken_words; lie; lie = lie->next_broken_word)
1879 subseg_change (lie->seg, lie->subseg);
1880 exp.X_op = O_subtract;
1881 exp.X_add_symbol = lie->add;
1882 exp.X_op_symbol = lie->sub;
1883 exp.X_add_number = lie->addnum;
1884 #ifdef TC_CONS_FIX_NEW
1885 TC_CONS_FIX_NEW (lie->frag,
1886 lie->word_goes_here - lie->frag->fr_literal,
1889 fix_new_exp (lie->frag,
1890 lie->word_goes_here - lie->frag->fr_literal,
1891 2, &exp, 0, BFD_RELOC_16);
1893 *prevP = lie->next_broken_word;
1896 prevP = &(lie->next_broken_word);
1898 for (lie = broken_words; lie;)
1900 struct broken_word *untruth;
1902 addressT table_addr;
1903 addressT from_addr, to_addr;
1906 subseg_change (lie->seg, lie->subseg);
1907 fragP = lie->dispfrag;
1909 /* Find out how many broken_words go here. */
1912 untruth && untruth->dispfrag == fragP;
1913 untruth = untruth->next_broken_word)
1914 if (untruth->added == 1)
1917 table_ptr = lie->dispfrag->fr_opcode;
1918 table_addr = (lie->dispfrag->fr_address
1919 + (table_ptr - lie->dispfrag->fr_literal));
1920 /* Create the jump around the long jumps. This is a short
1921 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1922 from_addr = table_addr;
1923 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1924 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1926 table_ptr += md_short_jump_size;
1927 table_addr += md_short_jump_size;
1930 lie && lie->dispfrag == fragP;
1931 m++, lie = lie->next_broken_word)
1933 if (lie->added == 2)
1935 /* Patch the jump table. */
1936 for (untruth = (struct broken_word *) (fragP->fr_symbol);
1937 untruth && untruth->dispfrag == fragP;
1938 untruth = untruth->next_broken_word)
1940 if (untruth->use_jump == lie)
1942 /* This is the offset from ??? to table_ptr+0.
1943 The target is the same for all users of this
1944 md_long_jump, but the "sub" bases (and hence the
1945 offsets) may be different. */
1946 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1947 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1948 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1950 md_number_to_chars (untruth->word_goes_here, to_word, 2);
1954 /* Install the long jump. */
1955 /* This is a long jump from table_ptr+0 to the final target. */
1956 from_addr = table_addr;
1957 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1958 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1960 table_ptr += md_long_jump_size;
1961 table_addr += md_long_jump_size;
1965 #endif /* not WORKING_DOT_WORD */
1967 /* Resolve symbol values. This needs to be done before processing
1973 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1974 resolve_symbol_value (symp);
1976 resolve_local_symbol_values ();
1977 resolve_reloc_expr_symbols ();
1981 #ifdef tc_frob_file_before_adjust
1982 tc_frob_file_before_adjust ();
1984 #ifdef obj_frob_file_before_adjust
1985 obj_frob_file_before_adjust ();
1988 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1990 #ifdef tc_frob_file_before_fix
1991 tc_frob_file_before_fix ();
1993 #ifdef obj_frob_file_before_fix
1994 obj_frob_file_before_fix ();
1997 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1999 /* Set up symbol table, and write it out. */
2003 bfd_boolean skip_next_symbol = FALSE;
2005 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2010 if (skip_next_symbol)
2012 /* Don't do anything besides moving the value of the
2013 symbol from the GAS value-field to the BFD value-field. */
2014 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2015 skip_next_symbol = FALSE;
2019 if (symbol_mri_common_p (symp))
2021 if (S_IS_EXTERNAL (symp))
2022 as_bad (_("%s: global symbols not supported in common sections"),
2024 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2028 name = S_GET_NAME (symp);
2032 decode_local_label_name ((char *) S_GET_NAME (symp));
2033 /* They only differ if `name' is a fb or dollar local
2035 if (name2 != name && ! S_IS_DEFINED (symp))
2036 as_bad (_("local label `%s' is not defined"), name2);
2039 /* Do it again, because adjust_reloc_syms might introduce
2040 more symbols. They'll probably only be section symbols,
2041 but they'll still need to have the values computed. */
2042 resolve_symbol_value (symp);
2044 /* Skip symbols which were equated to undefined or common
2046 if (symbol_equated_reloc_p (symp)
2047 || S_IS_WEAKREFR (symp))
2049 const char *sname = S_GET_NAME (symp);
2051 if (S_IS_COMMON (symp)
2052 && !TC_FAKE_LABEL (sname)
2053 && !S_IS_WEAKREFR (symp)
2054 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2056 expressionS *e = symbol_get_value_expression (symp);
2058 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2059 sname, S_GET_NAME (e->X_add_symbol));
2061 if (S_GET_SEGMENT (symp) == reg_section)
2063 /* Report error only if we know the symbol name. */
2064 if (S_GET_NAME (symp) != reg_section->name)
2065 as_bad (_("can't make global register symbol `%s'"),
2068 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2072 #ifdef obj_frob_symbol
2073 obj_frob_symbol (symp, punt);
2075 #ifdef tc_frob_symbol
2076 if (! punt || symbol_used_in_reloc_p (symp))
2077 tc_frob_symbol (symp, punt);
2080 /* If we don't want to keep this symbol, splice it out of
2081 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2082 want section symbols. Otherwise, we skip local symbols
2083 and symbols that the frob_symbol macros told us to punt,
2084 but we keep such symbols if they are used in relocs. */
2085 if (symp == abs_section_sym
2086 || (! EMIT_SECTION_SYMBOLS
2087 && symbol_section_p (symp))
2088 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2089 opposites. Sometimes the former checks flags and the
2090 latter examines the name... */
2091 || (!S_IS_EXTERNAL (symp)
2092 && (punt || S_IS_LOCAL (symp) ||
2093 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2094 && ! symbol_used_in_reloc_p (symp)))
2096 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2098 /* After symbol_remove, symbol_next(symp) still returns
2099 the one that came after it in the chain. So we don't
2100 need to do any extra cleanup work here. */
2104 /* Make sure we really got a value for the symbol. */
2105 if (! symbol_resolved_p (symp))
2107 as_bad (_("can't resolve value for symbol `%s'"),
2109 symbol_mark_resolved (symp);
2112 /* Set the value into the BFD symbol. Up til now the value
2113 has only been kept in the gas symbolS struct. */
2114 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2116 /* A warning construct is a warning symbol followed by the
2117 symbol warned about. Don't let anything object-format or
2118 target-specific muck with it; it's ready for output. */
2119 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2120 skip_next_symbol = TRUE;
2126 /* Now do any format-specific adjustments to the symbol table, such
2127 as adding file symbols. */
2128 #ifdef tc_adjust_symtab
2129 tc_adjust_symtab ();
2131 #ifdef obj_adjust_symtab
2132 obj_adjust_symtab ();
2135 /* Stop if there is an error. */
2139 /* Now that all the sizes are known, and contents correct, we can
2140 start writing to the file. */
2143 /* If *_frob_file changes the symbol value at this point, it is
2144 responsible for moving the changed value into symp->bsym->value
2145 as well. Hopefully all symbol value changing can be done in
2150 #ifdef obj_frob_file
2153 #ifdef obj_coff_generate_pdata
2154 obj_coff_generate_pdata ();
2156 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2158 #ifdef tc_frob_file_after_relocs
2159 tc_frob_file_after_relocs ();
2161 #ifdef obj_frob_file_after_relocs
2162 obj_frob_file_after_relocs ();
2165 /* Once all relocations have been written, we can compress the
2166 contents of the debug sections. This needs to be done before
2167 we start writing any sections, because it will affect the file
2168 layout, which is fixed once we start writing contents. */
2169 if (flag_compress_debug)
2170 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2172 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2175 #ifdef TC_GENERIC_RELAX_TABLE
2176 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2179 relax_frag (segT segment, fragS *fragP, long stretch)
2181 const relax_typeS *this_type;
2182 const relax_typeS *start_type;
2183 relax_substateT next_state;
2184 relax_substateT this_state;
2190 const relax_typeS *table;
2192 target = fragP->fr_offset;
2193 address = fragP->fr_address;
2194 table = TC_GENERIC_RELAX_TABLE;
2195 this_state = fragP->fr_subtype;
2196 start_type = this_type = table + this_state;
2197 symbolP = fragP->fr_symbol;
2203 sym_frag = symbol_get_frag (symbolP);
2205 #ifndef DIFF_EXPR_OK
2206 know (sym_frag != NULL);
2208 know (S_GET_SEGMENT (symbolP) != absolute_section
2209 || sym_frag == &zero_address_frag);
2210 target += S_GET_VALUE (symbolP);
2212 /* If SYM_FRAG has yet to be reached on this pass, assume it
2213 will move by STRETCH just as we did, unless there is an
2214 alignment frag between here and SYM_FRAG. An alignment may
2215 well absorb any STRETCH, and we don't want to choose a larger
2216 branch insn by overestimating the needed reach of this
2217 branch. It isn't critical to calculate TARGET exactly; We
2218 know we'll be doing another pass if STRETCH is non-zero. */
2221 && sym_frag->relax_marker != fragP->relax_marker
2222 && S_GET_SEGMENT (symbolP) == segment)
2225 || sym_frag->region == fragP->region)
2227 /* If we get here we know we have a forward branch. This
2228 relax pass may have stretched previous instructions so
2229 far that omitting STRETCH would make the branch
2230 negative. Don't allow this in case the negative reach is
2231 large enough to require a larger branch instruction. */
2232 else if (target < address)
2233 target = fragP->fr_next->fr_address + stretch;
2237 aim = target - address - fragP->fr_fix;
2238 #ifdef TC_PCREL_ADJUST
2239 /* Currently only the ns32k family needs this. */
2240 aim += TC_PCREL_ADJUST (fragP);
2243 #ifdef md_prepare_relax_scan
2244 /* Formerly called M68K_AIM_KLUDGE. */
2245 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2250 /* Look backwards. */
2251 for (next_state = this_type->rlx_more; next_state;)
2252 if (aim >= this_type->rlx_backward)
2256 /* Grow to next state. */
2257 this_state = next_state;
2258 this_type = table + this_state;
2259 next_state = this_type->rlx_more;
2264 /* Look forwards. */
2265 for (next_state = this_type->rlx_more; next_state;)
2266 if (aim <= this_type->rlx_forward)
2270 /* Grow to next state. */
2271 this_state = next_state;
2272 this_type = table + this_state;
2273 next_state = this_type->rlx_more;
2277 growth = this_type->rlx_length - start_type->rlx_length;
2279 fragP->fr_subtype = this_state;
2283 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2285 /* Relax_align. Advance location counter to next address that has 'alignment'
2286 lowest order bits all 0s, return size of adjustment made. */
2287 static relax_addressT
2288 relax_align (register relax_addressT address, /* Address now. */
2289 register int alignment /* Alignment (binary). */)
2291 relax_addressT mask;
2292 relax_addressT new_address;
2294 mask = ~((~0) << alignment);
2295 new_address = (address + mask) & (~mask);
2296 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2298 /* We must provide lots of padding, so the linker can discard it
2299 when needed. The linker will not add extra space, ever. */
2300 new_address += (1 << alignment);
2302 return (new_address - address);
2305 /* Now we have a segment, not a crowd of sub-segments, we can make
2310 After this, all frags in this segment have addresses that are correct
2311 within the segment. Since segments live in different file addresses,
2312 these frag addresses may not be the same as final object-file
2316 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2318 unsigned long frag_count;
2320 relax_addressT address;
2324 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2325 subseg_change (segment, 0);
2327 /* For each frag in segment: count and store (a 1st guess of)
2331 for (frag_count = 0, fragP = segment_frag_root;
2333 fragP = fragP->fr_next, frag_count ++)
2335 fragP->region = region;
2336 fragP->relax_marker = 0;
2337 fragP->fr_address = address;
2338 address += fragP->fr_fix;
2340 switch (fragP->fr_type)
2343 address += fragP->fr_offset * fragP->fr_var;
2350 addressT offset = relax_align (address, (int) fragP->fr_offset);
2352 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2355 if (offset % fragP->fr_var != 0)
2357 as_bad_where (fragP->fr_file, fragP->fr_line,
2358 _("alignment padding (%lu bytes) not a multiple of %ld"),
2359 (unsigned long) offset, (long) fragP->fr_var);
2360 offset -= (offset % fragP->fr_var);
2369 /* Assume .org is nugatory. It will grow with 1st relax. */
2376 case rs_machine_dependent:
2377 /* If fr_symbol is an expression, this call to
2378 resolve_symbol_value sets up the correct segment, which will
2379 likely be needed in md_estimate_size_before_relax. */
2380 if (fragP->fr_symbol)
2381 resolve_symbol_value (fragP->fr_symbol);
2383 address += md_estimate_size_before_relax (fragP, segment);
2386 #ifndef WORKING_DOT_WORD
2387 /* Broken words don't concern us yet. */
2388 case rs_broken_word:
2393 /* Initial guess is always 1; doing otherwise can result in
2394 stable solutions that are larger than the minimum. */
2395 address += fragP->fr_offset = 1;
2399 address += eh_frame_estimate_size_before_relax (fragP);
2403 address += dwarf2dbg_estimate_size_before_relax (fragP);
2407 BAD_CASE (fragP->fr_type);
2414 unsigned long max_iterations;
2416 /* Cumulative address adjustment. */
2419 /* Have we made any adjustment this pass? We can't just test
2420 stretch because one piece of code may have grown and another
2424 /* Most horrible, but gcc may give us some exception data that
2425 is impossible to assemble, of the form
2429 .uleb128 end - start
2435 If the leb128 is two bytes in size, then end-start is 128*128,
2436 which requires a three byte leb128. If the leb128 is three
2437 bytes in size, then end-start is 128*128-1, which requires a
2438 two byte leb128. We work around this dilemma by inserting
2439 an extra 4 bytes of alignment just after the .align. This
2440 works because the data after the align is accessed relative to
2443 This counter is used in a tiny state machine to detect
2444 whether a leb128 followed by an align is impossible to
2446 int rs_leb128_fudge = 0;
2448 /* We want to prevent going into an infinite loop where one frag grows
2449 depending upon the location of a symbol which is in turn moved by
2450 the growing frag. eg:
2456 So we dictate that this algorithm can be at most O2. */
2457 max_iterations = frag_count * frag_count;
2458 /* Check for overflow. */
2459 if (max_iterations < frag_count)
2460 max_iterations = frag_count;
2468 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2471 addressT was_address;
2475 fragP->relax_marker ^= 1;
2476 was_address = fragP->fr_address;
2477 address = fragP->fr_address += stretch;
2478 symbolP = fragP->fr_symbol;
2479 offset = fragP->fr_offset;
2481 switch (fragP->fr_type)
2483 case rs_fill: /* .fill never relaxes. */
2487 #ifndef WORKING_DOT_WORD
2488 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2489 for it I do not want to write it. I do not want to have
2490 anything to do with it. This is not the proper way to
2491 implement this misfeature. */
2492 case rs_broken_word:
2494 struct broken_word *lie;
2495 struct broken_word *untruth;
2497 /* Yes this is ugly (storing the broken_word pointer
2498 in the symbol slot). Still, this whole chunk of
2499 code is ugly, and I don't feel like doing anything
2500 about it. Think of it as stubbornness in action. */
2502 for (lie = (struct broken_word *) (fragP->fr_symbol);
2503 lie && lie->dispfrag == fragP;
2504 lie = lie->next_broken_word)
2510 offset = (S_GET_VALUE (lie->add)
2512 - S_GET_VALUE (lie->sub));
2513 if (offset <= -32768 || offset >= 32767)
2515 if (flag_warn_displacement)
2518 sprint_value (buf, (addressT) lie->addnum);
2519 as_warn_where (fragP->fr_file, fragP->fr_line,
2520 _(".word %s-%s+%s didn't fit"),
2521 S_GET_NAME (lie->add),
2522 S_GET_NAME (lie->sub),
2525 if (fragP->fr_subtype == 0)
2527 fragP->fr_subtype++;
2528 growth += md_short_jump_size;
2531 /* Redirect *all* words of this table with the same
2532 target, lest we have to handle the case where the
2533 same target but with a offset that fits on this
2534 round overflows at the next relaxation round. */
2535 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2536 untruth && untruth->dispfrag == lie->dispfrag;
2537 untruth = untruth->next_broken_word)
2538 if ((symbol_get_frag (untruth->add)
2539 == symbol_get_frag (lie->add))
2540 && (S_GET_VALUE (untruth->add)
2541 == S_GET_VALUE (lie->add)))
2544 untruth->use_jump = lie;
2548 growth += md_long_jump_size;
2553 } /* case rs_broken_word */
2559 addressT oldoff, newoff;
2561 oldoff = relax_align (was_address + fragP->fr_fix,
2563 newoff = relax_align (address + fragP->fr_fix,
2566 if (fragP->fr_subtype != 0)
2568 if (oldoff > fragP->fr_subtype)
2570 if (newoff > fragP->fr_subtype)
2574 growth = newoff - oldoff;
2576 /* If this align happens to follow a leb128 and
2577 we have determined that the leb128 is bouncing
2578 in size, then break the cycle by inserting an
2581 && (rs_leb128_fudge & 16) != 0
2582 && (rs_leb128_fudge & 15) >= 2)
2584 segment_info_type *seginfo = seg_info (segment);
2585 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2588 newf = frag_alloc (ob);
2589 obstack_blank_fast (ob, fragP->fr_var);
2590 obstack_finish (ob);
2591 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2592 memcpy (newf->fr_literal,
2593 fragP->fr_literal + fragP->fr_fix,
2595 newf->fr_type = rs_fill;
2596 newf->fr_address = address + fragP->fr_fix + newoff;
2598 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2600 if (newf->fr_offset * newf->fr_var
2601 != (offsetT) 1 << fragP->fr_offset)
2603 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2606 /* Include size of new frag in GROWTH. */
2607 growth += newf->fr_offset * newf->fr_var;
2608 /* Adjust the new frag address for the amount
2609 we'll add when we process the new frag. */
2610 newf->fr_address -= stretch + growth;
2611 newf->relax_marker ^= 1;
2612 fragP->fr_next = newf;
2614 as_warn (_("padding added"));
2622 addressT target = offset;
2627 /* Convert from an actual address to an octet offset
2628 into the section. Here it is assumed that the
2629 section's VMA is zero, and can omit subtracting it
2630 from the symbol's value to get the address offset. */
2631 know (S_GET_SEGMENT (symbolP)->vma == 0);
2632 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2635 know (fragP->fr_next);
2636 after = fragP->fr_next->fr_address + stretch;
2637 growth = target - after;
2642 /* Don't error on first few frag relax passes.
2643 The symbol might be an expression involving
2644 symbol values from other sections. If those
2645 sections have not yet been processed their
2646 frags will all have zero addresses, so we
2647 will calculate incorrect values for them. The
2648 number of passes we allow before giving an
2649 error is somewhat arbitrary. It should be at
2650 least one, with larger values requiring
2651 increasingly contrived dependencies between
2652 frags to trigger a false error. */
2655 /* Force another pass. */
2660 /* Growth may be negative, but variable part of frag
2661 cannot have fewer than 0 chars. That is, we can't
2663 as_bad_where (fragP->fr_file, fragP->fr_line,
2664 _("attempt to move .org backwards"));
2666 /* We've issued an error message. Change the
2667 frag to avoid cascading errors. */
2668 fragP->fr_type = rs_align;
2669 fragP->fr_subtype = 0;
2670 fragP->fr_offset = 0;
2671 fragP->fr_fix = after - address;
2682 amount = S_GET_VALUE (symbolP);
2683 if (S_GET_SEGMENT (symbolP) != absolute_section
2684 || S_IS_COMMON (symbolP)
2685 || ! S_IS_DEFINED (symbolP))
2687 as_bad_where (fragP->fr_file, fragP->fr_line,
2688 _(".space specifies non-absolute value"));
2689 /* Prevent repeat of this error message. */
2690 fragP->fr_symbol = 0;
2692 else if (amount < 0)
2694 /* Don't error on first few frag relax passes.
2695 See rs_org comment for a longer explanation. */
2702 as_warn_where (fragP->fr_file, fragP->fr_line,
2703 _(".space or .fill with negative value, ignored"));
2704 fragP->fr_symbol = 0;
2707 growth = (was_address + fragP->fr_fix + amount
2708 - fragP->fr_next->fr_address);
2712 case rs_machine_dependent:
2713 #ifdef md_relax_frag
2714 growth = md_relax_frag (segment, fragP, stretch);
2716 #ifdef TC_GENERIC_RELAX_TABLE
2717 /* The default way to relax a frag is to look through
2718 TC_GENERIC_RELAX_TABLE. */
2719 growth = relax_frag (segment, fragP, stretch);
2720 #endif /* TC_GENERIC_RELAX_TABLE */
2729 value = resolve_symbol_value (fragP->fr_symbol);
2730 size = sizeof_leb128 (value, fragP->fr_subtype);
2731 growth = size - fragP->fr_offset;
2732 fragP->fr_offset = size;
2737 growth = eh_frame_relax_frag (fragP);
2741 growth = dwarf2dbg_relax_frag (fragP);
2745 BAD_CASE (fragP->fr_type);
2752 if (fragP->fr_type == rs_leb128)
2753 rs_leb128_fudge += 16;
2754 else if (fragP->fr_type == rs_align
2755 && (rs_leb128_fudge & 16) != 0
2757 rs_leb128_fudge += 16;
2759 rs_leb128_fudge = 0;
2764 && (rs_leb128_fudge & 16) == 0
2765 && (rs_leb128_fudge & -16) != 0)
2766 rs_leb128_fudge += 1;
2768 rs_leb128_fudge = 0;
2770 /* Until nothing further to relax. */
2771 while (stretched && -- max_iterations);
2774 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2775 segment_name (segment));
2778 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2779 if (fragP->last_fr_address != fragP->fr_address)
2781 fragP->last_fr_address = fragP->fr_address;
2788 number_to_chars_bigendian (char *buf, valueT val, int n)
2794 buf[n] = val & 0xff;
2800 number_to_chars_littleendian (char *buf, valueT val, int n)
2806 *buf++ = val & 0xff;
2812 write_print_statistics (FILE *file)
2814 fprintf (file, "fixups: %d\n", n_fixups);
2817 /* For debugging. */
2818 extern int indent_level;
2821 print_fixup (fixS *fixp)
2824 fprintf (stderr, "fix ");
2825 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2826 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2828 fprintf (stderr, " pcrel");
2829 if (fixp->fx_pcrel_adjust)
2830 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2831 if (fixp->fx_im_disp)
2834 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2836 fprintf (stderr, " im_disp");
2840 fprintf (stderr, " tcbit");
2842 fprintf (stderr, " done");
2843 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2844 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2845 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2846 (long) fixp->fx_where,
2847 (unsigned long) fixp->fx_offset,
2848 (unsigned long) fixp->fx_addnumber);
2849 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2853 fprintf (stderr, "\n +<");
2854 print_symbol_value_1 (stderr, fixp->fx_addsy);
2855 fprintf (stderr, ">");
2859 fprintf (stderr, "\n -<");
2860 print_symbol_value_1 (stderr, fixp->fx_subsy);
2861 fprintf (stderr, ">");
2863 fprintf (stderr, "\n");
2864 #ifdef TC_FIX_DATA_PRINT
2865 TC_FIX_DATA_PRINT (stderr, fixp);