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
4 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"
32 #ifndef TC_ADJUST_RELOC_COUNT
33 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
36 #ifndef TC_FORCE_RELOCATION
37 #define TC_FORCE_RELOCATION(FIX) \
38 (generic_force_reloc (FIX))
41 #ifndef TC_FORCE_RELOCATION_ABS
42 #define TC_FORCE_RELOCATION_ABS(FIX) \
43 (TC_FORCE_RELOCATION (FIX))
46 #ifndef TC_FORCE_RELOCATION_LOCAL
47 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
49 || TC_FORCE_RELOCATION (FIX))
52 #ifndef TC_FORCE_RELOCATION_SUB_SAME
53 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
57 #ifndef md_register_arithmetic
58 # define md_register_arithmetic 1
61 #ifndef TC_FORCE_RELOCATION_SUB_ABS
62 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
63 (!md_register_arithmetic && (SEG) == reg_section)
66 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
68 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 0
70 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 1
74 #ifndef TC_VALIDATE_FIX_SUB
75 #ifdef UNDEFINED_DIFFERENCE_OK
76 /* The PA needs this for PIC code generation. */
77 #define TC_VALIDATE_FIX_SUB(FIX) 1
79 #define TC_VALIDATE_FIX_SUB(FIX) \
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 /* Relocs generated by ".reloc" pseudo. */
126 struct reloc_list* reloc_list;
128 void print_fixup (fixS *);
130 /* We generally attach relocs to frag chains. However, after we have
131 chained these all together into a segment, any relocs we add after
132 that must be attached to a segment. This will include relocs added
133 in md_estimate_size_for_relax, for example. */
134 static int frags_chained = 0;
138 #define RELOC_ENUM enum bfd_reloc_code_real
140 /* Create a fixS in obstack 'notes'. */
143 fix_new_internal (fragS *frag, /* Which frag? */
144 int where, /* Where in that frag? */
145 int size, /* 1, 2, or 4 usually. */
146 symbolS *add_symbol, /* X_add_symbol. */
147 symbolS *sub_symbol, /* X_op_symbol. */
148 offsetT offset, /* X_add_number. */
149 int pcrel, /* TRUE if PC-relative relocation. */
150 RELOC_ENUM r_type ATTRIBUTE_UNUSED /* Relocation type. */)
156 fixP = obstack_alloc (¬es, sizeof (fixS));
158 fixP->fx_frag = frag;
159 fixP->fx_where = where;
160 fixP->fx_size = size;
161 /* We've made fx_size a narrow field; check that it's wide enough. */
162 if (fixP->fx_size != size)
164 as_bad (_("field fx_size too small to hold %d"), size);
167 fixP->fx_addsy = add_symbol;
168 fixP->fx_subsy = sub_symbol;
169 fixP->fx_offset = offset;
170 fixP->fx_dot_value = dot_value;
171 fixP->fx_pcrel = pcrel;
172 fixP->fx_r_type = r_type;
173 fixP->fx_im_disp = 0;
174 fixP->fx_pcrel_adjust = 0;
175 fixP->fx_bit_fixP = 0;
176 fixP->fx_addnumber = 0;
180 fixP->fx_no_overflow = 0;
184 fixP->fx_cgen.insn = NULL;
185 fixP->fx_cgen.opinfo = 0;
189 TC_INIT_FIX_DATA (fixP);
192 as_where (&fixP->fx_file, &fixP->fx_line);
194 /* Usually, we want relocs sorted numerically, but while
195 comparing to older versions of gas that have relocs
196 reverse sorted, it is convenient to have this compile
197 time option. xoxorich. */
200 fixS **seg_fix_rootP = (frags_chained
201 ? &seg_info (now_seg)->fix_root
202 : &frchain_now->fix_root);
203 fixS **seg_fix_tailP = (frags_chained
204 ? &seg_info (now_seg)->fix_tail
205 : &frchain_now->fix_tail);
207 #ifdef REVERSE_SORT_RELOCS
209 fixP->fx_next = *seg_fix_rootP;
210 *seg_fix_rootP = fixP;
212 #else /* REVERSE_SORT_RELOCS */
214 fixP->fx_next = NULL;
217 (*seg_fix_tailP)->fx_next = fixP;
219 *seg_fix_rootP = fixP;
220 *seg_fix_tailP = fixP;
222 #endif /* REVERSE_SORT_RELOCS */
228 /* Create a fixup relative to a symbol (plus a constant). */
231 fix_new (fragS *frag, /* Which frag? */
232 int where, /* Where in that frag? */
233 int size, /* 1, 2, or 4 usually. */
234 symbolS *add_symbol, /* X_add_symbol. */
235 offsetT offset, /* X_add_number. */
236 int pcrel, /* TRUE if PC-relative relocation. */
237 RELOC_ENUM r_type /* Relocation type. */)
239 return fix_new_internal (frag, where, size, add_symbol,
240 (symbolS *) NULL, offset, pcrel, r_type);
243 /* Create a fixup for an expression. Currently we only support fixups
244 for difference expressions. That is itself more than most object
245 file formats support anyhow. */
248 fix_new_exp (fragS *frag, /* Which frag? */
249 int where, /* Where in that frag? */
250 int size, /* 1, 2, or 4 usually. */
251 expressionS *exp, /* Expression. */
252 int pcrel, /* TRUE if PC-relative relocation. */
253 RELOC_ENUM r_type /* Relocation type. */)
265 as_bad (_("register value used as expression"));
269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
270 the difference expression cannot immediately be reduced. */
272 symbolS *stmp = make_expr_symbol (exp);
274 exp->X_op = O_symbol;
275 exp->X_op_symbol = 0;
276 exp->X_add_symbol = stmp;
277 exp->X_add_number = 0;
279 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
283 add = exp->X_add_symbol;
284 off = exp->X_add_number;
285 r_type = BFD_RELOC_RVA;
289 sub = exp->X_add_symbol;
290 off = exp->X_add_number;
294 sub = exp->X_op_symbol;
297 add = exp->X_add_symbol;
300 off = exp->X_add_number;
304 add = make_expr_symbol (exp);
308 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
311 /* Generic function to determine whether a fixup requires a relocation. */
313 generic_force_reloc (fixS *fix)
315 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
316 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
319 if (fix->fx_addsy == NULL)
322 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
325 /* Append a string onto another string, bumping the pointer along. */
327 append (char **charPP, char *fromP, unsigned long length)
329 /* Don't trust memcpy() of 0 chars. */
333 memcpy (*charPP, fromP, length);
337 /* This routine records the largest alignment seen for each segment.
338 If the beginning of the segment is aligned on the worst-case
339 boundary, all of the other alignments within it will work. At
340 least one object format really uses this info. */
343 record_alignment (/* Segment to which alignment pertains. */
345 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
346 boundary, 2 => 4-byte boundary, etc.) */
349 if (seg == absolute_section)
352 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
353 bfd_set_section_alignment (stdoutput, seg, align);
357 get_recorded_alignment (segT seg)
359 if (seg == absolute_section)
362 return bfd_get_section_alignment (stdoutput, seg);
365 /* Reset the section indices after removing the gas created sections. */
368 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
370 int *countp = (int *) countparg;
372 sec->index = *countp;
377 chain_frchains_together_1 (segT section, struct frchain *frchp)
379 fragS dummy, *prev_frag = &dummy;
380 fixS fix_dummy, *prev_fix = &fix_dummy;
382 for (; frchp; frchp = frchp->frch_next)
384 prev_frag->fr_next = frchp->frch_root;
385 prev_frag = frchp->frch_last;
386 assert (prev_frag->fr_type != 0);
387 if (frchp->fix_root != (fixS *) NULL)
389 if (seg_info (section)->fix_root == (fixS *) NULL)
390 seg_info (section)->fix_root = frchp->fix_root;
391 prev_fix->fx_next = frchp->fix_root;
392 seg_info (section)->fix_tail = frchp->fix_tail;
393 prev_fix = frchp->fix_tail;
396 assert (prev_frag->fr_type != 0);
397 assert (prev_frag != &dummy);
398 prev_frag->fr_next = 0;
403 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
405 void *xxx ATTRIBUTE_UNUSED)
407 segment_info_type *info;
409 /* BFD may have introduced its own sections without using
410 subseg_new, so it is possible that seg_info is NULL. */
411 info = seg_info (section);
412 if (info != (segment_info_type *) NULL)
413 info->frchainP->frch_last
414 = chain_frchains_together_1 (section, info->frchainP);
416 /* Now that we've chained the frags together, we must add new fixups
417 to the segment, not to the frag chain. */
422 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
424 switch (fragP->fr_type)
432 HANDLE_ALIGN (fragP);
434 know (fragP->fr_next != NULL);
435 fragP->fr_offset = (fragP->fr_next->fr_address
437 - fragP->fr_fix) / fragP->fr_var;
438 if (fragP->fr_offset < 0)
440 as_bad_where (fragP->fr_file, fragP->fr_line,
441 _("attempt to .org/.space backwards? (%ld)"),
442 (long) fragP->fr_offset);
443 fragP->fr_offset = 0;
445 fragP->fr_type = rs_fill;
453 valueT value = S_GET_VALUE (fragP->fr_symbol);
456 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
459 fragP->fr_fix += size;
460 fragP->fr_type = rs_fill;
462 fragP->fr_offset = 0;
463 fragP->fr_symbol = NULL;
468 eh_frame_convert_frag (fragP);
472 dwarf2dbg_convert_frag (fragP);
475 case rs_machine_dependent:
476 md_convert_frag (stdoutput, sec, fragP);
478 assert (fragP->fr_next == NULL
479 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
482 /* After md_convert_frag, we make the frag into a ".space 0".
483 md_convert_frag() should set up any fixSs and constants
488 #ifndef WORKING_DOT_WORD
491 struct broken_word *lie;
493 if (fragP->fr_subtype)
495 fragP->fr_fix += md_short_jump_size;
496 for (lie = (struct broken_word *) (fragP->fr_symbol);
497 lie && lie->dispfrag == fragP;
498 lie = lie->next_broken_word)
500 fragP->fr_fix += md_long_jump_size;
508 BAD_CASE (fragP->fr_type);
512 md_frag_check (fragP);
516 struct relax_seg_info
523 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
525 segment_info_type *seginfo = seg_info (sec);
526 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
528 if (seginfo && seginfo->frchainP
529 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
534 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
538 segment_info_type *seginfo;
540 valueT size, newsize;
542 subseg_change (sec, 0);
544 seginfo = seg_info (sec);
545 if (seginfo && seginfo->frchainP)
547 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
548 cvt_frag_to_fill (sec, fragp);
549 for (fragp = seginfo->frchainP->frch_root;
551 fragp = fragp->fr_next)
552 /* Walk to last elt. */
554 size = fragp->fr_address + fragp->fr_fix;
559 flags = bfd_get_section_flags (abfd, sec);
561 if (size > 0 && ! seginfo->bss)
562 flags |= SEC_HAS_CONTENTS;
565 x = bfd_set_section_flags (abfd, sec, flags);
568 newsize = md_section_align (sec, size);
569 x = bfd_set_section_size (abfd, sec, newsize);
572 /* If the size had to be rounded up, add some padding in the last
574 assert (newsize >= size);
577 fragS *last = seginfo->frchainP->frch_last;
578 fragp = seginfo->frchainP->frch_root;
579 while (fragp->fr_next != last)
580 fragp = fragp->fr_next;
581 last->fr_address = size;
582 if ((newsize - size) % fragp->fr_var == 0)
583 fragp->fr_offset += (newsize - size) / fragp->fr_var;
585 /* If we hit this abort, it's likely due to subsegs_finish not
586 providing sufficient alignment on the last frag, and the
587 machine dependent code using alignment frags with fr_var
592 #ifdef tc_frob_section
593 tc_frob_section (sec);
595 #ifdef obj_frob_section
596 obj_frob_section (sec);
602 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
604 segment_info_type *seginfo = seg_info (sec);
605 fixS *fixp = seginfo->fix_root;
610 fprintf (stream, "sec %s relocs:\n", sec->name);
613 symbolS *s = fixp->fx_addsy;
615 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
616 (int) fixp->fx_r_type);
618 fprintf (stream, "no sym\n");
621 print_symbol_value_1 (stream, s);
622 fprintf (stream, "\n");
624 fixp = fixp->fx_next;
628 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
631 #ifndef EMIT_SECTION_SYMBOLS
632 #define EMIT_SECTION_SYMBOLS 1
635 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
636 and check for validity. Convert RELOC_LIST from using U.A fields
639 resolve_reloc_expr_symbols (void)
641 struct reloc_list *r;
643 for (r = reloc_list; r; r = r->next)
647 bfd_vma offset, addend;
649 reloc_howto_type *howto;
651 resolve_symbol_value (r->u.a.offset_sym);
652 symval = symbol_get_value_expression (r->u.a.offset_sym);
656 if (symval->X_op == O_constant)
657 sym = r->u.a.offset_sym;
658 else if (symval->X_op == O_symbol)
660 sym = symval->X_add_symbol;
661 offset = symval->X_add_number;
662 symval = symbol_get_value_expression (symval->X_add_symbol);
665 || symval->X_op != O_constant
666 || (sec = S_GET_SEGMENT (sym)) == NULL
667 || !SEG_NORMAL (sec))
669 as_bad_where (r->file, r->line, _("invalid offset expression"));
673 offset += S_GET_VALUE (sym);
676 addend = r->u.a.addend;
677 if (r->u.a.sym != NULL)
679 resolve_symbol_value (r->u.a.sym);
680 symval = symbol_get_value_expression (r->u.a.sym);
681 if (symval->X_op == O_constant)
683 else if (symval->X_op == O_symbol)
685 sym = symval->X_add_symbol;
686 addend += symval->X_add_number;
687 symval = symbol_get_value_expression (symval->X_add_symbol);
689 if (symval->X_op != O_constant)
691 as_bad_where (r->file, r->line, _("invalid reloc expression"));
694 else if (sym != NULL)
695 symbol_mark_used_in_reloc (sym);
699 if (abs_section_sym == NULL)
700 abs_section_sym = section_symbol (absolute_section);
701 sym = abs_section_sym;
704 howto = r->u.a.howto;
707 r->u.b.s = symbol_get_bfdsym (sym);
708 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
709 r->u.b.r.address = offset;
710 r->u.b.r.addend = addend;
711 r->u.b.r.howto = howto;
715 /* This pass over fixups decides whether symbols can be replaced with
719 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
721 void *xxx ATTRIBUTE_UNUSED)
723 segment_info_type *seginfo = seg_info (sec);
729 dump_section_relocs (abfd, sec, stderr);
731 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
735 else if (fixp->fx_addsy)
741 fprintf (stderr, "\n\nadjusting fixup:\n");
745 sym = fixp->fx_addsy;
747 /* All symbols should have already been resolved at this
748 point. It is possible to see unresolved expression
749 symbols, though, since they are not in the regular symbol
751 resolve_symbol_value (sym);
753 if (fixp->fx_subsy != NULL)
754 resolve_symbol_value (fixp->fx_subsy);
756 /* If this symbol is equated to an undefined or common symbol,
757 convert the fixup to being against that symbol. */
758 while (symbol_equated_reloc_p (sym)
759 || S_IS_WEAKREFR (sym))
761 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
764 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
765 fixp->fx_addsy = newsym;
769 if (symbol_mri_common_p (sym))
771 fixp->fx_offset += S_GET_VALUE (sym);
772 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
776 /* If the symbol is undefined, common, weak, or global (ELF
777 shared libs), we can't replace it with the section symbol. */
778 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
781 /* Is there some other (target cpu dependent) reason we can't adjust
782 this one? (E.g. relocations involving function addresses on
784 #ifdef tc_fix_adjustable
785 if (! tc_fix_adjustable (fixp))
789 /* Since we're reducing to section symbols, don't attempt to reduce
790 anything that's already using one. */
791 if (symbol_section_p (sym))
794 symsec = S_GET_SEGMENT (sym);
798 if (bfd_is_abs_section (symsec))
800 /* The fixup_segment routine normally will not use this
801 symbol in a relocation. */
805 /* Don't try to reduce relocs which refer to non-local symbols
806 in .linkonce sections. It can lead to confusion when a
807 debugging section refers to a .linkonce section. I hope
808 this will always be correct. */
809 if (symsec != sec && ! S_IS_LOCAL (sym))
811 if ((symsec->flags & SEC_LINK_ONCE) != 0
813 /* The GNU toolchain uses an extension for ELF: a
814 section beginning with the magic string
815 .gnu.linkonce is a linkonce section. */
816 && strncmp (segment_name (symsec), ".gnu.linkonce",
817 sizeof ".gnu.linkonce" - 1) == 0))
821 /* Never adjust a reloc against local symbol in a merge section
822 with non-zero addend. */
823 if ((symsec->flags & SEC_MERGE) != 0
824 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
827 /* Never adjust a reloc against TLS local symbol. */
828 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
831 /* We refetch the segment when calling section_symbol, rather
832 than using symsec, because S_GET_VALUE may wind up changing
833 the section when it calls resolve_symbol_value. */
834 fixp->fx_offset += S_GET_VALUE (sym);
835 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
837 fprintf (stderr, "\nadjusted fixup:\n");
842 dump_section_relocs (abfd, sec, stderr);
847 Go through all the fixS's in a segment and see which ones can be
848 handled now. (These consist of fixS where we have since discovered
849 the value of a symbol, or the address of the frag involved.)
850 For each one, call md_apply_fix to put the fix into the frag data.
852 Result is a count of how many relocation structs will be needed to
853 handle the remaining fixS's that we couldn't completely handle here.
854 These will be output later by emit_relocations(). */
857 fixup_segment (fixS *fixP, segT this_segment)
859 long seg_reloc_count = 0;
862 segT add_symbol_segment = absolute_section;
864 if (fixP != NULL && abs_section_sym == NULL)
865 abs_section_sym = section_symbol (absolute_section);
867 /* If the linker is doing the relaxing, we must not do any fixups.
869 Well, strictly speaking that's not true -- we could do any that
870 are PC-relative and don't cross regions that could change size.
871 And for the i960 we might be able to turn callx/callj into bal
872 anyways in cases where we know the maximum displacement. */
873 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
875 for (; fixP; fixP = fixP->fx_next)
878 if (fixP->fx_addsy == NULL)
880 /* There was no symbol required by this relocation.
881 However, BFD doesn't really handle relocations
882 without symbols well. So fake up a local symbol in
883 the absolute section. */
884 fixP->fx_addsy = abs_section_sym;
886 symbol_mark_used_in_reloc (fixP->fx_addsy);
887 if (fixP->fx_subsy != NULL)
888 symbol_mark_used_in_reloc (fixP->fx_subsy);
891 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
892 return seg_reloc_count;
895 for (; fixP; fixP = fixP->fx_next)
898 fprintf (stderr, "\nprocessing fixup:\n");
902 fragP = fixP->fx_frag;
904 #ifdef TC_VALIDATE_FIX
905 TC_VALIDATE_FIX (fixP, this_segment, skip);
907 add_number = fixP->fx_offset;
909 if (fixP->fx_addsy != NULL)
910 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
912 if (fixP->fx_subsy != NULL)
914 segT sub_symbol_segment;
915 resolve_symbol_value (fixP->fx_subsy);
916 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
917 if (fixP->fx_addsy != NULL
918 && sub_symbol_segment == add_symbol_segment
919 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
921 add_number += S_GET_VALUE (fixP->fx_addsy);
922 add_number -= S_GET_VALUE (fixP->fx_subsy);
923 fixP->fx_offset = add_number;
924 fixP->fx_addsy = NULL;
925 fixP->fx_subsy = NULL;
927 /* See the comment below about 68k weirdness. */
931 else if (sub_symbol_segment == absolute_section
932 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
934 add_number -= S_GET_VALUE (fixP->fx_subsy);
935 fixP->fx_offset = add_number;
936 fixP->fx_subsy = NULL;
938 else if (sub_symbol_segment == this_segment
939 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP))
941 add_number -= S_GET_VALUE (fixP->fx_subsy);
942 fixP->fx_offset = (add_number + fixP->fx_dot_value
943 + fixP->fx_frag->fr_address);
945 /* Make it pc-relative. If the back-end code has not
946 selected a pc-relative reloc, cancel the adjustment
947 we do later on all pc-relative relocs. */
950 /* Do this for m68k even if it's already described
951 as pc-relative. On the m68k, an operand of
952 "pc@(foo-.-2)" should address "foo" in a
957 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
958 fixP->fx_subsy = NULL;
961 else if (!TC_VALIDATE_FIX_SUB (fixP))
963 if (!md_register_arithmetic
964 && (add_symbol_segment == reg_section
965 || sub_symbol_segment == reg_section))
966 as_bad_where (fixP->fx_file, fixP->fx_line,
967 _("register value used as expression"));
969 as_bad_where (fixP->fx_file, fixP->fx_line,
970 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
971 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
972 segment_name (add_symbol_segment),
973 S_GET_NAME (fixP->fx_subsy),
974 segment_name (sub_symbol_segment));
980 if (add_symbol_segment == this_segment
981 && !TC_FORCE_RELOCATION_LOCAL (fixP))
983 /* This fixup was made when the symbol's segment was
984 SEG_UNKNOWN, but it is now in the local segment.
985 So we know how to do the address without relocation. */
986 add_number += S_GET_VALUE (fixP->fx_addsy);
987 fixP->fx_offset = add_number;
989 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
990 fixP->fx_addsy = NULL;
993 else if (add_symbol_segment == absolute_section
994 && !TC_FORCE_RELOCATION_ABS (fixP))
996 add_number += S_GET_VALUE (fixP->fx_addsy);
997 fixP->fx_offset = add_number;
998 fixP->fx_addsy = NULL;
1000 else if (add_symbol_segment != undefined_section
1001 && ! bfd_is_com_section (add_symbol_segment)
1002 && MD_APPLY_SYM_VALUE (fixP))
1003 add_number += S_GET_VALUE (fixP->fx_addsy);
1008 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1009 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1011 /* There was no symbol required by this relocation.
1012 However, BFD doesn't really handle relocations
1013 without symbols well. So fake up a local symbol in
1014 the absolute section. */
1015 fixP->fx_addsy = abs_section_sym;
1020 md_apply_fix (fixP, &add_number, this_segment);
1025 if (fixP->fx_addsy == NULL)
1026 fixP->fx_addsy = abs_section_sym;
1027 symbol_mark_used_in_reloc (fixP->fx_addsy);
1028 if (fixP->fx_subsy != NULL)
1029 symbol_mark_used_in_reloc (fixP->fx_subsy);
1032 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1034 if (fixP->fx_size < sizeof (valueT))
1039 mask--; /* Set all bits to one. */
1040 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1041 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1043 char buf[50], buf2[50];
1044 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1045 if (add_number > 1000)
1046 sprint_value (buf2, add_number);
1048 sprintf (buf2, "%ld", (long) add_number);
1049 as_bad_where (fixP->fx_file, fixP->fx_line,
1050 _("value of %s too large for field of %d bytes at %s"),
1051 buf2, fixP->fx_size, buf);
1052 } /* Generic error checking. */
1054 #ifdef WARN_SIGNED_OVERFLOW_WORD
1055 /* Warn if a .word value is too large when treated as a signed
1056 number. We already know it is not too negative. This is to
1057 catch over-large switches generated by gcc on the 68k. */
1058 if (!flag_signed_overflow_ok
1059 && fixP->fx_size == 2
1060 && add_number > 0x7fff)
1061 as_bad_where (fixP->fx_file, fixP->fx_line,
1062 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1064 (long) (fragP->fr_address + fixP->fx_where));
1066 } /* Not a bit fix. */
1068 #ifdef TC_VALIDATE_FIX
1069 skip: ATTRIBUTE_UNUSED_LABEL
1073 fprintf (stderr, "result:\n");
1076 } /* For each fixS in this segment. */
1078 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1079 return seg_reloc_count;
1083 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1085 void *xxx ATTRIBUTE_UNUSED)
1087 segment_info_type *seginfo = seg_info (sec);
1089 fixup_segment (seginfo->fix_root, sec);
1093 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1094 char *file, unsigned int line)
1097 bfd_reloc_status_type s;
1100 if (reloc->sym_ptr_ptr != NULL
1101 && (sym = *reloc->sym_ptr_ptr) != NULL
1102 && (sym->flags & BSF_KEEP) == 0
1103 && ((sym->flags & BSF_SECTION_SYM) == 0
1104 || (EMIT_SECTION_SYMBOLS
1105 && !bfd_is_abs_section (sym->section))))
1106 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1108 s = bfd_install_relocation (stdoutput, reloc,
1109 fragp->fr_literal, fragp->fr_address,
1115 case bfd_reloc_overflow:
1116 as_bad_where (file, line, _("relocation overflow"));
1118 case bfd_reloc_outofrange:
1119 as_bad_where (file, line, _("relocation out of range"));
1122 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1128 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1130 segment_info_type *seginfo = seg_info (sec);
1133 struct reloc_list *my_reloc_list, **rp, *r;
1137 /* If seginfo is NULL, we did not create this section; don't do
1138 anything with it. */
1139 if (seginfo == NULL)
1143 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1147 #ifdef RELOC_EXPANSION_POSSIBLE
1148 n *= MAX_RELOC_EXPANSION;
1151 /* Extract relocs for this section from reloc_list. */
1153 my_reloc_list = NULL;
1154 while ((r = *rp) != NULL)
1156 if (r->u.b.sec == sec)
1159 r->next = my_reloc_list;
1167 relocs = xcalloc (n, sizeof (arelent *));
1170 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1179 fx_size = fixp->fx_size;
1180 slack = TC_FX_SIZE_SLACK (fixp);
1182 fx_size = fx_size > slack ? fx_size - slack : 0;
1183 loc = fixp->fx_where + fx_size;
1184 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1185 as_bad_where (fixp->fx_file, fixp->fx_line,
1186 _("internal error: fixup not contained within frag"));
1188 #ifndef RELOC_EXPANSION_POSSIBLE
1190 arelent *reloc = tc_gen_reloc (sec, fixp);
1194 relocs[i++] = reloc;
1199 arelent **reloc = tc_gen_reloc (sec, fixp);
1201 for (j = 0; reloc[j]; j++)
1202 relocs[i++] = reloc[j];
1206 for ( ; j != 0; --j)
1207 install_reloc (sec, relocs[i - j], fixp->fx_frag,
1208 fixp->fx_file, fixp->fx_line);
1214 unsigned int i, j, nsyms;
1216 sympp = bfd_get_outsymbols (stdoutput);
1217 nsyms = bfd_get_symcount (stdoutput);
1218 for (i = 0; i < n; i++)
1219 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1221 for (j = 0; j < nsyms; j++)
1222 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1230 for (r = my_reloc_list; r != NULL; r = r->next)
1233 for (f = seginfo->frchainP->frch_root; f; f = f->fr_next)
1234 if (f->fr_address <= r->u.b.r.address
1235 && r->u.b.r.address < f->fr_address + f->fr_fix)
1238 as_bad_where (r->file, r->line,
1239 _("reloc not within (fixed part of) section"));
1242 relocs[n++] = &r->u.b.r;
1243 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1249 flagword flags = bfd_get_section_flags (abfd, sec);
1251 bfd_set_section_flags (abfd, sec, flags);
1252 bfd_set_reloc (stdoutput, sec, relocs, n);
1255 #ifdef SET_SECTION_RELOCS
1256 SET_SECTION_RELOCS (sec, relocs, n);
1264 fprintf (stderr, "relocs for sec %s\n", sec->name);
1265 for (i = 0; i < n; i++)
1268 s = *r->sym_ptr_ptr;
1269 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1270 i, r, (unsigned long)r->address, s->name, (unsigned long)r->addend);
1277 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1279 void *xxx ATTRIBUTE_UNUSED)
1281 segment_info_type *seginfo = seg_info (sec);
1282 addressT offset = 0;
1285 /* Write out the frags. */
1287 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1290 for (f = seginfo->frchainP->frch_root;
1299 assert (f->fr_type == rs_fill);
1302 x = bfd_set_section_contents (stdoutput, sec,
1303 f->fr_literal, (file_ptr) offset,
1304 (bfd_size_type) f->fr_fix);
1306 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1307 bfd_errmsg (bfd_get_error ()));
1308 offset += f->fr_fix;
1310 fill_literal = f->fr_literal + f->fr_fix;
1311 fill_size = f->fr_var;
1312 count = f->fr_offset;
1313 assert (count >= 0);
1314 if (fill_size && count)
1317 if (fill_size > sizeof (buf))
1319 /* Do it the old way. Can this ever happen? */
1322 x = bfd_set_section_contents (stdoutput, sec,
1325 (bfd_size_type) fill_size);
1327 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1328 bfd_errmsg (bfd_get_error ()));
1329 offset += fill_size;
1334 /* Build a buffer full of fill objects and output it as
1335 often as necessary. This saves on the overhead of
1336 potentially lots of bfd_set_section_contents calls. */
1340 n_per_buf = sizeof (buf);
1341 memset (buf, *fill_literal, n_per_buf);
1346 n_per_buf = sizeof (buf) / fill_size;
1347 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1348 memcpy (bufp, fill_literal, fill_size);
1350 for (; count > 0; count -= n_per_buf)
1352 n_per_buf = n_per_buf > count ? count : n_per_buf;
1353 x = bfd_set_section_contents
1354 (stdoutput, sec, buf, (file_ptr) offset,
1355 (bfd_size_type) n_per_buf * fill_size);
1357 as_fatal (_("cannot write to output file"));
1358 offset += n_per_buf * fill_size;
1366 merge_data_into_text (void)
1368 seg_info (text_section)->frchainP->frch_last->fr_next =
1369 seg_info (data_section)->frchainP->frch_root;
1370 seg_info (text_section)->frchainP->frch_last =
1371 seg_info (data_section)->frchainP->frch_last;
1372 seg_info (data_section)->frchainP = 0;
1383 /* Count symbols. We can't rely on a count made by the loop in
1384 write_object_file, because *_frob_file may add a new symbol or
1387 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1393 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1395 asympp = bfd_alloc (stdoutput, amt);
1396 symp = symbol_rootP;
1397 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1399 asympp[i] = symbol_get_bfdsym (symp);
1400 if (asympp[i]->flags != BSF_SECTION_SYM
1401 || !(bfd_is_const_section (asympp[i]->section)
1402 && asympp[i]->section->symbol == asympp[i]))
1403 asympp[i]->flags |= BSF_KEEP;
1404 symbol_mark_written (symp);
1409 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1411 symbol_table_frozen = 1;
1414 /* Finish the subsegments. After every sub-segment, we fake an
1415 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1416 ".fill 0" because that is the kind of frag that requires least
1417 thought. ".align" frags like to have a following frag since that
1418 makes calculating their intended length trivial. */
1420 #ifndef SUB_SEGMENT_ALIGN
1422 /* The last subsegment gets an alignment corresponding to the alignment
1423 of the section. This allows proper nop-filling at the end of
1424 code-bearing sections. */
1425 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1426 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1428 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1433 subsegs_finish (void)
1435 struct frchain *frchainP;
1438 for (s = stdoutput->sections; s; s = s->next)
1440 segment_info_type *seginfo = seg_info (s);
1444 for (frchainP = seginfo->frchainP;
1446 frchainP = frchainP->frch_next)
1450 subseg_set (s, frchainP->frch_subseg);
1452 /* This now gets called even if we had errors. In that case,
1453 any alignment is meaningless, and, moreover, will look weird
1454 if we are generating a listing. */
1457 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1458 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1459 && now_seg->entsize)
1461 unsigned int entsize = now_seg->entsize;
1464 while ((entsize & 1) == 0)
1469 if (entalign > alignment)
1470 alignment = entalign;
1474 if (subseg_text_p (now_seg))
1475 frag_align_code (alignment, 0);
1477 frag_align (alignment, 0, 0);
1479 /* frag_align will have left a new frag.
1480 Use this last frag for an empty ".fill".
1482 For this segment ...
1483 Create a last frag. Do not leave a "being filled in frag". */
1484 frag_wane (frag_now);
1485 frag_now->fr_fix = 0;
1486 know (frag_now->fr_next == NULL);
1491 /* Write the object file. */
1494 write_object_file (void)
1496 struct relax_seg_info rsi;
1497 #ifndef WORKING_DOT_WORD
1498 fragS *fragP; /* Track along all frags. */
1501 /* Do we really want to write it? */
1503 int n_warns, n_errs;
1504 n_warns = had_warnings ();
1505 n_errs = had_errors ();
1506 /* The -Z flag indicates that an object file should be generated,
1507 regardless of warnings and errors. */
1508 if (flag_always_generate_output)
1510 if (n_warns || n_errs)
1511 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1512 n_errs, n_errs == 1 ? "" : "s",
1513 n_warns, n_warns == 1 ? "" : "s");
1518 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1519 n_errs, n_errs == 1 ? "" : "s",
1520 n_warns, n_warns == 1 ? "" : "s");
1525 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1526 a routine to check for the definition of the procedure "_main",
1527 and if so -- fix it up so that it can be program entry point. */
1528 vms_check_for_main ();
1529 #endif /* OBJ_VMS */
1531 /* From now on, we don't care about sub-segments. Build one frag chain
1532 for each segment. Linked thru fr_next. */
1534 /* Remove the sections created by gas for its own purposes. */
1538 bfd_section_list_remove (stdoutput, reg_section);
1539 bfd_section_list_remove (stdoutput, expr_section);
1540 stdoutput->section_count -= 2;
1542 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1545 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1547 /* We have two segments. If user gave -R flag, then we must put the
1548 data frags into the text segment. Do this before relaxing so
1549 we know to take advantage of -R and make shorter addresses. */
1550 if (flag_readonly_data_in_text)
1552 merge_data_into_text ();
1558 #ifndef WORKING_DOT_WORD
1559 /* We need to reset the markers in the broken word list and
1560 associated frags between calls to relax_segment (via
1561 relax_seg). Since the broken word list is global, we do it
1562 once per round, rather than locally in relax_segment for each
1564 struct broken_word *brokp;
1566 for (brokp = broken_words;
1567 brokp != (struct broken_word *) NULL;
1568 brokp = brokp->next_broken_word)
1572 if (brokp->dispfrag != (fragS *) NULL
1573 && brokp->dispfrag->fr_type == rs_broken_word)
1574 brokp->dispfrag->fr_subtype = 0;
1579 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1585 /* Note - Most ports will use the default value of
1586 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1587 local symbols to be resolved, removing their frag information.
1588 Some ports however, will not have finished relaxing all of
1589 their frags and will still need the local symbol frag
1590 information. These ports can set
1591 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1592 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1594 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1596 /* Relaxation has completed. Freeze all syms. */
1599 #ifdef md_post_relax_hook
1603 #ifndef WORKING_DOT_WORD
1605 struct broken_word *lie;
1606 struct broken_word **prevP;
1608 prevP = &broken_words;
1609 for (lie = broken_words; lie; lie = lie->next_broken_word)
1614 subseg_change (lie->seg, lie->subseg);
1615 exp.X_op = O_subtract;
1616 exp.X_add_symbol = lie->add;
1617 exp.X_op_symbol = lie->sub;
1618 exp.X_add_number = lie->addnum;
1619 #ifdef TC_CONS_FIX_NEW
1620 TC_CONS_FIX_NEW (lie->frag,
1621 lie->word_goes_here - lie->frag->fr_literal,
1624 fix_new_exp (lie->frag,
1625 lie->word_goes_here - lie->frag->fr_literal,
1626 2, &exp, 0, BFD_RELOC_16);
1628 *prevP = lie->next_broken_word;
1631 prevP = &(lie->next_broken_word);
1633 for (lie = broken_words; lie;)
1635 struct broken_word *untruth;
1637 addressT table_addr;
1638 addressT from_addr, to_addr;
1641 subseg_change (lie->seg, lie->subseg);
1642 fragP = lie->dispfrag;
1644 /* Find out how many broken_words go here. */
1647 untruth && untruth->dispfrag == fragP;
1648 untruth = untruth->next_broken_word)
1649 if (untruth->added == 1)
1652 table_ptr = lie->dispfrag->fr_opcode;
1653 table_addr = (lie->dispfrag->fr_address
1654 + (table_ptr - lie->dispfrag->fr_literal));
1655 /* Create the jump around the long jumps. This is a short
1656 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1657 from_addr = table_addr;
1658 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1659 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1661 table_ptr += md_short_jump_size;
1662 table_addr += md_short_jump_size;
1665 lie && lie->dispfrag == fragP;
1666 m++, lie = lie->next_broken_word)
1668 if (lie->added == 2)
1670 /* Patch the jump table. */
1671 /* This is the offset from ??? to table_ptr+0. */
1672 to_addr = table_addr - S_GET_VALUE (lie->sub);
1673 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1674 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1676 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1677 for (untruth = lie->next_broken_word;
1678 untruth && untruth->dispfrag == fragP;
1679 untruth = untruth->next_broken_word)
1681 if (untruth->use_jump == lie)
1682 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1685 /* Install the long jump. */
1686 /* This is a long jump from table_ptr+0 to the final target. */
1687 from_addr = table_addr;
1688 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1689 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1691 table_ptr += md_long_jump_size;
1692 table_addr += md_long_jump_size;
1696 #endif /* not WORKING_DOT_WORD */
1698 /* Resolve symbol values. This needs to be done before processing
1704 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1705 resolve_symbol_value (symp);
1707 resolve_local_symbol_values ();
1708 resolve_reloc_expr_symbols ();
1712 #ifdef tc_frob_file_before_adjust
1713 tc_frob_file_before_adjust ();
1715 #ifdef obj_frob_file_before_adjust
1716 obj_frob_file_before_adjust ();
1719 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1721 #ifdef tc_frob_file_before_fix
1722 tc_frob_file_before_fix ();
1724 #ifdef obj_frob_file_before_fix
1725 obj_frob_file_before_fix ();
1728 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1730 /* Set up symbol table, and write it out. */
1734 bfd_boolean skip_next_symbol = FALSE;
1736 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1741 if (skip_next_symbol)
1743 /* Don't do anything besides moving the value of the
1744 symbol from the GAS value-field to the BFD value-field. */
1745 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1746 skip_next_symbol = FALSE;
1750 if (symbol_mri_common_p (symp))
1752 if (S_IS_EXTERNAL (symp))
1753 as_bad (_("%s: global symbols not supported in common sections"),
1755 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1759 name = S_GET_NAME (symp);
1763 decode_local_label_name ((char *) S_GET_NAME (symp));
1764 /* They only differ if `name' is a fb or dollar local
1766 if (name2 != name && ! S_IS_DEFINED (symp))
1767 as_bad (_("local label `%s' is not defined"), name2);
1770 /* Do it again, because adjust_reloc_syms might introduce
1771 more symbols. They'll probably only be section symbols,
1772 but they'll still need to have the values computed. */
1773 resolve_symbol_value (symp);
1775 /* Skip symbols which were equated to undefined or common
1777 if (symbol_equated_reloc_p (symp)
1778 || S_IS_WEAKREFR (symp))
1780 const char *name = S_GET_NAME (symp);
1781 if (S_IS_COMMON (symp)
1782 && !TC_FAKE_LABEL (name)
1783 && !S_IS_WEAKREFR (symp)
1784 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
1786 expressionS *e = symbol_get_value_expression (symp);
1787 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1788 name, S_GET_NAME (e->X_add_symbol));
1790 if (S_GET_SEGMENT (symp) == reg_section)
1792 /* Report error only if we know the symbol name. */
1793 if (S_GET_NAME (symp) != reg_section->name)
1794 as_bad (_("can't make global register symbol `%s'"),
1797 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1801 #ifdef obj_frob_symbol
1802 obj_frob_symbol (symp, punt);
1804 #ifdef tc_frob_symbol
1805 if (! punt || symbol_used_in_reloc_p (symp))
1806 tc_frob_symbol (symp, punt);
1809 /* If we don't want to keep this symbol, splice it out of
1810 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1811 want section symbols. Otherwise, we skip local symbols
1812 and symbols that the frob_symbol macros told us to punt,
1813 but we keep such symbols if they are used in relocs. */
1814 if (symp == abs_section_sym
1815 || (! EMIT_SECTION_SYMBOLS
1816 && symbol_section_p (symp))
1817 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1818 opposites. Sometimes the former checks flags and the
1819 latter examines the name... */
1820 || (!S_IS_EXTERNAL (symp)
1821 && (punt || S_IS_LOCAL (symp) ||
1822 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
1823 && ! symbol_used_in_reloc_p (symp)))
1825 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1827 /* After symbol_remove, symbol_next(symp) still returns
1828 the one that came after it in the chain. So we don't
1829 need to do any extra cleanup work here. */
1833 /* Make sure we really got a value for the symbol. */
1834 if (! symbol_resolved_p (symp))
1836 as_bad (_("can't resolve value for symbol `%s'"),
1838 symbol_mark_resolved (symp);
1841 /* Set the value into the BFD symbol. Up til now the value
1842 has only been kept in the gas symbolS struct. */
1843 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1845 /* A warning construct is a warning symbol followed by the
1846 symbol warned about. Don't let anything object-format or
1847 target-specific muck with it; it's ready for output. */
1848 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
1849 skip_next_symbol = TRUE;
1855 /* Now do any format-specific adjustments to the symbol table, such
1856 as adding file symbols. */
1857 #ifdef tc_adjust_symtab
1858 tc_adjust_symtab ();
1860 #ifdef obj_adjust_symtab
1861 obj_adjust_symtab ();
1864 /* Stop if there is an error. */
1868 /* Now that all the sizes are known, and contents correct, we can
1869 start writing to the file. */
1872 /* If *_frob_file changes the symbol value at this point, it is
1873 responsible for moving the changed value into symp->bsym->value
1874 as well. Hopefully all symbol value changing can be done in
1879 #ifdef obj_frob_file
1883 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1885 #ifdef tc_frob_file_after_relocs
1886 tc_frob_file_after_relocs ();
1888 #ifdef obj_frob_file_after_relocs
1889 obj_frob_file_after_relocs ();
1892 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1895 #ifdef TC_GENERIC_RELAX_TABLE
1896 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1899 relax_frag (segT segment, fragS *fragP, long stretch)
1901 const relax_typeS *this_type;
1902 const relax_typeS *start_type;
1903 relax_substateT next_state;
1904 relax_substateT this_state;
1910 const relax_typeS *table;
1912 target = fragP->fr_offset;
1913 address = fragP->fr_address;
1914 table = TC_GENERIC_RELAX_TABLE;
1915 this_state = fragP->fr_subtype;
1916 start_type = this_type = table + this_state;
1917 symbolP = fragP->fr_symbol;
1923 sym_frag = symbol_get_frag (symbolP);
1925 #ifndef DIFF_EXPR_OK
1926 know (sym_frag != NULL);
1928 know (S_GET_SEGMENT (symbolP) != absolute_section
1929 || sym_frag == &zero_address_frag);
1930 target += S_GET_VALUE (symbolP);
1932 /* If frag has yet to be reached on this pass,
1933 assume it will move by STRETCH just as we did.
1934 If this is not so, it will be because some frag
1935 between grows, and that will force another pass. */
1938 && sym_frag->relax_marker != fragP->relax_marker
1939 && S_GET_SEGMENT (symbolP) == segment)
1945 aim = target - address - fragP->fr_fix;
1946 #ifdef TC_PCREL_ADJUST
1947 /* Currently only the ns32k family needs this. */
1948 aim += TC_PCREL_ADJUST (fragP);
1951 #ifdef md_prepare_relax_scan
1952 /* Formerly called M68K_AIM_KLUDGE. */
1953 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
1958 /* Look backwards. */
1959 for (next_state = this_type->rlx_more; next_state;)
1960 if (aim >= this_type->rlx_backward)
1964 /* Grow to next state. */
1965 this_state = next_state;
1966 this_type = table + this_state;
1967 next_state = this_type->rlx_more;
1972 /* Look forwards. */
1973 for (next_state = this_type->rlx_more; next_state;)
1974 if (aim <= this_type->rlx_forward)
1978 /* Grow to next state. */
1979 this_state = next_state;
1980 this_type = table + this_state;
1981 next_state = this_type->rlx_more;
1985 growth = this_type->rlx_length - start_type->rlx_length;
1987 fragP->fr_subtype = this_state;
1991 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1993 /* Relax_align. Advance location counter to next address that has 'alignment'
1994 lowest order bits all 0s, return size of adjustment made. */
1995 static relax_addressT
1996 relax_align (register relax_addressT address, /* Address now. */
1997 register int alignment /* Alignment (binary). */)
1999 relax_addressT mask;
2000 relax_addressT new_address;
2002 mask = ~((~0) << alignment);
2003 new_address = (address + mask) & (~mask);
2004 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2006 /* We must provide lots of padding, so the linker can discard it
2007 when needed. The linker will not add extra space, ever. */
2008 new_address += (1 << alignment);
2010 return (new_address - address);
2013 /* Now we have a segment, not a crowd of sub-segments, we can make
2018 After this, all frags in this segment have addresses that are correct
2019 within the segment. Since segments live in different file addresses,
2020 these frag addresses may not be the same as final object-file
2024 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2026 unsigned long frag_count;
2028 relax_addressT address;
2031 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2032 subseg_change (segment, 0);
2034 /* For each frag in segment: count and store (a 1st guess of)
2037 for (frag_count = 0, fragP = segment_frag_root;
2039 fragP = fragP->fr_next, frag_count ++)
2041 fragP->relax_marker = 0;
2042 fragP->fr_address = address;
2043 address += fragP->fr_fix;
2045 switch (fragP->fr_type)
2048 address += fragP->fr_offset * fragP->fr_var;
2055 addressT offset = relax_align (address, (int) fragP->fr_offset);
2057 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2060 if (offset % fragP->fr_var != 0)
2062 as_bad_where (fragP->fr_file, fragP->fr_line,
2063 _("alignment padding (%lu bytes) not a multiple of %ld"),
2064 (unsigned long) offset, (long) fragP->fr_var);
2065 offset -= (offset % fragP->fr_var);
2074 /* Assume .org is nugatory. It will grow with 1st relax. */
2077 case rs_machine_dependent:
2078 /* If fr_symbol is an expression, this call to
2079 resolve_symbol_value sets up the correct segment, which will
2080 likely be needed in md_estimate_size_before_relax. */
2081 if (fragP->fr_symbol)
2082 resolve_symbol_value (fragP->fr_symbol);
2084 address += md_estimate_size_before_relax (fragP, segment);
2087 #ifndef WORKING_DOT_WORD
2088 /* Broken words don't concern us yet. */
2089 case rs_broken_word:
2094 /* Initial guess is always 1; doing otherwise can result in
2095 stable solutions that are larger than the minimum. */
2096 address += fragP->fr_offset = 1;
2100 address += eh_frame_estimate_size_before_relax (fragP);
2104 address += dwarf2dbg_estimate_size_before_relax (fragP);
2108 BAD_CASE (fragP->fr_type);
2115 unsigned long max_iterations;
2117 /* Cumulative address adjustment. */
2120 /* Have we made any adjustment this pass? We can't just test
2121 stretch because one piece of code may have grown and another
2125 /* Most horrible, but gcc may give us some exception data that
2126 is impossible to assemble, of the form
2130 .uleb128 end - start
2136 If the leb128 is two bytes in size, then end-start is 128*128,
2137 which requires a three byte leb128. If the leb128 is three
2138 bytes in size, then end-start is 128*128-1, which requires a
2139 two byte leb128. We work around this dilemma by inserting
2140 an extra 4 bytes of alignment just after the .align. This
2141 works because the data after the align is accessed relative to
2144 This counter is used in a tiny state machine to detect
2145 whether a leb128 followed by an align is impossible to
2147 int rs_leb128_fudge = 0;
2149 /* We want to prevent going into an infinite loop where one frag grows
2150 depending upon the location of a symbol which is in turn moved by
2151 the growing frag. eg:
2157 So we dictate that this algorithm can be at most O2. */
2158 max_iterations = frag_count * frag_count;
2159 /* Check for overflow. */
2160 if (max_iterations < frag_count)
2161 max_iterations = frag_count;
2169 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2172 addressT was_address;
2176 fragP->relax_marker ^= 1;
2177 was_address = fragP->fr_address;
2178 address = fragP->fr_address += stretch;
2179 symbolP = fragP->fr_symbol;
2180 offset = fragP->fr_offset;
2182 switch (fragP->fr_type)
2184 case rs_fill: /* .fill never relaxes. */
2188 #ifndef WORKING_DOT_WORD
2189 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2190 for it I do not want to write it. I do not want to have
2191 anything to do with it. This is not the proper way to
2192 implement this misfeature. */
2193 case rs_broken_word:
2195 struct broken_word *lie;
2196 struct broken_word *untruth;
2198 /* Yes this is ugly (storing the broken_word pointer
2199 in the symbol slot). Still, this whole chunk of
2200 code is ugly, and I don't feel like doing anything
2201 about it. Think of it as stubbornness in action. */
2203 for (lie = (struct broken_word *) (fragP->fr_symbol);
2204 lie && lie->dispfrag == fragP;
2205 lie = lie->next_broken_word)
2211 offset = (S_GET_VALUE (lie->add)
2213 - S_GET_VALUE (lie->sub));
2214 if (offset <= -32768 || offset >= 32767)
2216 if (flag_warn_displacement)
2219 sprint_value (buf, (addressT) lie->addnum);
2220 as_warn_where (fragP->fr_file, fragP->fr_line,
2221 _(".word %s-%s+%s didn't fit"),
2222 S_GET_NAME (lie->add),
2223 S_GET_NAME (lie->sub),
2227 if (fragP->fr_subtype == 0)
2229 fragP->fr_subtype++;
2230 growth += md_short_jump_size;
2232 for (untruth = lie->next_broken_word;
2233 untruth && untruth->dispfrag == lie->dispfrag;
2234 untruth = untruth->next_broken_word)
2235 if ((symbol_get_frag (untruth->add)
2236 == symbol_get_frag (lie->add))
2237 && (S_GET_VALUE (untruth->add)
2238 == S_GET_VALUE (lie->add)))
2241 untruth->use_jump = lie;
2243 growth += md_long_jump_size;
2248 } /* case rs_broken_word */
2254 addressT oldoff, newoff;
2256 oldoff = relax_align (was_address + fragP->fr_fix,
2258 newoff = relax_align (address + fragP->fr_fix,
2261 if (fragP->fr_subtype != 0)
2263 if (oldoff > fragP->fr_subtype)
2265 if (newoff > fragP->fr_subtype)
2269 growth = newoff - oldoff;
2271 /* If this align happens to follow a leb128 and
2272 we have determined that the leb128 is bouncing
2273 in size, then break the cycle by inserting an
2276 && (rs_leb128_fudge & 16) != 0
2277 && (rs_leb128_fudge & 15) >= 2)
2279 segment_info_type *seginfo = seg_info (segment);
2280 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2283 newf = frag_alloc (ob);
2284 obstack_blank_fast (ob, fragP->fr_var);
2285 obstack_finish (ob);
2286 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2287 memcpy (newf->fr_literal,
2288 fragP->fr_literal + fragP->fr_fix,
2290 newf->fr_type = rs_fill;
2292 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2294 if (newf->fr_offset * newf->fr_var
2295 != (offsetT) 1 << fragP->fr_offset)
2297 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2300 /* Include growth of new frag, because rs_fill
2301 frags don't normally grow. */
2302 growth += newf->fr_offset * newf->fr_var;
2303 /* The new frag address is newoff. Adjust this
2304 for the amount we'll add when we process the
2306 newf->fr_address = newoff - stretch - growth;
2307 newf->relax_marker ^= 1;
2308 fragP->fr_next = newf;
2310 as_warn (_("padding added"));
2318 addressT target = offset;
2323 /* Convert from an actual address to an octet offset
2324 into the section. Here it is assumed that the
2325 section's VMA is zero, and can omit subtracting it
2326 from the symbol's value to get the address offset. */
2327 know (S_GET_SEGMENT (symbolP)->vma == 0);
2328 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2331 know (fragP->fr_next);
2332 after = fragP->fr_next->fr_address + stretch;
2333 growth = target - after;
2338 /* Don't error on first few frag relax passes.
2339 The symbol might be an expression involving
2340 symbol values from other sections. If those
2341 sections have not yet been processed their
2342 frags will all have zero addresses, so we
2343 will calculate incorrect values for them. The
2344 number of passes we allow before giving an
2345 error is somewhat arbitrary. It should be at
2346 least one, with larger values requiring
2347 increasingly contrived dependencies between
2348 frags to trigger a false error. */
2351 /* Force another pass. */
2356 /* Growth may be negative, but variable part of frag
2357 cannot have fewer than 0 chars. That is, we can't
2359 as_bad_where (fragP->fr_file, fragP->fr_line,
2360 _("attempt to move .org backwards"));
2362 /* We've issued an error message. Change the
2363 frag to avoid cascading errors. */
2364 fragP->fr_type = rs_align;
2365 fragP->fr_subtype = 0;
2366 fragP->fr_offset = 0;
2367 fragP->fr_fix = after - address;
2378 amount = S_GET_VALUE (symbolP);
2379 if (S_GET_SEGMENT (symbolP) != absolute_section
2380 || S_IS_COMMON (symbolP)
2381 || ! S_IS_DEFINED (symbolP))
2383 as_bad_where (fragP->fr_file, fragP->fr_line,
2384 _(".space specifies non-absolute value"));
2385 /* Prevent repeat of this error message. */
2386 fragP->fr_symbol = 0;
2388 else if (amount < 0)
2390 /* Don't error on first few frag relax passes.
2391 See rs_org comment for a longer explanation. */
2398 as_warn_where (fragP->fr_file, fragP->fr_line,
2399 _(".space or .fill with negative value, ignored"));
2400 fragP->fr_symbol = 0;
2403 growth = (was_address + fragP->fr_fix + amount
2404 - fragP->fr_next->fr_address);
2408 case rs_machine_dependent:
2409 #ifdef md_relax_frag
2410 growth = md_relax_frag (segment, fragP, stretch);
2412 #ifdef TC_GENERIC_RELAX_TABLE
2413 /* The default way to relax a frag is to look through
2414 TC_GENERIC_RELAX_TABLE. */
2415 growth = relax_frag (segment, fragP, stretch);
2416 #endif /* TC_GENERIC_RELAX_TABLE */
2425 value = resolve_symbol_value (fragP->fr_symbol);
2426 size = sizeof_leb128 (value, fragP->fr_subtype);
2427 growth = size - fragP->fr_offset;
2428 fragP->fr_offset = size;
2433 growth = eh_frame_relax_frag (fragP);
2437 growth = dwarf2dbg_relax_frag (fragP);
2441 BAD_CASE (fragP->fr_type);
2448 if (fragP->fr_type == rs_leb128)
2449 rs_leb128_fudge += 16;
2450 else if (fragP->fr_type == rs_align
2451 && (rs_leb128_fudge & 16) != 0
2453 rs_leb128_fudge += 16;
2455 rs_leb128_fudge = 0;
2460 && (rs_leb128_fudge & 16) == 0
2461 && (rs_leb128_fudge & -16) != 0)
2462 rs_leb128_fudge += 1;
2464 rs_leb128_fudge = 0;
2466 /* Until nothing further to relax. */
2467 while (stretched && -- max_iterations);
2470 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2471 segment_name (segment));
2474 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2475 if (fragP->last_fr_address != fragP->fr_address)
2477 fragP->last_fr_address = fragP->fr_address;
2484 number_to_chars_bigendian (char *buf, valueT val, int n)
2490 buf[n] = val & 0xff;
2496 number_to_chars_littleendian (char *buf, valueT val, int n)
2502 *buf++ = val & 0xff;
2508 write_print_statistics (FILE *file)
2510 fprintf (file, "fixups: %d\n", n_fixups);
2513 /* For debugging. */
2514 extern int indent_level;
2517 print_fixup (fixS *fixp)
2520 fprintf (stderr, "fix ");
2521 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2522 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2524 fprintf (stderr, " pcrel");
2525 if (fixp->fx_pcrel_adjust)
2526 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2527 if (fixp->fx_im_disp)
2530 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2532 fprintf (stderr, " im_disp");
2536 fprintf (stderr, " tcbit");
2538 fprintf (stderr, " done");
2539 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2540 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2541 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2542 (long) fixp->fx_where,
2543 (unsigned long) fixp->fx_offset,
2544 (unsigned long) fixp->fx_addnumber);
2545 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2549 fprintf (stderr, "\n +<");
2550 print_symbol_value_1 (stderr, fixp->fx_addsy);
2551 fprintf (stderr, ">");
2555 fprintf (stderr, "\n -<");
2556 print_symbol_value_1 (stderr, fixp->fx_subsy);
2557 fprintf (stderr, ">");
2559 fprintf (stderr, "\n");
2560 #ifdef TC_FIX_DATA_PRINT
2561 TC_FIX_DATA_PRINT (stderr, fixp);