1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
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 2, 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, 59 Temple Place - Suite 330, Boston, MA
23 /* This thing should be set up to do byteordering correctly. But... */
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 /* This looks like a good idea. Let's try turning it on always, for now. */
32 #undef BFD_FAST_SECTION_FILL
33 #define BFD_FAST_SECTION_FILL
35 #ifndef TC_ADJUST_RELOC_COUNT
36 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
39 #ifndef TC_FORCE_RELOCATION
40 #define TC_FORCE_RELOCATION(FIXP) 0
43 #ifndef TC_FORCE_RELOCATION_SECTION
44 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
47 #ifndef TC_LINKRELAX_FIXUP
48 #define TC_LINKRELAX_FIXUP(SEG) 1
51 #ifndef TC_FIX_ADJUSTABLE
52 #define TC_FIX_ADJUSTABLE(fix) 1
55 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
56 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
59 #ifndef MD_PCREL_FROM_SECTION
60 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
63 #ifndef WORKING_DOT_WORD
64 extern CONST int md_short_jump_size;
65 extern CONST int md_long_jump_size;
68 /* Used to control final evaluation of expressions. */
69 int finalize_syms = 0;
71 int symbol_table_frozen;
72 void print_fixup PARAMS ((fixS *));
75 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
77 /* We generally attach relocs to frag chains. However, after we have
78 chained these all together into a segment, any relocs we add after
79 that must be attached to a segment. This will include relocs added
80 in md_estimate_size_for_relax, for example. */
81 static int frags_chained = 0;
87 struct frag *text_frag_root;
88 struct frag *data_frag_root;
89 struct frag *bss_frag_root;
91 struct frag *text_last_frag; /* Last frag in segment. */
92 struct frag *data_last_frag; /* Last frag in segment. */
93 static struct frag *bss_last_frag; /* Last frag in segment. */
97 static object_headers headers;
100 long string_byte_count;
101 char *next_object_file_charP; /* Tracks object file bytes. */
104 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
107 #endif /* BFD_ASSEMBLER */
112 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
113 symbolS *add, symbolS *sub,
114 offsetT offset, int pcrel,
115 bfd_reloc_code_real_type r_type));
117 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
118 symbolS *add, symbolS *sub,
119 offsetT offset, int pcrel,
122 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
123 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
125 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
126 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
127 static fragS *chain_frchains_together_1 PARAMS ((segT, struct frchain *));
130 static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
131 static void cvt_frag_to_fill PARAMS ((segT, fragS *));
132 static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
133 static void write_relocs PARAMS ((bfd *, asection *, PTR));
134 static void write_contents PARAMS ((bfd *, asection *, PTR));
135 static void set_symtab PARAMS ((void));
137 #if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
138 static void merge_data_into_text PARAMS ((void));
140 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
141 static void cvt_frag_to_fill PARAMS ((object_headers *, segT, fragS *));
142 static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
143 static void relax_and_size_all_segments PARAMS ((void));
145 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
146 static void set_segment_vma PARAMS ((bfd *, asection *, PTR));
149 /* Create a fixS in obstack 'notes'. */
152 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
154 fragS *frag; /* Which frag? */
155 int where; /* Where in that frag? */
156 int size; /* 1, 2, or 4 usually. */
157 symbolS *add_symbol; /* X_add_symbol. */
158 symbolS *sub_symbol; /* X_op_symbol. */
159 offsetT offset; /* X_add_number. */
160 int pcrel; /* TRUE if PC-relative relocation. */
162 bfd_reloc_code_real_type r_type; /* Relocation type. */
164 int r_type; /* Relocation type. */
171 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
173 fixP->fx_frag = frag;
174 fixP->fx_where = where;
175 fixP->fx_size = size;
176 /* We've made fx_size a narrow field; check that it's wide enough. */
177 if (fixP->fx_size != size)
179 as_bad (_("field fx_size too small to hold %d"), size);
182 fixP->fx_addsy = add_symbol;
183 fixP->fx_subsy = sub_symbol;
184 fixP->fx_offset = offset;
185 fixP->fx_pcrel = pcrel;
187 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
188 fixP->fx_r_type = r_type;
190 fixP->fx_im_disp = 0;
191 fixP->fx_pcrel_adjust = 0;
192 fixP->fx_bit_fixP = 0;
193 fixP->fx_addnumber = 0;
196 fixP->fx_no_overflow = 0;
200 fixP->fx_cgen.insn = NULL;
201 fixP->fx_cgen.opinfo = 0;
205 TC_INIT_FIX_DATA (fixP);
208 as_where (&fixP->fx_file, &fixP->fx_line);
210 /* Usually, we want relocs sorted numerically, but while
211 comparing to older versions of gas that have relocs
212 reverse sorted, it is convenient to have this compile
213 time option. xoxorich. */
217 fixS **seg_fix_rootP = (frags_chained
218 ? &seg_info (now_seg)->fix_root
219 : &frchain_now->fix_root);
220 fixS **seg_fix_tailP = (frags_chained
221 ? &seg_info (now_seg)->fix_tail
222 : &frchain_now->fix_tail);
225 #ifdef REVERSE_SORT_RELOCS
227 fixP->fx_next = *seg_fix_rootP;
228 *seg_fix_rootP = fixP;
230 #else /* REVERSE_SORT_RELOCS */
232 fixP->fx_next = NULL;
235 (*seg_fix_tailP)->fx_next = fixP;
237 *seg_fix_rootP = fixP;
238 *seg_fix_tailP = fixP;
240 #endif /* REVERSE_SORT_RELOCS */
246 /* Create a fixup relative to a symbol (plus a constant). */
249 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
250 fragS *frag; /* Which frag? */
251 int where; /* Where in that frag? */
252 int size; /* 1, 2, or 4 usually. */
253 symbolS *add_symbol; /* X_add_symbol. */
254 offsetT offset; /* X_add_number. */
255 int pcrel; /* TRUE if PC-relative relocation. */
257 bfd_reloc_code_real_type r_type; /* Relocation type. */
259 int r_type; /* Relocation type. */
262 return fix_new_internal (frag, where, size, add_symbol,
263 (symbolS *) NULL, offset, pcrel, r_type);
266 /* Create a fixup for an expression. Currently we only support fixups
267 for difference expressions. That is itself more than most object
268 file formats support anyhow. */
271 fix_new_exp (frag, where, size, exp, pcrel, r_type)
272 fragS *frag; /* Which frag? */
273 int where; /* Where in that frag? */
274 int size; /* 1, 2, or 4 usually. */
275 expressionS *exp; /* Expression. */
276 int pcrel; /* TRUE if PC-relative relocation. */
278 bfd_reloc_code_real_type r_type; /* Relocation type. */
280 int r_type; /* Relocation type. */
293 as_bad (_("register value used as expression"));
297 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
298 the difference expression cannot immediately be reduced. */
300 symbolS *stmp = make_expr_symbol (exp);
302 exp->X_op = O_symbol;
303 exp->X_op_symbol = 0;
304 exp->X_add_symbol = stmp;
305 exp->X_add_number = 0;
307 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
311 add = exp->X_add_symbol;
312 off = exp->X_add_number;
314 #if defined(BFD_ASSEMBLER)
315 r_type = BFD_RELOC_RVA;
317 #if defined(TC_RVA_RELOC)
318 r_type = TC_RVA_RELOC;
320 as_fatal (_("rva not supported"));
326 sub = exp->X_add_symbol;
327 off = exp->X_add_number;
331 sub = exp->X_op_symbol;
334 add = exp->X_add_symbol;
337 off = exp->X_add_number;
341 add = make_expr_symbol (exp);
345 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
348 /* Append a string onto another string, bumping the pointer along. */
350 append (charPP, fromP, length)
353 unsigned long length;
355 /* Don't trust memcpy() of 0 chars. */
359 memcpy (*charPP, fromP, length);
363 #ifndef BFD_ASSEMBLER
364 int section_alignment[SEG_MAXIMUM_ORDINAL];
367 /* This routine records the largest alignment seen for each segment.
368 If the beginning of the segment is aligned on the worst-case
369 boundary, all of the other alignments within it will work. At
370 least one object format really uses this info. */
373 record_alignment (seg, align)
374 /* Segment to which alignment pertains. */
376 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
380 if (seg == absolute_section)
383 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
384 bfd_set_section_alignment (stdoutput, seg, align);
386 if (align > section_alignment[(int) seg])
387 section_alignment[(int) seg] = align;
392 get_recorded_alignment (seg)
395 if (seg == absolute_section)
398 return bfd_get_section_alignment (stdoutput, seg);
400 return section_alignment[(int) seg];
406 /* Reset the section indices after removing the gas created sections. */
409 renumber_sections (abfd, sec, countparg)
410 bfd *abfd ATTRIBUTE_UNUSED;
414 int *countp = (int *) countparg;
416 sec->index = *countp;
420 #endif /* defined (BFD_ASSEMBLER) */
422 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
425 chain_frchains_together_1 (section, frchp)
427 struct frchain *frchp;
429 fragS dummy, *prev_frag = &dummy;
431 fixS fix_dummy, *prev_fix = &fix_dummy;
434 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
436 prev_frag->fr_next = frchp->frch_root;
437 prev_frag = frchp->frch_last;
438 assert (prev_frag->fr_type != 0);
440 if (frchp->fix_root != (fixS *) NULL)
442 if (seg_info (section)->fix_root == (fixS *) NULL)
443 seg_info (section)->fix_root = frchp->fix_root;
444 prev_fix->fx_next = frchp->fix_root;
445 seg_info (section)->fix_tail = frchp->fix_tail;
446 prev_fix = frchp->fix_tail;
450 assert (prev_frag->fr_type != 0);
451 prev_frag->fr_next = 0;
460 chain_frchains_together (abfd, section, xxx)
461 bfd *abfd ATTRIBUTE_UNUSED;
463 PTR xxx ATTRIBUTE_UNUSED;
465 segment_info_type *info;
467 /* BFD may have introduced its own sections without using
468 subseg_new, so it is possible that seg_info is NULL. */
469 info = seg_info (section);
470 if (info != (segment_info_type *) NULL)
471 info->frchainP->frch_last
472 = chain_frchains_together_1 (section, info->frchainP);
474 /* Now that we've chained the frags together, we must add new fixups
475 to the segment, not to the frag chain. */
481 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
484 remove_subsegs (head, seg, root, last)
490 *root = head->frch_root;
491 *last = chain_frchains_together_1 (seg, head);
496 #if defined (BFD_ASSEMBLER) || !defined (BFD)
500 cvt_frag_to_fill (sec, fragP)
501 segT sec ATTRIBUTE_UNUSED;
505 cvt_frag_to_fill (headersP, sec, fragP)
506 object_headers *headersP;
511 switch (fragP->fr_type)
519 HANDLE_ALIGN (fragP);
521 know (fragP->fr_next != NULL);
522 fragP->fr_offset = (fragP->fr_next->fr_address
524 - fragP->fr_fix) / fragP->fr_var;
525 if (fragP->fr_offset < 0)
527 as_bad_where (fragP->fr_file, fragP->fr_line,
528 _("attempt to .org/.space backwards? (%ld)"),
529 (long) fragP->fr_offset);
530 fragP->fr_offset = 0;
532 fragP->fr_type = rs_fill;
540 valueT value = S_GET_VALUE (fragP->fr_symbol);
543 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
546 fragP->fr_fix += size;
547 fragP->fr_type = rs_fill;
549 fragP->fr_offset = 0;
550 fragP->fr_symbol = NULL;
555 eh_frame_convert_frag (fragP);
559 dwarf2dbg_convert_frag (fragP);
562 case rs_machine_dependent:
564 md_convert_frag (stdoutput, sec, fragP);
566 md_convert_frag (headersP, sec, fragP);
569 assert (fragP->fr_next == NULL
570 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
573 /* After md_convert_frag, we make the frag into a ".space 0".
574 md_convert_frag() should set up any fixSs and constants
579 #ifndef WORKING_DOT_WORD
582 struct broken_word *lie;
584 if (fragP->fr_subtype)
586 fragP->fr_fix += md_short_jump_size;
587 for (lie = (struct broken_word *) (fragP->fr_symbol);
588 lie && lie->dispfrag == fragP;
589 lie = lie->next_broken_word)
591 fragP->fr_fix += md_long_jump_size;
599 BAD_CASE (fragP->fr_type);
604 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
607 static void relax_seg PARAMS ((bfd *, asection *, PTR));
609 relax_seg (abfd, sec, xxx)
610 bfd *abfd ATTRIBUTE_UNUSED;
614 segment_info_type *seginfo = seg_info (sec);
616 if (seginfo && seginfo->frchainP
617 && relax_segment (seginfo->frchainP->frch_root, sec))
619 int *result = (int *) xxx;
624 static void size_seg PARAMS ((bfd *, asection *, PTR));
626 size_seg (abfd, sec, xxx)
629 PTR xxx ATTRIBUTE_UNUSED;
633 segment_info_type *seginfo;
635 valueT size, newsize;
637 subseg_change (sec, 0);
639 seginfo = seg_info (sec);
640 if (seginfo && seginfo->frchainP)
642 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
643 cvt_frag_to_fill (sec, fragp);
644 for (fragp = seginfo->frchainP->frch_root;
646 fragp = fragp->fr_next)
647 /* Walk to last elt. */
649 size = fragp->fr_address + fragp->fr_fix;
654 flags = bfd_get_section_flags (abfd, sec);
656 if (size > 0 && ! seginfo->bss)
657 flags |= SEC_HAS_CONTENTS;
659 /* @@ This is just an approximation. */
660 if (seginfo && seginfo->fix_root)
664 x = bfd_set_section_flags (abfd, sec, flags);
667 newsize = md_section_align (sec, size);
668 x = bfd_set_section_size (abfd, sec, newsize);
671 /* If the size had to be rounded up, add some padding in the last
673 assert (newsize >= size);
676 fragS *last = seginfo->frchainP->frch_last;
677 fragp = seginfo->frchainP->frch_root;
678 while (fragp->fr_next != last)
679 fragp = fragp->fr_next;
680 last->fr_address = size;
681 if ((newsize - size) % fragp->fr_var == 0)
682 fragp->fr_offset += (newsize - size) / fragp->fr_var;
684 /* If we hit this abort, it's likely due to subsegs_finish not
685 providing sufficient alignment on the last frag, and the
686 machine dependent code using alignment frags with fr_var
691 #ifdef tc_frob_section
692 tc_frob_section (sec);
694 #ifdef obj_frob_section
695 obj_frob_section (sec);
701 dump_section_relocs (abfd, sec, stream_)
702 bfd *abfd ATTRIBUTE_UNUSED;
706 FILE *stream = (FILE *) stream_;
707 segment_info_type *seginfo = seg_info (sec);
708 fixS *fixp = seginfo->fix_root;
713 fprintf (stream, "sec %s relocs:\n", sec->name);
716 symbolS *s = fixp->fx_addsy;
718 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
719 (int) fixp->fx_r_type);
721 fprintf (stream, "no sym\n");
724 print_symbol_value_1 (stream, s);
725 fprintf (stream, "\n");
727 fixp = fixp->fx_next;
731 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
734 #ifndef EMIT_SECTION_SYMBOLS
735 #define EMIT_SECTION_SYMBOLS 1
739 adjust_reloc_syms (abfd, sec, xxx)
740 bfd *abfd ATTRIBUTE_UNUSED;
742 PTR xxx ATTRIBUTE_UNUSED;
744 segment_info_type *seginfo = seg_info (sec);
750 dump_section_relocs (abfd, sec, stderr);
752 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
756 else if (fixp->fx_addsy)
762 fprintf (stderr, "\n\nadjusting fixup:\n");
766 sym = fixp->fx_addsy;
768 /* All symbols should have already been resolved at this
769 point. It is possible to see unresolved expression
770 symbols, though, since they are not in the regular symbol
773 resolve_symbol_value (sym);
775 if (fixp->fx_subsy != NULL)
776 resolve_symbol_value (fixp->fx_subsy);
778 /* If this symbol is equated to an undefined symbol, convert
779 the fixup to being against that symbol. */
780 if (sym != NULL && symbol_equated_reloc_p (sym))
782 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
783 sym = symbol_get_value_expression (sym)->X_add_symbol;
784 fixp->fx_addsy = sym;
787 if (sym != NULL && symbol_mri_common_p (sym))
789 /* These symbols are handled specially in fixup_segment. */
793 symsec = S_GET_SEGMENT (sym);
798 if (bfd_is_abs_section (symsec))
800 /* The fixup_segment routine will not use this symbol in a
801 relocation unless TC_FORCE_RELOCATION returns 1. */
802 if (TC_FORCE_RELOCATION (fixp))
804 symbol_mark_used_in_reloc (fixp->fx_addsy);
805 #ifdef UNDEFINED_DIFFERENCE_OK
806 if (fixp->fx_subsy != NULL)
807 symbol_mark_used_in_reloc (fixp->fx_subsy);
813 /* If it's one of these sections, assume the symbol is
814 definitely going to be output. The code in
815 md_estimate_size_before_relax in tc-mips.c uses this test
816 as well, so if you change this code you should look at that
818 if (bfd_is_und_section (symsec)
819 || bfd_is_com_section (symsec))
821 symbol_mark_used_in_reloc (fixp->fx_addsy);
822 #ifdef UNDEFINED_DIFFERENCE_OK
823 /* We have the difference of an undefined symbol and some
824 other symbol. Make sure to mark the other symbol as used
825 in a relocation so that it will always be output. */
827 symbol_mark_used_in_reloc (fixp->fx_subsy);
832 /* Don't try to reduce relocs which refer to non-local symbols
833 in .linkonce sections. It can lead to confusion when a
834 debugging section refers to a .linkonce section. I hope
835 this will always be correct. */
836 if (symsec != sec && ! S_IS_LOCAL (sym))
842 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
847 /* The GNU toolchain uses an extension for ELF: a section
848 beginning with the magic string .gnu.linkonce is a
850 if (strncmp (segment_name (symsec), ".gnu.linkonce",
851 sizeof ".gnu.linkonce" - 1) == 0)
857 symbol_mark_used_in_reloc (fixp->fx_addsy);
858 #ifdef UNDEFINED_DIFFERENCE_OK
859 if (fixp->fx_subsy != NULL)
860 symbol_mark_used_in_reloc (fixp->fx_subsy);
866 /* Since we're reducing to section symbols, don't attempt to reduce
867 anything that's already using one. */
868 if (symbol_section_p (sym))
870 symbol_mark_used_in_reloc (fixp->fx_addsy);
875 /* We can never adjust a reloc against a weak symbol. If we
876 did, and the weak symbol was overridden by a real symbol
877 somewhere else, then our relocation would be pointing at
878 the wrong area of memory. */
881 symbol_mark_used_in_reloc (fixp->fx_addsy);
885 /* Never adjust a reloc against local symbol in a merge section
886 with non-zero addend. */
887 if ((symsec->flags & SEC_MERGE) && fixp->fx_offset)
889 symbol_mark_used_in_reloc (fixp->fx_addsy);
894 /* Is there some other reason we can't adjust this one? (E.g.,
895 call/bal links in i960-bout symbols.) */
896 #ifdef obj_fix_adjustable
897 if (! obj_fix_adjustable (fixp))
899 symbol_mark_used_in_reloc (fixp->fx_addsy);
904 /* Is there some other (target cpu dependent) reason we can't adjust
905 this one? (E.g. relocations involving function addresses on
907 #ifdef tc_fix_adjustable
908 if (! tc_fix_adjustable (fixp))
910 symbol_mark_used_in_reloc (fixp->fx_addsy);
915 /* If the section symbol isn't going to be output, the relocs
916 at least should still work. If not, figure out what to do
917 when we run into that case.
919 We refetch the segment when calling section_symbol, rather
920 than using symsec, because S_GET_VALUE may wind up changing
921 the section when it calls resolve_symbol_value. */
922 fixp->fx_offset += S_GET_VALUE (sym);
923 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
924 symbol_mark_used_in_reloc (fixp->fx_addsy);
926 fprintf (stderr, "\nadjusted fixup:\n");
933 #if 1 /* def RELOC_REQUIRES_SYMBOL */
936 /* There was no symbol required by this relocation. However,
937 BFD doesn't really handle relocations without symbols well.
938 (At least, the COFF support doesn't.) So for now we fake up
939 a local symbol in the absolute section. */
941 fixp->fx_addsy = section_symbol (absolute_section);
943 fixp->fx_addsy->sy_used_in_reloc = 1;
948 dump_section_relocs (abfd, sec, stderr);
952 write_relocs (abfd, sec, xxx)
955 PTR xxx ATTRIBUTE_UNUSED;
957 segment_info_type *seginfo = seg_info (sec);
964 /* If seginfo is NULL, we did not create this section; don't do
969 fixup_segment (seginfo->fix_root, sec);
972 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
975 #ifndef RELOC_EXPANSION_POSSIBLE
976 /* Set up reloc information as well. */
977 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
978 memset ((char *) relocs, 0, n * sizeof (arelent *));
981 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
984 bfd_reloc_status_type s;
993 /* If this is an undefined symbol which was equated to another
994 symbol, then generate the reloc against the latter symbol
995 rather than the former. */
996 sym = fixp->fx_addsy;
997 while (symbol_equated_reloc_p (sym))
1001 /* We must avoid looping, as that can occur with a badly
1003 n = symbol_get_value_expression (sym)->X_add_symbol;
1006 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
1009 fixp->fx_addsy = sym;
1011 reloc = tc_gen_reloc (sec, fixp);
1019 /* This test is triggered inappropriately for the SH. */
1020 if (fixp->fx_where + fixp->fx_size
1021 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1025 s = bfd_install_relocation (stdoutput, reloc,
1026 fixp->fx_frag->fr_literal,
1027 fixp->fx_frag->fr_address,
1033 case bfd_reloc_overflow:
1034 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation overflow"));
1036 case bfd_reloc_outofrange:
1037 as_bad_where (fixp->fx_file, fixp->fx_line, _("relocation out of range"));
1040 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1041 fixp->fx_file, fixp->fx_line, s);
1043 relocs[i++] = reloc;
1046 n = n * MAX_RELOC_EXPANSION;
1047 /* Set up reloc information as well. */
1048 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1051 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1055 bfd_reloc_status_type s;
1065 /* If this is an undefined symbol which was equated to another
1066 symbol, then generate the reloc against the latter symbol
1067 rather than the former. */
1068 sym = fixp->fx_addsy;
1069 while (symbol_equated_reloc_p (sym))
1070 sym = symbol_get_value_expression (sym)->X_add_symbol;
1071 fixp->fx_addsy = sym;
1073 reloc = tc_gen_reloc (sec, fixp);
1075 for (j = 0; reloc[j]; j++)
1077 relocs[i++] = reloc[j];
1080 data = fixp->fx_frag->fr_literal + fixp->fx_where;
1081 if (fixp->fx_where + fixp->fx_size
1082 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1083 as_bad_where (fixp->fx_file, fixp->fx_line,
1084 _("internal error: fixup not contained within frag"));
1085 for (j = 0; reloc[j]; j++)
1087 s = bfd_install_relocation (stdoutput, reloc[j],
1088 fixp->fx_frag->fr_literal,
1089 fixp->fx_frag->fr_address,
1095 case bfd_reloc_overflow:
1096 as_bad_where (fixp->fx_file, fixp->fx_line,
1097 _("relocation overflow"));
1100 as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
1101 fixp->fx_file, fixp->fx_line);
1112 sympp = bfd_get_outsymbols (stdoutput);
1113 nsyms = bfd_get_symcount (stdoutput);
1114 for (i = 0; i < n; i++)
1115 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1117 for (j = 0; j < nsyms; j++)
1118 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1127 bfd_set_reloc (stdoutput, sec, relocs, n);
1129 bfd_set_section_flags (abfd, sec,
1130 (bfd_get_section_flags (abfd, sec)
1131 & (flagword) ~SEC_RELOC));
1133 #ifdef SET_SECTION_RELOCS
1134 SET_SECTION_RELOCS (sec, relocs, n);
1142 fprintf (stderr, "relocs for sec %s\n", sec->name);
1143 for (i = 0; i < n; i++)
1146 s = *r->sym_ptr_ptr;
1147 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1148 i, r, r->address, s->name, r->addend);
1155 write_contents (abfd, sec, xxx)
1156 bfd *abfd ATTRIBUTE_UNUSED;
1158 PTR xxx ATTRIBUTE_UNUSED;
1160 segment_info_type *seginfo = seg_info (sec);
1161 unsigned long offset = 0;
1164 /* Write out the frags. */
1166 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1169 for (f = seginfo->frchainP->frch_root;
1174 unsigned long fill_size;
1178 assert (f->fr_type == rs_fill);
1181 x = bfd_set_section_contents (stdoutput, sec,
1182 f->fr_literal, (file_ptr) offset,
1183 (bfd_size_type) f->fr_fix);
1186 bfd_perror (stdoutput->filename);
1187 as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1188 exit (EXIT_FAILURE);
1190 offset += f->fr_fix;
1192 fill_literal = f->fr_literal + f->fr_fix;
1193 fill_size = f->fr_var;
1194 count = f->fr_offset;
1195 assert (count >= 0);
1196 if (fill_size && count)
1199 if (fill_size > sizeof (buf))
1201 /* Do it the old way. Can this ever happen? */
1204 x = bfd_set_section_contents (stdoutput, sec,
1207 (bfd_size_type) fill_size);
1210 bfd_perror (stdoutput->filename);
1211 as_perror (_("FATAL: Can't write %s"),
1212 stdoutput->filename);
1213 exit (EXIT_FAILURE);
1215 offset += fill_size;
1220 /* Build a buffer full of fill objects and output it as
1221 often as necessary. This saves on the overhead of
1222 potentially lots of bfd_set_section_contents calls. */
1226 n_per_buf = sizeof (buf);
1227 memset (buf, *fill_literal, n_per_buf);
1232 n_per_buf = sizeof (buf) / fill_size;
1233 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1234 memcpy (bufp, fill_literal, fill_size);
1236 for (; count > 0; count -= n_per_buf)
1238 n_per_buf = n_per_buf > count ? count : n_per_buf;
1239 x = bfd_set_section_contents
1240 (stdoutput, sec, buf, (file_ptr) offset,
1241 (bfd_size_type) n_per_buf * fill_size);
1243 as_fatal (_("cannot write to output file"));
1244 offset += n_per_buf * fill_size;
1252 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1254 merge_data_into_text ()
1256 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1257 seg_info (text_section)->frchainP->frch_last->fr_next =
1258 seg_info (data_section)->frchainP->frch_root;
1259 seg_info (text_section)->frchainP->frch_last =
1260 seg_info (data_section)->frchainP->frch_last;
1261 seg_info (data_section)->frchainP = 0;
1265 text_last_frag->fr_next = data_frag_root;
1266 text_last_frag = data_last_frag;
1267 data_last_frag = NULL;
1268 data_frag_root = NULL;
1271 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1272 tmp->fx_next = data_fix_root;
1273 text_fix_tail = data_fix_tail;
1276 text_fix_root = data_fix_root;
1277 data_fix_root = NULL;
1280 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1282 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1284 relax_and_size_all_segments ()
1288 relax_segment (text_frag_root, SEG_TEXT);
1289 relax_segment (data_frag_root, SEG_DATA);
1290 relax_segment (bss_frag_root, SEG_BSS);
1292 /* Now the addresses of frags are correct within the segment. */
1293 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1294 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1295 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1297 /* Join the 2 segments into 1 huge segment.
1298 To do this, re-compute every rn_address in the SEG_DATA frags.
1299 Then join the data frags after the text frags.
1301 Determine a_data [length of data segment]. */
1304 register relax_addressT slide;
1306 know ((text_last_frag->fr_type == rs_fill)
1307 && (text_last_frag->fr_offset == 0));
1309 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1310 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1311 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1313 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1314 /* For b.out: If the data section has a strict alignment
1315 requirement, its load address in the .o file will be
1316 rounded up from the size of the text section. These
1317 two values are *not* the same! Similarly for the bss
1319 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1322 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1323 fragP->fr_address += slide;
1325 know (text_last_frag != 0);
1326 text_last_frag->fr_next = data_frag_root;
1330 H_SET_DATA_SIZE (&headers, 0);
1334 /* See above comments on b.out data section address. */
1337 if (data_last_frag == 0)
1338 bss_vma = H_GET_TEXT_SIZE (&headers);
1340 bss_vma = data_last_frag->fr_address;
1341 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1342 bss_address_frag.fr_address = bss_vma;
1344 #else /* ! OBJ_BOUT */
1345 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1346 H_GET_DATA_SIZE (&headers));
1348 #endif /* ! OBJ_BOUT */
1350 /* Slide all the frags. */
1353 relax_addressT slide = bss_address_frag.fr_address;
1355 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1356 fragP->fr_address += slide;
1360 H_SET_BSS_SIZE (&headers,
1361 bss_last_frag->fr_address - bss_frag_root->fr_address);
1363 H_SET_BSS_SIZE (&headers, 0);
1365 #endif /* ! BFD_ASSEMBLER && ! BFD */
1367 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1369 #ifdef BFD_ASSEMBLER
1377 extern PTR bfd_alloc PARAMS ((bfd *, bfd_size_type));
1379 /* Count symbols. We can't rely on a count made by the loop in
1380 write_object_file, because *_frob_file may add a new symbol or
1383 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1389 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1391 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1392 symp = symbol_rootP;
1393 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1395 asympp[i] = symbol_get_bfdsym (symp);
1396 symbol_mark_written (symp);
1401 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1402 assert (result == true);
1403 symbol_table_frozen = 1;
1407 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1409 set_segment_vma (abfd, sec, xxx)
1412 PTR xxx ATTRIBUTE_UNUSED;
1414 static bfd_vma addr = 0;
1416 bfd_set_section_vma (abfd, sec, addr);
1417 addr += bfd_section_size (abfd, sec);
1419 #endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
1421 /* Finish the subsegments. After every sub-segment, we fake an
1422 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1423 ".fill 0" because that is the kind of frag that requires least
1424 thought. ".align" frags like to have a following frag since that
1425 makes calculating their intended length trivial. */
1427 #ifndef SUB_SEGMENT_ALIGN
1429 /* The last subsegment gets an aligment corresponding to the alignment
1430 of the section. This allows proper nop-filling at the end of
1431 code-bearing sections. */
1432 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1433 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
1434 ? get_recorded_alignment (SEG) : 0)
1436 #ifdef BFD_ASSEMBLER
1437 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1439 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 2
1447 struct frchain *frchainP;
1449 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1453 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1455 /* This now gets called even if we had errors. In that case,
1456 any alignment is meaningless, and, moreover, will look weird
1457 if we are generating a listing. */
1459 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1461 if (subseg_text_p (now_seg))
1462 frag_align_code (alignment, 0);
1464 frag_align (alignment, 0, 0);
1466 /* frag_align will have left a new frag.
1467 Use this last frag for an empty ".fill".
1469 For this segment ...
1470 Create a last frag. Do not leave a "being filled in frag". */
1471 frag_wane (frag_now);
1472 frag_now->fr_fix = 0;
1473 know (frag_now->fr_next == NULL);
1477 /* Write the object file. */
1480 write_object_file ()
1482 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1483 fragS *fragP; /* Track along all frags. */
1486 /* Do we really want to write it? */
1488 int n_warns, n_errs;
1489 n_warns = had_warnings ();
1490 n_errs = had_errors ();
1491 /* The -Z flag indicates that an object file should be generated,
1492 regardless of warnings and errors. */
1493 if (flag_always_generate_output)
1495 if (n_warns || n_errs)
1496 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1497 n_errs, n_errs == 1 ? "" : "s",
1498 n_warns, n_warns == 1 ? "" : "s");
1503 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1504 n_errs, n_errs == 1 ? "" : "s",
1505 n_warns, n_warns == 1 ? "" : "s");
1510 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1511 a routine to check for the definition of the procedure "_main",
1512 and if so -- fix it up so that it can be program entry point. */
1513 vms_check_for_main ();
1514 #endif /* OBJ_VMS */
1516 /* From now on, we don't care about sub-segments. Build one frag chain
1517 for each segment. Linked thru fr_next. */
1519 #ifdef BFD_ASSEMBLER
1520 /* Remove the sections created by gas for its own purposes. */
1525 seclist = &stdoutput->sections;
1528 if (*seclist == reg_section || *seclist == expr_section)
1530 bfd_section_list_remove (stdoutput, seclist);
1531 stdoutput->section_count--;
1534 seclist = &(*seclist)->next;
1537 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1540 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1542 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1543 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1544 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
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 !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1551 if (flag_readonly_data_in_text)
1553 merge_data_into_text ();
1557 #ifdef BFD_ASSEMBLER
1562 #ifndef WORKING_DOT_WORD
1563 /* We need to reset the markers in the broken word list and
1564 associated frags between calls to relax_segment (via
1565 relax_seg). Since the broken word list is global, we do it
1566 once per round, rather than locally in relax_segment for each
1568 struct broken_word *brokp;
1570 for (brokp = broken_words;
1571 brokp != (struct broken_word *) NULL;
1572 brokp = brokp->next_broken_word)
1576 if (brokp->dispfrag != (fragS *) NULL
1577 && brokp->dispfrag->fr_type == rs_broken_word)
1578 brokp->dispfrag->fr_subtype = 0;
1583 bfd_map_over_sections (stdoutput, relax_seg, &changed);
1588 /* Note - Most ports will use the default value of
1589 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1590 local symbols to be resolved, removing their frag information.
1591 Some ports however, will not have finished relaxing all of
1592 their frags and will still need the local symbol frag
1593 information. These ports can set
1594 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1595 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1597 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1599 relax_and_size_all_segments ();
1600 #endif /* BFD_ASSEMBLER */
1602 /* Relaxation has completed. Freeze all syms. */
1605 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1606 /* Now that the segments have their final sizes, run through the
1607 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1608 should too. Currently, only DJGPP uses this code, but other
1609 COFF targets may need to execute this too. */
1610 bfd_map_over_sections (stdoutput, set_segment_vma, (char *) 0);
1613 #ifndef BFD_ASSEMBLER
1614 /* Crawl the symbol chain.
1616 For each symbol whose value depends on a frag, take the address of
1617 that frag and subsume it into the value of the symbol.
1618 After this, there is just one way to lookup a symbol value.
1619 Values are left in their final state for object file emission.
1620 We adjust the values of 'L' local symbols, even if we do
1621 not intend to emit them to the object file, because their values
1622 are needed for fix-ups.
1624 Unless we saw a -L flag, remove all symbols that begin with 'L'
1625 from the symbol chain. (They are still pointed to by the fixes.)
1627 Count the remaining symbols.
1628 Assign a symbol number to each symbol.
1629 Count the number of string-table chars we will emit.
1630 Put this info into the headers as appropriate. */
1631 know (zero_address_frag.fr_address == 0);
1632 string_byte_count = sizeof (string_byte_count);
1634 obj_crawl_symbol_chain (&headers);
1636 if (string_byte_count == sizeof (string_byte_count))
1637 string_byte_count = 0;
1639 H_SET_STRING_SIZE (&headers, string_byte_count);
1641 /* Addresses of frags now reflect addresses we use in the object file.
1642 Symbol values are correct.
1643 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1644 Also converting any machine-dependent frags using md_convert_frag(); */
1645 subseg_change (SEG_TEXT, 0);
1647 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1649 /* At this point we have linked all the frags into a single
1650 chain. However, cvt_frag_to_fill may call md_convert_frag
1651 which may call fix_new. We need to ensure that fix_new adds
1652 the fixup to the right section. */
1653 if (fragP == data_frag_root)
1654 subseg_change (SEG_DATA, 0);
1656 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1658 /* Some assert macros don't work with # directives mixed in. */
1660 if (!(fragP->fr_next == NULL
1662 || fragP->fr_next == data_frag_root
1664 || ((fragP->fr_next->fr_address - fragP->fr_address)
1665 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1669 #endif /* ! BFD_ASSEMBLER */
1671 #ifndef WORKING_DOT_WORD
1673 struct broken_word *lie;
1674 struct broken_word **prevP;
1676 prevP = &broken_words;
1677 for (lie = broken_words; lie; lie = lie->next_broken_word)
1682 subseg_change (lie->seg, lie->subseg);
1683 exp.X_op = O_subtract;
1684 exp.X_add_symbol = lie->add;
1685 exp.X_op_symbol = lie->sub;
1686 exp.X_add_number = lie->addnum;
1687 #ifdef BFD_ASSEMBLER
1688 #ifdef TC_CONS_FIX_NEW
1689 TC_CONS_FIX_NEW (lie->frag,
1690 lie->word_goes_here - lie->frag->fr_literal,
1693 fix_new_exp (lie->frag,
1694 lie->word_goes_here - lie->frag->fr_literal,
1695 2, &exp, 0, BFD_RELOC_16);
1698 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1699 fix_new_exp (lie->frag,
1700 lie->word_goes_here - lie->frag->fr_literal,
1701 2, &exp, 0, NO_RELOC);
1704 fix_new_ns32k_exp (lie->frag,
1705 lie->word_goes_here - lie->frag->fr_literal,
1706 2, &exp, 0, 0, 2, 0, 0);
1708 fix_new_exp (lie->frag,
1709 lie->word_goes_here - lie->frag->fr_literal,
1711 #endif /* TC_NS32K */
1712 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1713 #endif /* BFD_ASSEMBLER */
1714 *prevP = lie->next_broken_word;
1717 prevP = &(lie->next_broken_word);
1719 for (lie = broken_words; lie;)
1721 struct broken_word *untruth;
1723 addressT table_addr;
1724 addressT from_addr, to_addr;
1727 subseg_change (lie->seg, lie->subseg);
1728 fragP = lie->dispfrag;
1730 /* Find out how many broken_words go here. */
1733 untruth && untruth->dispfrag == fragP;
1734 untruth = untruth->next_broken_word)
1735 if (untruth->added == 1)
1738 table_ptr = lie->dispfrag->fr_opcode;
1739 table_addr = (lie->dispfrag->fr_address
1740 + (table_ptr - lie->dispfrag->fr_literal));
1741 /* Create the jump around the long jumps. This is a short
1742 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1743 from_addr = table_addr;
1744 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1745 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1747 table_ptr += md_short_jump_size;
1748 table_addr += md_short_jump_size;
1751 lie && lie->dispfrag == fragP;
1752 m++, lie = lie->next_broken_word)
1754 if (lie->added == 2)
1756 /* Patch the jump table. */
1757 /* This is the offset from ??? to table_ptr+0. */
1758 to_addr = table_addr - S_GET_VALUE (lie->sub);
1759 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1760 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1762 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1763 for (untruth = lie->next_broken_word;
1764 untruth && untruth->dispfrag == fragP;
1765 untruth = untruth->next_broken_word)
1767 if (untruth->use_jump == lie)
1768 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1771 /* Install the long jump. */
1772 /* This is a long jump from table_ptr+0 to the final target. */
1773 from_addr = table_addr;
1774 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1775 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1777 table_ptr += md_long_jump_size;
1778 table_addr += md_long_jump_size;
1782 #endif /* not WORKING_DOT_WORD */
1784 #ifndef BFD_ASSEMBLER
1787 char *the_object_file;
1788 long object_file_size;
1789 /* Scan every FixS performing fixups. We had to wait until now to
1790 do this because md_convert_frag() may have made some fixSs. */
1793 subseg_change (SEG_TEXT, 0);
1794 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1795 subseg_change (SEG_DATA, 0);
1796 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1797 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1799 /* FIXME: Move this stuff into the pre-write-hook. */
1800 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1801 H_SET_ENTRY_POINT (&headers, 0);
1803 obj_pre_write_hook (&headers); /* Extra coff stuff. */
1805 object_file_size = H_GET_FILE_SIZE (&headers);
1806 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1808 output_file_create (out_file_name);
1810 obj_header_append (&next_object_file_charP, &headers);
1812 know ((next_object_file_charP - the_object_file)
1813 == H_GET_HEADER_SIZE (&headers));
1816 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1818 register long count;
1819 register char *fill_literal;
1820 register long fill_size;
1823 know (fragP->fr_type == rs_fill);
1824 append (&next_object_file_charP, fragP->fr_literal,
1825 (unsigned long) fragP->fr_fix);
1826 fill_literal = fragP->fr_literal + fragP->fr_fix;
1827 fill_size = fragP->fr_var;
1828 know (fragP->fr_offset >= 0);
1830 for (count = fragP->fr_offset; count; count--)
1831 append (&next_object_file_charP, fill_literal,
1832 (unsigned long) fill_size);
1835 know ((next_object_file_charP - the_object_file)
1836 == (H_GET_HEADER_SIZE (&headers)
1837 + H_GET_TEXT_SIZE (&headers)
1838 + H_GET_DATA_SIZE (&headers)));
1840 /* Emit relocations. */
1841 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1842 (relax_addressT) 0);
1843 know ((next_object_file_charP - the_object_file)
1844 == (H_GET_HEADER_SIZE (&headers)
1845 + H_GET_TEXT_SIZE (&headers)
1846 + H_GET_DATA_SIZE (&headers)
1847 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
1849 /* Make addresses in data relocation directives relative to beginning of
1850 first data fragment, not end of last text fragment: alignment of the
1851 start of the data segment may place a gap between the segments. */
1852 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1853 data0_frchainP->frch_root->fr_address);
1855 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1856 text_last_frag->fr_address);
1857 #endif /* TC_I960 */
1859 know ((next_object_file_charP - the_object_file)
1860 == (H_GET_HEADER_SIZE (&headers)
1861 + H_GET_TEXT_SIZE (&headers)
1862 + H_GET_DATA_SIZE (&headers)
1863 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1864 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1866 /* Emit line number entries. */
1867 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1868 know ((next_object_file_charP - the_object_file)
1869 == (H_GET_HEADER_SIZE (&headers)
1870 + H_GET_TEXT_SIZE (&headers)
1871 + H_GET_DATA_SIZE (&headers)
1872 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1873 + H_GET_DATA_RELOCATION_SIZE (&headers)
1874 + H_GET_LINENO_SIZE (&headers)));
1877 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1878 know ((next_object_file_charP - the_object_file)
1879 == (H_GET_HEADER_SIZE (&headers)
1880 + H_GET_TEXT_SIZE (&headers)
1881 + H_GET_DATA_SIZE (&headers)
1882 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1883 + H_GET_DATA_RELOCATION_SIZE (&headers)
1884 + H_GET_LINENO_SIZE (&headers)
1885 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1888 if (string_byte_count > 0)
1889 obj_emit_strings (&next_object_file_charP);
1892 bfd_seek (stdoutput, (file_ptr) 0, 0);
1893 bfd_bwrite (the_object_file, (bfd_size_type) object_file_size, stdoutput);
1896 /* Write the data to the file. */
1897 output_file_append (the_object_file, object_file_size, out_file_name);
1898 free (the_object_file);
1902 /* Now do the VMS-dependent part of writing the object file. */
1903 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1904 H_GET_DATA_SIZE (&headers),
1905 H_GET_BSS_SIZE (&headers),
1906 text_frag_root, data_frag_root);
1907 #endif /* OBJ_VMS */
1908 #else /* BFD_ASSEMBLER */
1910 /* Resolve symbol values. This needs to be done before processing
1916 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1917 resolve_symbol_value (symp);
1919 resolve_local_symbol_values ();
1923 #ifdef tc_frob_file_before_adjust
1924 tc_frob_file_before_adjust ();
1926 #ifdef obj_frob_file_before_adjust
1927 obj_frob_file_before_adjust ();
1930 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1932 /* Set up symbol table, and write it out. */
1937 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1942 if (symbol_mri_common_p (symp))
1944 if (S_IS_EXTERNAL (symp))
1945 as_bad (_("%s: global symbols not supported in common sections"),
1947 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1951 name = S_GET_NAME (symp);
1955 decode_local_label_name ((char *) S_GET_NAME (symp));
1956 /* They only differ if `name' is a fb or dollar local
1958 if (name2 != name && ! S_IS_DEFINED (symp))
1959 as_bad (_("local label `%s' is not defined"), name2);
1962 /* Do it again, because adjust_reloc_syms might introduce
1963 more symbols. They'll probably only be section symbols,
1964 but they'll still need to have the values computed. */
1965 resolve_symbol_value (symp);
1967 /* Skip symbols which were equated to undefined or common
1969 if (symbol_equated_reloc_p (symp))
1971 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1975 /* So far, common symbols have been treated like undefined symbols.
1976 Put them in the common section now. */
1977 if (S_IS_DEFINED (symp) == 0
1978 && S_GET_VALUE (symp) != 0)
1979 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1981 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1982 S_GET_NAME (symp), symp,
1984 symbol_get_bfdsym (symp)->flags,
1985 segment_name (S_GET_SEGMENT (symp)));
1988 #ifdef obj_frob_symbol
1989 obj_frob_symbol (symp, punt);
1991 #ifdef tc_frob_symbol
1992 if (! punt || symbol_used_in_reloc_p (symp))
1993 tc_frob_symbol (symp, punt);
1996 /* If we don't want to keep this symbol, splice it out of
1997 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1998 want section symbols. Otherwise, we skip local symbols
1999 and symbols that the frob_symbol macros told us to punt,
2000 but we keep such symbols if they are used in relocs. */
2001 if ((! EMIT_SECTION_SYMBOLS
2002 && symbol_section_p (symp))
2003 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
2004 opposites. Sometimes the former checks flags and the
2005 latter examines the name... */
2006 || (!S_IS_EXTERN (symp)
2007 && (S_IS_LOCAL (symp) || punt)
2008 && ! symbol_used_in_reloc_p (symp)))
2010 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2012 /* After symbol_remove, symbol_next(symp) still returns
2013 the one that came after it in the chain. So we don't
2014 need to do any extra cleanup work here. */
2018 /* Make sure we really got a value for the symbol. */
2019 if (! symbol_resolved_p (symp))
2021 as_bad (_("can't resolve value for symbol `%s'"),
2023 symbol_mark_resolved (symp);
2026 /* Set the value into the BFD symbol. Up til now the value
2027 has only been kept in the gas symbolS struct. */
2028 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2034 /* Now do any format-specific adjustments to the symbol table, such
2035 as adding file symbols. */
2036 #ifdef tc_adjust_symtab
2037 tc_adjust_symtab ();
2039 #ifdef obj_adjust_symtab
2040 obj_adjust_symtab ();
2043 /* Now that all the sizes are known, and contents correct, we can
2044 start writing to the file. */
2047 /* If *_frob_file changes the symbol value at this point, it is
2048 responsible for moving the changed value into symp->bsym->value
2049 as well. Hopefully all symbol value changing can be done in
2054 #ifdef obj_frob_file
2058 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2060 #ifdef tc_frob_file_after_relocs
2061 tc_frob_file_after_relocs ();
2063 #ifdef obj_frob_file_after_relocs
2064 obj_frob_file_after_relocs ();
2067 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2068 #endif /* BFD_ASSEMBLER */
2072 #ifdef TC_GENERIC_RELAX_TABLE
2074 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2077 relax_frag (segment, fragP, stretch)
2082 const relax_typeS *this_type;
2083 const relax_typeS *start_type;
2084 relax_substateT next_state;
2085 relax_substateT this_state;
2091 const relax_typeS *table;
2093 target = fragP->fr_offset;
2094 address = fragP->fr_address;
2095 table = TC_GENERIC_RELAX_TABLE;
2096 this_state = fragP->fr_subtype;
2097 start_type = this_type = table + this_state;
2098 symbolP = fragP->fr_symbol;
2104 sym_frag = symbol_get_frag (symbolP);
2106 #ifndef DIFF_EXPR_OK
2107 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2108 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2109 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2110 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2111 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2113 know (sym_frag != NULL);
2115 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
2116 || sym_frag == &zero_address_frag);
2117 target += S_GET_VALUE (symbolP);
2119 /* If frag has yet to be reached on this pass,
2120 assume it will move by STRETCH just as we did.
2121 If this is not so, it will be because some frag
2122 between grows, and that will force another pass. */
2125 && sym_frag->relax_marker != fragP->relax_marker
2126 && S_GET_SEGMENT (symbolP) == segment)
2132 aim = target - address - fragP->fr_fix;
2133 #ifdef TC_PCREL_ADJUST
2134 /* Currently only the ns32k family needs this. */
2135 aim += TC_PCREL_ADJUST (fragP);
2137 /* This machine doesn't want to use pcrel_adjust.
2138 In that case, pcrel_adjust should be zero. */
2140 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
2143 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2144 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2149 /* Look backwards. */
2150 for (next_state = this_type->rlx_more; next_state;)
2151 if (aim >= this_type->rlx_backward)
2155 /* Grow to next state. */
2156 this_state = next_state;
2157 this_type = table + this_state;
2158 next_state = this_type->rlx_more;
2163 /* Look forwards. */
2164 for (next_state = this_type->rlx_more; next_state;)
2165 if (aim <= this_type->rlx_forward)
2169 /* Grow to next state. */
2170 this_state = next_state;
2171 this_type = table + this_state;
2172 next_state = this_type->rlx_more;
2176 growth = this_type->rlx_length - start_type->rlx_length;
2178 fragP->fr_subtype = this_state;
2182 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2184 /* Relax_align. Advance location counter to next address that has 'alignment'
2185 lowest order bits all 0s, return size of adjustment made. */
2186 static relax_addressT
2187 relax_align (address, alignment)
2188 register relax_addressT address; /* Address now. */
2189 register int alignment; /* Alignment (binary). */
2191 relax_addressT mask;
2192 relax_addressT new_address;
2194 mask = ~((~0) << alignment);
2195 new_address = (address + mask) & (~mask);
2196 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2198 /* We must provide lots of padding, so the linker can discard it
2199 when needed. The linker will not add extra space, ever. */
2200 new_address += (1 << alignment);
2202 return (new_address - address);
2205 /* Now we have a segment, not a crowd of sub-segments, we can make
2210 After this, all frags in this segment have addresses that are correct
2211 within the segment. Since segments live in different file addresses,
2212 these frag addresses may not be the same as final object-file
2216 relax_segment (segment_frag_root, segment)
2217 struct frag *segment_frag_root;
2220 register struct frag *fragP;
2221 register relax_addressT address;
2224 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2225 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2227 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2228 subseg_change (segment, 0);
2230 /* For each frag in segment: count and store (a 1st guess of)
2233 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2235 fragP->relax_marker = 0;
2236 fragP->fr_address = address;
2237 address += fragP->fr_fix;
2239 switch (fragP->fr_type)
2242 address += fragP->fr_offset * fragP->fr_var;
2249 addressT offset = relax_align (address, (int) fragP->fr_offset);
2251 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2254 if (offset % fragP->fr_var != 0)
2256 as_bad_where (fragP->fr_file, fragP->fr_line,
2257 _("alignment padding (%lu bytes) not a multiple of %ld"),
2258 (unsigned long) offset, (long) fragP->fr_var);
2259 offset -= (offset % fragP->fr_var);
2268 /* Assume .org is nugatory. It will grow with 1st relax. */
2271 case rs_machine_dependent:
2272 /* If fr_symbol is an expression, this call to
2273 resolve_symbol_value sets up the correct segment, which will
2274 likely be needed in md_estimate_size_before_relax. */
2275 if (fragP->fr_symbol)
2276 resolve_symbol_value (fragP->fr_symbol);
2278 address += md_estimate_size_before_relax (fragP, segment);
2281 #ifndef WORKING_DOT_WORD
2282 /* Broken words don't concern us yet. */
2283 case rs_broken_word:
2288 /* Initial guess is always 1; doing otherwise can result in
2289 stable solutions that are larger than the minimum. */
2290 address += fragP->fr_offset = 1;
2294 address += eh_frame_estimate_size_before_relax (fragP);
2298 address += dwarf2dbg_estimate_size_before_relax (fragP);
2302 BAD_CASE (fragP->fr_type);
2309 long stretch; /* May be any size, 0 or negative. */
2310 /* Cumulative number of addresses we have relaxed this pass.
2311 We may have relaxed more than one address. */
2312 int stretched; /* Have we stretched on this pass? */
2313 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2314 grew, and another shrank. If a branch instruction doesn't fit anymore,
2315 we could be scrod. */
2322 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2325 addressT was_address;
2329 fragP->relax_marker ^= 1;
2330 was_address = fragP->fr_address;
2331 address = fragP->fr_address += stretch;
2332 symbolP = fragP->fr_symbol;
2333 offset = fragP->fr_offset;
2335 switch (fragP->fr_type)
2337 case rs_fill: /* .fill never relaxes. */
2341 #ifndef WORKING_DOT_WORD
2342 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2343 for it I do not want to write it. I do not want to have
2344 anything to do with it. This is not the proper way to
2345 implement this misfeature. */
2346 case rs_broken_word:
2348 struct broken_word *lie;
2349 struct broken_word *untruth;
2351 /* Yes this is ugly (storing the broken_word pointer
2352 in the symbol slot). Still, this whole chunk of
2353 code is ugly, and I don't feel like doing anything
2354 about it. Think of it as stubbornness in action. */
2356 for (lie = (struct broken_word *) (fragP->fr_symbol);
2357 lie && lie->dispfrag == fragP;
2358 lie = lie->next_broken_word)
2364 offset = (S_GET_VALUE (lie->add)
2366 - S_GET_VALUE (lie->sub));
2367 if (offset <= -32768 || offset >= 32767)
2369 if (flag_warn_displacement)
2372 sprint_value (buf, (addressT) lie->addnum);
2373 as_warn_where (fragP->fr_file, fragP->fr_line,
2374 _(".word %s-%s+%s didn't fit"),
2375 S_GET_NAME (lie->add),
2376 S_GET_NAME (lie->sub),
2380 if (fragP->fr_subtype == 0)
2382 fragP->fr_subtype++;
2383 growth += md_short_jump_size;
2385 for (untruth = lie->next_broken_word;
2386 untruth && untruth->dispfrag == lie->dispfrag;
2387 untruth = untruth->next_broken_word)
2388 if ((symbol_get_frag (untruth->add)
2389 == symbol_get_frag (lie->add))
2390 && (S_GET_VALUE (untruth->add)
2391 == S_GET_VALUE (lie->add)))
2394 untruth->use_jump = lie;
2396 growth += md_long_jump_size;
2401 } /* case rs_broken_word */
2407 addressT oldoff, newoff;
2409 oldoff = relax_align (was_address + fragP->fr_fix,
2411 newoff = relax_align (address + fragP->fr_fix,
2414 if (fragP->fr_subtype != 0)
2416 if (oldoff > fragP->fr_subtype)
2418 if (newoff > fragP->fr_subtype)
2422 growth = newoff - oldoff;
2428 addressT target = offset;
2433 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2434 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2435 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2436 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2437 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2438 know (symbolP->sy_frag);
2439 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2440 || (symbolP->sy_frag == &zero_address_frag));
2442 /* Convert from an actual address to an octet offset
2443 into the section. Here it is assumed that the
2444 section's VMA is zero, and can omit subtracting it
2445 from the symbol's value to get the address offset. */
2446 know (S_GET_SECTION (symbolP)->vma == 0);
2447 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2450 know (fragP->fr_next);
2451 after = fragP->fr_next->fr_address;
2452 growth = target - after;
2455 /* Growth may be negative, but variable part of frag
2456 cannot have fewer than 0 chars. That is, we can't
2458 as_bad_where (fragP->fr_file, fragP->fr_line,
2459 _("attempt to .org backwards"));
2461 /* We've issued an error message. Change the
2462 frag to avoid cascading errors. */
2463 fragP->fr_type = rs_align;
2464 fragP->fr_subtype = 0;
2465 fragP->fr_offset = 0;
2466 fragP->fr_fix = after - address;
2470 /* This is an absolute growth factor */
2481 amount = S_GET_VALUE (symbolP);
2482 if (S_GET_SEGMENT (symbolP) != absolute_section
2483 || S_IS_COMMON (symbolP)
2484 || ! S_IS_DEFINED (symbolP))
2486 as_bad_where (fragP->fr_file, fragP->fr_line,
2487 _(".space specifies non-absolute value"));
2488 /* Prevent repeat of this error message. */
2489 fragP->fr_symbol = 0;
2491 else if (amount < 0)
2493 as_warn_where (fragP->fr_file, fragP->fr_line,
2494 _(".space or .fill with negative value, ignored"));
2495 fragP->fr_symbol = 0;
2498 growth = (was_address + fragP->fr_fix + amount
2499 - fragP->fr_next->fr_address);
2503 case rs_machine_dependent:
2504 #ifdef md_relax_frag
2505 growth = md_relax_frag (segment, fragP, stretch);
2507 #ifdef TC_GENERIC_RELAX_TABLE
2508 /* The default way to relax a frag is to look through
2509 TC_GENERIC_RELAX_TABLE. */
2510 growth = relax_frag (segment, fragP, stretch);
2511 #endif /* TC_GENERIC_RELAX_TABLE */
2520 value = resolve_symbol_value (fragP->fr_symbol);
2521 size = sizeof_leb128 (value, fragP->fr_subtype);
2522 growth = size - fragP->fr_offset;
2523 fragP->fr_offset = size;
2528 growth = eh_frame_relax_frag (fragP);
2532 growth = dwarf2dbg_relax_frag (fragP);
2536 BAD_CASE (fragP->fr_type);
2544 } /* For each frag in the segment. */
2546 while (stretched); /* Until nothing further to relax. */
2550 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2551 if (fragP->last_fr_address != fragP->fr_address)
2553 fragP->last_fr_address = fragP->fr_address;
2559 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2561 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2562 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2567 Go through all the fixS's in a segment and see which ones can be
2568 handled now. (These consist of fixS where we have since discovered
2569 the value of a symbol, or the address of the frag involved.)
2570 For each one, call md_apply_fix3 to put the fix into the frag data.
2572 Result is a count of how many relocation structs will be needed to
2573 handle the remaining fixS's that we couldn't completely handle here.
2574 These will be output later by emit_relocations(). */
2577 fixup_segment (fixP, this_segment_type)
2578 register fixS *fixP;
2579 segT this_segment_type; /* N_TYPE bits for segment. */
2581 long seg_reloc_count = 0;
2582 symbolS *add_symbolP;
2583 symbolS *sub_symbolP;
2590 segT add_symbol_segment = absolute_section;
2592 /* If the linker is doing the relaxing, we must not do any fixups.
2594 Well, strictly speaking that's not true -- we could do any that are
2595 PC-relative and don't cross regions that could change size. And for the
2596 i960 (the only machine for which we've got a relaxing linker right now),
2597 we might be able to turn callx/callj into bal anyways in cases where we
2598 know the maximum displacement. */
2599 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
2601 for (; fixP; fixP = fixP->fx_next)
2603 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2604 return seg_reloc_count;
2607 for (; fixP; fixP = fixP->fx_next)
2610 fprintf (stderr, "\nprocessing fixup:\n");
2614 fragP = fixP->fx_frag;
2616 where = fixP->fx_where;
2617 place = fragP->fr_literal + where;
2618 size = fixP->fx_size;
2619 add_symbolP = fixP->fx_addsy;
2620 #ifdef TC_VALIDATE_FIX
2621 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2623 sub_symbolP = fixP->fx_subsy;
2624 add_number = fixP->fx_offset;
2625 pcrel = fixP->fx_pcrel;
2628 if (add_symbolP != NULL
2629 && symbol_mri_common_p (add_symbolP))
2631 know (add_symbolP->sy_value.X_op == O_symbol);
2632 add_number += S_GET_VALUE (add_symbolP);
2633 fixP->fx_offset = add_number;
2634 add_symbolP = fixP->fx_addsy =
2635 symbol_get_value_expression (add_symbolP)->X_add_symbol;
2639 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2643 resolve_symbol_value (sub_symbolP);
2644 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2646 if (add_symbolP != NULL)
2648 add_number += S_GET_VALUE (add_symbolP);
2650 fixP->fx_addsy = NULL;
2653 /* It's just -sym. */
2654 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2656 add_number -= S_GET_VALUE (sub_symbolP);
2657 fixP->fx_subsy = NULL;
2660 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2662 /* Should try converting to a constant. */
2667 as_bad_where (fixP->fx_file, fixP->fx_line,
2668 _("negative of non-absolute symbol `%s'"),
2669 S_GET_NAME (sub_symbolP));
2671 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2672 && SEG_NORMAL (add_symbol_segment))
2674 /* Difference of 2 symbols from same segment.
2675 Can't make difference of 2 undefineds: 'value' means
2676 something different for N_UNDF. */
2678 /* Makes no sense to use the difference of 2 arbitrary symbols
2679 as the target of a call instruction. */
2681 as_bad_where (fixP->fx_file, fixP->fx_line,
2682 _("callj to difference of two symbols"));
2683 #endif /* TC_I960 */
2684 add_number += (S_GET_VALUE (add_symbolP)
2685 - S_GET_VALUE (sub_symbolP));
2688 /* See the comment below about 68k weirdness. */
2692 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2695 pcrel = 0; /* No further pcrel processing. */
2697 /* Let the target machine make the final determination
2698 as to whether or not a relocation will be needed to
2699 handle this fixup. */
2700 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2703 fixP->fx_addsy = NULL;
2704 fixP->fx_subsy = NULL;
2709 /* Different segments in subtraction. */
2710 know (!(S_IS_EXTERNAL (sub_symbolP)
2711 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2713 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2714 add_number -= S_GET_VALUE (sub_symbolP);
2717 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2719 /* Make it pc-relative. */
2722 /* Do this for m68k even if it's already described
2723 as pc-relative. On the m68k, an operand of
2724 "pc@(foo-.-2)" should address "foo" in a
2725 pc-relative mode. */
2730 add_number += MD_PCREL_FROM_SECTION (fixP,
2736 add_number -= S_GET_VALUE (sub_symbolP);
2741 #ifdef UNDEFINED_DIFFERENCE_OK
2742 /* The PA needs this for PIC code generation. We basically
2743 don't want to do anything if we have the difference of two
2744 symbols at this point. */
2747 /* Leave it alone. */
2750 #ifdef BFD_ASSEMBLER
2751 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2752 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2754 /* Leave it alone. */
2760 sprint_value (buf, fragP->fr_address + where);
2761 as_bad_where (fixP->fx_file, fixP->fx_line,
2762 _("subtraction of two symbols in different sections `%s' {%s section} - `%s' {%s section} at file address %s"),
2763 S_GET_NAME (add_symbolP),
2764 segment_name (S_GET_SEGMENT (add_symbolP)),
2765 S_GET_NAME (sub_symbolP),
2766 segment_name (S_GET_SEGMENT (sub_symbolP)),
2774 if (add_symbol_segment == this_segment_type && pcrel && !plt
2775 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2777 /* This fixup was made when the symbol's segment was
2778 SEG_UNKNOWN, but it is now in the local segment.
2779 So we know how to do the address without relocation. */
2781 /* reloc_callj() may replace a 'call' with a 'calls' or a
2782 'bal', in which cases it modifies *fixP as appropriate.
2783 In the case of a 'calls', no further work is required,
2784 and *fixP has been set up to make the rest of the code
2787 #endif /* TC_I960 */
2789 add_number += S_GET_VALUE (add_symbolP);
2790 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2791 /* Lie. Don't want further pcrel processing. */
2794 /* Let the target machine make the final determination
2795 as to whether or not a relocation will be needed to
2796 handle this fixup. */
2797 if (!TC_FORCE_RELOCATION (fixP))
2800 fixP->fx_addsy = NULL;
2805 if (add_symbol_segment == absolute_section
2809 /* See comment about reloc_callj() above. */
2811 #endif /* TC_I960 */
2812 add_number += S_GET_VALUE (add_symbolP);
2814 /* Let the target machine make the final determination
2815 as to whether or not a relocation will be needed to
2816 handle this fixup. */
2818 if (!TC_FORCE_RELOCATION (fixP))
2820 fixP->fx_addsy = NULL;
2824 else if (add_symbol_segment == undefined_section
2825 #ifdef BFD_ASSEMBLER
2826 || bfd_is_com_section (add_symbol_segment)
2831 if ((int) fixP->fx_bit_fixP == 13)
2833 /* This is a COBR instruction. They have only a
2834 13-bit displacement and are only to be used
2835 for local branches: flag as error, don't generate
2837 as_bad_where (fixP->fx_file, fixP->fx_line,
2838 _("can't use COBR format with external label"));
2839 fixP->fx_addsy = NULL;
2843 #endif /* TC_I960 */
2847 if (S_IS_COMMON (add_symbolP))
2848 add_number += S_GET_VALUE (add_symbolP);
2849 #endif /* TE_I386AIX */
2850 #endif /* OBJ_COFF */
2856 if (TC_FIX_ADJUSTABLE (fixP))
2857 add_number += S_GET_VALUE (add_symbolP);
2864 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2865 if (add_symbolP == 0)
2867 #ifndef BFD_ASSEMBLER
2868 fixP->fx_addsy = &abs_symbol;
2870 fixP->fx_addsy = section_symbol (absolute_section);
2872 symbol_mark_used_in_reloc (fixP->fx_addsy);
2878 md_apply_fix3 (fixP, & add_number, this_segment_type);
2880 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2882 if ((size_t) size < sizeof (valueT))
2887 mask--; /* Set all bits to one. */
2888 mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
2889 if ((add_number & mask) != 0 && (add_number & mask) != mask)
2891 char buf[50], buf2[50];
2892 sprint_value (buf, fragP->fr_address + where);
2893 if (add_number > 1000)
2894 sprint_value (buf2, add_number);
2896 sprintf (buf2, "%ld", (long) add_number);
2897 as_bad_where (fixP->fx_file, fixP->fx_line,
2898 _("value of %s too large for field of %d bytes at %s"),
2900 } /* Generic error checking. */
2902 #ifdef WARN_SIGNED_OVERFLOW_WORD
2903 /* Warn if a .word value is too large when treated as a signed
2904 number. We already know it is not too negative. This is to
2905 catch over-large switches generated by gcc on the 68k. */
2906 if (!flag_signed_overflow_ok
2908 && add_number > 0x7fff)
2909 as_bad_where (fixP->fx_file, fixP->fx_line,
2910 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2912 (unsigned long) (fragP->fr_address + where));
2914 } /* Not a bit fix. */
2916 #ifdef TC_VALIDATE_FIX
2917 skip: ATTRIBUTE_UNUSED_LABEL
2921 fprintf (stderr, "result:\n");
2924 } /* For each fixS in this segment. */
2926 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2927 return seg_reloc_count;
2930 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2933 number_to_chars_bigendian (buf, val, n)
2942 buf[n] = val & 0xff;
2948 number_to_chars_littleendian (buf, val, n)
2957 *buf++ = val & 0xff;
2963 write_print_statistics (file)
2966 fprintf (file, "fixups: %d\n", n_fixups);
2969 /* For debugging. */
2970 extern int indent_level;
2977 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2979 fprintf (stderr, " pcrel");
2980 if (fixp->fx_pcrel_adjust)
2981 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2982 if (fixp->fx_im_disp)
2985 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2987 fprintf (stderr, " im_disp");
2991 fprintf (stderr, " tcbit");
2993 fprintf (stderr, " done");
2994 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2995 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2996 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2997 #ifdef BFD_ASSEMBLER
2998 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3001 #ifdef NEED_FX_R_TYPE
3002 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
3007 fprintf (stderr, "\n +<");
3008 print_symbol_value_1 (stderr, fixp->fx_addsy);
3009 fprintf (stderr, ">");
3013 fprintf (stderr, "\n -<");
3014 print_symbol_value_1 (stderr, fixp->fx_subsy);
3015 fprintf (stderr, ">");
3017 fprintf (stderr, "\n");
3018 #ifdef TC_FIX_DATA_PRINT
3019 TC_FIX_DATA_PRINT (stderr, fixp);