1 /* write.c - emit .o file
2 Copyright (C) 1986-2014 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* This thing should be set up to do byteordering correctly. But... */
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
29 #include "compress-debug.h"
31 #ifndef TC_FORCE_RELOCATION
32 #define TC_FORCE_RELOCATION(FIX) \
33 (generic_force_reloc (FIX))
36 #ifndef TC_FORCE_RELOCATION_ABS
37 #define TC_FORCE_RELOCATION_ABS(FIX) \
38 (TC_FORCE_RELOCATION (FIX))
41 #ifndef TC_FORCE_RELOCATION_LOCAL
42 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
44 || TC_FORCE_RELOCATION (FIX))
47 #ifndef TC_FORCE_RELOCATION_SUB_SAME
48 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
52 #ifndef md_register_arithmetic
53 # define md_register_arithmetic 1
56 #ifndef TC_FORCE_RELOCATION_SUB_ABS
57 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
58 (!md_register_arithmetic && (SEG) == reg_section)
61 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
64 (!md_register_arithmetic && (SEG) == reg_section)
66 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
70 #ifndef TC_VALIDATE_FIX_SUB
71 #ifdef UNDEFINED_DIFFERENCE_OK
72 /* The PA needs this for PIC code generation. */
73 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
74 (md_register_arithmetic || (SEG) != reg_section)
76 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
77 ((md_register_arithmetic || (SEG) != reg_section) \
78 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
79 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
83 #ifndef TC_LINKRELAX_FIXUP
84 #define TC_LINKRELAX_FIXUP(SEG) 1
87 #ifndef MD_APPLY_SYM_VALUE
88 #define MD_APPLY_SYM_VALUE(FIX) 1
91 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
92 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
95 #ifndef MD_PCREL_FROM_SECTION
96 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
103 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
104 fixups that far past the end of a frag. Having such fixups
105 is of course most most likely a bug in setting fx_size correctly.
106 A negative value disables the fixup check entirely, which is
107 appropriate for something like the Renesas / SuperH SH_COUNT
109 #ifndef TC_FX_SIZE_SLACK
110 #define TC_FX_SIZE_SLACK(FIX) 0
113 /* Used to control final evaluation of expressions. */
114 int finalize_syms = 0;
116 int symbol_table_frozen;
118 symbolS *abs_section_sym;
120 /* Remember the value of dot when parsing expressions. */
123 /* The frag that dot_value is based from. */
126 /* Relocs generated by ".reloc" pseudo. */
127 struct reloc_list* reloc_list;
129 void print_fixup (fixS *);
131 /* We generally attach relocs to frag chains. However, after we have
132 chained these all together into a segment, any relocs we add after
133 that must be attached to a segment. This will include relocs added
134 in md_estimate_size_for_relax, for example. */
135 static int frags_chained = 0;
139 #define RELOC_ENUM enum bfd_reloc_code_real
141 /* Create a fixS in obstack 'notes'. */
144 fix_new_internal (fragS *frag, /* Which frag? */
145 int where, /* Where in that frag? */
146 int size, /* 1, 2, or 4 usually. */
147 symbolS *add_symbol, /* X_add_symbol. */
148 symbolS *sub_symbol, /* X_op_symbol. */
149 offsetT offset, /* X_add_number. */
150 int pcrel, /* TRUE if PC-relative relocation. */
151 RELOC_ENUM r_type /* Relocation type. */,
152 int at_beginning) /* Add to the start of the list? */
158 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
160 fixP->fx_frag = frag;
161 fixP->fx_where = where;
162 fixP->fx_size = size;
163 /* We've made fx_size a narrow field; check that it's wide enough. */
164 if (fixP->fx_size != size)
166 as_bad (_("field fx_size too small to hold %d"), size);
169 fixP->fx_addsy = add_symbol;
170 fixP->fx_subsy = sub_symbol;
171 fixP->fx_offset = offset;
172 fixP->fx_dot_value = dot_value;
173 fixP->fx_dot_frag = dot_frag;
174 fixP->fx_pcrel = pcrel;
175 fixP->fx_r_type = r_type;
176 fixP->fx_im_disp = 0;
177 fixP->fx_pcrel_adjust = 0;
178 fixP->fx_bit_fixP = 0;
179 fixP->fx_addnumber = 0;
183 fixP->fx_no_overflow = 0;
187 fixP->fx_cgen.insn = NULL;
188 fixP->fx_cgen.opinfo = 0;
192 TC_INIT_FIX_DATA (fixP);
195 as_where (&fixP->fx_file, &fixP->fx_line);
199 fixS **seg_fix_rootP = (frags_chained
200 ? &seg_info (now_seg)->fix_root
201 : &frchain_now->fix_root);
202 fixS **seg_fix_tailP = (frags_chained
203 ? &seg_info (now_seg)->fix_tail
204 : &frchain_now->fix_tail);
208 fixP->fx_next = *seg_fix_rootP;
209 *seg_fix_rootP = fixP;
210 if (fixP->fx_next == NULL)
211 *seg_fix_tailP = fixP;
215 fixP->fx_next = NULL;
217 (*seg_fix_tailP)->fx_next = fixP;
219 *seg_fix_rootP = fixP;
220 *seg_fix_tailP = fixP;
227 /* Create a fixup relative to a symbol (plus a constant). */
230 fix_new (fragS *frag, /* Which frag? */
231 int where, /* Where in that frag? */
232 int size, /* 1, 2, or 4 usually. */
233 symbolS *add_symbol, /* X_add_symbol. */
234 offsetT offset, /* X_add_number. */
235 int pcrel, /* TRUE if PC-relative relocation. */
236 RELOC_ENUM r_type /* Relocation type. */)
238 return fix_new_internal (frag, where, size, add_symbol,
239 (symbolS *) NULL, offset, pcrel, r_type, FALSE);
242 /* Create a fixup for an expression. Currently we only support fixups
243 for difference expressions. That is itself more than most object
244 file formats support anyhow. */
247 fix_new_exp (fragS *frag, /* Which frag? */
248 int where, /* Where in that frag? */
249 int size, /* 1, 2, or 4 usually. */
250 expressionS *exp, /* Expression. */
251 int pcrel, /* TRUE if PC-relative relocation. */
252 RELOC_ENUM r_type /* Relocation type. */)
264 as_bad (_("register value used as expression"));
268 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
269 the difference expression cannot immediately be reduced. */
271 symbolS *stmp = make_expr_symbol (exp);
273 exp->X_op = O_symbol;
274 exp->X_op_symbol = 0;
275 exp->X_add_symbol = stmp;
276 exp->X_add_number = 0;
278 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
282 add = exp->X_add_symbol;
283 off = exp->X_add_number;
284 r_type = BFD_RELOC_RVA;
288 sub = exp->X_add_symbol;
289 off = exp->X_add_number;
293 sub = exp->X_op_symbol;
296 add = exp->X_add_symbol;
299 off = exp->X_add_number;
303 add = make_expr_symbol (exp);
307 return fix_new_internal (frag, where, size, add, sub, off, pcrel,
311 /* Create a fixup at the beginning of FRAG. The arguments are the same
312 as for fix_new, except that WHERE is implicitly 0. */
315 fix_at_start (fragS *frag, int size, symbolS *add_symbol,
316 offsetT offset, int pcrel, RELOC_ENUM r_type)
318 return fix_new_internal (frag, 0, size, add_symbol,
319 (symbolS *) NULL, offset, pcrel, r_type, TRUE);
322 /* Generic function to determine whether a fixup requires a relocation. */
324 generic_force_reloc (fixS *fix)
326 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
327 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
330 if (fix->fx_addsy == NULL)
333 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
336 /* Append a string onto another string, bumping the pointer along. */
338 append (char **charPP, char *fromP, unsigned long length)
340 /* Don't trust memcpy() of 0 chars. */
344 memcpy (*charPP, fromP, length);
348 /* This routine records the largest alignment seen for each segment.
349 If the beginning of the segment is aligned on the worst-case
350 boundary, all of the other alignments within it will work. At
351 least one object format really uses this info. */
354 record_alignment (/* Segment to which alignment pertains. */
356 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
357 boundary, 2 => 4-byte boundary, etc.) */
360 if (seg == absolute_section)
363 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
364 bfd_set_section_alignment (stdoutput, seg, align);
368 get_recorded_alignment (segT seg)
370 if (seg == absolute_section)
373 return bfd_get_section_alignment (stdoutput, seg);
376 /* Reset the section indices after removing the gas created sections. */
379 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
381 int *countp = (int *) countparg;
383 sec->index = *countp;
388 chain_frchains_together_1 (segT section, struct frchain *frchp)
390 fragS dummy, *prev_frag = &dummy;
391 fixS fix_dummy, *prev_fix = &fix_dummy;
393 for (; frchp; frchp = frchp->frch_next)
395 prev_frag->fr_next = frchp->frch_root;
396 prev_frag = frchp->frch_last;
397 gas_assert (prev_frag->fr_type != 0);
398 if (frchp->fix_root != (fixS *) NULL)
400 if (seg_info (section)->fix_root == (fixS *) NULL)
401 seg_info (section)->fix_root = frchp->fix_root;
402 prev_fix->fx_next = frchp->fix_root;
403 seg_info (section)->fix_tail = frchp->fix_tail;
404 prev_fix = frchp->fix_tail;
407 gas_assert (prev_frag != &dummy
408 && prev_frag->fr_type != 0);
409 prev_frag->fr_next = 0;
414 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
416 void *xxx ATTRIBUTE_UNUSED)
418 segment_info_type *info;
420 /* BFD may have introduced its own sections without using
421 subseg_new, so it is possible that seg_info is NULL. */
422 info = seg_info (section);
423 if (info != (segment_info_type *) NULL)
424 info->frchainP->frch_last
425 = chain_frchains_together_1 (section, info->frchainP);
427 /* Now that we've chained the frags together, we must add new fixups
428 to the segment, not to the frag chain. */
433 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
435 switch (fragP->fr_type)
443 HANDLE_ALIGN (fragP);
445 know (fragP->fr_next != NULL);
446 fragP->fr_offset = (fragP->fr_next->fr_address
448 - fragP->fr_fix) / fragP->fr_var;
449 if (fragP->fr_offset < 0)
451 as_bad_where (fragP->fr_file, fragP->fr_line,
452 _("attempt to .org/.space backwards? (%ld)"),
453 (long) fragP->fr_offset);
454 fragP->fr_offset = 0;
456 fragP->fr_type = rs_fill;
464 valueT value = S_GET_VALUE (fragP->fr_symbol);
467 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
470 fragP->fr_fix += size;
471 fragP->fr_type = rs_fill;
473 fragP->fr_offset = 0;
474 fragP->fr_symbol = NULL;
479 eh_frame_convert_frag (fragP);
483 dwarf2dbg_convert_frag (fragP);
486 case rs_machine_dependent:
487 md_convert_frag (stdoutput, sec, fragP);
489 gas_assert (fragP->fr_next == NULL
490 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
493 /* After md_convert_frag, we make the frag into a ".space 0".
494 md_convert_frag() should set up any fixSs and constants
499 #ifndef WORKING_DOT_WORD
502 struct broken_word *lie;
504 if (fragP->fr_subtype)
506 fragP->fr_fix += md_short_jump_size;
507 for (lie = (struct broken_word *) (fragP->fr_symbol);
508 lie && lie->dispfrag == fragP;
509 lie = lie->next_broken_word)
511 fragP->fr_fix += md_long_jump_size;
519 BAD_CASE (fragP->fr_type);
523 md_frag_check (fragP);
527 struct relax_seg_info
534 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
536 segment_info_type *seginfo = seg_info (sec);
537 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
539 if (seginfo && seginfo->frchainP
540 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
545 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
549 segment_info_type *seginfo;
551 valueT size, newsize;
553 subseg_change (sec, 0);
555 seginfo = seg_info (sec);
556 if (seginfo && seginfo->frchainP)
558 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
559 cvt_frag_to_fill (sec, fragp);
560 for (fragp = seginfo->frchainP->frch_root;
562 fragp = fragp->fr_next)
563 /* Walk to last elt. */
565 size = fragp->fr_address + fragp->fr_fix;
570 flags = bfd_get_section_flags (abfd, sec);
571 if (size == 0 && bfd_get_section_size (sec) != 0 &&
572 (flags & SEC_HAS_CONTENTS) != 0)
575 if (size > 0 && ! seginfo->bss)
576 flags |= SEC_HAS_CONTENTS;
579 x = bfd_set_section_flags (abfd, sec, flags);
582 newsize = md_section_align (sec, size);
583 x = bfd_set_section_size (abfd, sec, newsize);
586 /* If the size had to be rounded up, add some padding in the last
588 gas_assert (newsize >= size);
591 fragS *last = seginfo->frchainP->frch_last;
592 fragp = seginfo->frchainP->frch_root;
593 while (fragp->fr_next != last)
594 fragp = fragp->fr_next;
595 last->fr_address = size;
596 if ((newsize - size) % fragp->fr_var == 0)
597 fragp->fr_offset += (newsize - size) / fragp->fr_var;
599 /* If we hit this abort, it's likely due to subsegs_finish not
600 providing sufficient alignment on the last frag, and the
601 machine dependent code using alignment frags with fr_var
606 #ifdef tc_frob_section
607 tc_frob_section (sec);
609 #ifdef obj_frob_section
610 obj_frob_section (sec);
616 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
618 segment_info_type *seginfo = seg_info (sec);
619 fixS *fixp = seginfo->fix_root;
624 fprintf (stream, "sec %s relocs:\n", sec->name);
627 symbolS *s = fixp->fx_addsy;
629 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
630 (int) fixp->fx_r_type);
632 fprintf (stream, "no sym\n");
635 print_symbol_value_1 (stream, s);
636 fprintf (stream, "\n");
638 fixp = fixp->fx_next;
642 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
645 #ifndef EMIT_SECTION_SYMBOLS
646 #define EMIT_SECTION_SYMBOLS 1
649 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
650 and check for validity. Convert RELOC_LIST from using U.A fields
653 resolve_reloc_expr_symbols (void)
655 bfd_vma addr_mask = 1;
656 struct reloc_list *r;
658 /* Avoid a shift by the width of type. */
659 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
663 for (r = reloc_list; r; r = r->next)
665 reloc_howto_type *howto = r->u.a.howto;
668 bfd_vma offset, addend;
671 resolve_symbol_value (r->u.a.offset_sym);
672 symval = symbol_get_value_expression (r->u.a.offset_sym);
676 if (symval->X_op == O_constant)
677 sym = r->u.a.offset_sym;
678 else if (symval->X_op == O_symbol)
680 sym = symval->X_add_symbol;
681 offset = symval->X_add_number;
682 symval = symbol_get_value_expression (symval->X_add_symbol);
685 || symval->X_op != O_constant
686 || (sec = S_GET_SEGMENT (sym)) == NULL
687 || !SEG_NORMAL (sec))
689 as_bad_where (r->file, r->line, _("invalid offset expression"));
693 offset += S_GET_VALUE (sym);
696 addend = r->u.a.addend;
697 if (r->u.a.sym != NULL)
699 resolve_symbol_value (r->u.a.sym);
700 symval = symbol_get_value_expression (r->u.a.sym);
701 if (symval->X_op == O_constant)
703 else if (symval->X_op == O_symbol)
705 sym = symval->X_add_symbol;
706 addend += symval->X_add_number;
707 symval = symbol_get_value_expression (symval->X_add_symbol);
709 if (symval->X_op != O_constant)
711 as_bad_where (r->file, r->line, _("invalid reloc expression"));
714 else if (sym != NULL)
716 /* Convert relocs against local symbols to refer to the
717 corresponding section symbol plus offset instead. Keep
718 PC-relative relocs of the REL variety intact though to
719 prevent the offset from overflowing the relocated field,
720 unless it has enough bits to cover the whole address
722 if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
724 || (howto->partial_inplace
725 && (!howto->pc_relative
726 || howto->src_mask == addr_mask))))
728 asection *symsec = S_GET_SEGMENT (sym);
729 if (!(((symsec->flags & SEC_MERGE) != 0
731 || (symsec->flags & SEC_THREAD_LOCAL) != 0))
733 addend += S_GET_VALUE (sym);
734 sym = section_symbol (symsec);
737 symbol_mark_used_in_reloc (sym);
742 if (abs_section_sym == NULL)
743 abs_section_sym = section_symbol (absolute_section);
744 sym = abs_section_sym;
748 r->u.b.s = symbol_get_bfdsym (sym);
749 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
750 r->u.b.r.address = offset;
751 r->u.b.r.addend = addend;
752 r->u.b.r.howto = howto;
756 /* This pass over fixups decides whether symbols can be replaced with
760 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
762 void *xxx ATTRIBUTE_UNUSED)
764 segment_info_type *seginfo = seg_info (sec);
770 dump_section_relocs (abfd, sec, stderr);
772 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
776 else if (fixp->fx_addsy)
782 fprintf (stderr, "\n\nadjusting fixup:\n");
786 sym = fixp->fx_addsy;
788 /* All symbols should have already been resolved at this
789 point. It is possible to see unresolved expression
790 symbols, though, since they are not in the regular symbol
792 resolve_symbol_value (sym);
794 if (fixp->fx_subsy != NULL)
795 resolve_symbol_value (fixp->fx_subsy);
797 /* If this symbol is equated to an undefined or common symbol,
798 convert the fixup to being against that symbol. */
799 while (symbol_equated_reloc_p (sym)
800 || S_IS_WEAKREFR (sym))
802 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
805 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
806 fixp->fx_addsy = newsym;
810 if (symbol_mri_common_p (sym))
812 fixp->fx_offset += S_GET_VALUE (sym);
813 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
817 /* If the symbol is undefined, common, weak, or global (ELF
818 shared libs), we can't replace it with the section symbol. */
819 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
822 /* Is there some other (target cpu dependent) reason we can't adjust
823 this one? (E.g. relocations involving function addresses on
825 #ifdef tc_fix_adjustable
826 if (! tc_fix_adjustable (fixp))
830 /* Since we're reducing to section symbols, don't attempt to reduce
831 anything that's already using one. */
832 if (symbol_section_p (sym))
835 symsec = S_GET_SEGMENT (sym);
839 if (bfd_is_abs_section (symsec)
840 || symsec == reg_section)
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_section (asection *s)
1699 struct frchain *frchainP;
1700 segment_info_type *seginfo = seg_info (s);
1704 for (frchainP = seginfo->frchainP;
1706 frchainP = frchainP->frch_next)
1710 subseg_set (s, frchainP->frch_subseg);
1712 /* This now gets called even if we had errors. In that case,
1713 any alignment is meaningless, and, moreover, will look weird
1714 if we are generating a listing. */
1717 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1718 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1719 && now_seg->entsize)
1721 unsigned int entsize = now_seg->entsize;
1724 while ((entsize & 1) == 0)
1730 if (entalign > alignment)
1731 alignment = entalign;
1735 if (subseg_text_p (now_seg))
1736 frag_align_code (alignment, 0);
1738 frag_align (alignment, 0, 0);
1740 /* frag_align will have left a new frag.
1741 Use this last frag for an empty ".fill".
1743 For this segment ...
1744 Create a last frag. Do not leave a "being filled in frag". */
1745 frag_wane (frag_now);
1746 frag_now->fr_fix = 0;
1747 know (frag_now->fr_next == NULL);
1752 subsegs_finish (void)
1756 for (s = stdoutput->sections; s; s = s->next)
1757 subsegs_finish_section (s);
1762 create_obj_attrs_section (void)
1769 size = bfd_elf_obj_attr_size (stdoutput);
1772 name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1774 name = ".gnu.attributes";
1775 s = subseg_new (name, 0);
1776 elf_section_type (s)
1777 = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1778 bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1780 p = frag_more (size);
1781 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1783 subsegs_finish_section (s);
1784 relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1785 size_seg (stdoutput, s, NULL);
1790 /* Write the object file. */
1793 write_object_file (void)
1795 struct relax_seg_info rsi;
1796 #ifndef WORKING_DOT_WORD
1797 fragS *fragP; /* Track along all frags. */
1802 #ifdef md_pre_output_hook
1806 #ifdef md_pre_relax_hook
1810 /* From now on, we don't care about sub-segments. Build one frag chain
1811 for each segment. Linked thru fr_next. */
1813 /* Remove the sections created by gas for its own purposes. */
1817 bfd_section_list_remove (stdoutput, reg_section);
1818 bfd_section_list_remove (stdoutput, expr_section);
1819 stdoutput->section_count -= 2;
1821 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1824 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1826 /* We have two segments. If user gave -R flag, then we must put the
1827 data frags into the text segment. Do this before relaxing so
1828 we know to take advantage of -R and make shorter addresses. */
1829 if (flag_readonly_data_in_text)
1831 merge_data_into_text ();
1837 #ifndef WORKING_DOT_WORD
1838 /* We need to reset the markers in the broken word list and
1839 associated frags between calls to relax_segment (via
1840 relax_seg). Since the broken word list is global, we do it
1841 once per round, rather than locally in relax_segment for each
1843 struct broken_word *brokp;
1845 for (brokp = broken_words;
1846 brokp != (struct broken_word *) NULL;
1847 brokp = brokp->next_broken_word)
1851 if (brokp->dispfrag != (fragS *) NULL
1852 && brokp->dispfrag->fr_type == rs_broken_word)
1853 brokp->dispfrag->fr_subtype = 0;
1858 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1864 /* Note - Most ports will use the default value of
1865 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1866 local symbols to be resolved, removing their frag information.
1867 Some ports however, will not have finished relaxing all of
1868 their frags and will still need the local symbol frag
1869 information. These ports can set
1870 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1871 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1873 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1875 /* Relaxation has completed. Freeze all syms. */
1878 #ifdef md_post_relax_hook
1884 create_obj_attrs_section ();
1887 #ifndef WORKING_DOT_WORD
1889 struct broken_word *lie;
1890 struct broken_word **prevP;
1892 prevP = &broken_words;
1893 for (lie = broken_words; lie; lie = lie->next_broken_word)
1898 subseg_change (lie->seg, lie->subseg);
1899 exp.X_op = O_subtract;
1900 exp.X_add_symbol = lie->add;
1901 exp.X_op_symbol = lie->sub;
1902 exp.X_add_number = lie->addnum;
1903 #ifdef TC_CONS_FIX_NEW
1904 TC_CONS_FIX_NEW (lie->frag,
1905 lie->word_goes_here - lie->frag->fr_literal,
1906 2, &exp, TC_PARSE_CONS_RETURN_NONE);
1908 fix_new_exp (lie->frag,
1909 lie->word_goes_here - lie->frag->fr_literal,
1910 2, &exp, 0, BFD_RELOC_16);
1912 *prevP = lie->next_broken_word;
1915 prevP = &(lie->next_broken_word);
1917 for (lie = broken_words; lie;)
1919 struct broken_word *untruth;
1921 addressT table_addr;
1922 addressT from_addr, to_addr;
1925 subseg_change (lie->seg, lie->subseg);
1926 fragP = lie->dispfrag;
1928 /* Find out how many broken_words go here. */
1931 untruth && untruth->dispfrag == fragP;
1932 untruth = untruth->next_broken_word)
1933 if (untruth->added == 1)
1936 table_ptr = lie->dispfrag->fr_opcode;
1937 table_addr = (lie->dispfrag->fr_address
1938 + (table_ptr - lie->dispfrag->fr_literal));
1939 /* Create the jump around the long jumps. This is a short
1940 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1941 from_addr = table_addr;
1942 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1943 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1945 table_ptr += md_short_jump_size;
1946 table_addr += md_short_jump_size;
1949 lie && lie->dispfrag == fragP;
1950 m++, lie = lie->next_broken_word)
1952 if (lie->added == 2)
1954 /* Patch the jump table. */
1955 for (untruth = (struct broken_word *) (fragP->fr_symbol);
1956 untruth && untruth->dispfrag == fragP;
1957 untruth = untruth->next_broken_word)
1959 if (untruth->use_jump == lie)
1961 /* This is the offset from ??? to table_ptr+0.
1962 The target is the same for all users of this
1963 md_long_jump, but the "sub" bases (and hence the
1964 offsets) may be different. */
1965 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1966 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1967 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1969 md_number_to_chars (untruth->word_goes_here, to_word, 2);
1973 /* Install the long jump. */
1974 /* This is a long jump from table_ptr+0 to the final target. */
1975 from_addr = table_addr;
1976 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1977 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1979 table_ptr += md_long_jump_size;
1980 table_addr += md_long_jump_size;
1984 #endif /* not WORKING_DOT_WORD */
1986 /* Resolve symbol values. This needs to be done before processing
1992 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1993 resolve_symbol_value (symp);
1995 resolve_local_symbol_values ();
1996 resolve_reloc_expr_symbols ();
2000 #ifdef tc_frob_file_before_adjust
2001 tc_frob_file_before_adjust ();
2003 #ifdef obj_frob_file_before_adjust
2004 obj_frob_file_before_adjust ();
2007 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2009 #ifdef tc_frob_file_before_fix
2010 tc_frob_file_before_fix ();
2012 #ifdef obj_frob_file_before_fix
2013 obj_frob_file_before_fix ();
2016 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2018 /* Set up symbol table, and write it out. */
2022 bfd_boolean skip_next_symbol = FALSE;
2024 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2029 if (skip_next_symbol)
2031 /* Don't do anything besides moving the value of the
2032 symbol from the GAS value-field to the BFD value-field. */
2033 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2034 skip_next_symbol = FALSE;
2038 if (symbol_mri_common_p (symp))
2040 if (S_IS_EXTERNAL (symp))
2041 as_bad (_("%s: global symbols not supported in common sections"),
2043 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2047 name = S_GET_NAME (symp);
2051 decode_local_label_name ((char *) S_GET_NAME (symp));
2052 /* They only differ if `name' is a fb or dollar local
2054 if (name2 != name && ! S_IS_DEFINED (symp))
2055 as_bad (_("local label `%s' is not defined"), name2);
2058 /* Do it again, because adjust_reloc_syms might introduce
2059 more symbols. They'll probably only be section symbols,
2060 but they'll still need to have the values computed. */
2061 resolve_symbol_value (symp);
2063 /* Skip symbols which were equated to undefined or common
2065 if (symbol_equated_reloc_p (symp)
2066 || S_IS_WEAKREFR (symp))
2068 const char *sname = S_GET_NAME (symp);
2070 if (S_IS_COMMON (symp)
2071 && !TC_FAKE_LABEL (sname)
2072 && !S_IS_WEAKREFR (symp)
2073 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2075 expressionS *e = symbol_get_value_expression (symp);
2077 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2078 sname, S_GET_NAME (e->X_add_symbol));
2080 if (S_GET_SEGMENT (symp) == reg_section)
2082 /* Report error only if we know the symbol name. */
2083 if (S_GET_NAME (symp) != reg_section->name)
2084 as_bad (_("can't make global register symbol `%s'"),
2087 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2091 #ifdef obj_frob_symbol
2092 obj_frob_symbol (symp, punt);
2094 #ifdef tc_frob_symbol
2095 if (! punt || symbol_used_in_reloc_p (symp))
2096 tc_frob_symbol (symp, punt);
2099 /* If we don't want to keep this symbol, splice it out of
2100 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2101 want section symbols. Otherwise, we skip local symbols
2102 and symbols that the frob_symbol macros told us to punt,
2103 but we keep such symbols if they are used in relocs. */
2104 if (symp == abs_section_sym
2105 || (! EMIT_SECTION_SYMBOLS
2106 && symbol_section_p (symp))
2107 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2108 opposites. Sometimes the former checks flags and the
2109 latter examines the name... */
2110 || (!S_IS_EXTERNAL (symp)
2111 && (punt || S_IS_LOCAL (symp) ||
2112 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2113 && ! symbol_used_in_reloc_p (symp)))
2115 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2117 /* After symbol_remove, symbol_next(symp) still returns
2118 the one that came after it in the chain. So we don't
2119 need to do any extra cleanup work here. */
2123 /* Make sure we really got a value for the symbol. */
2124 if (! symbol_resolved_p (symp))
2126 as_bad (_("can't resolve value for symbol `%s'"),
2128 symbol_mark_resolved (symp);
2131 /* Set the value into the BFD symbol. Up til now the value
2132 has only been kept in the gas symbolS struct. */
2133 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2135 /* A warning construct is a warning symbol followed by the
2136 symbol warned about. Don't let anything object-format or
2137 target-specific muck with it; it's ready for output. */
2138 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2139 skip_next_symbol = TRUE;
2145 /* Now do any format-specific adjustments to the symbol table, such
2146 as adding file symbols. */
2147 #ifdef tc_adjust_symtab
2148 tc_adjust_symtab ();
2150 #ifdef obj_adjust_symtab
2151 obj_adjust_symtab ();
2154 /* Stop if there is an error. */
2158 /* Now that all the sizes are known, and contents correct, we can
2159 start writing to the file. */
2162 /* If *_frob_file changes the symbol value at this point, it is
2163 responsible for moving the changed value into symp->bsym->value
2164 as well. Hopefully all symbol value changing can be done in
2169 #ifdef obj_frob_file
2172 #ifdef obj_coff_generate_pdata
2173 obj_coff_generate_pdata ();
2175 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2177 #ifdef tc_frob_file_after_relocs
2178 tc_frob_file_after_relocs ();
2180 #ifdef obj_frob_file_after_relocs
2181 obj_frob_file_after_relocs ();
2184 /* Once all relocations have been written, we can compress the
2185 contents of the debug sections. This needs to be done before
2186 we start writing any sections, because it will affect the file
2187 layout, which is fixed once we start writing contents. */
2188 if (flag_compress_debug)
2189 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2191 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2194 #ifdef TC_GENERIC_RELAX_TABLE
2195 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2198 relax_frag (segT segment, fragS *fragP, long stretch)
2200 const relax_typeS *this_type;
2201 const relax_typeS *start_type;
2202 relax_substateT next_state;
2203 relax_substateT this_state;
2209 const relax_typeS *table;
2211 target = fragP->fr_offset;
2212 address = fragP->fr_address;
2213 table = TC_GENERIC_RELAX_TABLE;
2214 this_state = fragP->fr_subtype;
2215 start_type = this_type = table + this_state;
2216 symbolP = fragP->fr_symbol;
2222 sym_frag = symbol_get_frag (symbolP);
2224 #ifndef DIFF_EXPR_OK
2225 know (sym_frag != NULL);
2227 know (S_GET_SEGMENT (symbolP) != absolute_section
2228 || sym_frag == &zero_address_frag);
2229 target += S_GET_VALUE (symbolP);
2231 /* If SYM_FRAG has yet to be reached on this pass, assume it
2232 will move by STRETCH just as we did, unless there is an
2233 alignment frag between here and SYM_FRAG. An alignment may
2234 well absorb any STRETCH, and we don't want to choose a larger
2235 branch insn by overestimating the needed reach of this
2236 branch. It isn't critical to calculate TARGET exactly; We
2237 know we'll be doing another pass if STRETCH is non-zero. */
2240 && sym_frag->relax_marker != fragP->relax_marker
2241 && S_GET_SEGMENT (symbolP) == segment)
2244 || sym_frag->region == fragP->region)
2246 /* If we get here we know we have a forward branch. This
2247 relax pass may have stretched previous instructions so
2248 far that omitting STRETCH would make the branch
2249 negative. Don't allow this in case the negative reach is
2250 large enough to require a larger branch instruction. */
2251 else if (target < address)
2252 target = fragP->fr_next->fr_address + stretch;
2256 aim = target - address - fragP->fr_fix;
2257 #ifdef TC_PCREL_ADJUST
2258 /* Currently only the ns32k family needs this. */
2259 aim += TC_PCREL_ADJUST (fragP);
2262 #ifdef md_prepare_relax_scan
2263 /* Formerly called M68K_AIM_KLUDGE. */
2264 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2269 /* Look backwards. */
2270 for (next_state = this_type->rlx_more; next_state;)
2271 if (aim >= this_type->rlx_backward)
2275 /* Grow to next state. */
2276 this_state = next_state;
2277 this_type = table + this_state;
2278 next_state = this_type->rlx_more;
2283 /* Look forwards. */
2284 for (next_state = this_type->rlx_more; next_state;)
2285 if (aim <= this_type->rlx_forward)
2289 /* Grow to next state. */
2290 this_state = next_state;
2291 this_type = table + this_state;
2292 next_state = this_type->rlx_more;
2296 growth = this_type->rlx_length - start_type->rlx_length;
2298 fragP->fr_subtype = this_state;
2302 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2304 /* Relax_align. Advance location counter to next address that has 'alignment'
2305 lowest order bits all 0s, return size of adjustment made. */
2306 static relax_addressT
2307 relax_align (register relax_addressT address, /* Address now. */
2308 register int alignment /* Alignment (binary). */)
2310 relax_addressT mask;
2311 relax_addressT new_address;
2313 mask = ~((relax_addressT) ~0 << alignment);
2314 new_address = (address + mask) & (~mask);
2315 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2317 /* We must provide lots of padding, so the linker can discard it
2318 when needed. The linker will not add extra space, ever. */
2319 new_address += (1 << alignment);
2321 return (new_address - address);
2324 /* Now we have a segment, not a crowd of sub-segments, we can make
2329 After this, all frags in this segment have addresses that are correct
2330 within the segment. Since segments live in different file addresses,
2331 these frag addresses may not be the same as final object-file
2335 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2337 unsigned long frag_count;
2339 relax_addressT address;
2343 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2344 subseg_change (segment, 0);
2346 /* For each frag in segment: count and store (a 1st guess of)
2350 for (frag_count = 0, fragP = segment_frag_root;
2352 fragP = fragP->fr_next, frag_count ++)
2354 fragP->region = region;
2355 fragP->relax_marker = 0;
2356 fragP->fr_address = address;
2357 address += fragP->fr_fix;
2359 switch (fragP->fr_type)
2362 address += fragP->fr_offset * fragP->fr_var;
2369 addressT offset = relax_align (address, (int) fragP->fr_offset);
2371 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2374 if (offset % fragP->fr_var != 0)
2376 as_bad_where (fragP->fr_file, fragP->fr_line,
2377 _("alignment padding (%lu bytes) not a multiple of %ld"),
2378 (unsigned long) offset, (long) fragP->fr_var);
2379 offset -= (offset % fragP->fr_var);
2388 /* Assume .org is nugatory. It will grow with 1st relax. */
2395 case rs_machine_dependent:
2396 /* If fr_symbol is an expression, this call to
2397 resolve_symbol_value sets up the correct segment, which will
2398 likely be needed in md_estimate_size_before_relax. */
2399 if (fragP->fr_symbol)
2400 resolve_symbol_value (fragP->fr_symbol);
2402 address += md_estimate_size_before_relax (fragP, segment);
2405 #ifndef WORKING_DOT_WORD
2406 /* Broken words don't concern us yet. */
2407 case rs_broken_word:
2412 /* Initial guess is always 1; doing otherwise can result in
2413 stable solutions that are larger than the minimum. */
2414 address += fragP->fr_offset = 1;
2418 address += eh_frame_estimate_size_before_relax (fragP);
2422 address += dwarf2dbg_estimate_size_before_relax (fragP);
2426 BAD_CASE (fragP->fr_type);
2433 unsigned long max_iterations;
2435 /* Cumulative address adjustment. */
2438 /* Have we made any adjustment this pass? We can't just test
2439 stretch because one piece of code may have grown and another
2443 /* Most horrible, but gcc may give us some exception data that
2444 is impossible to assemble, of the form
2448 .uleb128 end - start
2454 If the leb128 is two bytes in size, then end-start is 128*128,
2455 which requires a three byte leb128. If the leb128 is three
2456 bytes in size, then end-start is 128*128-1, which requires a
2457 two byte leb128. We work around this dilemma by inserting
2458 an extra 4 bytes of alignment just after the .align. This
2459 works because the data after the align is accessed relative to
2462 This counter is used in a tiny state machine to detect
2463 whether a leb128 followed by an align is impossible to
2465 int rs_leb128_fudge = 0;
2467 /* We want to prevent going into an infinite loop where one frag grows
2468 depending upon the location of a symbol which is in turn moved by
2469 the growing frag. eg:
2475 So we dictate that this algorithm can be at most O2. */
2476 max_iterations = frag_count * frag_count;
2477 /* Check for overflow. */
2478 if (max_iterations < frag_count)
2479 max_iterations = frag_count;
2487 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2490 addressT was_address;
2494 fragP->relax_marker ^= 1;
2495 was_address = fragP->fr_address;
2496 address = fragP->fr_address += stretch;
2497 symbolP = fragP->fr_symbol;
2498 offset = fragP->fr_offset;
2500 switch (fragP->fr_type)
2502 case rs_fill: /* .fill never relaxes. */
2506 #ifndef WORKING_DOT_WORD
2507 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2508 for it I do not want to write it. I do not want to have
2509 anything to do with it. This is not the proper way to
2510 implement this misfeature. */
2511 case rs_broken_word:
2513 struct broken_word *lie;
2514 struct broken_word *untruth;
2516 /* Yes this is ugly (storing the broken_word pointer
2517 in the symbol slot). Still, this whole chunk of
2518 code is ugly, and I don't feel like doing anything
2519 about it. Think of it as stubbornness in action. */
2521 for (lie = (struct broken_word *) (fragP->fr_symbol);
2522 lie && lie->dispfrag == fragP;
2523 lie = lie->next_broken_word)
2529 offset = (S_GET_VALUE (lie->add)
2531 - S_GET_VALUE (lie->sub));
2532 if (offset <= -32768 || offset >= 32767)
2534 if (flag_warn_displacement)
2537 sprint_value (buf, (addressT) lie->addnum);
2538 as_warn_where (fragP->fr_file, fragP->fr_line,
2539 _(".word %s-%s+%s didn't fit"),
2540 S_GET_NAME (lie->add),
2541 S_GET_NAME (lie->sub),
2544 if (fragP->fr_subtype == 0)
2546 fragP->fr_subtype++;
2547 growth += md_short_jump_size;
2550 /* Redirect *all* words of this table with the same
2551 target, lest we have to handle the case where the
2552 same target but with a offset that fits on this
2553 round overflows at the next relaxation round. */
2554 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2555 untruth && untruth->dispfrag == lie->dispfrag;
2556 untruth = untruth->next_broken_word)
2557 if ((symbol_get_frag (untruth->add)
2558 == symbol_get_frag (lie->add))
2559 && (S_GET_VALUE (untruth->add)
2560 == S_GET_VALUE (lie->add)))
2563 untruth->use_jump = lie;
2567 growth += md_long_jump_size;
2572 } /* case rs_broken_word */
2578 addressT oldoff, newoff;
2580 oldoff = relax_align (was_address + fragP->fr_fix,
2582 newoff = relax_align (address + fragP->fr_fix,
2585 if (fragP->fr_subtype != 0)
2587 if (oldoff > fragP->fr_subtype)
2589 if (newoff > fragP->fr_subtype)
2593 growth = newoff - oldoff;
2595 /* If this align happens to follow a leb128 and
2596 we have determined that the leb128 is bouncing
2597 in size, then break the cycle by inserting an
2600 && (rs_leb128_fudge & 16) != 0
2601 && (rs_leb128_fudge & 15) >= 2)
2603 segment_info_type *seginfo = seg_info (segment);
2604 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2607 newf = frag_alloc (ob);
2608 obstack_blank_fast (ob, fragP->fr_var);
2609 obstack_finish (ob);
2610 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2611 memcpy (newf->fr_literal,
2612 fragP->fr_literal + fragP->fr_fix,
2614 newf->fr_type = rs_fill;
2615 newf->fr_address = address + fragP->fr_fix + newoff;
2617 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2619 if (newf->fr_offset * newf->fr_var
2620 != (offsetT) 1 << fragP->fr_offset)
2622 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2625 /* Include size of new frag in GROWTH. */
2626 growth += newf->fr_offset * newf->fr_var;
2627 /* Adjust the new frag address for the amount
2628 we'll add when we process the new frag. */
2629 newf->fr_address -= stretch + growth;
2630 newf->relax_marker ^= 1;
2631 fragP->fr_next = newf;
2633 as_warn (_("padding added"));
2641 addressT target = offset;
2646 /* Convert from an actual address to an octet offset
2647 into the section. Here it is assumed that the
2648 section's VMA is zero, and can omit subtracting it
2649 from the symbol's value to get the address offset. */
2650 know (S_GET_SEGMENT (symbolP)->vma == 0);
2651 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2654 know (fragP->fr_next);
2655 after = fragP->fr_next->fr_address + stretch;
2656 growth = target - after;
2661 /* Don't error on first few frag relax passes.
2662 The symbol might be an expression involving
2663 symbol values from other sections. If those
2664 sections have not yet been processed their
2665 frags will all have zero addresses, so we
2666 will calculate incorrect values for them. The
2667 number of passes we allow before giving an
2668 error is somewhat arbitrary. It should be at
2669 least one, with larger values requiring
2670 increasingly contrived dependencies between
2671 frags to trigger a false error. */
2674 /* Force another pass. */
2679 /* Growth may be negative, but variable part of frag
2680 cannot have fewer than 0 chars. That is, we can't
2682 as_bad_where (fragP->fr_file, fragP->fr_line,
2683 _("attempt to move .org backwards"));
2685 /* We've issued an error message. Change the
2686 frag to avoid cascading errors. */
2687 fragP->fr_type = rs_align;
2688 fragP->fr_subtype = 0;
2689 fragP->fr_offset = 0;
2690 fragP->fr_fix = after - address;
2701 amount = S_GET_VALUE (symbolP);
2702 if (S_GET_SEGMENT (symbolP) != absolute_section
2703 || S_IS_COMMON (symbolP)
2704 || ! S_IS_DEFINED (symbolP))
2706 as_bad_where (fragP->fr_file, fragP->fr_line,
2707 _(".space specifies non-absolute value"));
2708 /* Prevent repeat of this error message. */
2709 fragP->fr_symbol = 0;
2711 else if (amount < 0)
2713 /* Don't error on first few frag relax passes.
2714 See rs_org comment for a longer explanation. */
2721 as_warn_where (fragP->fr_file, fragP->fr_line,
2722 _(".space or .fill with negative value, ignored"));
2723 fragP->fr_symbol = 0;
2726 growth = (was_address + fragP->fr_fix + amount
2727 - fragP->fr_next->fr_address);
2731 case rs_machine_dependent:
2732 #ifdef md_relax_frag
2733 growth = md_relax_frag (segment, fragP, stretch);
2735 #ifdef TC_GENERIC_RELAX_TABLE
2736 /* The default way to relax a frag is to look through
2737 TC_GENERIC_RELAX_TABLE. */
2738 growth = relax_frag (segment, fragP, stretch);
2739 #endif /* TC_GENERIC_RELAX_TABLE */
2748 value = resolve_symbol_value (fragP->fr_symbol);
2749 size = sizeof_leb128 (value, fragP->fr_subtype);
2750 growth = size - fragP->fr_offset;
2751 fragP->fr_offset = size;
2756 growth = eh_frame_relax_frag (fragP);
2760 growth = dwarf2dbg_relax_frag (fragP);
2764 BAD_CASE (fragP->fr_type);
2771 if (fragP->fr_type == rs_leb128)
2772 rs_leb128_fudge += 16;
2773 else if (fragP->fr_type == rs_align
2774 && (rs_leb128_fudge & 16) != 0
2776 rs_leb128_fudge += 16;
2778 rs_leb128_fudge = 0;
2783 && (rs_leb128_fudge & 16) == 0
2784 && (rs_leb128_fudge & -16) != 0)
2785 rs_leb128_fudge += 1;
2787 rs_leb128_fudge = 0;
2789 /* Until nothing further to relax. */
2790 while (stretched && -- max_iterations);
2793 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2794 segment_name (segment));
2797 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2798 if (fragP->last_fr_address != fragP->fr_address)
2800 fragP->last_fr_address = fragP->fr_address;
2807 number_to_chars_bigendian (char *buf, valueT val, int n)
2813 buf[n] = val & 0xff;
2819 number_to_chars_littleendian (char *buf, valueT val, int n)
2825 *buf++ = val & 0xff;
2831 write_print_statistics (FILE *file)
2833 fprintf (file, "fixups: %d\n", n_fixups);
2836 /* For debugging. */
2837 extern int indent_level;
2840 print_fixup (fixS *fixp)
2843 fprintf (stderr, "fix ");
2844 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2845 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2847 fprintf (stderr, " pcrel");
2848 if (fixp->fx_pcrel_adjust)
2849 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2850 if (fixp->fx_im_disp)
2853 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2855 fprintf (stderr, " im_disp");
2859 fprintf (stderr, " tcbit");
2861 fprintf (stderr, " done");
2862 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2863 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2864 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2865 (long) fixp->fx_where,
2866 (unsigned long) fixp->fx_offset,
2867 (unsigned long) fixp->fx_addnumber);
2868 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2872 fprintf (stderr, "\n +<");
2873 print_symbol_value_1 (stderr, fixp->fx_addsy);
2874 fprintf (stderr, ">");
2878 fprintf (stderr, "\n -<");
2879 print_symbol_value_1 (stderr, fixp->fx_subsy);
2880 fprintf (stderr, ">");
2882 fprintf (stderr, "\n");
2883 #ifdef TC_FIX_DATA_PRINT
2884 TC_FIX_DATA_PRINT (stderr, fixp);