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
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 #ifndef TC_ADJUST_RELOC_COUNT
32 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
35 #ifndef TC_FORCE_RELOCATION
36 #define TC_FORCE_RELOCATION(FIX) \
37 (generic_force_reloc (FIX))
40 #ifndef TC_FORCE_RELOCATION_ABS
41 #define TC_FORCE_RELOCATION_ABS(FIX) \
42 (TC_FORCE_RELOCATION (FIX))
45 #ifndef TC_FORCE_RELOCATION_LOCAL
46 #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) \
54 (! SEG_NORMAL (SEG) || TC_FORCE_RELOCATION (FIX))
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX) 0
61 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 0
65 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 1
69 #ifndef TC_VALIDATE_FIX_SUB
70 #ifdef UNDEFINED_DIFFERENCE_OK
71 /* The PA needs this for PIC code generation. */
72 #define TC_VALIDATE_FIX_SUB(FIX) 1
75 #define TC_VALIDATE_FIX_SUB(FIX) \
76 ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
77 || (FIX)->fx_r_type == BFD_RELOC_GPREL16)
79 #define TC_VALIDATE_FIX_SUB(FIX) 0
84 #ifndef TC_LINKRELAX_FIXUP
85 #define TC_LINKRELAX_FIXUP(SEG) 1
88 #ifndef MD_APPLY_SYM_VALUE
89 #define MD_APPLY_SYM_VALUE(FIX) 1
92 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
93 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
96 #ifndef MD_PCREL_FROM_SECTION
97 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #ifndef WORKING_DOT_WORD
101 extern const int md_short_jump_size;
102 extern const int md_long_jump_size;
105 /* Used to control final evaluation of expressions. */
106 int finalize_syms = 0;
108 int symbol_table_frozen;
110 symbolS *abs_section_sym;
112 /* Remember the value of dot when parsing expressions. */
115 void print_fixup PARAMS ((fixS *));
118 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
120 /* We generally attach relocs to frag chains. However, after we have
121 chained these all together into a segment, any relocs we add after
122 that must be attached to a segment. This will include relocs added
123 in md_estimate_size_for_relax, for example. */
124 static int frags_chained = 0;
127 #ifndef BFD_ASSEMBLER
129 #ifndef MANY_SEGMENTS
130 struct frag *text_frag_root;
131 struct frag *data_frag_root;
132 struct frag *bss_frag_root;
134 struct frag *text_last_frag; /* Last frag in segment. */
135 struct frag *data_last_frag; /* Last frag in segment. */
136 static struct frag *bss_last_frag; /* Last frag in segment. */
140 static object_headers headers;
143 long string_byte_count;
144 char *next_object_file_charP; /* Tracks object file bytes. */
147 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
150 #endif /* BFD_ASSEMBLER */
155 #define RELOC_ENUM enum bfd_reloc_code_real
157 #define RELOC_ENUM int
160 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
161 symbolS *add, symbolS *sub,
162 offsetT offset, int pcrel,
164 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
165 static long fixup_segment PARAMS ((fixS *, segT));
167 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
168 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
169 static fragS *chain_frchains_together_1 PARAMS ((segT, struct frchain *));
172 static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
173 static void cvt_frag_to_fill PARAMS ((segT, fragS *));
174 static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
175 static void fix_segment PARAMS ((bfd *, asection *, PTR));
176 static void write_relocs PARAMS ((bfd *, asection *, PTR));
177 static void write_contents PARAMS ((bfd *, asection *, PTR));
178 static void set_symtab PARAMS ((void));
180 #if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
181 static void merge_data_into_text PARAMS ((void));
183 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
184 static void cvt_frag_to_fill PARAMS ((object_headers *, segT, fragS *));
185 static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
186 static void relax_and_size_all_segments PARAMS ((void));
189 /* Create a fixS in obstack 'notes'. */
192 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
194 fragS *frag; /* Which frag? */
195 int where; /* Where in that frag? */
196 int size; /* 1, 2, or 4 usually. */
197 symbolS *add_symbol; /* X_add_symbol. */
198 symbolS *sub_symbol; /* X_op_symbol. */
199 offsetT offset; /* X_add_number. */
200 int pcrel; /* TRUE if PC-relative relocation. */
201 RELOC_ENUM r_type ATTRIBUTE_UNUSED; /* Relocation type. */
207 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
209 fixP->fx_frag = frag;
210 fixP->fx_where = where;
211 fixP->fx_size = size;
212 /* We've made fx_size a narrow field; check that it's wide enough. */
213 if (fixP->fx_size != size)
215 as_bad (_("field fx_size too small to hold %d"), size);
218 fixP->fx_addsy = add_symbol;
219 fixP->fx_subsy = sub_symbol;
220 fixP->fx_offset = offset;
221 fixP->fx_dot_value = dot_value;
222 fixP->fx_pcrel = pcrel;
224 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
225 fixP->fx_r_type = r_type;
227 fixP->fx_im_disp = 0;
228 fixP->fx_pcrel_adjust = 0;
229 fixP->fx_bit_fixP = 0;
230 fixP->fx_addnumber = 0;
233 fixP->fx_no_overflow = 0;
237 fixP->fx_cgen.insn = NULL;
238 fixP->fx_cgen.opinfo = 0;
242 TC_INIT_FIX_DATA (fixP);
245 as_where (&fixP->fx_file, &fixP->fx_line);
247 /* Usually, we want relocs sorted numerically, but while
248 comparing to older versions of gas that have relocs
249 reverse sorted, it is convenient to have this compile
250 time option. xoxorich. */
254 fixS **seg_fix_rootP = (frags_chained
255 ? &seg_info (now_seg)->fix_root
256 : &frchain_now->fix_root);
257 fixS **seg_fix_tailP = (frags_chained
258 ? &seg_info (now_seg)->fix_tail
259 : &frchain_now->fix_tail);
262 #ifdef REVERSE_SORT_RELOCS
264 fixP->fx_next = *seg_fix_rootP;
265 *seg_fix_rootP = fixP;
267 #else /* REVERSE_SORT_RELOCS */
269 fixP->fx_next = NULL;
272 (*seg_fix_tailP)->fx_next = fixP;
274 *seg_fix_rootP = fixP;
275 *seg_fix_tailP = fixP;
277 #endif /* REVERSE_SORT_RELOCS */
283 /* Create a fixup relative to a symbol (plus a constant). */
286 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
287 fragS *frag; /* Which frag? */
288 int where; /* Where in that frag? */
289 int size; /* 1, 2, or 4 usually. */
290 symbolS *add_symbol; /* X_add_symbol. */
291 offsetT offset; /* X_add_number. */
292 int pcrel; /* TRUE if PC-relative relocation. */
293 RELOC_ENUM r_type; /* Relocation type. */
295 return fix_new_internal (frag, where, size, add_symbol,
296 (symbolS *) NULL, offset, pcrel, r_type);
299 /* Create a fixup for an expression. Currently we only support fixups
300 for difference expressions. That is itself more than most object
301 file formats support anyhow. */
304 fix_new_exp (frag, where, size, exp, pcrel, r_type)
305 fragS *frag; /* Which frag? */
306 int where; /* Where in that frag? */
307 int size; /* 1, 2, or 4 usually. */
308 expressionS *exp; /* Expression. */
309 int pcrel; /* TRUE if PC-relative relocation. */
310 RELOC_ENUM r_type; /* Relocation type. */
322 as_bad (_("register value used as expression"));
326 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
327 the difference expression cannot immediately be reduced. */
329 symbolS *stmp = make_expr_symbol (exp);
331 exp->X_op = O_symbol;
332 exp->X_op_symbol = 0;
333 exp->X_add_symbol = stmp;
334 exp->X_add_number = 0;
336 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
340 add = exp->X_add_symbol;
341 off = exp->X_add_number;
343 #if defined(BFD_ASSEMBLER)
344 r_type = BFD_RELOC_RVA;
346 #if defined(TC_RVA_RELOC)
347 r_type = TC_RVA_RELOC;
349 as_fatal (_("rva not supported"));
355 sub = exp->X_add_symbol;
356 off = exp->X_add_number;
360 sub = exp->X_op_symbol;
363 add = exp->X_add_symbol;
366 off = exp->X_add_number;
370 add = make_expr_symbol (exp);
374 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
377 /* Generic function to determine whether a fixup requires a relocation. */
379 generic_force_reloc (fix)
383 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
384 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
387 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
390 /* Append a string onto another string, bumping the pointer along. */
392 append (charPP, fromP, length)
395 unsigned long length;
397 /* Don't trust memcpy() of 0 chars. */
401 memcpy (*charPP, fromP, length);
405 #ifndef BFD_ASSEMBLER
406 int section_alignment[SEG_MAXIMUM_ORDINAL];
409 /* This routine records the largest alignment seen for each segment.
410 If the beginning of the segment is aligned on the worst-case
411 boundary, all of the other alignments within it will work. At
412 least one object format really uses this info. */
415 record_alignment (seg, align)
416 /* Segment to which alignment pertains. */
418 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
422 if (seg == absolute_section)
425 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
426 bfd_set_section_alignment (stdoutput, seg, align);
428 if (align > section_alignment[(int) seg])
429 section_alignment[(int) seg] = align;
434 get_recorded_alignment (seg)
437 if (seg == absolute_section)
440 return bfd_get_section_alignment (stdoutput, seg);
442 return section_alignment[(int) seg];
448 /* Reset the section indices after removing the gas created sections. */
451 renumber_sections (abfd, sec, countparg)
452 bfd *abfd ATTRIBUTE_UNUSED;
456 int *countp = (int *) countparg;
458 sec->index = *countp;
462 #endif /* defined (BFD_ASSEMBLER) */
464 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
467 chain_frchains_together_1 (section, frchp)
469 struct frchain *frchp;
471 fragS dummy, *prev_frag = &dummy;
473 fixS fix_dummy, *prev_fix = &fix_dummy;
476 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
478 prev_frag->fr_next = frchp->frch_root;
479 prev_frag = frchp->frch_last;
480 assert (prev_frag->fr_type != 0);
482 if (frchp->fix_root != (fixS *) NULL)
484 if (seg_info (section)->fix_root == (fixS *) NULL)
485 seg_info (section)->fix_root = frchp->fix_root;
486 prev_fix->fx_next = frchp->fix_root;
487 seg_info (section)->fix_tail = frchp->fix_tail;
488 prev_fix = frchp->fix_tail;
492 assert (prev_frag->fr_type != 0);
493 prev_frag->fr_next = 0;
502 chain_frchains_together (abfd, section, xxx)
503 bfd *abfd ATTRIBUTE_UNUSED;
505 PTR xxx ATTRIBUTE_UNUSED;
507 segment_info_type *info;
509 /* BFD may have introduced its own sections without using
510 subseg_new, so it is possible that seg_info is NULL. */
511 info = seg_info (section);
512 if (info != (segment_info_type *) NULL)
513 info->frchainP->frch_last
514 = chain_frchains_together_1 (section, info->frchainP);
516 /* Now that we've chained the frags together, we must add new fixups
517 to the segment, not to the frag chain. */
523 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
526 remove_subsegs (head, seg, root, last)
532 *root = head->frch_root;
533 *last = chain_frchains_together_1 (seg, head);
538 #if defined (BFD_ASSEMBLER) || !defined (BFD)
542 cvt_frag_to_fill (sec, fragP)
543 segT sec ATTRIBUTE_UNUSED;
547 cvt_frag_to_fill (headersP, sec, fragP)
548 object_headers *headersP;
553 switch (fragP->fr_type)
561 HANDLE_ALIGN (fragP);
563 know (fragP->fr_next != NULL);
564 fragP->fr_offset = (fragP->fr_next->fr_address
566 - fragP->fr_fix) / fragP->fr_var;
567 if (fragP->fr_offset < 0)
569 as_bad_where (fragP->fr_file, fragP->fr_line,
570 _("attempt to .org/.space backwards? (%ld)"),
571 (long) fragP->fr_offset);
572 fragP->fr_offset = 0;
574 fragP->fr_type = rs_fill;
582 valueT value = S_GET_VALUE (fragP->fr_symbol);
585 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
588 fragP->fr_fix += size;
589 fragP->fr_type = rs_fill;
591 fragP->fr_offset = 0;
592 fragP->fr_symbol = NULL;
597 eh_frame_convert_frag (fragP);
601 dwarf2dbg_convert_frag (fragP);
604 case rs_machine_dependent:
606 md_convert_frag (stdoutput, sec, fragP);
608 md_convert_frag (headersP, sec, fragP);
611 assert (fragP->fr_next == NULL
612 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
615 /* After md_convert_frag, we make the frag into a ".space 0".
616 md_convert_frag() should set up any fixSs and constants
621 #ifndef WORKING_DOT_WORD
624 struct broken_word *lie;
626 if (fragP->fr_subtype)
628 fragP->fr_fix += md_short_jump_size;
629 for (lie = (struct broken_word *) (fragP->fr_symbol);
630 lie && lie->dispfrag == fragP;
631 lie = lie->next_broken_word)
633 fragP->fr_fix += md_long_jump_size;
641 BAD_CASE (fragP->fr_type);
646 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
649 static void relax_seg PARAMS ((bfd *, asection *, PTR));
651 relax_seg (abfd, sec, xxx)
652 bfd *abfd ATTRIBUTE_UNUSED;
656 segment_info_type *seginfo = seg_info (sec);
658 if (seginfo && seginfo->frchainP
659 && relax_segment (seginfo->frchainP->frch_root, sec))
661 int *result = (int *) xxx;
666 static void size_seg PARAMS ((bfd *, asection *, PTR));
668 size_seg (abfd, sec, xxx)
671 PTR xxx ATTRIBUTE_UNUSED;
675 segment_info_type *seginfo;
677 valueT size, newsize;
679 subseg_change (sec, 0);
681 seginfo = seg_info (sec);
682 if (seginfo && seginfo->frchainP)
684 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
685 cvt_frag_to_fill (sec, fragp);
686 for (fragp = seginfo->frchainP->frch_root;
688 fragp = fragp->fr_next)
689 /* Walk to last elt. */
691 size = fragp->fr_address + fragp->fr_fix;
696 flags = bfd_get_section_flags (abfd, sec);
698 if (size > 0 && ! seginfo->bss)
699 flags |= SEC_HAS_CONTENTS;
701 /* @@ This is just an approximation. */
702 if (seginfo && seginfo->fix_root)
706 x = bfd_set_section_flags (abfd, sec, flags);
709 newsize = md_section_align (sec, size);
710 x = bfd_set_section_size (abfd, sec, newsize);
713 /* If the size had to be rounded up, add some padding in the last
715 assert (newsize >= size);
718 fragS *last = seginfo->frchainP->frch_last;
719 fragp = seginfo->frchainP->frch_root;
720 while (fragp->fr_next != last)
721 fragp = fragp->fr_next;
722 last->fr_address = size;
723 if ((newsize - size) % fragp->fr_var == 0)
724 fragp->fr_offset += (newsize - size) / fragp->fr_var;
726 /* If we hit this abort, it's likely due to subsegs_finish not
727 providing sufficient alignment on the last frag, and the
728 machine dependent code using alignment frags with fr_var
733 #ifdef tc_frob_section
734 tc_frob_section (sec);
736 #ifdef obj_frob_section
737 obj_frob_section (sec);
743 dump_section_relocs (abfd, sec, stream_)
744 bfd *abfd ATTRIBUTE_UNUSED;
748 FILE *stream = (FILE *) stream_;
749 segment_info_type *seginfo = seg_info (sec);
750 fixS *fixp = seginfo->fix_root;
755 fprintf (stream, "sec %s relocs:\n", sec->name);
758 symbolS *s = fixp->fx_addsy;
760 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
761 (int) fixp->fx_r_type);
763 fprintf (stream, "no sym\n");
766 print_symbol_value_1 (stream, s);
767 fprintf (stream, "\n");
769 fixp = fixp->fx_next;
773 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
776 #ifndef EMIT_SECTION_SYMBOLS
777 #define EMIT_SECTION_SYMBOLS 1
780 /* This pass over fixups decides whether symbols can be replaced with
784 adjust_reloc_syms (abfd, sec, xxx)
785 bfd *abfd ATTRIBUTE_UNUSED;
787 PTR xxx ATTRIBUTE_UNUSED;
789 segment_info_type *seginfo = seg_info (sec);
795 dump_section_relocs (abfd, sec, stderr);
797 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
801 else if (fixp->fx_addsy)
807 fprintf (stderr, "\n\nadjusting fixup:\n");
811 sym = fixp->fx_addsy;
813 /* All symbols should have already been resolved at this
814 point. It is possible to see unresolved expression
815 symbols, though, since they are not in the regular symbol
817 resolve_symbol_value (sym);
819 if (fixp->fx_subsy != NULL)
820 resolve_symbol_value (fixp->fx_subsy);
822 /* If this symbol is equated to an undefined symbol, convert
823 the fixup to being against that symbol. */
824 if (symbol_equated_reloc_p (sym))
826 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
827 sym = symbol_get_value_expression (sym)->X_add_symbol;
828 fixp->fx_addsy = sym;
831 if (symbol_mri_common_p (sym))
833 /* These symbols are handled specially in fixup_segment. */
837 /* If the symbol is undefined, common, weak, or global (ELF
838 shared libs), we can't replace it with the section symbol. */
839 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
842 /* Is there some other (target cpu dependent) reason we can't adjust
843 this one? (E.g. relocations involving function addresses on
845 #ifdef tc_fix_adjustable
846 if (! tc_fix_adjustable (fixp))
850 /* Since we're reducing to section symbols, don't attempt to reduce
851 anything that's already using one. */
852 if (symbol_section_p (sym))
855 symsec = S_GET_SEGMENT (sym);
859 if (bfd_is_abs_section (symsec))
861 /* The fixup_segment routine normally will not use this
862 symbol in a relocation. */
866 /* Don't try to reduce relocs which refer to non-local symbols
867 in .linkonce sections. It can lead to confusion when a
868 debugging section refers to a .linkonce section. I hope
869 this will always be correct. */
870 if (symsec != sec && ! S_IS_LOCAL (sym))
872 if ((symsec->flags & SEC_LINK_ONCE) != 0
874 /* The GNU toolchain uses an extension for ELF: a
875 section beginning with the magic string
876 .gnu.linkonce is a linkonce section. */
877 && strncmp (segment_name (symsec), ".gnu.linkonce",
878 sizeof ".gnu.linkonce" - 1) == 0))
882 /* Never adjust a reloc against local symbol in a merge section
883 with non-zero addend. */
884 if ((symsec->flags & SEC_MERGE) != 0
885 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
888 /* Never adjust a reloc against TLS local symbol. */
889 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
892 /* We refetch the segment when calling section_symbol, rather
893 than using symsec, because S_GET_VALUE may wind up changing
894 the section when it calls resolve_symbol_value. */
895 fixp->fx_offset += S_GET_VALUE (sym);
896 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
898 fprintf (stderr, "\nadjusted fixup:\n");
903 dump_section_relocs (abfd, sec, stderr);
907 fix_segment (abfd, sec, xxx)
908 bfd *abfd ATTRIBUTE_UNUSED;
910 PTR xxx ATTRIBUTE_UNUSED;
912 segment_info_type *seginfo = seg_info (sec);
914 fixup_segment (seginfo->fix_root, sec);
918 write_relocs (abfd, sec, xxx)
921 PTR xxx ATTRIBUTE_UNUSED;
923 segment_info_type *seginfo = seg_info (sec);
930 /* If seginfo is NULL, we did not create this section; don't do
936 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
939 #ifndef RELOC_EXPANSION_POSSIBLE
940 /* Set up reloc information as well. */
941 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
942 memset ((char *) relocs, 0, n * sizeof (arelent *));
945 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
948 bfd_reloc_status_type s;
957 /* If this is an undefined symbol which was equated to another
958 symbol, then generate the reloc against the latter symbol
959 rather than the former. */
960 sym = fixp->fx_addsy;
961 while (symbol_equated_reloc_p (sym))
965 /* We must avoid looping, as that can occur with a badly
967 n = symbol_get_value_expression (sym)->X_add_symbol;
970 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
973 fixp->fx_addsy = sym;
975 reloc = tc_gen_reloc (sec, fixp);
983 /* This test is triggered inappropriately for the SH. */
984 if (fixp->fx_where + fixp->fx_size
985 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
989 s = bfd_install_relocation (stdoutput, reloc,
990 fixp->fx_frag->fr_literal,
991 fixp->fx_frag->fr_address,
997 case bfd_reloc_overflow:
998 as_bad_where (fixp->fx_file, fixp->fx_line,
999 _("relocation overflow"));
1001 case bfd_reloc_outofrange:
1002 as_bad_where (fixp->fx_file, fixp->fx_line,
1003 _("relocation out of range"));
1006 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1007 fixp->fx_file, fixp->fx_line, s);
1009 relocs[i++] = reloc;
1012 n = n * MAX_RELOC_EXPANSION;
1013 /* Set up reloc information as well. */
1014 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1017 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1021 bfd_reloc_status_type s;
1031 /* If this is an undefined symbol which was equated to another
1032 symbol, then generate the reloc against the latter symbol
1033 rather than the former. */
1034 sym = fixp->fx_addsy;
1035 while (symbol_equated_reloc_p (sym))
1039 /* We must avoid looping, as that can occur with a badly
1041 n = symbol_get_value_expression (sym)->X_add_symbol;
1044 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
1047 fixp->fx_addsy = sym;
1049 reloc = tc_gen_reloc (sec, fixp);
1051 for (j = 0; reloc[j]; j++)
1053 relocs[i++] = reloc[j];
1056 data = fixp->fx_frag->fr_literal + fixp->fx_where;
1057 if (fixp->fx_where + fixp->fx_size
1058 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1059 as_bad_where (fixp->fx_file, fixp->fx_line,
1060 _("internal error: fixup not contained within frag"));
1061 for (j = 0; reloc[j]; j++)
1063 s = bfd_install_relocation (stdoutput, reloc[j],
1064 fixp->fx_frag->fr_literal,
1065 fixp->fx_frag->fr_address,
1071 case bfd_reloc_overflow:
1072 as_bad_where (fixp->fx_file, fixp->fx_line,
1073 _("relocation overflow"));
1075 case bfd_reloc_outofrange:
1076 as_bad_where (fixp->fx_file, fixp->fx_line,
1077 _("relocation out of range"));
1080 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1081 fixp->fx_file, fixp->fx_line, s);
1092 sympp = bfd_get_outsymbols (stdoutput);
1093 nsyms = bfd_get_symcount (stdoutput);
1094 for (i = 0; i < n; i++)
1095 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1097 for (j = 0; j < nsyms; j++)
1098 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1107 bfd_set_reloc (stdoutput, sec, relocs, n);
1109 bfd_set_section_flags (abfd, sec,
1110 (bfd_get_section_flags (abfd, sec)
1111 & (flagword) ~SEC_RELOC));
1113 #ifdef SET_SECTION_RELOCS
1114 SET_SECTION_RELOCS (sec, relocs, n);
1122 fprintf (stderr, "relocs for sec %s\n", sec->name);
1123 for (i = 0; i < n; i++)
1126 s = *r->sym_ptr_ptr;
1127 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1128 i, r, r->address, s->name, r->addend);
1135 write_contents (abfd, sec, xxx)
1136 bfd *abfd ATTRIBUTE_UNUSED;
1138 PTR xxx ATTRIBUTE_UNUSED;
1140 segment_info_type *seginfo = seg_info (sec);
1141 unsigned long offset = 0;
1144 /* Write out the frags. */
1146 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1149 for (f = seginfo->frchainP->frch_root;
1154 unsigned long fill_size;
1158 assert (f->fr_type == rs_fill);
1161 x = bfd_set_section_contents (stdoutput, sec,
1162 f->fr_literal, (file_ptr) offset,
1163 (bfd_size_type) f->fr_fix);
1166 bfd_perror (stdoutput->filename);
1167 as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1168 exit (EXIT_FAILURE);
1170 offset += f->fr_fix;
1172 fill_literal = f->fr_literal + f->fr_fix;
1173 fill_size = f->fr_var;
1174 count = f->fr_offset;
1175 assert (count >= 0);
1176 if (fill_size && count)
1179 if (fill_size > sizeof (buf))
1181 /* Do it the old way. Can this ever happen? */
1184 x = bfd_set_section_contents (stdoutput, sec,
1187 (bfd_size_type) fill_size);
1190 bfd_perror (stdoutput->filename);
1191 as_perror (_("FATAL: Can't write %s"),
1192 stdoutput->filename);
1193 exit (EXIT_FAILURE);
1195 offset += fill_size;
1200 /* Build a buffer full of fill objects and output it as
1201 often as necessary. This saves on the overhead of
1202 potentially lots of bfd_set_section_contents calls. */
1206 n_per_buf = sizeof (buf);
1207 memset (buf, *fill_literal, n_per_buf);
1212 n_per_buf = sizeof (buf) / fill_size;
1213 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1214 memcpy (bufp, fill_literal, fill_size);
1216 for (; count > 0; count -= n_per_buf)
1218 n_per_buf = n_per_buf > count ? count : n_per_buf;
1219 x = bfd_set_section_contents
1220 (stdoutput, sec, buf, (file_ptr) offset,
1221 (bfd_size_type) n_per_buf * fill_size);
1223 as_fatal (_("cannot write to output file"));
1224 offset += n_per_buf * fill_size;
1232 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1234 merge_data_into_text ()
1236 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1237 seg_info (text_section)->frchainP->frch_last->fr_next =
1238 seg_info (data_section)->frchainP->frch_root;
1239 seg_info (text_section)->frchainP->frch_last =
1240 seg_info (data_section)->frchainP->frch_last;
1241 seg_info (data_section)->frchainP = 0;
1245 text_last_frag->fr_next = data_frag_root;
1246 text_last_frag = data_last_frag;
1247 data_last_frag = NULL;
1248 data_frag_root = NULL;
1251 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1252 tmp->fx_next = data_fix_root;
1253 text_fix_tail = data_fix_tail;
1256 text_fix_root = data_fix_root;
1257 data_fix_root = NULL;
1260 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1262 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1264 relax_and_size_all_segments ()
1268 relax_segment (text_frag_root, SEG_TEXT);
1269 relax_segment (data_frag_root, SEG_DATA);
1270 relax_segment (bss_frag_root, SEG_BSS);
1272 /* Now the addresses of frags are correct within the segment. */
1273 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1274 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1275 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1277 /* Join the 2 segments into 1 huge segment.
1278 To do this, re-compute every rn_address in the SEG_DATA frags.
1279 Then join the data frags after the text frags.
1281 Determine a_data [length of data segment]. */
1284 register relax_addressT slide;
1286 know ((text_last_frag->fr_type == rs_fill)
1287 && (text_last_frag->fr_offset == 0));
1289 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1290 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1291 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1293 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1294 /* For b.out: If the data section has a strict alignment
1295 requirement, its load address in the .o file will be
1296 rounded up from the size of the text section. These
1297 two values are *not* the same! Similarly for the bss
1299 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1302 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1303 fragP->fr_address += slide;
1305 know (text_last_frag != 0);
1306 text_last_frag->fr_next = data_frag_root;
1310 H_SET_DATA_SIZE (&headers, 0);
1314 /* See above comments on b.out data section address. */
1317 if (data_last_frag == 0)
1318 bss_vma = H_GET_TEXT_SIZE (&headers);
1320 bss_vma = data_last_frag->fr_address;
1321 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1322 bss_address_frag.fr_address = bss_vma;
1324 #else /* ! OBJ_BOUT */
1325 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1326 H_GET_DATA_SIZE (&headers));
1328 #endif /* ! OBJ_BOUT */
1330 /* Slide all the frags. */
1333 relax_addressT slide = bss_address_frag.fr_address;
1335 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1336 fragP->fr_address += slide;
1340 H_SET_BSS_SIZE (&headers,
1341 bss_last_frag->fr_address - bss_frag_root->fr_address);
1343 H_SET_BSS_SIZE (&headers, 0);
1345 #endif /* ! BFD_ASSEMBLER && ! BFD */
1347 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1349 #ifdef BFD_ASSEMBLER
1357 extern PTR bfd_alloc PARAMS ((bfd *, bfd_size_type));
1359 /* Count symbols. We can't rely on a count made by the loop in
1360 write_object_file, because *_frob_file may add a new symbol or
1363 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1369 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1371 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1372 symp = symbol_rootP;
1373 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1375 asympp[i] = symbol_get_bfdsym (symp);
1376 symbol_mark_written (symp);
1381 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1383 symbol_table_frozen = 1;
1387 /* Finish the subsegments. After every sub-segment, we fake an
1388 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1389 ".fill 0" because that is the kind of frag that requires least
1390 thought. ".align" frags like to have a following frag since that
1391 makes calculating their intended length trivial. */
1393 #ifndef SUB_SEGMENT_ALIGN
1395 /* The last subsegment gets an aligment corresponding to the alignment
1396 of the section. This allows proper nop-filling at the end of
1397 code-bearing sections. */
1398 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1399 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
1400 ? get_recorded_alignment (SEG) : 0)
1402 #ifdef BFD_ASSEMBLER
1403 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1405 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 2
1413 struct frchain *frchainP;
1415 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1419 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1421 /* This now gets called even if we had errors. In that case,
1422 any alignment is meaningless, and, moreover, will look weird
1423 if we are generating a listing. */
1426 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1427 #ifdef BFD_ASSEMBLER
1428 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1429 && now_seg->entsize)
1431 unsigned int entsize = now_seg->entsize;
1434 while ((entsize & 1) == 0)
1439 if (entalign > alignment)
1440 alignment = entalign;
1445 if (subseg_text_p (now_seg))
1446 frag_align_code (alignment, 0);
1448 frag_align (alignment, 0, 0);
1450 /* frag_align will have left a new frag.
1451 Use this last frag for an empty ".fill".
1453 For this segment ...
1454 Create a last frag. Do not leave a "being filled in frag". */
1455 frag_wane (frag_now);
1456 frag_now->fr_fix = 0;
1457 know (frag_now->fr_next == NULL);
1461 /* Write the object file. */
1464 write_object_file ()
1466 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1467 fragS *fragP; /* Track along all frags. */
1470 /* Do we really want to write it? */
1472 int n_warns, n_errs;
1473 n_warns = had_warnings ();
1474 n_errs = had_errors ();
1475 /* The -Z flag indicates that an object file should be generated,
1476 regardless of warnings and errors. */
1477 if (flag_always_generate_output)
1479 if (n_warns || n_errs)
1480 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1481 n_errs, n_errs == 1 ? "" : "s",
1482 n_warns, n_warns == 1 ? "" : "s");
1487 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1488 n_errs, n_errs == 1 ? "" : "s",
1489 n_warns, n_warns == 1 ? "" : "s");
1494 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1495 a routine to check for the definition of the procedure "_main",
1496 and if so -- fix it up so that it can be program entry point. */
1497 vms_check_for_main ();
1498 #endif /* OBJ_VMS */
1500 /* From now on, we don't care about sub-segments. Build one frag chain
1501 for each segment. Linked thru fr_next. */
1503 #ifdef BFD_ASSEMBLER
1504 /* Remove the sections created by gas for its own purposes. */
1509 seclist = &stdoutput->sections;
1512 if (*seclist == reg_section || *seclist == expr_section)
1514 bfd_section_list_remove (stdoutput, seclist);
1515 stdoutput->section_count--;
1518 seclist = &(*seclist)->next;
1521 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1524 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1526 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1527 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1528 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1531 /* We have two segments. If user gave -R flag, then we must put the
1532 data frags into the text segment. Do this before relaxing so
1533 we know to take advantage of -R and make shorter addresses. */
1534 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1535 if (flag_readonly_data_in_text)
1537 merge_data_into_text ();
1541 #ifdef BFD_ASSEMBLER
1546 #ifndef WORKING_DOT_WORD
1547 /* We need to reset the markers in the broken word list and
1548 associated frags between calls to relax_segment (via
1549 relax_seg). Since the broken word list is global, we do it
1550 once per round, rather than locally in relax_segment for each
1552 struct broken_word *brokp;
1554 for (brokp = broken_words;
1555 brokp != (struct broken_word *) NULL;
1556 brokp = brokp->next_broken_word)
1560 if (brokp->dispfrag != (fragS *) NULL
1561 && brokp->dispfrag->fr_type == rs_broken_word)
1562 brokp->dispfrag->fr_subtype = 0;
1567 bfd_map_over_sections (stdoutput, relax_seg, &changed);
1572 /* Note - Most ports will use the default value of
1573 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1574 local symbols to be resolved, removing their frag information.
1575 Some ports however, will not have finished relaxing all of
1576 their frags and will still need the local symbol frag
1577 information. These ports can set
1578 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1579 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1581 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1583 relax_and_size_all_segments ();
1584 #endif /* BFD_ASSEMBLER */
1586 /* Relaxation has completed. Freeze all syms. */
1589 #ifndef BFD_ASSEMBLER
1590 /* Crawl the symbol chain.
1592 For each symbol whose value depends on a frag, take the address of
1593 that frag and subsume it into the value of the symbol.
1594 After this, there is just one way to lookup a symbol value.
1595 Values are left in their final state for object file emission.
1596 We adjust the values of 'L' local symbols, even if we do
1597 not intend to emit them to the object file, because their values
1598 are needed for fix-ups.
1600 Unless we saw a -L flag, remove all symbols that begin with 'L'
1601 from the symbol chain. (They are still pointed to by the fixes.)
1603 Count the remaining symbols.
1604 Assign a symbol number to each symbol.
1605 Count the number of string-table chars we will emit.
1606 Put this info into the headers as appropriate. */
1607 know (zero_address_frag.fr_address == 0);
1608 string_byte_count = sizeof (string_byte_count);
1610 obj_crawl_symbol_chain (&headers);
1612 if (string_byte_count == sizeof (string_byte_count))
1613 string_byte_count = 0;
1615 H_SET_STRING_SIZE (&headers, string_byte_count);
1617 /* Addresses of frags now reflect addresses we use in the object file.
1618 Symbol values are correct.
1619 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1620 Also converting any machine-dependent frags using md_convert_frag(); */
1621 subseg_change (SEG_TEXT, 0);
1623 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1625 /* At this point we have linked all the frags into a single
1626 chain. However, cvt_frag_to_fill may call md_convert_frag
1627 which may call fix_new. We need to ensure that fix_new adds
1628 the fixup to the right section. */
1629 if (fragP == data_frag_root)
1630 subseg_change (SEG_DATA, 0);
1632 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1634 /* Some assert macros don't work with # directives mixed in. */
1636 if (!(fragP->fr_next == NULL
1638 || fragP->fr_next == data_frag_root
1640 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1641 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1645 #endif /* ! BFD_ASSEMBLER */
1647 #ifndef WORKING_DOT_WORD
1649 struct broken_word *lie;
1650 struct broken_word **prevP;
1652 prevP = &broken_words;
1653 for (lie = broken_words; lie; lie = lie->next_broken_word)
1658 subseg_change (lie->seg, lie->subseg);
1659 exp.X_op = O_subtract;
1660 exp.X_add_symbol = lie->add;
1661 exp.X_op_symbol = lie->sub;
1662 exp.X_add_number = lie->addnum;
1663 #ifdef BFD_ASSEMBLER
1664 #ifdef TC_CONS_FIX_NEW
1665 TC_CONS_FIX_NEW (lie->frag,
1666 lie->word_goes_here - lie->frag->fr_literal,
1669 fix_new_exp (lie->frag,
1670 lie->word_goes_here - lie->frag->fr_literal,
1671 2, &exp, 0, BFD_RELOC_16);
1674 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1675 fix_new_exp (lie->frag,
1676 lie->word_goes_here - lie->frag->fr_literal,
1677 2, &exp, 0, NO_RELOC);
1680 fix_new_ns32k_exp (lie->frag,
1681 lie->word_goes_here - lie->frag->fr_literal,
1682 2, &exp, 0, 0, 2, 0, 0);
1684 fix_new_exp (lie->frag,
1685 lie->word_goes_here - lie->frag->fr_literal,
1687 #endif /* TC_NS32K */
1688 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1689 #endif /* BFD_ASSEMBLER */
1690 *prevP = lie->next_broken_word;
1693 prevP = &(lie->next_broken_word);
1695 for (lie = broken_words; lie;)
1697 struct broken_word *untruth;
1699 addressT table_addr;
1700 addressT from_addr, to_addr;
1703 subseg_change (lie->seg, lie->subseg);
1704 fragP = lie->dispfrag;
1706 /* Find out how many broken_words go here. */
1709 untruth && untruth->dispfrag == fragP;
1710 untruth = untruth->next_broken_word)
1711 if (untruth->added == 1)
1714 table_ptr = lie->dispfrag->fr_opcode;
1715 table_addr = (lie->dispfrag->fr_address
1716 + (table_ptr - lie->dispfrag->fr_literal));
1717 /* Create the jump around the long jumps. This is a short
1718 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1719 from_addr = table_addr;
1720 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1721 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1723 table_ptr += md_short_jump_size;
1724 table_addr += md_short_jump_size;
1727 lie && lie->dispfrag == fragP;
1728 m++, lie = lie->next_broken_word)
1730 if (lie->added == 2)
1732 /* Patch the jump table. */
1733 /* This is the offset from ??? to table_ptr+0. */
1734 to_addr = table_addr - S_GET_VALUE (lie->sub);
1735 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1736 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1738 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1739 for (untruth = lie->next_broken_word;
1740 untruth && untruth->dispfrag == fragP;
1741 untruth = untruth->next_broken_word)
1743 if (untruth->use_jump == lie)
1744 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1747 /* Install the long jump. */
1748 /* This is a long jump from table_ptr+0 to the final target. */
1749 from_addr = table_addr;
1750 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1751 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1753 table_ptr += md_long_jump_size;
1754 table_addr += md_long_jump_size;
1758 #endif /* not WORKING_DOT_WORD */
1760 #ifndef BFD_ASSEMBLER
1763 char *the_object_file;
1764 long object_file_size;
1765 /* Scan every FixS performing fixups. We had to wait until now to
1766 do this because md_convert_frag() may have made some fixSs. */
1769 subseg_change (SEG_TEXT, 0);
1770 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1771 subseg_change (SEG_DATA, 0);
1772 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1773 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1775 /* FIXME: Move this stuff into the pre-write-hook. */
1776 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1777 H_SET_ENTRY_POINT (&headers, 0);
1779 obj_pre_write_hook (&headers); /* Extra coff stuff. */
1781 object_file_size = H_GET_FILE_SIZE (&headers);
1782 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1784 output_file_create (out_file_name);
1786 obj_header_append (&next_object_file_charP, &headers);
1788 know ((next_object_file_charP - the_object_file)
1789 == H_GET_HEADER_SIZE (&headers));
1792 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1794 register long count;
1795 register char *fill_literal;
1796 register long fill_size;
1799 know (fragP->fr_type == rs_fill);
1800 append (&next_object_file_charP, fragP->fr_literal,
1801 (unsigned long) fragP->fr_fix);
1802 fill_literal = fragP->fr_literal + fragP->fr_fix;
1803 fill_size = fragP->fr_var;
1804 know (fragP->fr_offset >= 0);
1806 for (count = fragP->fr_offset; count; count--)
1807 append (&next_object_file_charP, fill_literal,
1808 (unsigned long) fill_size);
1811 know ((next_object_file_charP - the_object_file)
1812 == (H_GET_HEADER_SIZE (&headers)
1813 + H_GET_TEXT_SIZE (&headers)
1814 + H_GET_DATA_SIZE (&headers)));
1816 /* Emit relocations. */
1817 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1818 (relax_addressT) 0);
1819 know ((next_object_file_charP - the_object_file)
1820 == (H_GET_HEADER_SIZE (&headers)
1821 + H_GET_TEXT_SIZE (&headers)
1822 + H_GET_DATA_SIZE (&headers)
1823 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
1825 /* Make addresses in data relocation directives relative to beginning of
1826 first data fragment, not end of last text fragment: alignment of the
1827 start of the data segment may place a gap between the segments. */
1828 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1829 data0_frchainP->frch_root->fr_address);
1831 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1832 text_last_frag->fr_address);
1833 #endif /* TC_I960 */
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)
1839 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1840 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1842 /* Emit line number entries. */
1843 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1844 know ((next_object_file_charP - the_object_file)
1845 == (H_GET_HEADER_SIZE (&headers)
1846 + H_GET_TEXT_SIZE (&headers)
1847 + H_GET_DATA_SIZE (&headers)
1848 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1849 + H_GET_DATA_RELOCATION_SIZE (&headers)
1850 + H_GET_LINENO_SIZE (&headers)));
1853 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1854 know ((next_object_file_charP - the_object_file)
1855 == (H_GET_HEADER_SIZE (&headers)
1856 + H_GET_TEXT_SIZE (&headers)
1857 + H_GET_DATA_SIZE (&headers)
1858 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1859 + H_GET_DATA_RELOCATION_SIZE (&headers)
1860 + H_GET_LINENO_SIZE (&headers)
1861 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1864 if (string_byte_count > 0)
1865 obj_emit_strings (&next_object_file_charP);
1868 bfd_seek (stdoutput, (file_ptr) 0, 0);
1869 bfd_bwrite (the_object_file, (bfd_size_type) object_file_size, stdoutput);
1872 /* Write the data to the file. */
1873 output_file_append (the_object_file, object_file_size, out_file_name);
1874 free (the_object_file);
1878 /* Now do the VMS-dependent part of writing the object file. */
1879 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1880 H_GET_DATA_SIZE (&headers),
1881 H_GET_BSS_SIZE (&headers),
1882 text_frag_root, data_frag_root);
1883 #endif /* OBJ_VMS */
1884 #else /* BFD_ASSEMBLER */
1886 /* Resolve symbol values. This needs to be done before processing
1892 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1893 resolve_symbol_value (symp);
1895 resolve_local_symbol_values ();
1899 #ifdef tc_frob_file_before_adjust
1900 tc_frob_file_before_adjust ();
1902 #ifdef obj_frob_file_before_adjust
1903 obj_frob_file_before_adjust ();
1906 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1908 #ifdef tc_frob_file_before_fix
1909 tc_frob_file_before_fix ();
1911 #ifdef obj_frob_file_before_fix
1912 obj_frob_file_before_fix ();
1915 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1917 /* Set up symbol table, and write it out. */
1922 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1927 if (symbol_mri_common_p (symp))
1929 if (S_IS_EXTERNAL (symp))
1930 as_bad (_("%s: global symbols not supported in common sections"),
1932 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1936 name = S_GET_NAME (symp);
1940 decode_local_label_name ((char *) S_GET_NAME (symp));
1941 /* They only differ if `name' is a fb or dollar local
1943 if (name2 != name && ! S_IS_DEFINED (symp))
1944 as_bad (_("local label `%s' is not defined"), name2);
1947 /* Do it again, because adjust_reloc_syms might introduce
1948 more symbols. They'll probably only be section symbols,
1949 but they'll still need to have the values computed. */
1950 resolve_symbol_value (symp);
1952 /* Skip symbols which were equated to undefined or common
1954 if (symbol_equated_reloc_p (symp))
1956 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1960 /* So far, common symbols have been treated like undefined symbols.
1961 Put them in the common section now. */
1962 if (S_IS_DEFINED (symp) == 0
1963 && S_GET_VALUE (symp) != 0)
1964 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1966 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1967 S_GET_NAME (symp), symp,
1969 symbol_get_bfdsym (symp)->flags,
1970 segment_name (S_GET_SEGMENT (symp)));
1973 #ifdef obj_frob_symbol
1974 obj_frob_symbol (symp, punt);
1976 #ifdef tc_frob_symbol
1977 if (! punt || symbol_used_in_reloc_p (symp))
1978 tc_frob_symbol (symp, punt);
1981 /* If we don't want to keep this symbol, splice it out of
1982 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1983 want section symbols. Otherwise, we skip local symbols
1984 and symbols that the frob_symbol macros told us to punt,
1985 but we keep such symbols if they are used in relocs. */
1986 if (symp == abs_section_sym
1987 || (! EMIT_SECTION_SYMBOLS
1988 && symbol_section_p (symp))
1989 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1990 opposites. Sometimes the former checks flags and the
1991 latter examines the name... */
1992 || (!S_IS_EXTERN (symp)
1993 && (punt || S_IS_LOCAL (symp))
1994 && ! symbol_used_in_reloc_p (symp)))
1996 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1998 /* After symbol_remove, symbol_next(symp) still returns
1999 the one that came after it in the chain. So we don't
2000 need to do any extra cleanup work here. */
2004 /* Make sure we really got a value for the symbol. */
2005 if (! symbol_resolved_p (symp))
2007 as_bad (_("can't resolve value for symbol `%s'"),
2009 symbol_mark_resolved (symp);
2012 /* Set the value into the BFD symbol. Up til now the value
2013 has only been kept in the gas symbolS struct. */
2014 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2020 /* Now do any format-specific adjustments to the symbol table, such
2021 as adding file symbols. */
2022 #ifdef tc_adjust_symtab
2023 tc_adjust_symtab ();
2025 #ifdef obj_adjust_symtab
2026 obj_adjust_symtab ();
2029 /* Now that all the sizes are known, and contents correct, we can
2030 start writing to the file. */
2033 /* If *_frob_file changes the symbol value at this point, it is
2034 responsible for moving the changed value into symp->bsym->value
2035 as well. Hopefully all symbol value changing can be done in
2040 #ifdef obj_frob_file
2044 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2046 #ifdef tc_frob_file_after_relocs
2047 tc_frob_file_after_relocs ();
2049 #ifdef obj_frob_file_after_relocs
2050 obj_frob_file_after_relocs ();
2053 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2054 #endif /* BFD_ASSEMBLER */
2058 #ifdef TC_GENERIC_RELAX_TABLE
2060 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2063 relax_frag (segment, fragP, stretch)
2068 const relax_typeS *this_type;
2069 const relax_typeS *start_type;
2070 relax_substateT next_state;
2071 relax_substateT this_state;
2077 const relax_typeS *table;
2079 target = fragP->fr_offset;
2080 address = fragP->fr_address;
2081 table = TC_GENERIC_RELAX_TABLE;
2082 this_state = fragP->fr_subtype;
2083 start_type = this_type = table + this_state;
2084 symbolP = fragP->fr_symbol;
2090 sym_frag = symbol_get_frag (symbolP);
2092 #ifndef DIFF_EXPR_OK
2093 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2094 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2095 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2096 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2097 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2099 know (sym_frag != NULL);
2101 know (S_GET_SEGMENT (symbolP) != absolute_section
2102 || sym_frag == &zero_address_frag);
2103 target += S_GET_VALUE (symbolP);
2105 /* If frag has yet to be reached on this pass,
2106 assume it will move by STRETCH just as we did.
2107 If this is not so, it will be because some frag
2108 between grows, and that will force another pass. */
2111 && sym_frag->relax_marker != fragP->relax_marker
2112 && S_GET_SEGMENT (symbolP) == segment)
2118 aim = target - address - fragP->fr_fix;
2119 #ifdef TC_PCREL_ADJUST
2120 /* Currently only the ns32k family needs this. */
2121 aim += TC_PCREL_ADJUST (fragP);
2123 /* This machine doesn't want to use pcrel_adjust.
2124 In that case, pcrel_adjust should be zero. */
2126 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
2129 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2130 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2135 /* Look backwards. */
2136 for (next_state = this_type->rlx_more; next_state;)
2137 if (aim >= this_type->rlx_backward)
2141 /* Grow to next state. */
2142 this_state = next_state;
2143 this_type = table + this_state;
2144 next_state = this_type->rlx_more;
2149 /* Look forwards. */
2150 for (next_state = this_type->rlx_more; next_state;)
2151 if (aim <= this_type->rlx_forward)
2155 /* Grow to next state. */
2156 this_state = next_state;
2157 this_type = table + this_state;
2158 next_state = this_type->rlx_more;
2162 growth = this_type->rlx_length - start_type->rlx_length;
2164 fragP->fr_subtype = this_state;
2168 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2170 /* Relax_align. Advance location counter to next address that has 'alignment'
2171 lowest order bits all 0s, return size of adjustment made. */
2172 static relax_addressT
2173 relax_align (address, alignment)
2174 register relax_addressT address; /* Address now. */
2175 register int alignment; /* Alignment (binary). */
2177 relax_addressT mask;
2178 relax_addressT new_address;
2180 mask = ~((~0) << alignment);
2181 new_address = (address + mask) & (~mask);
2182 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2184 /* We must provide lots of padding, so the linker can discard it
2185 when needed. The linker will not add extra space, ever. */
2186 new_address += (1 << alignment);
2188 return (new_address - address);
2191 /* Now we have a segment, not a crowd of sub-segments, we can make
2196 After this, all frags in this segment have addresses that are correct
2197 within the segment. Since segments live in different file addresses,
2198 these frag addresses may not be the same as final object-file
2202 relax_segment (segment_frag_root, segment)
2203 struct frag *segment_frag_root;
2206 register struct frag *fragP;
2207 register relax_addressT address;
2210 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2211 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2213 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2214 subseg_change (segment, 0);
2216 /* For each frag in segment: count and store (a 1st guess of)
2219 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2221 fragP->relax_marker = 0;
2222 fragP->fr_address = address;
2223 address += fragP->fr_fix;
2225 switch (fragP->fr_type)
2228 address += fragP->fr_offset * fragP->fr_var;
2235 addressT offset = relax_align (address, (int) fragP->fr_offset);
2237 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2240 if (offset % fragP->fr_var != 0)
2242 as_bad_where (fragP->fr_file, fragP->fr_line,
2243 _("alignment padding (%lu bytes) not a multiple of %ld"),
2244 (unsigned long) offset, (long) fragP->fr_var);
2245 offset -= (offset % fragP->fr_var);
2254 /* Assume .org is nugatory. It will grow with 1st relax. */
2257 case rs_machine_dependent:
2258 /* If fr_symbol is an expression, this call to
2259 resolve_symbol_value sets up the correct segment, which will
2260 likely be needed in md_estimate_size_before_relax. */
2261 if (fragP->fr_symbol)
2262 resolve_symbol_value (fragP->fr_symbol);
2264 address += md_estimate_size_before_relax (fragP, segment);
2267 #ifndef WORKING_DOT_WORD
2268 /* Broken words don't concern us yet. */
2269 case rs_broken_word:
2274 /* Initial guess is always 1; doing otherwise can result in
2275 stable solutions that are larger than the minimum. */
2276 address += fragP->fr_offset = 1;
2280 address += eh_frame_estimate_size_before_relax (fragP);
2284 address += dwarf2dbg_estimate_size_before_relax (fragP);
2288 BAD_CASE (fragP->fr_type);
2295 long stretch; /* May be any size, 0 or negative. */
2296 /* Cumulative number of addresses we have relaxed this pass.
2297 We may have relaxed more than one address. */
2298 int stretched; /* Have we stretched on this pass? */
2299 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2300 grew, and another shrank. If a branch instruction doesn't fit anymore,
2301 we could be scrod. */
2308 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2311 addressT was_address;
2315 fragP->relax_marker ^= 1;
2316 was_address = fragP->fr_address;
2317 address = fragP->fr_address += stretch;
2318 symbolP = fragP->fr_symbol;
2319 offset = fragP->fr_offset;
2321 switch (fragP->fr_type)
2323 case rs_fill: /* .fill never relaxes. */
2327 #ifndef WORKING_DOT_WORD
2328 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2329 for it I do not want to write it. I do not want to have
2330 anything to do with it. This is not the proper way to
2331 implement this misfeature. */
2332 case rs_broken_word:
2334 struct broken_word *lie;
2335 struct broken_word *untruth;
2337 /* Yes this is ugly (storing the broken_word pointer
2338 in the symbol slot). Still, this whole chunk of
2339 code is ugly, and I don't feel like doing anything
2340 about it. Think of it as stubbornness in action. */
2342 for (lie = (struct broken_word *) (fragP->fr_symbol);
2343 lie && lie->dispfrag == fragP;
2344 lie = lie->next_broken_word)
2350 offset = (S_GET_VALUE (lie->add)
2352 - S_GET_VALUE (lie->sub));
2353 if (offset <= -32768 || offset >= 32767)
2355 if (flag_warn_displacement)
2358 sprint_value (buf, (addressT) lie->addnum);
2359 as_warn_where (fragP->fr_file, fragP->fr_line,
2360 _(".word %s-%s+%s didn't fit"),
2361 S_GET_NAME (lie->add),
2362 S_GET_NAME (lie->sub),
2366 if (fragP->fr_subtype == 0)
2368 fragP->fr_subtype++;
2369 growth += md_short_jump_size;
2371 for (untruth = lie->next_broken_word;
2372 untruth && untruth->dispfrag == lie->dispfrag;
2373 untruth = untruth->next_broken_word)
2374 if ((symbol_get_frag (untruth->add)
2375 == symbol_get_frag (lie->add))
2376 && (S_GET_VALUE (untruth->add)
2377 == S_GET_VALUE (lie->add)))
2380 untruth->use_jump = lie;
2382 growth += md_long_jump_size;
2387 } /* case rs_broken_word */
2393 addressT oldoff, newoff;
2395 oldoff = relax_align (was_address + fragP->fr_fix,
2397 newoff = relax_align (address + fragP->fr_fix,
2400 if (fragP->fr_subtype != 0)
2402 if (oldoff > fragP->fr_subtype)
2404 if (newoff > fragP->fr_subtype)
2408 growth = newoff - oldoff;
2414 addressT target = offset;
2419 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2420 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2421 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2422 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2423 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2424 know (symbolP->sy_frag);
2425 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2426 || (symbolP->sy_frag == &zero_address_frag));
2428 /* Convert from an actual address to an octet offset
2429 into the section. Here it is assumed that the
2430 section's VMA is zero, and can omit subtracting it
2431 from the symbol's value to get the address offset. */
2432 know (S_GET_SECTION (symbolP)->vma == 0);
2433 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2436 know (fragP->fr_next);
2437 after = fragP->fr_next->fr_address;
2438 growth = target - after;
2441 /* Growth may be negative, but variable part of frag
2442 cannot have fewer than 0 chars. That is, we can't
2444 as_bad_where (fragP->fr_file, fragP->fr_line,
2445 _("attempt to .org backwards"));
2447 /* We've issued an error message. Change the
2448 frag to avoid cascading errors. */
2449 fragP->fr_type = rs_align;
2450 fragP->fr_subtype = 0;
2451 fragP->fr_offset = 0;
2452 fragP->fr_fix = after - address;
2456 /* This is an absolute growth factor */
2467 amount = S_GET_VALUE (symbolP);
2468 if (S_GET_SEGMENT (symbolP) != absolute_section
2469 || S_IS_COMMON (symbolP)
2470 || ! S_IS_DEFINED (symbolP))
2472 as_bad_where (fragP->fr_file, fragP->fr_line,
2473 _(".space specifies non-absolute value"));
2474 /* Prevent repeat of this error message. */
2475 fragP->fr_symbol = 0;
2477 else if (amount < 0)
2479 as_warn_where (fragP->fr_file, fragP->fr_line,
2480 _(".space or .fill with negative value, ignored"));
2481 fragP->fr_symbol = 0;
2484 growth = (was_address + fragP->fr_fix + amount
2485 - fragP->fr_next->fr_address);
2489 case rs_machine_dependent:
2490 #ifdef md_relax_frag
2491 growth = md_relax_frag (segment, fragP, stretch);
2493 #ifdef TC_GENERIC_RELAX_TABLE
2494 /* The default way to relax a frag is to look through
2495 TC_GENERIC_RELAX_TABLE. */
2496 growth = relax_frag (segment, fragP, stretch);
2497 #endif /* TC_GENERIC_RELAX_TABLE */
2506 value = resolve_symbol_value (fragP->fr_symbol);
2507 size = sizeof_leb128 (value, fragP->fr_subtype);
2508 growth = size - fragP->fr_offset;
2509 fragP->fr_offset = size;
2514 growth = eh_frame_relax_frag (fragP);
2518 growth = dwarf2dbg_relax_frag (fragP);
2522 BAD_CASE (fragP->fr_type);
2530 } /* For each frag in the segment. */
2532 while (stretched); /* Until nothing further to relax. */
2536 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2537 if (fragP->last_fr_address != fragP->fr_address)
2539 fragP->last_fr_address = fragP->fr_address;
2545 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2549 Go through all the fixS's in a segment and see which ones can be
2550 handled now. (These consist of fixS where we have since discovered
2551 the value of a symbol, or the address of the frag involved.)
2552 For each one, call md_apply_fix3 to put the fix into the frag data.
2554 Result is a count of how many relocation structs will be needed to
2555 handle the remaining fixS's that we couldn't completely handle here.
2556 These will be output later by emit_relocations(). */
2559 fixup_segment (fixP, this_segment)
2563 long seg_reloc_count = 0;
2566 segT add_symbol_segment = absolute_section;
2568 if (fixP != NULL && abs_section_sym == NULL)
2570 #ifndef BFD_ASSEMBLER
2571 abs_section_sym = &abs_symbol;
2573 abs_section_sym = section_symbol (absolute_section);
2577 /* If the linker is doing the relaxing, we must not do any fixups.
2579 Well, strictly speaking that's not true -- we could do any that
2580 are PC-relative and don't cross regions that could change size.
2581 And for the i960 we might be able to turn callx/callj into bal
2582 anyways in cases where we know the maximum displacement. */
2583 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
2585 for (; fixP; fixP = fixP->fx_next)
2588 if (fixP->fx_addsy == NULL)
2590 /* There was no symbol required by this relocation.
2591 However, BFD doesn't really handle relocations
2592 without symbols well. So fake up a local symbol in
2593 the absolute section. */
2594 fixP->fx_addsy = abs_section_sym;
2596 symbol_mark_used_in_reloc (fixP->fx_addsy);
2597 if (fixP->fx_subsy != NULL)
2598 symbol_mark_used_in_reloc (fixP->fx_subsy);
2601 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2602 return seg_reloc_count;
2605 for (; fixP; fixP = fixP->fx_next)
2608 fprintf (stderr, "\nprocessing fixup:\n");
2612 fragP = fixP->fx_frag;
2614 #ifdef TC_VALIDATE_FIX
2615 TC_VALIDATE_FIX (fixP, this_segment, skip);
2617 add_number = fixP->fx_offset;
2619 if (fixP->fx_addsy != NULL
2620 && symbol_mri_common_p (fixP->fx_addsy))
2622 know (fixP->fx_addsy->sy_value.X_op == O_symbol);
2623 add_number += S_GET_VALUE (fixP->fx_addsy);
2624 fixP->fx_offset = add_number;
2626 = symbol_get_value_expression (fixP->fx_addsy)->X_add_symbol;
2629 if (fixP->fx_addsy != NULL)
2630 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
2632 if (fixP->fx_subsy != NULL)
2634 segT sub_symbol_segment;
2635 resolve_symbol_value (fixP->fx_subsy);
2636 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
2637 if (fixP->fx_addsy != NULL
2638 && sub_symbol_segment == add_symbol_segment
2639 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
2641 add_number += S_GET_VALUE (fixP->fx_addsy);
2642 add_number -= S_GET_VALUE (fixP->fx_subsy);
2643 fixP->fx_offset = add_number;
2644 /* If the back-end code has selected a pc-relative
2645 reloc, adjust the value to be pc-relative. */
2648 /* See the comment below about 68k weirdness. */
2652 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2653 fixP->fx_addsy = NULL;
2654 fixP->fx_subsy = NULL;
2657 else if (sub_symbol_segment == absolute_section
2658 && !TC_FORCE_RELOCATION_SUB_ABS (fixP))
2660 add_number -= S_GET_VALUE (fixP->fx_subsy);
2661 fixP->fx_offset = add_number;
2662 fixP->fx_subsy = NULL;
2664 else if (sub_symbol_segment == this_segment
2665 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP))
2667 add_number -= S_GET_VALUE (fixP->fx_subsy);
2668 fixP->fx_offset = (add_number + fixP->fx_dot_value
2669 + fixP->fx_frag->fr_address);
2671 /* Make it pc-relative. If the back-end code has not
2672 selected a pc-relative reloc, cancel the adjustment
2673 we do later on all pc-relative relocs. */
2676 /* Do this for m68k even if it's already described
2677 as pc-relative. On the m68k, an operand of
2678 "pc@(foo-.-2)" should address "foo" in a
2679 pc-relative mode. */
2683 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
2684 fixP->fx_subsy = NULL;
2687 else if (!TC_VALIDATE_FIX_SUB (fixP))
2689 as_bad_where (fixP->fx_file, fixP->fx_line,
2690 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2691 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
2692 segment_name (add_symbol_segment),
2693 S_GET_NAME (fixP->fx_subsy),
2694 segment_name (sub_symbol_segment));
2700 if (add_symbol_segment == this_segment
2701 && !TC_FORCE_RELOCATION_LOCAL (fixP))
2703 /* This fixup was made when the symbol's segment was
2704 SEG_UNKNOWN, but it is now in the local segment.
2705 So we know how to do the address without relocation. */
2706 add_number += S_GET_VALUE (fixP->fx_addsy);
2707 fixP->fx_offset = add_number;
2709 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2710 fixP->fx_addsy = NULL;
2713 else if (add_symbol_segment == absolute_section
2714 && !TC_FORCE_RELOCATION_ABS (fixP))
2716 add_number += S_GET_VALUE (fixP->fx_addsy);
2717 fixP->fx_offset = add_number;
2718 fixP->fx_addsy = NULL;
2720 else if (add_symbol_segment != undefined_section
2721 #ifdef BFD_ASSEMBLER
2722 && ! bfd_is_com_section (add_symbol_segment)
2724 && MD_APPLY_SYM_VALUE (fixP))
2725 add_number += S_GET_VALUE (fixP->fx_addsy);
2730 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2731 if (!fixP->fx_done && fixP->fx_addsy == NULL)
2733 /* There was no symbol required by this relocation.
2734 However, BFD doesn't really handle relocations
2735 without symbols well. So fake up a local symbol in
2736 the absolute section. */
2737 fixP->fx_addsy = abs_section_sym;
2742 md_apply_fix3 (fixP, &add_number, this_segment);
2747 if (fixP->fx_addsy == NULL)
2748 fixP->fx_addsy = abs_section_sym;
2749 symbol_mark_used_in_reloc (fixP->fx_addsy);
2750 if (fixP->fx_subsy != NULL)
2751 symbol_mark_used_in_reloc (fixP->fx_subsy);
2754 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
2756 if (fixP->fx_size < sizeof (valueT))
2761 mask--; /* Set all bits to one. */
2762 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
2763 if ((add_number & mask) != 0 && (add_number & mask) != mask)
2765 char buf[50], buf2[50];
2766 sprint_value (buf, fragP->fr_address + fixP->fx_where);
2767 if (add_number > 1000)
2768 sprint_value (buf2, add_number);
2770 sprintf (buf2, "%ld", (long) add_number);
2771 as_bad_where (fixP->fx_file, fixP->fx_line,
2772 _("value of %s too large for field of %d bytes at %s"),
2773 buf2, fixP->fx_size, buf);
2774 } /* Generic error checking. */
2776 #ifdef WARN_SIGNED_OVERFLOW_WORD
2777 /* Warn if a .word value is too large when treated as a signed
2778 number. We already know it is not too negative. This is to
2779 catch over-large switches generated by gcc on the 68k. */
2780 if (!flag_signed_overflow_ok
2781 && fixP->fx_size == 2
2782 && add_number > 0x7fff)
2783 as_bad_where (fixP->fx_file, fixP->fx_line,
2784 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2786 (long) (fragP->fr_address + fixP->fx_where));
2788 } /* Not a bit fix. */
2790 #ifdef TC_VALIDATE_FIX
2791 skip: ATTRIBUTE_UNUSED_LABEL
2795 fprintf (stderr, "result:\n");
2798 } /* For each fixS in this segment. */
2800 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2801 return seg_reloc_count;
2804 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2807 number_to_chars_bigendian (buf, val, n)
2816 buf[n] = val & 0xff;
2822 number_to_chars_littleendian (buf, val, n)
2831 *buf++ = val & 0xff;
2837 write_print_statistics (file)
2840 fprintf (file, "fixups: %d\n", n_fixups);
2843 /* For debugging. */
2844 extern int indent_level;
2851 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2853 fprintf (stderr, " pcrel");
2854 if (fixp->fx_pcrel_adjust)
2855 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2856 if (fixp->fx_im_disp)
2859 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2861 fprintf (stderr, " im_disp");
2865 fprintf (stderr, " tcbit");
2867 fprintf (stderr, " done");
2868 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2869 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2870 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2871 #ifdef BFD_ASSEMBLER
2872 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2875 #ifdef NEED_FX_R_TYPE
2876 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2881 fprintf (stderr, "\n +<");
2882 print_symbol_value_1 (stderr, fixp->fx_addsy);
2883 fprintf (stderr, ">");
2887 fprintf (stderr, "\n -<");
2888 print_symbol_value_1 (stderr, fixp->fx_subsy);
2889 fprintf (stderr, ">");
2891 fprintf (stderr, "\n");
2892 #ifdef TC_FIX_DATA_PRINT
2893 TC_FIX_DATA_PRINT (stderr, fixp);