1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This thing should be set up to do byteordering correctly. But... */
27 #include "output-file.h"
28 #include "dwarf2dbg.h"
30 /* This looks like a good idea. Let's try turning it on always, for now. */
31 #undef BFD_FAST_SECTION_FILL
32 #define BFD_FAST_SECTION_FILL
34 #ifndef TC_ADJUST_RELOC_COUNT
35 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
38 #ifndef TC_FORCE_RELOCATION
39 #define TC_FORCE_RELOCATION(FIXP) 0
42 #ifndef TC_FORCE_RELOCATION_SECTION
43 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
46 #ifndef TC_LINKRELAX_FIXUP
47 #define TC_LINKRELAX_FIXUP(SEG) 1
50 #ifndef TC_FIX_ADJUSTABLE
51 #define TC_FIX_ADJUSTABLE(fix) 1
54 #ifndef MD_PCREL_FROM_SECTION
55 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
58 #ifndef WORKING_DOT_WORD
59 extern CONST
int md_short_jump_size
;
60 extern CONST
int md_long_jump_size
;
63 int symbol_table_frozen
;
64 void print_fixup
PARAMS ((fixS
*));
67 static void renumber_sections
PARAMS ((bfd
*, asection
*, PTR
));
69 /* We generally attach relocs to frag chains. However, after we have
70 chained these all together into a segment, any relocs we add after
71 that must be attached to a segment. This will include relocs added
72 in md_estimate_size_for_relax, for example. */
73 static int frags_chained
= 0;
79 struct frag
*text_frag_root
;
80 struct frag
*data_frag_root
;
81 struct frag
*bss_frag_root
;
83 struct frag
*text_last_frag
; /* Last frag in segment. */
84 struct frag
*data_last_frag
; /* Last frag in segment. */
85 static struct frag
*bss_last_frag
; /* Last frag in segment. */
89 static object_headers headers
;
92 long string_byte_count
;
93 char *next_object_file_charP
; /* Tracks object file bytes. */
96 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
99 #endif /* BFD_ASSEMBLER */
104 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
105 symbolS
*add
, symbolS
*sub
,
106 offsetT offset
, int pcrel
,
107 bfd_reloc_code_real_type r_type
));
109 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
110 symbolS
*add
, symbolS
*sub
,
111 offsetT offset
, int pcrel
,
114 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
115 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
117 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
118 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
119 static fragS
*chain_frchains_together_1
PARAMS ((segT
, struct frchain
*));
122 static void chain_frchains_together
PARAMS ((bfd
*, segT
, PTR
));
123 static void cvt_frag_to_fill
PARAMS ((segT
, fragS
*));
124 static void relax_and_size_seg
PARAMS ((bfd
*, asection
*, PTR
));
125 static void adjust_reloc_syms
PARAMS ((bfd
*, asection
*, PTR
));
126 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
127 static void write_contents
PARAMS ((bfd
*, asection
*, PTR
));
128 static void set_symtab
PARAMS ((void));
130 #if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
131 static void merge_data_into_text
PARAMS ((void));
133 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
134 static void cvt_frag_to_fill
PARAMS ((object_headers
*, segT
, fragS
*));
135 static void remove_subsegs
PARAMS ((frchainS
*, int, fragS
**, fragS
**));
136 static void relax_and_size_all_segments
PARAMS ((void));
138 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
139 static void set_segment_vma
PARAMS ((bfd
*, asection
*, PTR
));
142 /* Create a fixS in obstack 'notes'. */
145 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
147 fragS
*frag
; /* Which frag? */
148 int where
; /* Where in that frag? */
149 int size
; /* 1, 2, or 4 usually. */
150 symbolS
*add_symbol
; /* X_add_symbol. */
151 symbolS
*sub_symbol
; /* X_op_symbol. */
152 offsetT offset
; /* X_add_number. */
153 int pcrel
; /* TRUE if PC-relative relocation. */
155 bfd_reloc_code_real_type r_type
; /* Relocation type. */
157 int r_type
; /* Relocation type. */
164 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
166 fixP
->fx_frag
= frag
;
167 fixP
->fx_where
= where
;
168 fixP
->fx_size
= size
;
169 /* We've made fx_size a narrow field; check that it's wide enough. */
170 if (fixP
->fx_size
!= size
)
172 as_bad (_("field fx_size too small to hold %d"), size
);
175 fixP
->fx_addsy
= add_symbol
;
176 fixP
->fx_subsy
= sub_symbol
;
177 fixP
->fx_offset
= offset
;
178 fixP
->fx_pcrel
= pcrel
;
180 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
181 fixP
->fx_r_type
= r_type
;
183 fixP
->fx_im_disp
= 0;
184 fixP
->fx_pcrel_adjust
= 0;
185 fixP
->fx_bit_fixP
= 0;
186 fixP
->fx_addnumber
= 0;
189 fixP
->fx_no_overflow
= 0;
193 fixP
->fx_cgen
.insn
= NULL
;
194 fixP
->fx_cgen
.opinfo
= 0;
198 TC_INIT_FIX_DATA (fixP
);
201 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
203 /* Usually, we want relocs sorted numerically, but while
204 comparing to older versions of gas that have relocs
205 reverse sorted, it is convenient to have this compile
206 time option. xoxorich. */
210 fixS
**seg_fix_rootP
= (frags_chained
211 ? &seg_info (now_seg
)->fix_root
212 : &frchain_now
->fix_root
);
213 fixS
**seg_fix_tailP
= (frags_chained
214 ? &seg_info (now_seg
)->fix_tail
215 : &frchain_now
->fix_tail
);
218 #ifdef REVERSE_SORT_RELOCS
220 fixP
->fx_next
= *seg_fix_rootP
;
221 *seg_fix_rootP
= fixP
;
223 #else /* REVERSE_SORT_RELOCS */
225 fixP
->fx_next
= NULL
;
228 (*seg_fix_tailP
)->fx_next
= fixP
;
230 *seg_fix_rootP
= fixP
;
231 *seg_fix_tailP
= fixP
;
233 #endif /* REVERSE_SORT_RELOCS */
239 /* Create a fixup relative to a symbol (plus a constant). */
242 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
243 fragS
*frag
; /* Which frag? */
244 int where
; /* Where in that frag? */
245 int size
; /* 1, 2, or 4 usually. */
246 symbolS
*add_symbol
; /* X_add_symbol. */
247 offsetT offset
; /* X_add_number. */
248 int pcrel
; /* TRUE if PC-relative relocation. */
250 bfd_reloc_code_real_type r_type
; /* Relocation type. */
252 int r_type
; /* Relocation type. */
255 return fix_new_internal (frag
, where
, size
, add_symbol
,
256 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
259 /* Create a fixup for an expression. Currently we only support fixups
260 for difference expressions. That is itself more than most object
261 file formats support anyhow. */
264 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
265 fragS
*frag
; /* Which frag? */
266 int where
; /* Where in that frag? */
267 int size
; /* 1, 2, or 4 usually. */
268 expressionS
*exp
; /* Expression. */
269 int pcrel
; /* TRUE if PC-relative relocation. */
271 bfd_reloc_code_real_type r_type
; /* Relocation type. */
273 int r_type
; /* Relocation type. */
286 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
287 the difference expression cannot immediately be reduced. */
289 symbolS
*stmp
= make_expr_symbol (exp
);
291 exp
->X_op
= O_symbol
;
292 exp
->X_op_symbol
= 0;
293 exp
->X_add_symbol
= stmp
;
294 exp
->X_add_number
= 0;
296 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
300 add
= exp
->X_add_symbol
;
301 off
= exp
->X_add_number
;
303 #if defined(BFD_ASSEMBLER)
304 r_type
= BFD_RELOC_RVA
;
306 #if defined(TC_RVA_RELOC)
307 r_type
= TC_RVA_RELOC
;
309 as_fatal (_("rva not supported"));
315 sub
= exp
->X_add_symbol
;
316 off
= exp
->X_add_number
;
320 sub
= exp
->X_op_symbol
;
323 add
= exp
->X_add_symbol
;
326 off
= exp
->X_add_number
;
330 add
= make_expr_symbol (exp
);
334 return fix_new_internal (frag
, where
, size
, add
, sub
, off
, pcrel
, r_type
);
337 /* Append a string onto another string, bumping the pointer along. */
339 append (charPP
, fromP
, length
)
342 unsigned long length
;
344 /* Don't trust memcpy() of 0 chars. */
348 memcpy (*charPP
, fromP
, length
);
352 #ifndef BFD_ASSEMBLER
353 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
356 /* This routine records the largest alignment seen for each segment.
357 If the beginning of the segment is aligned on the worst-case
358 boundary, all of the other alignments within it will work. At
359 least one object format really uses this info. */
362 record_alignment (seg
, align
)
363 /* Segment to which alignment pertains. */
365 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
369 if (seg
== absolute_section
)
372 if ((unsigned int) align
> bfd_get_section_alignment (stdoutput
, seg
))
373 bfd_set_section_alignment (stdoutput
, seg
, align
);
375 if (align
> section_alignment
[(int) seg
])
376 section_alignment
[(int) seg
] = align
;
381 get_recorded_alignment (seg
)
384 if (seg
== absolute_section
)
387 return bfd_get_section_alignment (stdoutput
, seg
);
389 return section_alignment
[(int) seg
];
395 /* Reset the section indices after removing the gas created sections. */
398 renumber_sections (abfd
, sec
, countparg
)
399 bfd
*abfd ATTRIBUTE_UNUSED
;
403 int *countp
= (int *) countparg
;
405 sec
->index
= *countp
;
409 #endif /* defined (BFD_ASSEMBLER) */
411 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
414 chain_frchains_together_1 (section
, frchp
)
416 struct frchain
*frchp
;
418 fragS dummy
, *prev_frag
= &dummy
;
420 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
423 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
425 prev_frag
->fr_next
= frchp
->frch_root
;
426 prev_frag
= frchp
->frch_last
;
427 assert (prev_frag
->fr_type
!= 0);
429 if (frchp
->fix_root
!= (fixS
*) NULL
)
431 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
432 seg_info (section
)->fix_root
= frchp
->fix_root
;
433 prev_fix
->fx_next
= frchp
->fix_root
;
434 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
435 prev_fix
= frchp
->fix_tail
;
439 assert (prev_frag
->fr_type
!= 0);
440 prev_frag
->fr_next
= 0;
449 chain_frchains_together (abfd
, section
, xxx
)
450 bfd
*abfd ATTRIBUTE_UNUSED
;
452 PTR xxx ATTRIBUTE_UNUSED
;
454 segment_info_type
*info
;
456 /* BFD may have introduced its own sections without using
457 subseg_new, so it is possible that seg_info is NULL. */
458 info
= seg_info (section
);
459 if (info
!= (segment_info_type
*) NULL
)
460 info
->frchainP
->frch_last
461 = chain_frchains_together_1 (section
, info
->frchainP
);
463 /* Now that we've chained the frags together, we must add new fixups
464 to the segment, not to the frag chain. */
470 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
473 remove_subsegs (head
, seg
, root
, last
)
479 *root
= head
->frch_root
;
480 *last
= chain_frchains_together_1 (seg
, head
);
485 #if defined (BFD_ASSEMBLER) || !defined (BFD)
489 cvt_frag_to_fill (sec
, fragP
)
490 segT sec ATTRIBUTE_UNUSED
;
494 cvt_frag_to_fill (headersP
, sec
, fragP
)
495 object_headers
*headersP
;
500 switch (fragP
->fr_type
)
508 HANDLE_ALIGN (fragP
);
510 know (fragP
->fr_next
!= NULL
);
511 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
513 - fragP
->fr_fix
) / fragP
->fr_var
;
514 if (fragP
->fr_offset
< 0)
516 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
517 _("attempt to .org/.space backwards? (%ld)"),
518 (long) fragP
->fr_offset
);
520 fragP
->fr_type
= rs_fill
;
528 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
531 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
534 fragP
->fr_fix
+= size
;
535 fragP
->fr_type
= rs_fill
;
537 fragP
->fr_offset
= 0;
538 fragP
->fr_symbol
= NULL
;
543 eh_frame_convert_frag (fragP
);
547 dwarf2dbg_convert_frag (fragP
);
550 case rs_machine_dependent
:
552 md_convert_frag (stdoutput
, sec
, fragP
);
554 md_convert_frag (headersP
, sec
, fragP
);
557 assert (fragP
->fr_next
== NULL
558 || ((offsetT
) (fragP
->fr_next
->fr_address
- fragP
->fr_address
)
561 /* After md_convert_frag, we make the frag into a ".space 0".
562 md_convert_frag() should set up any fixSs and constants
567 #ifndef WORKING_DOT_WORD
570 struct broken_word
*lie
;
572 if (fragP
->fr_subtype
)
574 fragP
->fr_fix
+= md_short_jump_size
;
575 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
576 lie
&& lie
->dispfrag
== fragP
;
577 lie
= lie
->next_broken_word
)
579 fragP
->fr_fix
+= md_long_jump_size
;
587 BAD_CASE (fragP
->fr_type
);
592 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
596 relax_and_size_seg (abfd
, sec
, xxx
)
599 PTR xxx ATTRIBUTE_UNUSED
;
603 segment_info_type
*seginfo
;
605 valueT size
, newsize
;
607 subseg_change (sec
, 0);
609 flags
= bfd_get_section_flags (abfd
, sec
);
611 seginfo
= seg_info (sec
);
612 if (seginfo
&& seginfo
->frchainP
)
614 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
615 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
616 cvt_frag_to_fill (sec
, fragp
);
617 for (fragp
= seginfo
->frchainP
->frch_root
;
619 fragp
= fragp
->fr_next
)
620 /* Walk to last elt. */
622 size
= fragp
->fr_address
+ fragp
->fr_fix
;
627 if (size
> 0 && ! seginfo
->bss
)
628 flags
|= SEC_HAS_CONTENTS
;
630 /* @@ This is just an approximation. */
631 if (seginfo
&& seginfo
->fix_root
)
635 x
= bfd_set_section_flags (abfd
, sec
, flags
);
638 newsize
= md_section_align (sec
, size
);
639 x
= bfd_set_section_size (abfd
, sec
, newsize
);
642 /* If the size had to be rounded up, add some padding in the last
644 assert (newsize
>= size
);
647 fragS
*last
= seginfo
->frchainP
->frch_last
;
648 fragp
= seginfo
->frchainP
->frch_root
;
649 while (fragp
->fr_next
!= last
)
650 fragp
= fragp
->fr_next
;
651 last
->fr_address
= size
;
652 fragp
->fr_offset
+= newsize
- size
;
655 #ifdef tc_frob_section
656 tc_frob_section (sec
);
658 #ifdef obj_frob_section
659 obj_frob_section (sec
);
665 dump_section_relocs (abfd
, sec
, stream_
)
666 bfd
*abfd ATTRIBUTE_UNUSED
;
670 FILE *stream
= (FILE *) stream_
;
671 segment_info_type
*seginfo
= seg_info (sec
);
672 fixS
*fixp
= seginfo
->fix_root
;
677 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
680 symbolS
*s
= fixp
->fx_addsy
;
682 fprintf (stream
, " %08lx: type %d ", (unsigned long) fixp
,
683 (int) fixp
->fx_r_type
);
685 fprintf (stream
, "no sym\n");
688 print_symbol_value_1 (stream
, s
);
689 fprintf (stream
, "\n");
691 fixp
= fixp
->fx_next
;
695 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
698 #ifndef EMIT_SECTION_SYMBOLS
699 #define EMIT_SECTION_SYMBOLS 1
703 adjust_reloc_syms (abfd
, sec
, xxx
)
704 bfd
*abfd ATTRIBUTE_UNUSED
;
706 PTR xxx ATTRIBUTE_UNUSED
;
708 segment_info_type
*seginfo
= seg_info (sec
);
714 dump_section_relocs (abfd
, sec
, stderr
);
716 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
720 else if (fixp
->fx_addsy
)
726 fprintf (stderr
, "\n\nadjusting fixup:\n");
730 sym
= fixp
->fx_addsy
;
732 /* All symbols should have already been resolved at this
733 point. It is possible to see unresolved expression
734 symbols, though, since they are not in the regular symbol
737 resolve_symbol_value (sym
, 1);
739 if (fixp
->fx_subsy
!= NULL
)
740 resolve_symbol_value (fixp
->fx_subsy
, 1);
742 /* If this symbol is equated to an undefined symbol, convert
743 the fixup to being against that symbol. */
744 if (sym
!= NULL
&& symbol_equated_p (sym
)
745 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
747 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
748 sym
= symbol_get_value_expression (sym
)->X_add_symbol
;
749 fixp
->fx_addsy
= sym
;
752 if (sym
!= NULL
&& symbol_mri_common_p (sym
))
754 /* These symbols are handled specially in fixup_segment. */
758 symsec
= S_GET_SEGMENT (sym
);
763 if (bfd_is_abs_section (symsec
))
765 /* The fixup_segment routine will not use this symbol in a
766 relocation unless TC_FORCE_RELOCATION returns 1. */
767 if (TC_FORCE_RELOCATION (fixp
))
769 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
770 #ifdef UNDEFINED_DIFFERENCE_OK
771 if (fixp
->fx_subsy
!= NULL
)
772 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
778 /* If it's one of these sections, assume the symbol is
779 definitely going to be output. The code in
780 md_estimate_size_before_relax in tc-mips.c uses this test
781 as well, so if you change this code you should look at that
783 if (bfd_is_und_section (symsec
)
784 || bfd_is_com_section (symsec
))
786 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
787 #ifdef UNDEFINED_DIFFERENCE_OK
788 /* We have the difference of an undefined symbol and some
789 other symbol. Make sure to mark the other symbol as used
790 in a relocation so that it will always be output. */
792 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
797 /* Don't try to reduce relocs which refer to non-local symbols
798 in .linkonce sections. It can lead to confusion when a
799 debugging section refers to a .linkonce section. I hope
800 this will always be correct. */
801 if (symsec
!= sec
&& ! S_IS_LOCAL (sym
))
807 if ((bfd_get_section_flags (stdoutput
, symsec
) & SEC_LINK_ONCE
)
812 /* The GNU toolchain uses an extension for ELF: a section
813 beginning with the magic string .gnu.linkonce is a
815 if (strncmp (segment_name (symsec
), ".gnu.linkonce",
816 sizeof ".gnu.linkonce" - 1) == 0)
822 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
823 #ifdef UNDEFINED_DIFFERENCE_OK
824 if (fixp
->fx_subsy
!= NULL
)
825 symbol_mark_used_in_reloc (fixp
->fx_subsy
);
831 /* Since we're reducing to section symbols, don't attempt to reduce
832 anything that's already using one. */
833 if (symbol_section_p (sym
))
835 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
840 /* We can never adjust a reloc against a weak symbol. If we
841 did, and the weak symbol was overridden by a real symbol
842 somewhere else, then our relocation would be pointing at
843 the wrong area of memory. */
846 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
851 /* Is there some other reason we can't adjust this one? (E.g.,
852 call/bal links in i960-bout symbols.) */
853 #ifdef obj_fix_adjustable
854 if (! obj_fix_adjustable (fixp
))
856 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
861 /* Is there some other (target cpu dependent) reason we can't adjust
862 this one? (E.g. relocations involving function addresses on
864 #ifdef tc_fix_adjustable
865 if (! tc_fix_adjustable (fixp
))
867 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
872 /* If the section symbol isn't going to be output, the relocs
873 at least should still work. If not, figure out what to do
874 when we run into that case.
876 We refetch the segment when calling section_symbol, rather
877 than using symsec, because S_GET_VALUE may wind up changing
878 the section when it calls resolve_symbol_value. */
879 fixp
->fx_offset
+= S_GET_VALUE (sym
);
880 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
881 symbol_mark_used_in_reloc (fixp
->fx_addsy
);
883 fprintf (stderr
, "\nadjusted fixup:\n");
890 #if 1 /* def RELOC_REQUIRES_SYMBOL */
893 /* There was no symbol required by this relocation. However,
894 BFD doesn't really handle relocations without symbols well.
895 (At least, the COFF support doesn't.) So for now we fake up
896 a local symbol in the absolute section. */
898 fixp
->fx_addsy
= section_symbol (absolute_section
);
900 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
905 dump_section_relocs (abfd
, sec
, stderr
);
909 write_relocs (abfd
, sec
, xxx
)
912 PTR xxx ATTRIBUTE_UNUSED
;
914 segment_info_type
*seginfo
= seg_info (sec
);
921 /* If seginfo is NULL, we did not create this section; don't do
926 fixup_segment (seginfo
->fix_root
, sec
);
929 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
932 #ifndef RELOC_EXPANSION_POSSIBLE
933 /* Set up reloc information as well. */
934 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
935 memset ((char *) relocs
, 0, n
* sizeof (arelent
*));
938 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
941 bfd_reloc_status_type s
;
950 /* If this is an undefined symbol which was equated to another
951 symbol, then use generate the reloc against the latter symbol
952 rather than the former. */
953 sym
= fixp
->fx_addsy
;
954 while (symbol_equated_p (sym
)
955 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
959 /* We must avoid looping, as that can occur with a badly
961 n
= symbol_get_value_expression (sym
)->X_add_symbol
;
964 fixp
->fx_offset
+= symbol_get_value_expression (sym
)->X_add_number
;
967 fixp
->fx_addsy
= sym
;
969 reloc
= tc_gen_reloc (sec
, fixp
);
977 /* This test is triggered inappropriately for the SH. */
978 if (fixp
->fx_where
+ fixp
->fx_size
979 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
983 s
= bfd_install_relocation (stdoutput
, reloc
,
984 fixp
->fx_frag
->fr_literal
,
985 fixp
->fx_frag
->fr_address
,
991 case bfd_reloc_overflow
:
992 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, _("relocation overflow"));
994 case bfd_reloc_outofrange
:
995 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, _("relocation out of range"));
998 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
999 fixp
->fx_file
, fixp
->fx_line
, s
);
1001 relocs
[i
++] = reloc
;
1004 n
= n
* MAX_RELOC_EXPANSION
;
1005 /* Set up reloc information as well. */
1006 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
1009 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
1013 bfd_reloc_status_type s
;
1023 /* If this is an undefined symbol which was equated to another
1024 symbol, then generate the reloc against the latter symbol
1025 rather than the former. */
1026 sym
= fixp
->fx_addsy
;
1027 while (symbol_equated_p (sym
)
1028 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
1029 sym
= symbol_get_value_expression (sym
)->X_add_symbol
;
1030 fixp
->fx_addsy
= sym
;
1032 reloc
= tc_gen_reloc (sec
, fixp
);
1034 for (j
= 0; reloc
[j
]; j
++)
1036 relocs
[i
++] = reloc
[j
];
1039 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
1040 if (fixp
->fx_where
+ fixp
->fx_size
1041 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
1042 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1043 _("internal error: fixup not contained within frag"));
1044 for (j
= 0; reloc
[j
]; j
++)
1046 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
1047 fixp
->fx_frag
->fr_literal
,
1048 fixp
->fx_frag
->fr_address
,
1054 case bfd_reloc_overflow
:
1055 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1056 _("relocation overflow"));
1059 as_fatal (_("%s:%u: bad return from bfd_install_relocation"),
1060 fixp
->fx_file
, fixp
->fx_line
);
1071 sympp
= bfd_get_outsymbols (stdoutput
);
1072 nsyms
= bfd_get_symcount (stdoutput
);
1073 for (i
= 0; i
< n
; i
++)
1074 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1076 for (j
= 0; j
< nsyms
; j
++)
1077 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
1086 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1088 bfd_set_section_flags (abfd
, sec
,
1089 (bfd_get_section_flags (abfd
, sec
)
1090 & (flagword
) ~SEC_RELOC
));
1092 #ifdef SET_SECTION_RELOCS
1093 SET_SECTION_RELOCS (sec
, relocs
, n
);
1101 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1102 for (i
= 0; i
< n
; i
++)
1105 s
= *r
->sym_ptr_ptr
;
1106 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1107 i
, r
, r
->address
, s
->name
, r
->addend
);
1114 write_contents (abfd
, sec
, xxx
)
1115 bfd
*abfd ATTRIBUTE_UNUSED
;
1117 PTR xxx ATTRIBUTE_UNUSED
;
1119 segment_info_type
*seginfo
= seg_info (sec
);
1120 unsigned long offset
= 0;
1123 /* Write out the frags. */
1125 || !(bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1128 for (f
= seginfo
->frchainP
->frch_root
;
1133 unsigned long fill_size
;
1137 assert (f
->fr_type
== rs_fill
);
1140 x
= bfd_set_section_contents (stdoutput
, sec
,
1141 f
->fr_literal
, (file_ptr
) offset
,
1142 (bfd_size_type
) f
->fr_fix
);
1145 bfd_perror (stdoutput
->filename
);
1146 as_perror (_("FATAL: Can't write %s"), stdoutput
->filename
);
1147 exit (EXIT_FAILURE
);
1149 offset
+= f
->fr_fix
;
1151 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1152 fill_size
= f
->fr_var
;
1153 count
= f
->fr_offset
;
1154 assert (count
>= 0);
1155 if (fill_size
&& count
)
1158 if (fill_size
> sizeof (buf
))
1160 /* Do it the old way. Can this ever happen? */
1163 x
= bfd_set_section_contents (stdoutput
, sec
,
1166 (bfd_size_type
) fill_size
);
1169 bfd_perror (stdoutput
->filename
);
1170 as_perror (_("FATAL: Can't write %s"),
1171 stdoutput
->filename
);
1172 exit (EXIT_FAILURE
);
1174 offset
+= fill_size
;
1179 /* Build a buffer full of fill objects and output it as
1180 often as necessary. This saves on the overhead of
1181 potentially lots of bfd_set_section_contents calls. */
1185 n_per_buf
= sizeof (buf
);
1186 memset (buf
, *fill_literal
, n_per_buf
);
1191 n_per_buf
= sizeof (buf
) / fill_size
;
1192 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1193 memcpy (bufp
, fill_literal
, fill_size
);
1195 for (; count
> 0; count
-= n_per_buf
)
1197 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1198 x
= bfd_set_section_contents
1199 (stdoutput
, sec
, buf
, (file_ptr
) offset
,
1200 (bfd_size_type
) n_per_buf
* fill_size
);
1202 as_fatal (_("Cannot write to output file."));
1203 offset
+= n_per_buf
* fill_size
;
1211 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1213 merge_data_into_text ()
1215 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1216 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1217 seg_info (data_section
)->frchainP
->frch_root
;
1218 seg_info (text_section
)->frchainP
->frch_last
=
1219 seg_info (data_section
)->frchainP
->frch_last
;
1220 seg_info (data_section
)->frchainP
= 0;
1224 text_last_frag
->fr_next
= data_frag_root
;
1225 text_last_frag
= data_last_frag
;
1226 data_last_frag
= NULL
;
1227 data_frag_root
= NULL
;
1230 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1231 tmp
->fx_next
= data_fix_root
;
1232 text_fix_tail
= data_fix_tail
;
1235 text_fix_root
= data_fix_root
;
1236 data_fix_root
= NULL
;
1239 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1241 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1243 relax_and_size_all_segments ()
1247 relax_segment (text_frag_root
, SEG_TEXT
);
1248 relax_segment (data_frag_root
, SEG_DATA
);
1249 relax_segment (bss_frag_root
, SEG_BSS
);
1251 /* Now the addresses of frags are correct within the segment. */
1252 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1253 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1254 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1256 /* Join the 2 segments into 1 huge segment.
1257 To do this, re-compute every rn_address in the SEG_DATA frags.
1258 Then join the data frags after the text frags.
1260 Determine a_data [length of data segment]. */
1263 register relax_addressT slide
;
1265 know ((text_last_frag
->fr_type
== rs_fill
)
1266 && (text_last_frag
->fr_offset
== 0));
1268 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1269 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1270 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1272 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1273 /* For b.out: If the data section has a strict alignment
1274 requirement, its load address in the .o file will be
1275 rounded up from the size of the text section. These
1276 two values are *not* the same! Similarly for the bss
1278 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1281 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1282 fragP
->fr_address
+= slide
;
1284 know (text_last_frag
!= 0);
1285 text_last_frag
->fr_next
= data_frag_root
;
1289 H_SET_DATA_SIZE (&headers
, 0);
1293 /* See above comments on b.out data section address. */
1296 if (data_last_frag
== 0)
1297 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1299 bss_vma
= data_last_frag
->fr_address
;
1300 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1301 bss_address_frag
.fr_address
= bss_vma
;
1303 #else /* ! OBJ_BOUT */
1304 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1305 H_GET_DATA_SIZE (&headers
));
1307 #endif /* ! OBJ_BOUT */
1309 /* Slide all the frags. */
1312 relax_addressT slide
= bss_address_frag
.fr_address
;
1314 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1315 fragP
->fr_address
+= slide
;
1319 H_SET_BSS_SIZE (&headers
,
1320 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1322 H_SET_BSS_SIZE (&headers
, 0);
1324 #endif /* ! BFD_ASSEMBLER && ! BFD */
1326 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1328 #ifdef BFD_ASSEMBLER
1336 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1338 /* Count symbols. We can't rely on a count made by the loop in
1339 write_object_file, because *_frob_file may add a new symbol or
1342 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1349 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1350 nsyms
* sizeof (asymbol
*));
1351 symp
= symbol_rootP
;
1352 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1354 asympp
[i
] = symbol_get_bfdsym (symp
);
1355 symbol_mark_written (symp
);
1360 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1361 assert (result
== true);
1362 symbol_table_frozen
= 1;
1366 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1368 set_segment_vma (abfd
, sec
, xxx
)
1371 PTR xxx ATTRIBUTE_UNUSED
;
1373 static bfd_vma addr
= 0;
1375 bfd_set_section_vma (abfd
, sec
, addr
);
1376 addr
+= bfd_section_size (abfd
, sec
);
1378 #endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
1380 /* Finish the subsegments. After every sub-segment, we fake an
1381 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1382 ".fill 0" because that is the kind of frag that requires least
1383 thought. ".align" frags like to have a following frag since that
1384 makes calculating their intended length trivial. */
1386 #ifndef SUB_SEGMENT_ALIGN
1387 #ifdef BFD_ASSEMBLER
1388 #define SUB_SEGMENT_ALIGN(SEG) (0)
1390 #define SUB_SEGMENT_ALIGN(SEG) (2)
1397 struct frchain
*frchainP
;
1399 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1403 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1405 /* This now gets called even if we had errors. In that case,
1406 any alignment is meaningless, and, moreover, will look weird
1407 if we are generating a listing. */
1408 alignment
= had_errors () ? 0 : SUB_SEGMENT_ALIGN (now_seg
);
1410 /* The last subsegment gets an aligment corresponding to the
1411 alignment of the section. This allows proper nop-filling
1412 at the end of code-bearing sections. */
1413 if (!frchainP
->frch_next
|| frchainP
->frch_next
->frch_seg
!= now_seg
)
1414 alignment
= get_recorded_alignment (now_seg
);
1418 if (subseg_text_p (now_seg
))
1419 frag_align_code (alignment
, 0);
1421 frag_align (alignment
, 0, 0);
1424 /* frag_align will have left a new frag.
1425 Use this last frag for an empty ".fill".
1427 For this segment ...
1428 Create a last frag. Do not leave a "being filled in frag". */
1429 frag_wane (frag_now
);
1430 frag_now
->fr_fix
= 0;
1431 know (frag_now
->fr_next
== NULL
);
1435 /* Write the object file. */
1438 write_object_file ()
1440 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1441 fragS
*fragP
; /* Track along all frags. */
1444 /* Do we really want to write it? */
1446 int n_warns
, n_errs
;
1447 n_warns
= had_warnings ();
1448 n_errs
= had_errors ();
1449 /* The -Z flag indicates that an object file should be generated,
1450 regardless of warnings and errors. */
1451 if (flag_always_generate_output
)
1453 if (n_warns
|| n_errs
)
1454 as_warn (_("%d error%s, %d warning%s, generating bad object file.\n"),
1455 n_errs
, n_errs
== 1 ? "" : "s",
1456 n_warns
, n_warns
== 1 ? "" : "s");
1461 as_fatal (_("%d error%s, %d warning%s, no object file generated.\n"),
1462 n_errs
, n_errs
== 1 ? "" : "s",
1463 n_warns
, n_warns
== 1 ? "" : "s");
1468 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1469 a routine to check for the definition of the procedure "_main",
1470 and if so -- fix it up so that it can be program entry point. */
1471 vms_check_for_main ();
1472 #endif /* OBJ_VMS */
1474 /* From now on, we don't care about sub-segments. Build one frag chain
1475 for each segment. Linked thru fr_next. */
1477 #ifdef BFD_ASSEMBLER
1478 /* Remove the sections created by gas for its own purposes. */
1480 asection
**seclist
, *sec
;
1483 seclist
= &stdoutput
->sections
;
1484 while (seclist
&& *seclist
)
1487 while (sec
== reg_section
|| sec
== expr_section
)
1491 stdoutput
->section_count
--;
1496 seclist
= &(*seclist
)->next
;
1499 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1502 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1504 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1505 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1506 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1509 /* We have two segments. If user gave -R flag, then we must put the
1510 data frags into the text segment. Do this before relaxing so
1511 we know to take advantage of -R and make shorter addresses. */
1512 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1513 if (flag_readonly_data_in_text
)
1515 merge_data_into_text ();
1519 #ifdef BFD_ASSEMBLER
1520 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1522 relax_and_size_all_segments ();
1523 #endif /* BFD_ASSEMBLER */
1525 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1526 /* Now that the segments have their final sizes, run through the
1527 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1528 should too. Currently, only DJGPP uses this code, but other
1529 COFF targets may need to execute this too. */
1530 bfd_map_over_sections (stdoutput
, set_segment_vma
, (char *) 0);
1533 #ifndef BFD_ASSEMBLER
1534 /* Crawl the symbol chain.
1536 For each symbol whose value depends on a frag, take the address of
1537 that frag and subsume it into the value of the symbol.
1538 After this, there is just one way to lookup a symbol value.
1539 Values are left in their final state for object file emission.
1540 We adjust the values of 'L' local symbols, even if we do
1541 not intend to emit them to the object file, because their values
1542 are needed for fix-ups.
1544 Unless we saw a -L flag, remove all symbols that begin with 'L'
1545 from the symbol chain. (They are still pointed to by the fixes.)
1547 Count the remaining symbols.
1548 Assign a symbol number to each symbol.
1549 Count the number of string-table chars we will emit.
1550 Put this info into the headers as appropriate. */
1551 know (zero_address_frag
.fr_address
== 0);
1552 string_byte_count
= sizeof (string_byte_count
);
1554 obj_crawl_symbol_chain (&headers
);
1556 if (string_byte_count
== sizeof (string_byte_count
))
1557 string_byte_count
= 0;
1559 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1561 /* Addresses of frags now reflect addresses we use in the object file.
1562 Symbol values are correct.
1563 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1564 Also converting any machine-dependent frags using md_convert_frag(); */
1565 subseg_change (SEG_TEXT
, 0);
1567 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1569 /* At this point we have linked all the frags into a single
1570 chain. However, cvt_frag_to_fill may call md_convert_frag
1571 which may call fix_new. We need to ensure that fix_new adds
1572 the fixup to the right section. */
1573 if (fragP
== data_frag_root
)
1574 subseg_change (SEG_DATA
, 0);
1576 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1578 /* Some assert macros don't work with # directives mixed in. */
1580 if (!(fragP
->fr_next
== NULL
1582 || fragP
->fr_next
== data_frag_root
1584 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1585 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1589 #endif /* ! BFD_ASSEMBLER */
1591 #ifndef WORKING_DOT_WORD
1593 struct broken_word
*lie
;
1594 struct broken_word
**prevP
;
1596 prevP
= &broken_words
;
1597 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1602 subseg_change (lie
->seg
, lie
->subseg
);
1603 exp
.X_op
= O_subtract
;
1604 exp
.X_add_symbol
= lie
->add
;
1605 exp
.X_op_symbol
= lie
->sub
;
1606 exp
.X_add_number
= lie
->addnum
;
1607 #ifdef BFD_ASSEMBLER
1608 #ifdef TC_CONS_FIX_NEW
1609 TC_CONS_FIX_NEW (lie
->frag
,
1610 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1613 fix_new_exp (lie
->frag
,
1614 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1615 2, &exp
, 0, BFD_RELOC_16
);
1618 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1619 fix_new_exp (lie
->frag
,
1620 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1621 2, &exp
, 0, NO_RELOC
);
1624 fix_new_ns32k_exp (lie
->frag
,
1625 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1626 2, &exp
, 0, 0, 2, 0, 0);
1628 fix_new_exp (lie
->frag
,
1629 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1631 #endif /* TC_NS32K */
1632 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1633 #endif /* BFD_ASSEMBLER */
1634 *prevP
= lie
->next_broken_word
;
1637 prevP
= &(lie
->next_broken_word
);
1639 for (lie
= broken_words
; lie
;)
1641 struct broken_word
*untruth
;
1643 addressT table_addr
;
1644 addressT from_addr
, to_addr
;
1647 subseg_change (lie
->seg
, lie
->subseg
);
1648 fragP
= lie
->dispfrag
;
1650 /* Find out how many broken_words go here. */
1653 untruth
&& untruth
->dispfrag
== fragP
;
1654 untruth
= untruth
->next_broken_word
)
1655 if (untruth
->added
== 1)
1658 table_ptr
= lie
->dispfrag
->fr_opcode
;
1659 table_addr
= (lie
->dispfrag
->fr_address
1660 + (table_ptr
- lie
->dispfrag
->fr_literal
));
1661 /* Create the jump around the long jumps. This is a short
1662 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1663 from_addr
= table_addr
;
1664 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1665 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1667 table_ptr
+= md_short_jump_size
;
1668 table_addr
+= md_short_jump_size
;
1671 lie
&& lie
->dispfrag
== fragP
;
1672 m
++, lie
= lie
->next_broken_word
)
1674 if (lie
->added
== 2)
1676 /* Patch the jump table. */
1677 /* This is the offset from ??? to table_ptr+0. */
1678 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1679 #ifdef BFD_ASSEMBLER
1680 to_addr
-= symbol_get_frag (lie
->sub
)->fr_address
;
1682 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1683 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr
, lie
);
1685 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1686 for (untruth
= lie
->next_broken_word
;
1687 untruth
&& untruth
->dispfrag
== fragP
;
1688 untruth
= untruth
->next_broken_word
)
1690 if (untruth
->use_jump
== lie
)
1691 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1694 /* Install the long jump. */
1695 /* This is a long jump from table_ptr+0 to the final target. */
1696 from_addr
= table_addr
;
1697 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1698 #ifdef BFD_ASSEMBLER
1699 to_addr
+= symbol_get_frag (lie
->add
)->fr_address
;
1701 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
,
1703 table_ptr
+= md_long_jump_size
;
1704 table_addr
+= md_long_jump_size
;
1708 #endif /* not WORKING_DOT_WORD */
1710 #ifndef BFD_ASSEMBLER
1713 char *the_object_file
;
1714 long object_file_size
;
1715 /* Scan every FixS performing fixups. We had to wait until now to
1716 do this because md_convert_frag() may have made some fixSs. */
1719 subseg_change (SEG_TEXT
, 0);
1720 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1721 subseg_change (SEG_DATA
, 0);
1722 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1723 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1725 /* FIXME: Move this stuff into the pre-write-hook. */
1726 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1727 H_SET_ENTRY_POINT (&headers
, 0);
1729 obj_pre_write_hook (&headers
); /* Extra coff stuff. */
1731 object_file_size
= H_GET_FILE_SIZE (&headers
);
1732 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1734 output_file_create (out_file_name
);
1736 obj_header_append (&next_object_file_charP
, &headers
);
1738 know ((next_object_file_charP
- the_object_file
)
1739 == H_GET_HEADER_SIZE (&headers
));
1742 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1744 register long count
;
1745 register char *fill_literal
;
1746 register long fill_size
;
1749 know (fragP
->fr_type
== rs_fill
);
1750 append (&next_object_file_charP
, fragP
->fr_literal
,
1751 (unsigned long) fragP
->fr_fix
);
1752 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1753 fill_size
= fragP
->fr_var
;
1754 know (fragP
->fr_offset
>= 0);
1756 for (count
= fragP
->fr_offset
; count
; count
--)
1757 append (&next_object_file_charP
, fill_literal
,
1758 (unsigned long) fill_size
);
1761 know ((next_object_file_charP
- the_object_file
)
1762 == (H_GET_HEADER_SIZE (&headers
)
1763 + H_GET_TEXT_SIZE (&headers
)
1764 + H_GET_DATA_SIZE (&headers
)));
1766 /* Emit relocations. */
1767 obj_emit_relocations (&next_object_file_charP
, text_fix_root
,
1768 (relax_addressT
) 0);
1769 know ((next_object_file_charP
- the_object_file
)
1770 == (H_GET_HEADER_SIZE (&headers
)
1771 + H_GET_TEXT_SIZE (&headers
)
1772 + H_GET_DATA_SIZE (&headers
)
1773 + H_GET_TEXT_RELOCATION_SIZE (&headers
)));
1775 /* Make addresses in data relocation directives relative to beginning of
1776 first data fragment, not end of last text fragment: alignment of the
1777 start of the data segment may place a gap between the segments. */
1778 obj_emit_relocations (&next_object_file_charP
, data_fix_root
,
1779 data0_frchainP
->frch_root
->fr_address
);
1781 obj_emit_relocations (&next_object_file_charP
, data_fix_root
,
1782 text_last_frag
->fr_address
);
1783 #endif /* TC_I960 */
1785 know ((next_object_file_charP
- the_object_file
)
1786 == (H_GET_HEADER_SIZE (&headers
)
1787 + H_GET_TEXT_SIZE (&headers
)
1788 + H_GET_DATA_SIZE (&headers
)
1789 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1790 + H_GET_DATA_RELOCATION_SIZE (&headers
)));
1792 /* Emit line number entries. */
1793 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1794 know ((next_object_file_charP
- the_object_file
)
1795 == (H_GET_HEADER_SIZE (&headers
)
1796 + H_GET_TEXT_SIZE (&headers
)
1797 + H_GET_DATA_SIZE (&headers
)
1798 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1799 + H_GET_DATA_RELOCATION_SIZE (&headers
)
1800 + H_GET_LINENO_SIZE (&headers
)));
1803 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1804 know ((next_object_file_charP
- the_object_file
)
1805 == (H_GET_HEADER_SIZE (&headers
)
1806 + H_GET_TEXT_SIZE (&headers
)
1807 + H_GET_DATA_SIZE (&headers
)
1808 + H_GET_TEXT_RELOCATION_SIZE (&headers
)
1809 + H_GET_DATA_RELOCATION_SIZE (&headers
)
1810 + H_GET_LINENO_SIZE (&headers
)
1811 + H_GET_SYMBOL_TABLE_SIZE (&headers
)));
1814 if (string_byte_count
> 0)
1815 obj_emit_strings (&next_object_file_charP
);
1818 bfd_seek (stdoutput
, 0, 0);
1819 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1822 /* Write the data to the file. */
1823 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1824 free (the_object_file
);
1828 /* Now do the VMS-dependent part of writing the object file. */
1829 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1830 H_GET_DATA_SIZE (&headers
),
1831 H_GET_BSS_SIZE (&headers
),
1832 text_frag_root
, data_frag_root
);
1833 #endif /* OBJ_VMS */
1834 #else /* BFD_ASSEMBLER */
1836 /* Resolve symbol values. This needs to be done before processing
1842 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1843 resolve_symbol_value (symp
, 1);
1845 resolve_local_symbol_values ();
1849 #ifdef tc_frob_file_before_adjust
1850 tc_frob_file_before_adjust ();
1852 #ifdef obj_frob_file_before_adjust
1853 obj_frob_file_before_adjust ();
1856 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *) 0);
1858 /* Set up symbol table, and write it out. */
1863 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1868 if (symbol_mri_common_p (symp
))
1870 if (S_IS_EXTERNAL (symp
))
1871 as_bad (_("%s: global symbols not supported in common sections"),
1873 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1877 name
= S_GET_NAME (symp
);
1881 decode_local_label_name ((char *) S_GET_NAME (symp
));
1882 /* They only differ if `name' is a fb or dollar local
1884 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1885 as_bad (_("local label %s is not defined"), name2
);
1888 /* Do it again, because adjust_reloc_syms might introduce
1889 more symbols. They'll probably only be section symbols,
1890 but they'll still need to have the values computed. */
1891 resolve_symbol_value (symp
, 1);
1893 /* Skip symbols which were equated to undefined or common
1895 if (symbol_equated_p (symp
)
1896 && (! S_IS_DEFINED (symp
) || S_IS_COMMON (symp
)))
1898 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1902 /* So far, common symbols have been treated like undefined symbols.
1903 Put them in the common section now. */
1904 if (S_IS_DEFINED (symp
) == 0
1905 && S_GET_VALUE (symp
) != 0)
1906 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1908 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1909 S_GET_NAME (symp
), symp
,
1911 symbol_get_bfdsym (symp
)->flags
,
1912 segment_name (S_GET_SEGMENT (symp
)));
1915 #ifdef obj_frob_symbol
1916 obj_frob_symbol (symp
, punt
);
1918 #ifdef tc_frob_symbol
1919 if (! punt
|| symbol_used_in_reloc_p (symp
))
1920 tc_frob_symbol (symp
, punt
);
1923 /* If we don't want to keep this symbol, splice it out of
1924 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1925 want section symbols. Otherwise, we skip local symbols
1926 and symbols that the frob_symbol macros told us to punt,
1927 but we keep such symbols if they are used in relocs. */
1928 if ((! EMIT_SECTION_SYMBOLS
1929 && symbol_section_p (symp
))
1930 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1931 opposites. Sometimes the former checks flags and the
1932 latter examines the name... */
1933 || (!S_IS_EXTERN (symp
)
1934 && (S_IS_LOCAL (symp
) || punt
)
1935 && ! symbol_used_in_reloc_p (symp
)))
1937 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1939 /* After symbol_remove, symbol_next(symp) still returns
1940 the one that came after it in the chain. So we don't
1941 need to do any extra cleanup work here. */
1945 /* Make sure we really got a value for the symbol. */
1946 if (! symbol_resolved_p (symp
))
1948 as_bad (_("can't resolve value for symbol \"%s\""),
1950 symbol_mark_resolved (symp
);
1953 /* Set the value into the BFD symbol. Up til now the value
1954 has only been kept in the gas symbolS struct. */
1955 symbol_get_bfdsym (symp
)->value
= S_GET_VALUE (symp
);
1961 /* Now do any format-specific adjustments to the symbol table, such
1962 as adding file symbols. */
1963 #ifdef tc_adjust_symtab
1964 tc_adjust_symtab ();
1966 #ifdef obj_adjust_symtab
1967 obj_adjust_symtab ();
1970 /* Now that all the sizes are known, and contents correct, we can
1971 start writing to the file. */
1974 /* If *_frob_file changes the symbol value at this point, it is
1975 responsible for moving the changed value into symp->bsym->value
1976 as well. Hopefully all symbol value changing can be done in
1981 #ifdef obj_frob_file
1985 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1987 #ifdef tc_frob_file_after_relocs
1988 tc_frob_file_after_relocs ();
1990 #ifdef obj_frob_file_after_relocs
1991 obj_frob_file_after_relocs ();
1994 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1995 #endif /* BFD_ASSEMBLER */
1999 #ifdef TC_GENERIC_RELAX_TABLE
2001 static int is_dnrange
PARAMS ((fragS
*, fragS
*));
2003 /* Subroutines of relax_segment. */
2009 for (; f1
; f1
= f1
->fr_next
)
2010 if (f1
->fr_next
== f2
)
2015 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2018 relax_frag (fragP
, stretch
)
2022 const relax_typeS
*this_type
;
2023 const relax_typeS
*start_type
;
2024 relax_substateT next_state
;
2025 relax_substateT this_state
;
2026 long aim
, target
, growth
;
2027 symbolS
*symbolP
= fragP
->fr_symbol
;
2028 long offset
= fragP
->fr_offset
;
2029 /* Recompute was_address by undoing "+= stretch" done by relax_segment. */
2030 unsigned long was_address
= fragP
->fr_address
- stretch
;
2031 unsigned long address
= fragP
->fr_address
;
2032 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
2034 this_state
= fragP
->fr_subtype
;
2035 start_type
= this_type
= table
+ this_state
;
2040 #ifndef DIFF_EXPR_OK
2041 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2042 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2043 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2044 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2045 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2047 know (symbolP
->sy_frag
);
2049 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2050 || symbolP
->sy_frag
== &zero_address_frag
);
2051 target
+= S_GET_VALUE (symbolP
) + symbol_get_frag (symbolP
)->fr_address
;
2053 /* If frag has yet to be reached on this pass,
2054 assume it will move by STRETCH just as we did.
2055 If this is not so, it will be because some frag
2056 between grows, and that will force another pass.
2058 Beware zero-length frags.
2060 There should be a faster way to do this. */
2062 if (symbol_get_frag (symbolP
)->fr_address
>= was_address
2063 && is_dnrange (fragP
, symbol_get_frag (symbolP
)))
2069 aim
= target
- address
- fragP
->fr_fix
;
2070 #ifdef TC_PCREL_ADJUST
2071 /* Currently only the ns32k family needs this. */
2072 aim
+= TC_PCREL_ADJUST (fragP
);
2074 /* This machine doesn't want to use pcrel_adjust.
2075 In that case, pcrel_adjust should be zero. */
2077 assert (fragP
->fr_targ
.ns32k
.pcrel_adjust
== 0);
2080 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2081 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2086 /* Look backwards. */
2087 for (next_state
= this_type
->rlx_more
; next_state
;)
2088 if (aim
>= this_type
->rlx_backward
)
2092 /* Grow to next state. */
2093 this_state
= next_state
;
2094 this_type
= table
+ this_state
;
2095 next_state
= this_type
->rlx_more
;
2100 /* Look forwards. */
2101 for (next_state
= this_type
->rlx_more
; next_state
;)
2102 if (aim
<= this_type
->rlx_forward
)
2106 /* Grow to next state. */
2107 this_state
= next_state
;
2108 this_type
= table
+ this_state
;
2109 next_state
= this_type
->rlx_more
;
2113 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2115 fragP
->fr_subtype
= this_state
;
2119 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2121 /* Relax_align. Advance location counter to next address that has 'alignment'
2122 lowest order bits all 0s, return size of adjustment made. */
2123 static relax_addressT
2124 relax_align (address
, alignment
)
2125 register relax_addressT address
; /* Address now. */
2126 register int alignment
; /* Alignment (binary). */
2128 relax_addressT mask
;
2129 relax_addressT new_address
;
2131 mask
= ~((~0) << alignment
);
2132 new_address
= (address
+ mask
) & (~mask
);
2133 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2135 /* We must provide lots of padding, so the linker can discard it
2136 when needed. The linker will not add extra space, ever. */
2137 new_address
+= (1 << alignment
);
2139 return (new_address
- address
);
2142 /* Now we have a segment, not a crowd of sub-segments, we can make
2147 After this, all frags in this segment have addresses that are correct
2148 within the segment. Since segments live in different file addresses,
2149 these frag addresses may not be the same as final object-file
2153 relax_segment (segment_frag_root
, segment
)
2154 struct frag
*segment_frag_root
;
2157 register struct frag
*fragP
;
2158 register relax_addressT address
;
2159 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2160 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
2162 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2163 subseg_change (segment
, 0);
2165 /* For each frag in segment: count and store (a 1st guess of)
2168 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2170 fragP
->fr_address
= address
;
2171 address
+= fragP
->fr_fix
;
2173 switch (fragP
->fr_type
)
2176 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2183 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2185 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2188 if (offset
% fragP
->fr_var
!= 0)
2190 as_bad (_("alignment padding (%lu bytes) not a multiple of %ld"),
2191 (unsigned long) offset
, (long) fragP
->fr_var
);
2192 offset
-= (offset
% fragP
->fr_var
);
2201 /* Assume .org is nugatory. It will grow with 1st relax. */
2204 case rs_machine_dependent
:
2205 address
+= md_estimate_size_before_relax (fragP
, segment
);
2208 #ifndef WORKING_DOT_WORD
2209 /* Broken words don't concern us yet. */
2210 case rs_broken_word
:
2215 /* Initial guess is always 1; doing otherwise can result in
2216 stable solutions that are larger than the minimum. */
2217 address
+= fragP
->fr_offset
= 1;
2221 address
+= eh_frame_estimate_size_before_relax (fragP
);
2225 address
+= dwarf2dbg_estimate_size_before_relax (fragP
);
2229 BAD_CASE (fragP
->fr_type
);
2236 long stretch
; /* May be any size, 0 or negative. */
2237 /* Cumulative number of addresses we have relaxed this pass.
2238 We may have relaxed more than one address. */
2239 long stretched
; /* Have we stretched on this pass? */
2240 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2241 grew, and another shrank. If a branch instruction doesn't fit anymore,
2242 we could be scrod. */
2246 stretch
= stretched
= 0;
2248 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2251 addressT was_address
;
2255 was_address
= fragP
->fr_address
;
2256 address
= fragP
->fr_address
+= stretch
;
2257 symbolP
= fragP
->fr_symbol
;
2258 offset
= fragP
->fr_offset
;
2260 switch (fragP
->fr_type
)
2262 case rs_fill
: /* .fill never relaxes. */
2266 #ifndef WORKING_DOT_WORD
2267 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2268 for it I do not want to write it. I do not want to have
2269 anything to do with it. This is not the proper way to
2270 implement this misfeature. */
2271 case rs_broken_word
:
2273 struct broken_word
*lie
;
2274 struct broken_word
*untruth
;
2276 /* Yes this is ugly (storing the broken_word pointer
2277 in the symbol slot). Still, this whole chunk of
2278 code is ugly, and I don't feel like doing anything
2279 about it. Think of it as stubbornness in action. */
2281 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2282 lie
&& lie
->dispfrag
== fragP
;
2283 lie
= lie
->next_broken_word
)
2289 offset
= (symbol_get_frag (lie
->add
)->fr_address
2290 + S_GET_VALUE (lie
->add
)
2292 - (symbol_get_frag (lie
->sub
)->fr_address
2293 + S_GET_VALUE (lie
->sub
)));
2294 if (offset
<= -32768 || offset
>= 32767)
2296 if (flag_warn_displacement
)
2299 sprint_value (buf
, (addressT
) lie
->addnum
);
2300 as_warn (_(".word %s-%s+%s didn't fit"),
2301 S_GET_NAME (lie
->add
),
2302 S_GET_NAME (lie
->sub
),
2306 if (fragP
->fr_subtype
== 0)
2308 fragP
->fr_subtype
++;
2309 growth
+= md_short_jump_size
;
2311 for (untruth
= lie
->next_broken_word
;
2312 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2313 untruth
= untruth
->next_broken_word
)
2314 if ((symbol_get_frag (untruth
->add
)
2315 == symbol_get_frag (lie
->add
))
2316 && (S_GET_VALUE (untruth
->add
)
2317 == S_GET_VALUE (lie
->add
)))
2320 untruth
->use_jump
= lie
;
2322 growth
+= md_long_jump_size
;
2327 } /* case rs_broken_word */
2333 addressT oldoff
, newoff
;
2335 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2337 newoff
= relax_align (address
+ fragP
->fr_fix
,
2340 if (fragP
->fr_subtype
!= 0)
2342 if (oldoff
> fragP
->fr_subtype
)
2344 if (newoff
> fragP
->fr_subtype
)
2348 growth
= newoff
- oldoff
;
2354 long target
= offset
;
2359 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2360 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2361 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2362 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2363 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2364 know (symbolP
->sy_frag
);
2365 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2366 || (symbolP
->sy_frag
== &zero_address_frag
));
2368 target
+= (S_GET_VALUE (symbolP
)
2369 + symbol_get_frag (symbolP
)->fr_address
);
2370 } /* if we have a symbol */
2372 know (fragP
->fr_next
);
2373 after
= fragP
->fr_next
->fr_address
;
2374 growth
= target
- after
;
2377 /* Growth may be negative, but variable part of frag
2378 cannot have fewer than 0 chars. That is, we can't
2380 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2381 _("attempt to .org backwards ignored"));
2383 /* We've issued an error message. Change the
2384 frag to avoid cascading errors. */
2385 fragP
->fr_type
= rs_align
;
2386 fragP
->fr_subtype
= 0;
2387 fragP
->fr_offset
= 0;
2388 fragP
->fr_fix
= after
- address
;
2392 /* This is an absolute growth factor */
2400 growth
= S_GET_VALUE (symbolP
);
2401 if (symbol_get_frag (symbolP
) != &zero_address_frag
2402 || S_IS_COMMON (symbolP
)
2403 || ! S_IS_DEFINED (symbolP
))
2404 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2405 _(".space specifies non-absolute value"));
2406 fragP
->fr_symbol
= 0;
2409 as_warn (_(".space or .fill with negative value, ignored"));
2417 case rs_machine_dependent
:
2418 #ifdef md_relax_frag
2419 growth
= md_relax_frag (fragP
, stretch
);
2421 #ifdef TC_GENERIC_RELAX_TABLE
2422 /* The default way to relax a frag is to look through
2423 TC_GENERIC_RELAX_TABLE. */
2424 growth
= relax_frag (fragP
, stretch
);
2425 #endif /* TC_GENERIC_RELAX_TABLE */
2434 value
= resolve_symbol_value (fragP
->fr_symbol
, 0);
2435 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2436 growth
= size
- fragP
->fr_offset
;
2437 fragP
->fr_offset
= size
;
2442 growth
= eh_frame_relax_frag (fragP
);
2446 growth
= dwarf2dbg_relax_frag (fragP
);
2450 BAD_CASE (fragP
->fr_type
);
2458 } /* For each frag in the segment. */
2460 while (stretched
); /* Until nothing further to relax. */
2463 /* We now have valid fr_address'es for each frag. */
2465 /* All fr_address's are correct, relative to their own segment.
2466 We have made all the fixS we will ever make. */
2469 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2471 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2472 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2477 Go through all the fixS's in a segment and see which ones can be
2478 handled now. (These consist of fixS where we have since discovered
2479 the value of a symbol, or the address of the frag involved.)
2480 For each one, call md_apply_fix to put the fix into the frag data.
2482 Result is a count of how many relocation structs will be needed to
2483 handle the remaining fixS's that we couldn't completely handle here.
2484 These will be output later by emit_relocations(). */
2487 fixup_segment (fixP
, this_segment_type
)
2488 register fixS
*fixP
;
2489 segT this_segment_type
; /* N_TYPE bits for segment. */
2491 long seg_reloc_count
= 0;
2492 symbolS
*add_symbolP
;
2493 symbolS
*sub_symbolP
;
2500 segT add_symbol_segment
= absolute_section
;
2502 /* If the linker is doing the relaxing, we must not do any fixups.
2504 Well, strictly speaking that's not true -- we could do any that are
2505 PC-relative and don't cross regions that could change size. And for the
2506 i960 (the only machine for which we've got a relaxing linker right now),
2507 we might be able to turn callx/callj into bal anyways in cases where we
2508 know the maximum displacement. */
2509 if (linkrelax
&& TC_LINKRELAX_FIXUP (this_segment_type
))
2511 for (; fixP
; fixP
= fixP
->fx_next
)
2513 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2514 return seg_reloc_count
;
2517 for (; fixP
; fixP
= fixP
->fx_next
)
2520 fprintf (stderr
, "\nprocessing fixup:\n");
2524 fragP
= fixP
->fx_frag
;
2526 where
= fixP
->fx_where
;
2527 place
= fragP
->fr_literal
+ where
;
2528 size
= fixP
->fx_size
;
2529 add_symbolP
= fixP
->fx_addsy
;
2530 #ifdef TC_VALIDATE_FIX
2531 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2533 sub_symbolP
= fixP
->fx_subsy
;
2534 add_number
= fixP
->fx_offset
;
2535 pcrel
= fixP
->fx_pcrel
;
2538 if (add_symbolP
!= NULL
2539 && symbol_mri_common_p (add_symbolP
))
2541 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2542 add_number
+= S_GET_VALUE (add_symbolP
);
2543 fixP
->fx_offset
= add_number
;
2544 add_symbolP
= fixP
->fx_addsy
=
2545 symbol_get_value_expression (add_symbolP
)->X_add_symbol
;
2549 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2553 resolve_symbol_value (sub_symbolP
, 1);
2554 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2556 if (add_symbolP
!= NULL
)
2558 add_number
+= S_GET_VALUE (add_symbolP
);
2560 fixP
->fx_addsy
= NULL
;
2563 /* It's just -sym. */
2564 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2566 add_number
-= S_GET_VALUE (sub_symbolP
);
2567 fixP
->fx_subsy
= NULL
;
2570 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2572 /* Should try converting to a constant. */
2577 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2578 _("Negative of non-absolute symbol %s"),
2579 S_GET_NAME (sub_symbolP
));
2581 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2582 && SEG_NORMAL (add_symbol_segment
))
2584 /* Difference of 2 symbols from same segment.
2585 Can't make difference of 2 undefineds: 'value' means
2586 something different for N_UNDF. */
2588 /* Makes no sense to use the difference of 2 arbitrary symbols
2589 as the target of a call instruction. */
2591 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2592 _("callj to difference of 2 symbols"));
2593 #endif /* TC_I960 */
2594 add_number
+= S_GET_VALUE (add_symbolP
) -
2595 S_GET_VALUE (sub_symbolP
);
2598 pcrel
= 0; /* No further pcrel processing. */
2600 /* Let the target machine make the final determination
2601 as to whether or not a relocation will be needed to
2602 handle this fixup. */
2603 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2606 fixP
->fx_addsy
= NULL
;
2607 fixP
->fx_subsy
= NULL
;
2612 /* Different segments in subtraction. */
2613 know (!(S_IS_EXTERNAL (sub_symbolP
)
2614 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2616 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2617 add_number
-= S_GET_VALUE (sub_symbolP
);
2620 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2622 /* Do this even if it's already described as
2623 pc-relative. For example, on the m68k, an
2624 operand of "pc@(foo-.-2)" should address
2625 "foo" in a pc-relative mode. */
2630 /* Make it pc-relative. */
2631 add_number
+= (MD_PCREL_FROM_SECTION (fixP
, this_segment_type
)
2632 - S_GET_VALUE (sub_symbolP
));
2639 #ifdef UNDEFINED_DIFFERENCE_OK
2640 /* The PA needs this for PIC code generation. We basically
2641 don't want to do anything if we have the difference of two
2642 symbols at this point. */
2645 /* Leave it alone. */
2648 #ifdef BFD_ASSEMBLER
2649 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2650 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2652 /* Leave it alone. */
2658 sprint_value (buf
, fragP
->fr_address
+ where
);
2659 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2660 _("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
2661 S_GET_NAME (add_symbolP
),
2662 segment_name (S_GET_SEGMENT (add_symbolP
)),
2663 S_GET_NAME (sub_symbolP
),
2664 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2672 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2673 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2675 /* This fixup was made when the symbol's segment was
2676 SEG_UNKNOWN, but it is now in the local segment.
2677 So we know how to do the address without relocation. */
2679 /* reloc_callj() may replace a 'call' with a 'calls' or a
2680 'bal', in which cases it modifies *fixP as appropriate.
2681 In the case of a 'calls', no further work is required,
2682 and *fixP has been set up to make the rest of the code
2685 #endif /* TC_I960 */
2687 add_number
+= S_GET_VALUE (add_symbolP
);
2688 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2689 /* Lie. Don't want further pcrel processing. */
2692 /* Let the target machine make the final determination
2693 as to whether or not a relocation will be needed to
2694 handle this fixup. */
2695 if (!TC_FORCE_RELOCATION (fixP
))
2698 fixP
->fx_addsy
= NULL
;
2703 if (add_symbol_segment
== absolute_section
2707 /* See comment about reloc_callj() above. */
2709 #endif /* TC_I960 */
2710 add_number
+= S_GET_VALUE (add_symbolP
);
2712 /* Let the target machine make the final determination
2713 as to whether or not a relocation will be needed to
2714 handle this fixup. */
2716 if (!TC_FORCE_RELOCATION (fixP
))
2718 fixP
->fx_addsy
= NULL
;
2722 else if (add_symbol_segment
== undefined_section
2723 #ifdef BFD_ASSEMBLER
2724 || bfd_is_com_section (add_symbol_segment
)
2729 if ((int) fixP
->fx_bit_fixP
== 13)
2731 /* This is a COBR instruction. They have only a
2732 13-bit displacement and are only to be used
2733 for local branches: flag as error, don't generate
2735 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2736 _("can't use COBR format with external label"));
2737 fixP
->fx_addsy
= NULL
;
2741 #endif /* TC_I960 */
2745 if (S_IS_COMMON (add_symbolP
))
2746 add_number
+= S_GET_VALUE (add_symbolP
);
2747 #endif /* TE_I386AIX */
2748 #endif /* OBJ_COFF */
2754 if (TC_FIX_ADJUSTABLE (fixP
))
2755 add_number
+= S_GET_VALUE (add_symbolP
);
2762 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2763 if (add_symbolP
== 0)
2765 #ifndef BFD_ASSEMBLER
2766 fixP
->fx_addsy
= &abs_symbol
;
2768 fixP
->fx_addsy
= section_symbol (absolute_section
);
2770 symbol_mark_used_in_reloc (fixP
->fx_addsy
);
2777 #ifdef MD_APPLY_FIX3
2778 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2780 #ifdef BFD_ASSEMBLER
2781 md_apply_fix (fixP
, &add_number
);
2783 md_apply_fix (fixP
, add_number
);
2787 #ifndef TC_HANDLES_FX_DONE
2788 /* If the tc-* files haven't been converted, assume it's handling
2789 it the old way, where a null fx_addsy means that the fix has
2790 been applied completely, and no further work is needed. */
2791 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2796 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2798 if ((size_t) size
< sizeof (valueT
))
2803 mask
--; /* Set all bits to one. */
2804 mask
<<= size
* 8 - (fixP
->fx_signed
? 1 : 0);
2805 if ((add_number
& mask
) != 0 && (add_number
& mask
) != mask
)
2807 char buf
[50], buf2
[50];
2808 sprint_value (buf
, fragP
->fr_address
+ where
);
2809 if (add_number
> 1000)
2810 sprint_value (buf2
, add_number
);
2812 sprintf (buf2
, "%ld", (long) add_number
);
2813 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2814 _("Value of %s too large for field of %d bytes at %s"),
2816 } /* Generic error checking. */
2818 #ifdef WARN_SIGNED_OVERFLOW_WORD
2819 /* Warn if a .word value is too large when treated as a signed
2820 number. We already know it is not too negative. This is to
2821 catch over-large switches generated by gcc on the 68k. */
2822 if (!flag_signed_overflow_ok
2824 && add_number
> 0x7fff)
2825 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2826 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
2828 (unsigned long) (fragP
->fr_address
+ where
));
2830 } /* Not a bit fix. */
2832 #ifdef TC_VALIDATE_FIX
2833 skip
: ATTRIBUTE_UNUSED_LABEL
2837 fprintf (stderr
, "result:\n");
2840 } /* For each fixS in this segment. */
2842 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2843 return seg_reloc_count
;
2846 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2849 number_to_chars_bigendian (buf
, val
, n
)
2854 if ((size_t) n
> sizeof (val
) || n
<= 0)
2858 buf
[n
] = val
& 0xff;
2864 number_to_chars_littleendian (buf
, val
, n
)
2869 if ((size_t) n
> sizeof (val
) || n
<= 0)
2873 *buf
++ = val
& 0xff;
2879 write_print_statistics (file
)
2882 fprintf (file
, "fixups: %d\n", n_fixups
);
2885 /* For debugging. */
2886 extern int indent_level
;
2893 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2895 fprintf (stderr
, " pcrel");
2896 if (fixp
->fx_pcrel_adjust
)
2897 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2898 if (fixp
->fx_im_disp
)
2901 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2903 fprintf (stderr
, " im_disp");
2907 fprintf (stderr
, " tcbit");
2909 fprintf (stderr
, " done");
2910 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2911 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2912 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2913 #ifdef BFD_ASSEMBLER
2914 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2917 #ifdef NEED_FX_R_TYPE
2918 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2923 fprintf (stderr
, "\n +<");
2924 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2925 fprintf (stderr
, ">");
2929 fprintf (stderr
, "\n -<");
2930 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2931 fprintf (stderr
, ">");
2933 fprintf (stderr
, "\n");
2934 #ifdef TC_FIX_DATA_PRINT
2935 TC_FIX_DATA_PRINT (stderr
, fixp
);