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
);
531 fragP
->fr_type
= rs_fill
;
539 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
542 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
545 fragP
->fr_fix
+= size
;
546 fragP
->fr_type
= rs_fill
;
548 fragP
->fr_offset
= 0;
549 fragP
->fr_symbol
= NULL
;
554 eh_frame_convert_frag (fragP
);
558 dwarf2dbg_convert_frag (fragP
);
561 case rs_machine_dependent
:
563 md_convert_frag (stdoutput
, sec
, fragP
);
565 md_convert_frag (headersP
, sec
, fragP
);
568 assert (fragP
->fr_next
== NULL
569 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
572 /* After md_convert_frag, we make the frag into a ".space 0".
573 md_convert_frag() should set up any fixSs and constants
578 #ifndef WORKING_DOT_WORD
581 struct broken_word
*lie
;
583 if (fragP
->fr_subtype
)
585 fragP
->fr_fix
+= md_short_jump_size
;
586 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
587 lie
&& lie
->dispfrag
== fragP
;
588 lie
= lie
->next_broken_word
)
590 fragP
->fr_fix
+= md_long_jump_size
;
598 BAD_CASE (fragP
->fr_type
);
603 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
606 static void relax_seg
PARAMS ((bfd
*, asection
*, PTR
));
608 relax_seg (abfd
, sec
, xxx
)
609 bfd
*abfd ATTRIBUTE_UNUSED
;
613 segment_info_type
*seginfo
= seg_info (sec
);
615 if (seginfo
&& seginfo
->frchainP
616 && relax_segment (seginfo
->frchainP
->frch_root
, sec
))
618 int *result
= (int *) xxx
;
623 static void size_seg
PARAMS ((bfd
*, asection
*, PTR
));
625 size_seg (abfd
, sec
, xxx
)
628 PTR xxx ATTRIBUTE_UNUSED
;
632 segment_info_type
*seginfo
;
634 valueT size
, newsize
;
636 subseg_change (sec
, 0);
638 seginfo
= seg_info (sec
);
639 if (seginfo
&& seginfo
->frchainP
)
641 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
642 cvt_frag_to_fill (sec
, fragp
);
643 for (fragp
= seginfo
->frchainP
->frch_root
;
645 fragp
= fragp
->fr_next
)
646 /* Walk to last elt. */
648 size
= fragp
->fr_address
+ fragp
->fr_fix
;
653 flags
= bfd_get_section_flags (abfd
, sec
);
655 if (size
> 0 && ! seginfo
->bss
)
656 flags
|= SEC_HAS_CONTENTS
;
658 /* @@ This is just an approximation. */
659 if (seginfo
&& seginfo
->fix_root
)
663 x
= bfd_set_section_flags (abfd
, sec
, flags
);
666 newsize
= md_section_align (sec
, size
);
667 x
= bfd_set_section_size (abfd
, sec
, newsize
);
670 /* If the size had to be rounded up, add some padding in the last
672 assert (newsize
>= size
);
675 fragS
*last
= seginfo
->frchainP
->frch_last
;
676 fragp
= seginfo
->frchainP
->frch_root
;
677 while (fragp
->fr_next
!= last
)
678 fragp
= fragp
->fr_next
;
679 last
->fr_address
= size
;
680 fragp
->fr_offset
+= newsize
- size
;
683 #ifdef tc_frob_section
684 tc_frob_section (sec
);
686 #ifdef obj_frob_section
687 obj_frob_section (sec
);
693 dump_section_relocs (abfd
, sec
, stream_
)
694 bfd
*abfd ATTRIBUTE_UNUSED
;
698 FILE *stream
= (FILE *) stream_
;
699 segment_info_type
*seginfo
= seg_info (sec
);
700 fixS
*fixp
= seginfo
->fix_root
;
705 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
708 symbolS
*s
= fixp
->fx_addsy
;
710 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
711 (int) fixp
->fx_r_type
);
713 fprintf (stream
, "no sym\n");
716 print_symbol_value_1 (stream
, s
);
717 fprintf (stream
, "\n");
719 fixp
= fixp
->fx_next
;
723 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
726 #ifndef EMIT_SECTION_SYMBOLS
727 #define EMIT_SECTION_SYMBOLS 1
731 adjust_reloc_syms (abfd
, sec
, xxx
)
732 bfd
*abfd ATTRIBUTE_UNUSED
;
734 PTR xxx ATTRIBUTE_UNUSED
;
736 segment_info_type
*seginfo
= seg_info (sec
);
742 dump_section_relocs (abfd
, sec
, stderr
);
744 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
748 else if (fixp
->fx_addsy
)
754 fprintf (stderr
, "\n\nadjusting fixup:\n");
758 sym
= fixp
->fx_addsy
;
760 /* All symbols should have already been resolved at this
761 point. It is possible to see unresolved expression
762 symbols, though, since they are not in the regular symbol
765 resolve_symbol_value (sym
);
767 if (fixp
->fx_subsy
!= NULL
)
768 resolve_symbol_value (fixp
->fx_subsy
);
770 /* If this symbol is equated to an undefined symbol, convert
771 the fixup to being against that symbol. */
772 if (sym
!= NULL
&& symbol_equated_reloc_p (sym
))
774 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
775 sym
= symbol_get_value_expression (sym
)->X_add_symbol
;
776 fixp
->fx_addsy
= sym
;
779 if (sym
!= NULL
&& symbol_mri_common_p (sym
))
781 /* These symbols are handled specially in fixup_segment. */
785 symsec
= S_GET_SEGMENT (sym
);
790 if (bfd_is_abs_section (symsec
))
792 /* The fixup_segment routine will not use this symbol in a
793 relocation unless TC_FORCE_RELOCATION returns 1. */
794 if (TC_FORCE_RELOCATION (fixp
))
796 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
797 #ifdef UNDEFINED_DIFFERENCE_OK
798 if (fixp
->fx_subsy
!= NULL
)
799 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
805 /* If it's one of these sections, assume the symbol is
806 definitely going to be output. The code in
807 md_estimate_size_before_relax in tc-mips.c uses this test
808 as well, so if you change this code you should look at that
810 if (bfd_is_und_section (symsec
)
811 || bfd_is_com_section (symsec
))
813 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
814 #ifdef UNDEFINED_DIFFERENCE_OK
815 /* We have the difference of an undefined symbol and some
816 other symbol. Make sure to mark the other symbol as used
817 in a relocation so that it will always be output. */
819 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
824 /* Don't try to reduce relocs which refer to non-local symbols
825 in .linkonce sections. It can lead to confusion when a
826 debugging section refers to a .linkonce section. I hope
827 this will always be correct. */
828 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
834 if ((bfd_get_section_flags (stdoutput
, symsec
) & SEC_LINK_ONCE
)
839 /* The GNU toolchain uses an extension for ELF: a section
840 beginning with the magic string .gnu.linkonce is a
842 if (strncmp (segment_name (symsec
), ".gnu.linkonce",
843 sizeof ".gnu.linkonce" - 1) == 0)
849 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
850 #ifdef UNDEFINED_DIFFERENCE_OK
851 if (fixp
->fx_subsy
!= NULL
)
852 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
858 /* Since we're reducing to section symbols, don't attempt to reduce
859 anything that's already using one. */
860 if (symbol_section_p (sym
))
862 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
867 /* We can never adjust a reloc against a weak symbol. If we
868 did, and the weak symbol was overridden by a real symbol
869 somewhere else, then our relocation would be pointing at
870 the wrong area of memory. */
873 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
877 /* Never adjust a reloc against local symbol in a merge section
878 with non-zero addend. */
879 if ((symsec
->flags
& SEC_MERGE
) && fixp
->fx_offset
)
881 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
886 /* Is there some other reason we can't adjust this one? (E.g.,
887 call/bal links in i960-bout symbols.) */
888 #ifdef obj_fix_adjustable
889 if (! obj_fix_adjustable (fixp
))
891 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
896 /* Is there some other (target cpu dependent) reason we can't adjust
897 this one? (E.g. relocations involving function addresses on
899 #ifdef tc_fix_adjustable
900 if (! tc_fix_adjustable (fixp
))
902 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
907 /* If the section symbol isn't going to be output, the relocs
908 at least should still work. If not, figure out what to do
909 when we run into that case.
911 We refetch the segment when calling section_symbol, rather
912 than using symsec, because S_GET_VALUE may wind up changing
913 the section when it calls resolve_symbol_value. */
914 fixp
->fx_offset
+= S_GET_VALUE (sym
);
915 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
916 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
918 fprintf (stderr
, "\nadjusted fixup:\n");
925 #if 1 /* def RELOC_REQUIRES_SYMBOL */
928 /* There was no symbol required by this relocation. However,
929 BFD doesn't really handle relocations without symbols well.
930 (At least, the COFF support doesn't.) So for now we fake up
931 a local symbol in the absolute section. */
933 fixp
->fx_addsy
= section_symbol (absolute_section
);
935 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
940 dump_section_relocs (abfd
, sec
, stderr
);
944 write_relocs (abfd
, sec
, xxx
)
947 PTR xxx ATTRIBUTE_UNUSED
;
949 segment_info_type
*seginfo
= seg_info (sec
);
956 /* If seginfo is NULL, we did not create this section; don't do
961 fixup_segment (seginfo
->fix_root
, sec
);
964 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
967 #ifndef RELOC_EXPANSION_POSSIBLE
968 /* Set up reloc information as well. */
969 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
970 memset ((char *) relocs
, 0, n
* sizeof (arelent
*));
973 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
976 bfd_reloc_status_type s
;
985 /* If this is an undefined symbol which was equated to another
986 symbol, then generate the reloc against the latter symbol
987 rather than the former. */
988 sym
= fixp
->fx_addsy
;
989 while (symbol_equated_reloc_p (sym
))
993 /* We must avoid looping, as that can occur with a badly
995 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
998 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
1001 fixp
->fx_addsy
= sym
;
1003 reloc
= tc_gen_reloc (sec
, fixp
);
1011 /* This test is triggered inappropriately for the SH. */
1012 if (fixp
->fx_where
+ fixp
->fx_size
1013 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
1017 s
= bfd_install_relocation (stdoutput
, reloc
,
1018 fixp
->fx_frag
->fr_literal
,
1019 fixp
->fx_frag
->fr_address
,
1025 case bfd_reloc_overflow
:
1026 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, _("relocation overflow"));
1028 case bfd_reloc_outofrange
:
1029 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, _("relocation out of range"));
1032 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1033 fixp
->fx_file
, fixp
->fx_line
, s
);
1035 relocs
[i
++] = reloc
;
1038 n
= n
* MAX_RELOC_EXPANSION
;
1039 /* Set up reloc information as well. */
1040 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
1043 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1047 bfd_reloc_status_type s
;
1057 /* If this is an undefined symbol which was equated to another
1058 symbol, then generate the reloc against the latter symbol
1059 rather than the former. */
1060 sym
= fixp
->fx_addsy
;
1061 while (symbol_equated_reloc_p (sym
))
1062 sym
= symbol_get_value_expression (sym
)->X_add_symbol
;
1063 fixp
->fx_addsy
= sym
;
1065 reloc
= tc_gen_reloc (sec
, fixp
);
1067 for (j
= 0; reloc
[j
]; j
++)
1069 relocs
[i
++] = reloc
[j
];
1072 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
1073 if (fixp
->fx_where
+ fixp
->fx_size
1074 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
1075 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1076 _("internal error: fixup not contained within frag"));
1077 for (j
= 0; reloc
[j
]; j
++)
1079 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
1080 fixp
->fx_frag
->fr_literal
,
1081 fixp
->fx_frag
->fr_address
,
1087 case bfd_reloc_overflow
:
1088 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1089 _("relocation overflow"));
1092 as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
1093 fixp
->fx_file
, fixp
->fx_line
);
1104 sympp
= bfd_get_outsymbols (stdoutput
);
1105 nsyms
= bfd_get_symcount (stdoutput
);
1106 for (i
= 0; i
< n
; i
++)
1107 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1109 for (j
= 0; j
< nsyms
; j
++)
1110 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
1119 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1121 bfd_set_section_flags (abfd
, sec
,
1122 (bfd_get_section_flags (abfd
, sec
)
1123 & (flagword
) ~SEC_RELOC
));
1125 #ifdef SET_SECTION_RELOCS
1126 SET_SECTION_RELOCS (sec
, relocs
, n
);
1134 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1135 for (i
= 0; i
< n
; i
++)
1138 s
= *r
->sym_ptr_ptr
;
1139 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1140 i
, r
, r
->address
, s
->name
, r
->addend
);
1147 write_contents (abfd
, sec
, xxx
)
1148 bfd
*abfd ATTRIBUTE_UNUSED
;
1150 PTR xxx ATTRIBUTE_UNUSED
;
1152 segment_info_type
*seginfo
= seg_info (sec
);
1153 unsigned long offset
= 0;
1156 /* Write out the frags. */
1158 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1161 for (f
= seginfo
->frchainP
->frch_root
;
1166 unsigned long fill_size
;
1170 assert (f
->fr_type
== rs_fill
);
1173 x
= bfd_set_section_contents (stdoutput
, sec
,
1174 f
->fr_literal
, (file_ptr
) offset
,
1175 (bfd_size_type
) f
->fr_fix
);
1178 bfd_perror (stdoutput
->filename
);
1179 as_perror (_("FATAL: Can't write %s"), stdoutput
->filename
);
1180 exit (EXIT_FAILURE
);
1182 offset
+= f
->fr_fix
;
1184 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1185 fill_size
= f
->fr_var
;
1186 count
= f
->fr_offset
;
1187 assert (count
>= 0);
1188 if (fill_size
&& count
)
1191 if (fill_size
> sizeof (buf
))
1193 /* Do it the old way. Can this ever happen? */
1196 x
= bfd_set_section_contents (stdoutput
, sec
,
1199 (bfd_size_type
) fill_size
);
1202 bfd_perror (stdoutput
->filename
);
1203 as_perror (_("FATAL: Can't write %s"),
1204 stdoutput
->filename
);
1205 exit (EXIT_FAILURE
);
1207 offset
+= fill_size
;
1212 /* Build a buffer full of fill objects and output it as
1213 often as necessary. This saves on the overhead of
1214 potentially lots of bfd_set_section_contents calls. */
1218 n_per_buf
= sizeof (buf
);
1219 memset (buf
, *fill_literal
, n_per_buf
);
1224 n_per_buf
= sizeof (buf
) / fill_size
;
1225 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1226 memcpy (bufp
, fill_literal
, fill_size
);
1228 for (; count
> 0; count
-= n_per_buf
)
1230 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1231 x
= bfd_set_section_contents
1232 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1233 (bfd_size_type
) n_per_buf
* fill_size
);
1235 as_fatal (_("cannot write to output file"));
1236 offset
+= n_per_buf
* fill_size
;
1244 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1246 merge_data_into_text ()
1248 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1249 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1250 seg_info (data_section
)->frchainP
->frch_root
;
1251 seg_info (text_section
)->frchainP
->frch_last
=
1252 seg_info (data_section
)->frchainP
->frch_last
;
1253 seg_info (data_section
)->frchainP
= 0;
1257 text_last_frag
->fr_next
= data_frag_root
;
1258 text_last_frag
= data_last_frag
;
1259 data_last_frag
= NULL
;
1260 data_frag_root
= NULL
;
1263 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1264 tmp
->fx_next
= data_fix_root
;
1265 text_fix_tail
= data_fix_tail
;
1268 text_fix_root
= data_fix_root
;
1269 data_fix_root
= NULL
;
1272 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1274 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1276 relax_and_size_all_segments ()
1280 relax_segment (text_frag_root
, SEG_TEXT
);
1281 relax_segment (data_frag_root
, SEG_DATA
);
1282 relax_segment (bss_frag_root
, SEG_BSS
);
1284 /* Now the addresses of frags are correct within the segment. */
1285 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1286 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1287 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1289 /* Join the 2 segments into 1 huge segment.
1290 To do this, re-compute every rn_address in the SEG_DATA frags.
1291 Then join the data frags after the text frags.
1293 Determine a_data [length of data segment]. */
1296 register relax_addressT slide
;
1298 know ((text_last_frag
->fr_type
== rs_fill
)
1299 && (text_last_frag
->fr_offset
== 0));
1301 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1302 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1303 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1305 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1306 /* For b.out: If the data section has a strict alignment
1307 requirement, its load address in the .o file will be
1308 rounded up from the size of the text section. These
1309 two values are *not* the same! Similarly for the bss
1311 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1314 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1315 fragP
->fr_address
+= slide
;
1317 know (text_last_frag
!= 0);
1318 text_last_frag
->fr_next
= data_frag_root
;
1322 H_SET_DATA_SIZE (&headers
, 0);
1326 /* See above comments on b.out data section address. */
1329 if (data_last_frag
== 0)
1330 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1332 bss_vma
= data_last_frag
->fr_address
;
1333 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1334 bss_address_frag
.fr_address
= bss_vma
;
1336 #else /* ! OBJ_BOUT */
1337 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1338 H_GET_DATA_SIZE (&headers
));
1340 #endif /* ! OBJ_BOUT */
1342 /* Slide all the frags. */
1345 relax_addressT slide
= bss_address_frag
.fr_address
;
1347 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1348 fragP
->fr_address
+= slide
;
1352 H_SET_BSS_SIZE (&headers
,
1353 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1355 H_SET_BSS_SIZE (&headers
, 0);
1357 #endif /* ! BFD_ASSEMBLER && ! BFD */
1359 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1361 #ifdef BFD_ASSEMBLER
1369 extern PTR bfd_alloc
PARAMS ((bfd
*, bfd_size_type
));
1371 /* Count symbols. We can't rely on a count made by the loop in
1372 write_object_file, because *_frob_file may add a new symbol or
1375 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1381 bfd_size_type amt
= (bfd_size_type
) nsyms
* sizeof (asymbol
*);
1383 asympp
= (asymbol
**) bfd_alloc (stdoutput
, amt
);
1384 symp
= symbol_rootP
;
1385 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1387 asympp
[i
] = symbol_get_bfdsym (symp
);
1388 symbol_mark_written (symp
);
1393 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1394 assert (result
== true);
1395 symbol_table_frozen
= 1;
1399 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1401 set_segment_vma (abfd
, sec
, xxx
)
1404 PTR xxx ATTRIBUTE_UNUSED
;
1406 static bfd_vma addr
= 0;
1408 bfd_set_section_vma (abfd
, sec
, addr
);
1409 addr
+= bfd_section_size (abfd
, sec
);
1411 #endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
1413 /* Finish the subsegments. After every sub-segment, we fake an
1414 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1415 ".fill 0" because that is the kind of frag that requires least
1416 thought. ".align" frags like to have a following frag since that
1417 makes calculating their intended length trivial. */
1419 #ifndef SUB_SEGMENT_ALIGN
1420 #ifdef BFD_ASSEMBLER
1421 #define SUB_SEGMENT_ALIGN(SEG) (0)
1423 #define SUB_SEGMENT_ALIGN(SEG) (2)
1430 struct frchain
*frchainP
;
1432 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1436 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1438 /* This now gets called even if we had errors. In that case,
1439 any alignment is meaningless, and, moreover, will look weird
1440 if we are generating a listing. */
1441 alignment
= had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg
);
1443 /* The last subsegment gets an aligment corresponding to the
1444 alignment of the section. This allows proper nop-filling
1445 at the end of code-bearing sections. */
1446 if (!frchainP
->frch_next
|| frchainP
->frch_next
->frch_seg
!= now_seg
)
1447 alignment
= get_recorded_alignment (now_seg
);
1449 if (subseg_text_p (now_seg
))
1450 frag_align_code (alignment
, 0);
1452 frag_align (alignment
, 0, 0);
1454 /* frag_align will have left a new frag.
1455 Use this last frag for an empty ".fill".
1457 For this segment ...
1458 Create a last frag. Do not leave a "being filled in frag". */
1459 frag_wane (frag_now
);
1460 frag_now
->fr_fix
= 0;
1461 know (frag_now
->fr_next
== NULL
);
1465 /* Write the object file. */
1468 write_object_file ()
1470 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1471 fragS
*fragP
; /* Track along all frags. */
1474 /* Do we really want to write it? */
1476 int n_warns
, n_errs
;
1477 n_warns
= had_warnings ();
1478 n_errs
= had_errors ();
1479 /* The -Z flag indicates that an object file should be generated,
1480 regardless of warnings and errors. */
1481 if (flag_always_generate_output
)
1483 if (n_warns
|| n_errs
)
1484 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1485 n_errs
, n_errs
== 1 ? "" : "s",
1486 n_warns
, n_warns
== 1 ? "" : "s");
1491 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1492 n_errs
, n_errs
== 1 ? "" : "s",
1493 n_warns
, n_warns
== 1 ? "" : "s");
1498 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1499 a routine to check for the definition of the procedure "_main",
1500 and if so -- fix it up so that it can be program entry point. */
1501 vms_check_for_main ();
1502 #endif /* OBJ_VMS */
1504 /* From now on, we don't care about sub-segments. Build one frag chain
1505 for each segment. Linked thru fr_next. */
1507 #ifdef BFD_ASSEMBLER
1508 /* Remove the sections created by gas for its own purposes. */
1510 asection
**seclist
, *sec
;
1513 seclist
= &stdoutput
->sections
;
1514 while (seclist
&& *seclist
)
1517 while (sec
== reg_section
|| sec
== expr_section
)
1521 stdoutput
->section_count
--;
1526 seclist
= &(*seclist
)->next
;
1529 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1532 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1534 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1535 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1536 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1539 /* We have two segments. If user gave -R flag, then we must put the
1540 data frags into the text segment. Do this before relaxing so
1541 we know to take advantage of -R and make shorter addresses. */
1542 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1543 if (flag_readonly_data_in_text
)
1545 merge_data_into_text ();
1549 #ifdef BFD_ASSEMBLER
1554 #ifndef WORKING_DOT_WORD
1555 /* We need to reset the markers in the broken word list and
1556 associated frags between calls to relax_segment (via
1557 relax_seg). Since the broken word list is global, we do it
1558 once per round, rather than locally in relax_segment for each
1560 struct broken_word
*brokp
;
1562 for (brokp
= broken_words
;
1563 brokp
!= (struct broken_word
*) NULL
;
1564 brokp
= brokp
->next_broken_word
)
1568 if (brokp
->dispfrag
!= (fragS
*) NULL
1569 && brokp
->dispfrag
->fr_type
== rs_broken_word
)
1570 brokp
->dispfrag
->fr_subtype
= 0;
1575 bfd_map_over_sections (stdoutput
, relax_seg
, &changed
);
1580 /* Note - Most ports will use the default value of
1581 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1582 local symbols to be resolved, removing their frag information.
1583 Some ports however, will not have finished relaxing all of
1584 their frags and will still need the local symbol frag
1585 information. These ports can set
1586 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1587 finalize_syms
= TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
;
1589 bfd_map_over_sections (stdoutput
, size_seg
, (char *) 0);
1591 relax_and_size_all_segments ();
1592 #endif /* BFD_ASSEMBLER */
1594 /* Relaxation has completed. Freeze all syms. */
1597 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1598 /* Now that the segments have their final sizes, run through the
1599 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1600 should too. Currently, only DJGPP uses this code, but other
1601 COFF targets may need to execute this too. */
1602 bfd_map_over_sections (stdoutput
, set_segment_vma
, (char *) 0);
1605 #ifndef BFD_ASSEMBLER
1606 /* Crawl the symbol chain.
1608 For each symbol whose value depends on a frag, take the address of
1609 that frag and subsume it into the value of the symbol.
1610 After this, there is just one way to lookup a symbol value.
1611 Values are left in their final state for object file emission.
1612 We adjust the values of 'L' local symbols, even if we do
1613 not intend to emit them to the object file, because their values
1614 are needed for fix-ups.
1616 Unless we saw a -L flag, remove all symbols that begin with 'L'
1617 from the symbol chain. (They are still pointed to by the fixes.)
1619 Count the remaining symbols.
1620 Assign a symbol number to each symbol.
1621 Count the number of string-table chars we will emit.
1622 Put this info into the headers as appropriate. */
1623 know (zero_address_frag
.fr_address
== 0);
1624 string_byte_count
= sizeof (string_byte_count
);
1626 obj_crawl_symbol_chain (&headers
);
1628 if (string_byte_count
== sizeof (string_byte_count
))
1629 string_byte_count
= 0;
1631 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1633 /* Addresses of frags now reflect addresses we use in the object file.
1634 Symbol values are correct.
1635 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1636 Also converting any machine-dependent frags using md_convert_frag(); */
1637 subseg_change (SEG_TEXT
, 0);
1639 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1641 /* At this point we have linked all the frags into a single
1642 chain. However, cvt_frag_to_fill may call md_convert_frag
1643 which may call fix_new. We need to ensure that fix_new adds
1644 the fixup to the right section. */
1645 if (fragP
== data_frag_root
)
1646 subseg_change (SEG_DATA
, 0);
1648 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1650 /* Some assert macros don't work with # directives mixed in. */
1652 if (!(fragP
->fr_next
== NULL
1654 || fragP
->fr_next
== data_frag_root
1656 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1657 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1661 #endif /* ! BFD_ASSEMBLER */
1663 #ifndef WORKING_DOT_WORD
1665 struct broken_word
*lie
;
1666 struct broken_word
**prevP
;
1668 prevP
= &broken_words
;
1669 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1674 subseg_change (lie
->seg
, lie
->subseg
);
1675 exp
.X_op
= O_subtract
;
1676 exp
.X_add_symbol
= lie
->add
;
1677 exp
.X_op_symbol
= lie
->sub
;
1678 exp
.X_add_number
= lie
->addnum
;
1679 #ifdef BFD_ASSEMBLER
1680 #ifdef TC_CONS_FIX_NEW
1681 TC_CONS_FIX_NEW (lie
->frag
,
1682 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1685 fix_new_exp (lie
->frag
,
1686 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1687 2, &exp
, 0, BFD_RELOC_16
);
1690 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1691 fix_new_exp (lie
->frag
,
1692 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1693 2, &exp
, 0, NO_RELOC
);
1696 fix_new_ns32k_exp (lie
->frag
,
1697 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1698 2, &exp
, 0, 0, 2, 0, 0);
1700 fix_new_exp (lie
->frag
,
1701 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1703 #endif /* TC_NS32K */
1704 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1705 #endif /* BFD_ASSEMBLER */
1706 *prevP
= lie
->next_broken_word
;
1709 prevP
= &(lie
->next_broken_word
);
1711 for (lie
= broken_words
; lie
;)
1713 struct broken_word
*untruth
;
1715 addressT table_addr
;
1716 addressT from_addr
, to_addr
;
1719 subseg_change (lie
->seg
, lie
->subseg
);
1720 fragP
= lie
->dispfrag
;
1722 /* Find out how many broken_words go here. */
1725 untruth
&& untruth
->dispfrag
== fragP
;
1726 untruth
= untruth
->next_broken_word
)
1727 if (untruth
->added
== 1)
1730 table_ptr
= lie
->dispfrag
->fr_opcode
;
1731 table_addr
= (lie
->dispfrag
->fr_address
1732 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1733 /* Create the jump around the long jumps. This is a short
1734 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1735 from_addr
= table_addr
;
1736 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1737 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1739 table_ptr
+= md_short_jump_size
;
1740 table_addr
+= md_short_jump_size
;
1743 lie
&& lie
->dispfrag
== fragP
;
1744 m
++, lie
= lie
->next_broken_word
)
1746 if (lie
->added
== 2)
1748 /* Patch the jump table. */
1749 /* This is the offset from ??? to table_ptr+0. */
1750 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1751 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1752 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr
, lie
);
1754 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1755 for (untruth
= lie
->next_broken_word
;
1756 untruth
&& untruth
->dispfrag
== fragP
;
1757 untruth
= untruth
->next_broken_word
)
1759 if (untruth
->use_jump
== lie
)
1760 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1763 /* Install the long jump. */
1764 /* This is a long jump from table_ptr+0 to the final target. */
1765 from_addr
= table_addr
;
1766 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1767 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1769 table_ptr
+= md_long_jump_size
;
1770 table_addr
+= md_long_jump_size
;
1774 #endif /* not WORKING_DOT_WORD */
1776 #ifndef BFD_ASSEMBLER
1779 char *the_object_file
;
1780 long object_file_size
;
1781 /* Scan every FixS performing fixups. We had to wait until now to
1782 do this because md_convert_frag() may have made some fixSs. */
1785 subseg_change (SEG_TEXT
, 0);
1786 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1787 subseg_change (SEG_DATA
, 0);
1788 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1789 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1791 /* FIXME: Move this stuff into the pre-write-hook. */
1792 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1793 H_SET_ENTRY_POINT (&headers
, 0);
1795 obj_pre_write_hook (&headers
); /* Extra coff stuff. */
1797 object_file_size
= H_GET_FILE_SIZE (&headers
);
1798 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1800 output_file_create (out_file_name
);
1802 obj_header_append (&next_object_file_charP
, &headers
);
1804 know ((next_object_file_charP
- the_object_file
)
1805 == H_GET_HEADER_SIZE (&headers
));
1808 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1810 register long count
;
1811 register char *fill_literal
;
1812 register long fill_size
;
1815 know (fragP
->fr_type
== rs_fill
);
1816 append (&next_object_file_charP
, fragP
->fr_literal
,
1817 (unsigned long) fragP
->fr_fix
);
1818 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1819 fill_size
= fragP
->fr_var
;
1820 know (fragP
->fr_offset
>= 0);
1822 for (count
= fragP
->fr_offset
; count
; count
--)
1823 append (&next_object_file_charP
, fill_literal
,
1824 (unsigned long) fill_size
);
1827 know ((next_object_file_charP
- the_object_file
)
1828 == (H_GET_HEADER_SIZE (&headers
)
1829 + H_GET_TEXT_SIZE (&headers
)
1830 + H_GET_DATA_SIZE (&headers
)));
1832 /* Emit relocations. */
1833 obj_emit_relocations (&next_object_file_charP
, text_fix_root
,
1834 (relax_addressT
) 0);
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
)));
1841 /* Make addresses in data relocation directives relative to beginning of
1842 first data fragment, not end of last text fragment: alignment of the
1843 start of the data segment may place a gap between the segments. */
1844 obj_emit_relocations (&next_object_file_charP
, data_fix_root
,
1845 data0_frchainP
->frch_root
->fr_address
);
1847 obj_emit_relocations (&next_object_file_charP
, data_fix_root
,
1848 text_last_frag
->fr_address
);
1849 #endif /* TC_I960 */
1851 know ((next_object_file_charP
- the_object_file
)
1852 == (H_GET_HEADER_SIZE (&headers
)
1853 + H_GET_TEXT_SIZE (&headers
)
1854 + H_GET_DATA_SIZE (&headers
)
1855 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1856 + H_GET_DATA_RELOCATION_SIZE (&headers
)));
1858 /* Emit line number entries. */
1859 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1860 know ((next_object_file_charP
- the_object_file
)
1861 == (H_GET_HEADER_SIZE (&headers
)
1862 + H_GET_TEXT_SIZE (&headers
)
1863 + H_GET_DATA_SIZE (&headers
)
1864 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1865 + H_GET_DATA_RELOCATION_SIZE (&headers
)
1866 + H_GET_LINENO_SIZE (&headers
)));
1869 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1870 know ((next_object_file_charP
- the_object_file
)
1871 == (H_GET_HEADER_SIZE (&headers
)
1872 + H_GET_TEXT_SIZE (&headers
)
1873 + H_GET_DATA_SIZE (&headers
)
1874 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1875 + H_GET_DATA_RELOCATION_SIZE (&headers
)
1876 + H_GET_LINENO_SIZE (&headers
)
1877 + H_GET_SYMBOL_TABLE_SIZE (&headers
)));
1880 if (string_byte_count
> 0)
1881 obj_emit_strings (&next_object_file_charP
);
1884 bfd_seek (stdoutput
, (file_ptr
) 0, 0);
1885 bfd_bwrite (the_object_file
, (bfd_size_type
) object_file_size
, stdoutput
);
1888 /* Write the data to the file. */
1889 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1890 free (the_object_file
);
1894 /* Now do the VMS-dependent part of writing the object file. */
1895 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1896 H_GET_DATA_SIZE (&headers
),
1897 H_GET_BSS_SIZE (&headers
),
1898 text_frag_root
, data_frag_root
);
1899 #endif /* OBJ_VMS */
1900 #else /* BFD_ASSEMBLER */
1902 /* Resolve symbol values. This needs to be done before processing
1908 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1909 resolve_symbol_value (symp
);
1911 resolve_local_symbol_values ();
1915 #ifdef tc_frob_file_before_adjust
1916 tc_frob_file_before_adjust ();
1918 #ifdef obj_frob_file_before_adjust
1919 obj_frob_file_before_adjust ();
1922 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1924 /* Set up symbol table, and write it out. */
1929 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1934 if (symbol_mri_common_p (symp
))
1936 if (S_IS_EXTERNAL (symp
))
1937 as_bad (_("%s: global symbols not supported in common sections"),
1939 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1943 name
= S_GET_NAME (symp
);
1947 decode_local_label_name ((char *) S_GET_NAME (symp
));
1948 /* They only differ if `name' is a fb or dollar local
1950 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1951 as_bad (_("local label `%s' is not defined"), name2
);
1954 /* Do it again, because adjust_reloc_syms might introduce
1955 more symbols. They'll probably only be section symbols,
1956 but they'll still need to have the values computed. */
1957 resolve_symbol_value (symp
);
1959 /* Skip symbols which were equated to undefined or common
1961 if (symbol_equated_reloc_p (symp
))
1963 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1967 /* So far, common symbols have been treated like undefined symbols.
1968 Put them in the common section now. */
1969 if (S_IS_DEFINED (symp
) == 0
1970 && S_GET_VALUE (symp
) != 0)
1971 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1973 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1974 S_GET_NAME (symp
), symp
,
1976 symbol_get_bfdsym (symp
)->flags
,
1977 segment_name (S_GET_SEGMENT (symp
)));
1980 #ifdef obj_frob_symbol
1981 obj_frob_symbol (symp
, punt
);
1983 #ifdef tc_frob_symbol
1984 if (! punt
|| symbol_used_in_reloc_p (symp
))
1985 tc_frob_symbol (symp
, punt
);
1988 /* If we don't want to keep this symbol, splice it out of
1989 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1990 want section symbols. Otherwise, we skip local symbols
1991 and symbols that the frob_symbol macros told us to punt,
1992 but we keep such symbols if they are used in relocs. */
1993 if ((! EMIT_SECTION_SYMBOLS
1994 && symbol_section_p (symp
))
1995 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1996 opposites. Sometimes the former checks flags and the
1997 latter examines the name... */
1998 || (!S_IS_EXTERN (symp
)
1999 && (S_IS_LOCAL (symp
) || punt
)
2000 && ! symbol_used_in_reloc_p (symp
)))
2002 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
2004 /* After symbol_remove, symbol_next(symp) still returns
2005 the one that came after it in the chain. So we don't
2006 need to do any extra cleanup work here. */
2010 /* Make sure we really got a value for the symbol. */
2011 if (! symbol_resolved_p (symp
))
2013 as_bad (_("can't resolve value for symbol `%s'"),
2015 symbol_mark_resolved (symp
);
2018 /* Set the value into the BFD symbol. Up til now the value
2019 has only been kept in the gas symbolS struct. */
2020 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
2026 /* Now do any format-specific adjustments to the symbol table, such
2027 as adding file symbols. */
2028 #ifdef tc_adjust_symtab
2029 tc_adjust_symtab ();
2031 #ifdef obj_adjust_symtab
2032 obj_adjust_symtab ();
2035 /* Now that all the sizes are known, and contents correct, we can
2036 start writing to the file. */
2039 /* If *_frob_file changes the symbol value at this point, it is
2040 responsible for moving the changed value into symp->bsym->value
2041 as well. Hopefully all symbol value changing can be done in
2046 #ifdef obj_frob_file
2050 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
2052 #ifdef tc_frob_file_after_relocs
2053 tc_frob_file_after_relocs ();
2055 #ifdef obj_frob_file_after_relocs
2056 obj_frob_file_after_relocs ();
2059 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
2060 #endif /* BFD_ASSEMBLER */
2064 #ifdef TC_GENERIC_RELAX_TABLE
2066 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2069 relax_frag (segment
, fragP
, stretch
)
2074 const relax_typeS
*this_type
;
2075 const relax_typeS
*start_type
;
2076 relax_substateT next_state
;
2077 relax_substateT this_state
;
2083 const relax_typeS
*table
;
2085 target
= fragP
->fr_offset
;
2086 address
= fragP
->fr_address
;
2087 table
= TC_GENERIC_RELAX_TABLE
;
2088 this_state
= fragP
->fr_subtype
;
2089 start_type
= this_type
= table
+ this_state
;
2090 symbolP
= fragP
->fr_symbol
;
2096 sym_frag
= symbol_get_frag (symbolP
);
2098 #ifndef DIFF_EXPR_OK
2099 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2100 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2101 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2102 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2103 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2105 know (sym_frag
!= NULL
);
2107 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2108 || sym_frag
== &zero_address_frag
);
2109 target
+= S_GET_VALUE (symbolP
);
2111 /* If frag has yet to be reached on this pass,
2112 assume it will move by STRETCH just as we did.
2113 If this is not so, it will be because some frag
2114 between grows, and that will force another pass. */
2117 && sym_frag
->relax_marker
!= fragP
->relax_marker
2118 && S_GET_SEGMENT (symbolP
) == segment
)
2124 aim
= target
- address
- fragP
->fr_fix
;
2125 #ifdef TC_PCREL_ADJUST
2126 /* Currently only the ns32k family needs this. */
2127 aim
+= TC_PCREL_ADJUST (fragP
);
2129 /* This machine doesn't want to use pcrel_adjust.
2130 In that case, pcrel_adjust should be zero. */
2132 assert (fragP
->fr_targ
.ns32k
.pcrel_adjust
== 0);
2135 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2136 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2141 /* Look backwards. */
2142 for (next_state
= this_type
->rlx_more
; next_state
;)
2143 if (aim
>= this_type
->rlx_backward
)
2147 /* Grow to next state. */
2148 this_state
= next_state
;
2149 this_type
= table
+ this_state
;
2150 next_state
= this_type
->rlx_more
;
2155 /* Look forwards. */
2156 for (next_state
= this_type
->rlx_more
; next_state
;)
2157 if (aim
<= this_type
->rlx_forward
)
2161 /* Grow to next state. */
2162 this_state
= next_state
;
2163 this_type
= table
+ this_state
;
2164 next_state
= this_type
->rlx_more
;
2168 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2170 fragP
->fr_subtype
= this_state
;
2174 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2176 /* Relax_align. Advance location counter to next address that has 'alignment'
2177 lowest order bits all 0s, return size of adjustment made. */
2178 static relax_addressT
2179 relax_align (address
, alignment
)
2180 register relax_addressT address
; /* Address now. */
2181 register int alignment
; /* Alignment (binary). */
2183 relax_addressT mask
;
2184 relax_addressT new_address
;
2186 mask
= ~((~0) << alignment
);
2187 new_address
= (address
+ mask
) & (~mask
);
2188 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2190 /* We must provide lots of padding, so the linker can discard it
2191 when needed. The linker will not add extra space, ever. */
2192 new_address
+= (1 << alignment
);
2194 return (new_address
- address
);
2197 /* Now we have a segment, not a crowd of sub-segments, we can make
2202 After this, all frags in this segment have addresses that are correct
2203 within the segment. Since segments live in different file addresses,
2204 these frag addresses may not be the same as final object-file
2208 relax_segment (segment_frag_root
, segment
)
2209 struct frag
*segment_frag_root
;
2212 register struct frag
*fragP
;
2213 register relax_addressT address
;
2216 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2217 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
2219 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2220 subseg_change (segment
, 0);
2222 /* For each frag in segment: count and store (a 1st guess of)
2225 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2227 fragP
->relax_marker
= 0;
2228 fragP
->fr_address
= address
;
2229 address
+= fragP
->fr_fix
;
2231 switch (fragP
->fr_type
)
2234 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2241 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2243 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2246 if (offset
% fragP
->fr_var
!= 0)
2248 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2249 _("alignment padding (%lu bytes) not a multiple of %ld"),
2250 (unsigned long) offset
, (long) fragP
->fr_var
);
2251 offset
-= (offset
% fragP
->fr_var
);
2260 /* Assume .org is nugatory. It will grow with 1st relax. */
2263 case rs_machine_dependent
:
2264 /* If fr_symbol is an expression, this call to
2265 resolve_symbol_value sets up the correct segment, which will
2266 likely be needed in md_estimate_size_before_relax. */
2267 if (fragP
->fr_symbol
)
2268 resolve_symbol_value (fragP
->fr_symbol
);
2270 address
+= md_estimate_size_before_relax (fragP
, segment
);
2273 #ifndef WORKING_DOT_WORD
2274 /* Broken words don't concern us yet. */
2275 case rs_broken_word
:
2280 /* Initial guess is always 1; doing otherwise can result in
2281 stable solutions that are larger than the minimum. */
2282 address
+= fragP
->fr_offset
= 1;
2286 address
+= eh_frame_estimate_size_before_relax (fragP
);
2290 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2294 BAD_CASE (fragP
->fr_type
);
2301 long stretch
; /* May be any size, 0 or negative. */
2302 /* Cumulative number of addresses we have relaxed this pass.
2303 We may have relaxed more than one address. */
2304 int stretched
; /* Have we stretched on this pass? */
2305 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2306 grew, and another shrank. If a branch instruction doesn't fit anymore,
2307 we could be scrod. */
2314 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2317 addressT was_address
;
2321 fragP
->relax_marker
^= 1;
2322 was_address
= fragP
->fr_address
;
2323 address
= fragP
->fr_address
+= stretch
;
2324 symbolP
= fragP
->fr_symbol
;
2325 offset
= fragP
->fr_offset
;
2327 switch (fragP
->fr_type
)
2329 case rs_fill
: /* .fill never relaxes. */
2333 #ifndef WORKING_DOT_WORD
2334 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2335 for it I do not want to write it. I do not want to have
2336 anything to do with it. This is not the proper way to
2337 implement this misfeature. */
2338 case rs_broken_word
:
2340 struct broken_word
*lie
;
2341 struct broken_word
*untruth
;
2343 /* Yes this is ugly (storing the broken_word pointer
2344 in the symbol slot). Still, this whole chunk of
2345 code is ugly, and I don't feel like doing anything
2346 about it. Think of it as stubbornness in action. */
2348 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2349 lie
&& lie
->dispfrag
== fragP
;
2350 lie
= lie
->next_broken_word
)
2356 offset
= (S_GET_VALUE (lie
->add
)
2358 - S_GET_VALUE (lie
->sub
));
2359 if (offset
<= -32768 || offset
>= 32767)
2361 if (flag_warn_displacement
)
2364 sprint_value (buf
, (addressT
) lie
->addnum
);
2365 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2366 _(".word %s-%s+%s didn't fit"),
2367 S_GET_NAME (lie
->add
),
2368 S_GET_NAME (lie
->sub
),
2372 if (fragP
->fr_subtype
== 0)
2374 fragP
->fr_subtype
++;
2375 growth
+= md_short_jump_size
;
2377 for (untruth
= lie
->next_broken_word
;
2378 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2379 untruth
= untruth
->next_broken_word
)
2380 if ((symbol_get_frag (untruth
->add
)
2381 == symbol_get_frag (lie
->add
))
2382 && (S_GET_VALUE (untruth
->add
)
2383 == S_GET_VALUE (lie
->add
)))
2386 untruth
->use_jump
= lie
;
2388 growth
+= md_long_jump_size
;
2393 } /* case rs_broken_word */
2399 addressT oldoff
, newoff
;
2401 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2403 newoff
= relax_align (address
+ fragP
->fr_fix
,
2406 if (fragP
->fr_subtype
!= 0)
2408 if (oldoff
> fragP
->fr_subtype
)
2410 if (newoff
> fragP
->fr_subtype
)
2414 growth
= newoff
- oldoff
;
2420 addressT target
= offset
;
2425 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2426 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2427 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2428 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2429 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2430 know (symbolP
->sy_frag
);
2431 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2432 || (symbolP
->sy_frag
== &zero_address_frag
));
2434 /* Convert from an actual address to an octet offset
2435 into the section. Here it is assumed that the
2436 section's VMA is zero, and can omit subtracting it
2437 from the symbol's value to get the address offset. */
2438 know (S_GET_SECTION (symbolP
)->vma
== 0);
2439 target
+= S_GET_VALUE (symbolP
) * OCTETS_PER_BYTE
;
2442 know (fragP
->fr_next
);
2443 after
= fragP
->fr_next
->fr_address
;
2444 growth
= target
- after
;
2447 /* Growth may be negative, but variable part of frag
2448 cannot have fewer than 0 chars. That is, we can't
2450 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2451 _("attempt to .org backwards"));
2453 /* We've issued an error message. Change the
2454 frag to avoid cascading errors. */
2455 fragP
->fr_type
= rs_align
;
2456 fragP
->fr_subtype
= 0;
2457 fragP
->fr_offset
= 0;
2458 fragP
->fr_fix
= after
- address
;
2462 /* This is an absolute growth factor */
2473 amount
= S_GET_VALUE (symbolP
);
2474 if (S_GET_SEGMENT (symbolP
) != absolute_section
2475 || S_IS_COMMON (symbolP
)
2476 || ! S_IS_DEFINED (symbolP
))
2478 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2479 _(".space specifies non-absolute value"));
2480 /* Prevent repeat of this error message. */
2481 fragP
->fr_symbol
= 0;
2483 else if (amount
< 0)
2485 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2486 _(".space or .fill with negative value, ignored"));
2487 fragP
->fr_symbol
= 0;
2490 growth
= (was_address
+ fragP
->fr_fix
+ amount
2491 - fragP
->fr_next
->fr_address
);
2495 case rs_machine_dependent
:
2496 #ifdef md_relax_frag
2497 growth
= md_relax_frag (segment
, fragP
, stretch
);
2499 #ifdef TC_GENERIC_RELAX_TABLE
2500 /* The default way to relax a frag is to look through
2501 TC_GENERIC_RELAX_TABLE. */
2502 growth
= relax_frag (segment
, fragP
, stretch
);
2503 #endif /* TC_GENERIC_RELAX_TABLE */
2512 value
= resolve_symbol_value (fragP
->fr_symbol
);
2513 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2514 growth
= size
- fragP
->fr_offset
;
2515 fragP
->fr_offset
= size
;
2520 growth
= eh_frame_relax_frag (fragP
);
2524 growth
= dwarf2dbg_relax_frag (fragP
);
2528 BAD_CASE (fragP
->fr_type
);
2536 } /* For each frag in the segment. */
2538 while (stretched
); /* Until nothing further to relax. */
2542 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2543 if (fragP
->last_fr_address
!= fragP
->fr_address
)
2545 fragP
->last_fr_address
= fragP
->fr_address
;
2551 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2553 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2554 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2559 Go through all the fixS's in a segment and see which ones can be
2560 handled now. (These consist of fixS where we have since discovered
2561 the value of a symbol, or the address of the frag involved.)
2562 For each one, call md_apply_fix3 to put the fix into the frag data.
2564 Result is a count of how many relocation structs will be needed to
2565 handle the remaining fixS's that we couldn't completely handle here.
2566 These will be output later by emit_relocations(). */
2569 fixup_segment (fixP
, this_segment_type
)
2570 register fixS
*fixP
;
2571 segT this_segment_type
; /* N_TYPE bits for segment. */
2573 long seg_reloc_count
= 0;
2574 symbolS
*add_symbolP
;
2575 symbolS
*sub_symbolP
;
2582 segT add_symbol_segment
= absolute_section
;
2584 /* If the linker is doing the relaxing, we must not do any fixups.
2586 Well, strictly speaking that's not true -- we could do any that are
2587 PC-relative and don't cross regions that could change size. And for the
2588 i960 (the only machine for which we've got a relaxing linker right now),
2589 we might be able to turn callx/callj into bal anyways in cases where we
2590 know the maximum displacement. */
2591 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment_type
))
2593 for (; fixP
; fixP
= fixP
->fx_next
)
2595 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2596 return seg_reloc_count
;
2599 for (; fixP
; fixP
= fixP
->fx_next
)
2602 fprintf (stderr
, "\nprocessing fixup:\n");
2606 fragP
= fixP
->fx_frag
;
2608 where
= fixP
->fx_where
;
2609 place
= fragP
->fr_literal
+ where
;
2610 size
= fixP
->fx_size
;
2611 add_symbolP
= fixP
->fx_addsy
;
2612 #ifdef TC_VALIDATE_FIX
2613 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2615 sub_symbolP
= fixP
->fx_subsy
;
2616 add_number
= fixP
->fx_offset
;
2617 pcrel
= fixP
->fx_pcrel
;
2620 if (add_symbolP
!= NULL
2621 && symbol_mri_common_p (add_symbolP
))
2623 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2624 add_number
+= S_GET_VALUE (add_symbolP
);
2625 fixP
->fx_offset
= add_number
;
2626 add_symbolP
= fixP
->fx_addsy
=
2627 symbol_get_value_expression (add_symbolP
)->X_add_symbol
;
2631 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2635 resolve_symbol_value (sub_symbolP
);
2636 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2638 if (add_symbolP
!= NULL
)
2640 add_number
+= S_GET_VALUE (add_symbolP
);
2642 fixP
->fx_addsy
= NULL
;
2645 /* It's just -sym. */
2646 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2648 add_number
-= S_GET_VALUE (sub_symbolP
);
2649 fixP
->fx_subsy
= NULL
;
2652 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2654 /* Should try converting to a constant. */
2659 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2660 _("negative of non-absolute symbol `%s'"),
2661 S_GET_NAME (sub_symbolP
));
2663 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2664 && SEG_NORMAL (add_symbol_segment
))
2666 /* Difference of 2 symbols from same segment.
2667 Can't make difference of 2 undefineds: 'value' means
2668 something different for N_UNDF. */
2670 /* Makes no sense to use the difference of 2 arbitrary symbols
2671 as the target of a call instruction. */
2673 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2674 _("callj to difference of two symbols"));
2675 #endif /* TC_I960 */
2676 add_number
+= (S_GET_VALUE (add_symbolP
)
2677 - S_GET_VALUE (sub_symbolP
));
2680 /* See the comment below about 68k weirdness. */
2684 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2687 pcrel
= 0; /* No further pcrel processing. */
2689 /* Let the target machine make the final determination
2690 as to whether or not a relocation will be needed to
2691 handle this fixup. */
2692 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2695 fixP
->fx_addsy
= NULL
;
2696 fixP
->fx_subsy
= NULL
;
2701 /* Different segments in subtraction. */
2702 know (!(S_IS_EXTERNAL (sub_symbolP
)
2703 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2705 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2706 add_number
-= S_GET_VALUE (sub_symbolP
);
2709 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2711 /* Make it pc-relative. */
2714 /* Do this for m68k even if it's already described
2715 as pc-relative. On the m68k, an operand of
2716 "pc@(foo-.-2)" should address "foo" in a
2717 pc-relative mode. */
2722 add_number
+= MD_PCREL_FROM_SECTION (fixP
,
2728 add_number
-= S_GET_VALUE (sub_symbolP
);
2733 #ifdef UNDEFINED_DIFFERENCE_OK
2734 /* The PA needs this for PIC code generation. We basically
2735 don't want to do anything if we have the difference of two
2736 symbols at this point. */
2739 /* Leave it alone. */
2742 #ifdef BFD_ASSEMBLER
2743 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2744 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2746 /* Leave it alone. */
2752 sprint_value (buf
, fragP
->fr_address
+ where
);
2753 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2754 _("subtraction of two symbols in different sections `%s' {%s section} - `%s' {%s section} at file address %s"),
2755 S_GET_NAME (add_symbolP
),
2756 segment_name (S_GET_SEGMENT (add_symbolP
)),
2757 S_GET_NAME (sub_symbolP
),
2758 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2766 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2767 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2769 /* This fixup was made when the symbol's segment was
2770 SEG_UNKNOWN, but it is now in the local segment.
2771 So we know how to do the address without relocation. */
2773 /* reloc_callj() may replace a 'call' with a 'calls' or a
2774 'bal', in which cases it modifies *fixP as appropriate.
2775 In the case of a 'calls', no further work is required,
2776 and *fixP has been set up to make the rest of the code
2779 #endif /* TC_I960 */
2781 add_number
+= S_GET_VALUE (add_symbolP
);
2782 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2783 /* Lie. Don't want further pcrel processing. */
2786 /* Let the target machine make the final determination
2787 as to whether or not a relocation will be needed to
2788 handle this fixup. */
2789 if (!TC_FORCE_RELOCATION (fixP
))
2792 fixP
->fx_addsy
= NULL
;
2797 if (add_symbol_segment
== absolute_section
2801 /* See comment about reloc_callj() above. */
2803 #endif /* TC_I960 */
2804 add_number
+= S_GET_VALUE (add_symbolP
);
2806 /* Let the target machine make the final determination
2807 as to whether or not a relocation will be needed to
2808 handle this fixup. */
2810 if (!TC_FORCE_RELOCATION (fixP
))
2812 fixP
->fx_addsy
= NULL
;
2816 else if (add_symbol_segment
== undefined_section
2817 #ifdef BFD_ASSEMBLER
2818 || bfd_is_com_section (add_symbol_segment
)
2823 if ((int) fixP
->fx_bit_fixP
== 13)
2825 /* This is a COBR instruction. They have only a
2826 13-bit displacement and are only to be used
2827 for local branches: flag as error, don't generate
2829 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2830 _("can't use COBR format with external label"));
2831 fixP
->fx_addsy
= NULL
;
2835 #endif /* TC_I960 */
2839 if (S_IS_COMMON (add_symbolP
))
2840 add_number
+= S_GET_VALUE (add_symbolP
);
2841 #endif /* TE_I386AIX */
2842 #endif /* OBJ_COFF */
2848 if (TC_FIX_ADJUSTABLE (fixP
))
2849 add_number
+= S_GET_VALUE (add_symbolP
);
2856 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2857 if (add_symbolP
== 0)
2859 #ifndef BFD_ASSEMBLER
2860 fixP
->fx_addsy
= &abs_symbol
;
2862 fixP
->fx_addsy
= section_symbol (absolute_section
);
2864 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2870 md_apply_fix3 (fixP
, & add_number
, this_segment_type
);
2872 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2874 if ((size_t) size
< sizeof (valueT
))
2879 mask
--; /* Set all bits to one. */
2880 mask
<<= size
* 8 - (fixP
->fx_signed
? 1 : 0);
2881 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
2883 char buf
[50], buf2
[50];
2884 sprint_value (buf
, fragP
->fr_address
+ where
);
2885 if (add_number
> 1000)
2886 sprint_value (buf2
, add_number
);
2888 sprintf (buf2
, "%ld", (long) add_number
);
2889 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2890 _("value of %s too large for field of %d bytes at %s"),
2892 } /* Generic error checking. */
2894 #ifdef WARN_SIGNED_OVERFLOW_WORD
2895 /* Warn if a .word value is too large when treated as a signed
2896 number. We already know it is not too negative. This is to
2897 catch over-large switches generated by gcc on the 68k. */
2898 if (!flag_signed_overflow_ok
2900 && add_number
> 0x7fff)
2901 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2902 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2904 (unsigned long) (fragP
->fr_address
+ where
));
2906 } /* Not a bit fix. */
2908 #ifdef TC_VALIDATE_FIX
2909 skip
: ATTRIBUTE_UNUSED_LABEL
2913 fprintf (stderr
, "result:\n");
2916 } /* For each fixS in this segment. */
2918 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2919 return seg_reloc_count
;
2922 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2925 number_to_chars_bigendian (buf
, val
, n
)
2930 if ((size_t) n
> sizeof (val
) || n
<= 0)
2934 buf
[n
] = val
& 0xff;
2940 number_to_chars_littleendian (buf
, val
, n
)
2945 if ((size_t) n
> sizeof (val
) || n
<= 0)
2949 *buf
++ = val
& 0xff;
2955 write_print_statistics (file
)
2958 fprintf (file
, "fixups: %d\n", n_fixups
);
2961 /* For debugging. */
2962 extern int indent_level
;
2969 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2971 fprintf (stderr
, " pcrel");
2972 if (fixp
->fx_pcrel_adjust
)
2973 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2974 if (fixp
->fx_im_disp
)
2977 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2979 fprintf (stderr
, " im_disp");
2983 fprintf (stderr
, " tcbit");
2985 fprintf (stderr
, " done");
2986 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2987 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2988 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2989 #ifdef BFD_ASSEMBLER
2990 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2993 #ifdef NEED_FX_R_TYPE
2994 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2999 fprintf (stderr
, "\n +<");
3000 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
3001 fprintf (stderr
, ">");
3005 fprintf (stderr
, "\n -<");
3006 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
3007 fprintf (stderr
, ">");
3009 fprintf (stderr
, "\n");
3010 #ifdef TC_FIX_DATA_PRINT
3011 TC_FIX_DATA_PRINT (stderr
, fixp
);