1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 1997
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"
29 /* This looks like a good idea. Let's try turning it on always, for now. */
30 #undef BFD_FAST_SECTION_FILL
31 #define BFD_FAST_SECTION_FILL
33 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
34 instruction so that the disassembler does not choke on it. */
36 #define NOP_OPCODE 0x00
39 #ifndef TC_ADJUST_RELOC_COUNT
40 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
43 #ifndef TC_FORCE_RELOCATION
44 #define TC_FORCE_RELOCATION(FIXP) 0
47 #ifndef TC_FORCE_RELOCATION_SECTION
48 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
51 #ifndef MD_PCREL_FROM_SECTION
52 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
55 #ifndef WORKING_DOT_WORD
56 extern CONST
int md_short_jump_size
;
57 extern CONST
int md_long_jump_size
;
60 int symbol_table_frozen
;
61 void print_fixup
PARAMS ((fixS
*));
64 static void renumber_sections
PARAMS ((bfd
*, asection
*, PTR
));
66 /* We generally attach relocs to frag chains. However, after we have
67 chained these all together into a segment, any relocs we add after
68 that must be attached to a segment. This will include relocs added
69 in md_estimate_size_for_relax, for example. */
70 static int frags_chained
= 0;
76 struct frag
*text_frag_root
;
77 struct frag
*data_frag_root
;
78 struct frag
*bss_frag_root
;
80 struct frag
*text_last_frag
; /* Last frag in segment. */
81 struct frag
*data_last_frag
; /* Last frag in segment. */
82 static struct frag
*bss_last_frag
; /* Last frag in segment. */
86 static object_headers headers
;
89 long string_byte_count
;
90 char *next_object_file_charP
; /* Tracks object file bytes. */
93 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
96 #endif /* BFD_ASSEMBLER */
101 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
102 symbolS
*add
, symbolS
*sub
,
103 offsetT offset
, int pcrel
,
104 bfd_reloc_code_real_type r_type
));
106 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
107 symbolS
*add
, symbolS
*sub
,
108 offsetT offset
, int pcrel
,
111 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
112 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
114 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
115 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
116 static fragS
*chain_frchains_together_1
PARAMS ((segT
, struct frchain
*));
119 static void chain_frchains_together
PARAMS ((bfd
*, segT
, PTR
));
120 static void cvt_frag_to_fill
PARAMS ((segT
, fragS
*));
121 static void relax_and_size_seg
PARAMS ((bfd
*, asection
*, PTR
));
122 static void adjust_reloc_syms
PARAMS ((bfd
*, asection
*, PTR
));
123 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
124 static void write_contents
PARAMS ((bfd
*, asection
*, PTR
));
125 static void set_symtab
PARAMS ((void));
127 #if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
128 static void merge_data_into_text
PARAMS ((void));
130 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
131 static void cvt_frag_to_fill
PARAMS ((object_headers
*, segT
, fragS
*));
132 static void remove_subsegs
PARAMS ((frchainS
*, int, fragS
**, fragS
**));
133 static void relax_and_size_all_segments
PARAMS ((void));
139 * Create a fixS in obstack 'notes'.
142 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
144 fragS
*frag
; /* Which frag? */
145 int where
; /* Where in that frag? */
146 int size
; /* 1, 2, or 4 usually. */
147 symbolS
*add_symbol
; /* X_add_symbol. */
148 symbolS
*sub_symbol
; /* X_op_symbol. */
149 offsetT offset
; /* X_add_number. */
150 int pcrel
; /* TRUE if PC-relative relocation. */
152 bfd_reloc_code_real_type r_type
; /* Relocation type */
154 int r_type
; /* Relocation type */
161 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
163 fixP
->fx_frag
= frag
;
164 fixP
->fx_where
= where
;
165 fixP
->fx_size
= size
;
166 /* We've made fx_size a narrow field; check that it's wide enough. */
167 if (fixP
->fx_size
!= size
)
169 as_bad ("field fx_size too small to hold %d", size
);
172 fixP
->fx_addsy
= add_symbol
;
173 fixP
->fx_subsy
= sub_symbol
;
174 fixP
->fx_offset
= offset
;
175 fixP
->fx_pcrel
= pcrel
;
177 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
178 fixP
->fx_r_type
= r_type
;
180 fixP
->fx_im_disp
= 0;
181 fixP
->fx_pcrel_adjust
= 0;
182 fixP
->fx_bit_fixP
= 0;
183 fixP
->fx_addnumber
= 0;
186 fixP
->fx_no_overflow
= 0;
190 TC_INIT_FIX_DATA(fixP
);
193 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
195 /* Usually, we want relocs sorted numerically, but while
196 comparing to older versions of gas that have relocs
197 reverse sorted, it is convenient to have this compile
198 time option. xoxorich. */
203 fixS
**seg_fix_rootP
= (frags_chained
204 ? &seg_info (now_seg
)->fix_root
205 : &frchain_now
->fix_root
);
206 fixS
**seg_fix_tailP
= (frags_chained
207 ? &seg_info (now_seg
)->fix_tail
208 : &frchain_now
->fix_tail
);
211 #ifdef REVERSE_SORT_RELOCS
213 fixP
->fx_next
= *seg_fix_rootP
;
214 *seg_fix_rootP
= fixP
;
216 #else /* REVERSE_SORT_RELOCS */
218 fixP
->fx_next
= NULL
;
221 (*seg_fix_tailP
)->fx_next
= fixP
;
223 *seg_fix_rootP
= fixP
;
224 *seg_fix_tailP
= fixP
;
226 #endif /* REVERSE_SORT_RELOCS */
233 /* Create a fixup relative to a symbol (plus a constant). */
236 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
237 fragS
*frag
; /* Which frag? */
238 int where
; /* Where in that frag? */
239 int size
; /* 1, 2, or 4 usually. */
240 symbolS
*add_symbol
; /* X_add_symbol. */
241 offsetT offset
; /* X_add_number. */
242 int pcrel
; /* TRUE if PC-relative relocation. */
244 bfd_reloc_code_real_type r_type
; /* Relocation type */
246 int r_type
; /* Relocation type */
249 return fix_new_internal (frag
, where
, size
, add_symbol
,
250 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
253 /* Create a fixup for an expression. Currently we only support fixups
254 for difference expressions. That is itself more than most object
255 file formats support anyhow. */
258 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
259 fragS
*frag
; /* Which frag? */
260 int where
; /* Where in that frag? */
261 int size
; /* 1, 2, or 4 usually. */
262 expressionS
*exp
; /* Expression. */
263 int pcrel
; /* TRUE if PC-relative relocation. */
265 bfd_reloc_code_real_type r_type
; /* Relocation type */
267 int r_type
; /* Relocation type */
280 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
281 the difference expression cannot immediately be reduced. */
283 symbolS
*stmp
= make_expr_symbol (exp
);
284 exp
->X_op
= O_symbol
;
285 exp
->X_op_symbol
= 0;
286 exp
->X_add_symbol
= stmp
;
287 exp
->X_add_number
= 0;
288 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
292 add
= exp
->X_add_symbol
;
293 off
= exp
->X_add_number
;
295 #if defined(BFD_ASSEMBLER)
296 r_type
= BFD_RELOC_RVA
;
298 #if defined(TC_RVA_RELOC)
299 r_type
= TC_RVA_RELOC
;
301 as_fatal("rva not supported");
307 sub
= exp
->X_add_symbol
;
308 off
= exp
->X_add_number
;
312 sub
= exp
->X_op_symbol
;
315 add
= exp
->X_add_symbol
;
318 off
= exp
->X_add_number
;
322 add
= make_expr_symbol (exp
);
326 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
330 /* Append a string onto another string, bumping the pointer along. */
332 append (charPP
, fromP
, length
)
335 unsigned long length
;
337 /* Don't trust memcpy() of 0 chars. */
341 memcpy (*charPP
, fromP
, length
);
345 #ifndef BFD_ASSEMBLER
346 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
350 * This routine records the largest alignment seen for each segment.
351 * If the beginning of the segment is aligned on the worst-case
352 * boundary, all of the other alignments within it will work. At
353 * least one object format really uses this info.
356 record_alignment (seg
, align
)
357 /* Segment to which alignment pertains */
359 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
363 if (seg
== absolute_section
)
366 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
367 bfd_set_section_alignment (stdoutput
, seg
, align
);
369 if (align
> section_alignment
[(int) seg
])
370 section_alignment
[(int) seg
] = align
;
376 /* Reset the section indices after removing the gas created sections. */
379 renumber_sections (abfd
, sec
, countparg
)
384 int *countp
= (int *) countparg
;
386 sec
->index
= *countp
;
390 #endif /* defined (BFD_ASSEMBLER) */
392 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
395 chain_frchains_together_1 (section
, frchp
)
397 struct frchain
*frchp
;
399 fragS dummy
, *prev_frag
= &dummy
;
401 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
404 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
406 prev_frag
->fr_next
= frchp
->frch_root
;
407 prev_frag
= frchp
->frch_last
;
408 assert (prev_frag
->fr_type
!= 0);
410 if (frchp
->fix_root
!= (fixS
*) NULL
)
412 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
413 seg_info (section
)->fix_root
= frchp
->fix_root
;
414 prev_fix
->fx_next
= frchp
->fix_root
;
415 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
416 prev_fix
= frchp
->fix_tail
;
420 assert (prev_frag
->fr_type
!= 0);
421 prev_frag
->fr_next
= 0;
430 chain_frchains_together (abfd
, section
, xxx
)
431 bfd
*abfd
; /* unused */
433 PTR xxx
; /* unused */
435 segment_info_type
*info
;
437 /* BFD may have introduced its own sections without using
438 subseg_new, so it is possible that seg_info is NULL. */
439 info
= seg_info (section
);
440 if (info
!= (segment_info_type
*) NULL
)
441 info
->frchainP
->frch_last
442 = chain_frchains_together_1 (section
, info
->frchainP
);
444 /* Now that we've chained the frags together, we must add new fixups
445 to the segment, not to the frag chain. */
451 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
454 remove_subsegs (head
, seg
, root
, last
)
460 *root
= head
->frch_root
;
461 *last
= chain_frchains_together_1 (seg
, head
);
466 #if defined (BFD_ASSEMBLER) || !defined (BFD)
470 cvt_frag_to_fill (sec
, fragP
)
475 cvt_frag_to_fill (headersP
, sec
, fragP
)
476 object_headers
*headersP
;
481 switch (fragP
->fr_type
)
488 HANDLE_ALIGN (fragP
);
490 know (fragP
->fr_next
!= NULL
);
491 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
493 - fragP
->fr_fix
) / fragP
->fr_var
;
494 if (fragP
->fr_offset
< 0)
496 as_bad ("attempt to .org/.space backwards? (%ld)",
497 (long) fragP
->fr_offset
);
499 fragP
->fr_type
= rs_fill
;
507 valueT value
= S_GET_VALUE (fragP
->fr_symbol
);
510 size
= output_leb128 (fragP
->fr_literal
+ fragP
->fr_fix
, value
,
513 fragP
->fr_fix
+= size
;
514 fragP
->fr_type
= rs_fill
;
516 fragP
->fr_offset
= 0;
517 fragP
->fr_symbol
= NULL
;
521 case rs_machine_dependent
:
523 md_convert_frag (stdoutput
, sec
, fragP
);
525 md_convert_frag (headersP
, sec
, fragP
);
528 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
531 * After md_convert_frag, we make the frag into a ".space 0".
532 * Md_convert_frag() should set up any fixSs and constants
538 #ifndef WORKING_DOT_WORD
541 struct broken_word
*lie
;
543 if (fragP
->fr_subtype
)
545 fragP
->fr_fix
+= md_short_jump_size
;
546 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
547 lie
&& lie
->dispfrag
== fragP
;
548 lie
= lie
->next_broken_word
)
550 fragP
->fr_fix
+= md_long_jump_size
;
558 BAD_CASE (fragP
->fr_type
);
563 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
567 relax_and_size_seg (abfd
, sec
, xxx
)
574 segment_info_type
*seginfo
;
576 valueT size
, newsize
;
578 subseg_change (sec
, 0);
580 flags
= bfd_get_section_flags (abfd
, sec
);
582 seginfo
= seg_info (sec
);
583 if (seginfo
&& seginfo
->frchainP
)
585 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
586 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
587 cvt_frag_to_fill (sec
, fragp
);
588 for (fragp
= seginfo
->frchainP
->frch_root
;
590 fragp
= fragp
->fr_next
)
591 /* walk to last elt */;
592 size
= fragp
->fr_address
+ fragp
->fr_fix
;
597 if (size
> 0 && ! seginfo
->bss
)
598 flags
|= SEC_HAS_CONTENTS
;
600 /* @@ This is just an approximation. */
601 if (seginfo
&& seginfo
->fix_root
)
605 x
= bfd_set_section_flags (abfd
, sec
, flags
);
608 newsize
= md_section_align (sec
, size
);
609 x
= bfd_set_section_size (abfd
, sec
, newsize
);
612 /* If the size had to be rounded up, add some padding in the last
614 assert (newsize
>= size
);
617 fragS
*last
= seginfo
->frchainP
->frch_last
;
618 fragp
= seginfo
->frchainP
->frch_root
;
619 while (fragp
->fr_next
!= last
)
620 fragp
= fragp
->fr_next
;
621 last
->fr_address
= size
;
622 fragp
->fr_offset
+= newsize
- size
;
625 #ifdef tc_frob_section
626 tc_frob_section (sec
);
628 #ifdef obj_frob_section
629 obj_frob_section (sec
);
635 dump_section_relocs (abfd
, sec
, stream_
)
640 FILE *stream
= (FILE *) stream_
;
641 segment_info_type
*seginfo
= seg_info (sec
);
642 fixS
*fixp
= seginfo
->fix_root
;
647 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
650 symbolS
*s
= fixp
->fx_addsy
;
653 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
654 s
->bsym
->section
->name
);
655 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
657 fprintf (stream
, " section sym");
659 fprintf (stream
, "+%x", S_GET_VALUE (s
));
662 fprintf (stream
, "+%x", S_GET_VALUE (s
));
663 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
666 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
667 fixp
= fixp
->fx_next
;
671 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
674 #ifndef EMIT_SECTION_SYMBOLS
675 #define EMIT_SECTION_SYMBOLS 1
679 adjust_reloc_syms (abfd
, sec
, xxx
)
684 segment_info_type
*seginfo
= seg_info (sec
);
690 dump_section_relocs (abfd
, sec
, stderr
);
692 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
695 else if (fixp
->fx_addsy
)
703 fprintf (stderr
, "\n\nadjusting fixup:\n");
707 sym
= fixp
->fx_addsy
;
709 /* All symbols should have already been resolved at this
710 point. It is possible to see unresolved expression
711 symbols, though, since they are not in the regular symbol
713 if (sym
!= NULL
&& ! sym
->sy_resolved
)
714 resolve_symbol_value (sym
, 1);
715 if (fixp
->fx_subsy
!= NULL
&& ! fixp
->fx_subsy
->sy_resolved
)
716 resolve_symbol_value (fixp
->fx_subsy
, 1);
718 /* If this symbol is equated to an undefined symbol, convert
719 the fixup to being against that symbol. */
720 if (sym
->sy_value
.X_op
== O_symbol
721 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
723 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
724 sym
= sym
->sy_value
.X_add_symbol
;
725 fixp
->fx_addsy
= sym
;
728 symsec
= S_GET_SEGMENT (sym
);
730 if (sym
!= NULL
&& sym
->sy_mri_common
)
732 /* These symbols are handled specially in fixup_segment. */
736 if (bfd_is_abs_section (symsec
))
738 /* The fixup_segment routine will not use this symbol in a
739 relocation unless TC_FORCE_RELOCATION returns 1. */
740 if (TC_FORCE_RELOCATION (fixp
))
742 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
743 #ifdef UNDEFINED_DIFFERENCE_OK
744 if (fixp
->fx_subsy
!= NULL
)
745 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
751 /* If it's one of these sections, assume the symbol is
752 definitely going to be output. The code in
753 md_estimate_size_before_relax in tc-mips.c uses this test
754 as well, so if you change this code you should look at that
756 if (bfd_is_und_section (symsec
)
757 || bfd_is_com_section (symsec
))
759 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
760 #ifdef UNDEFINED_DIFFERENCE_OK
761 /* We have the difference of an undefined symbol and some
762 other symbol. Make sure to mark the other symbol as used
763 in a relocation so that it will always be output. */
765 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
770 /* Don't try to reduce relocs which refer to .linkonce
771 sections. It can lead to confusion when a debugging
772 section refers to a .linkonce section. I hope this will
773 always be correct. */
780 if ((bfd_get_section_flags (stdoutput
, symsec
) & SEC_LINK_ONCE
)
785 /* The GNU toolchain uses an extension for ELF: a section
786 beginning with the magic string .gnu.linkonce is a
788 if (strncmp (segment_name (symsec
), ".gnu.linkonce",
789 sizeof ".gnu.linkonce" - 1) == 0)
795 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
796 #ifdef UNDEFINED_DIFFERENCE_OK
797 if (fixp
->fx_subsy
!= NULL
)
798 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
804 /* Since we're reducing to section symbols, don't attempt to reduce
805 anything that's already using one. */
806 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
808 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
812 /* Is there some other reason we can't adjust this one? (E.g.,
813 call/bal links in i960-bout symbols.) */
814 #ifdef obj_fix_adjustable
815 if (! obj_fix_adjustable (fixp
))
817 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
822 /* Is there some other (target cpu dependent) reason we can't adjust
823 this one? (E.g. relocations involving function addresses on
825 #ifdef tc_fix_adjustable
826 if (! tc_fix_adjustable (fixp
))
828 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
833 /* If the section symbol isn't going to be output, the relocs
834 at least should still work. If not, figure out what to do
835 when we run into that case.
837 We refetch the segment when calling section_symbol, rather
838 than using symsec, because S_GET_VALUE may wind up changing
839 the section when it calls resolve_symbol_value. */
840 fixp
->fx_offset
+= S_GET_VALUE (sym
);
841 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
842 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
847 #if 1/*def RELOC_REQUIRES_SYMBOL*/
850 /* There was no symbol required by this relocation. However,
851 BFD doesn't really handle relocations without symbols well.
852 (At least, the COFF support doesn't.) So for now we fake up
853 a local symbol in the absolute section. */
855 fixp
->fx_addsy
= section_symbol (absolute_section
);
856 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
860 dump_section_relocs (abfd
, sec
, stderr
);
864 write_relocs (abfd
, sec
, xxx
)
869 segment_info_type
*seginfo
= seg_info (sec
);
876 /* If seginfo is NULL, we did not create this section; don't do
881 fixup_segment (seginfo
->fix_root
, sec
);
884 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
887 #ifndef RELOC_EXPANSION_POSSIBLE
888 /* Set up reloc information as well. */
889 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
890 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
893 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
896 bfd_reloc_status_type s
;
905 /* If this is an undefined symbol which was equated to another
906 symbol, then use generate the reloc against the latter symbol
907 rather than the former. */
908 sym
= fixp
->fx_addsy
;
909 while (sym
->sy_value
.X_op
== O_symbol
910 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
914 /* We must avoid looping, as that can occur with a badly
916 n
= sym
->sy_value
.X_add_symbol
;
919 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
922 fixp
->fx_addsy
= sym
;
924 reloc
= tc_gen_reloc (sec
, fixp
);
932 /* This test is triggered inappropriately for the SH. */
933 if (fixp
->fx_where
+ fixp
->fx_size
934 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
938 s
= bfd_install_relocation (stdoutput
, reloc
,
939 fixp
->fx_frag
->fr_literal
,
940 fixp
->fx_frag
->fr_address
,
946 case bfd_reloc_overflow
:
947 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
950 as_fatal ("%s:%u: bad return from bfd_install_relocation",
951 fixp
->fx_file
, fixp
->fx_line
);
956 n
= n
* MAX_RELOC_EXPANSION
;
957 /* Set up reloc information as well. */
958 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
961 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
965 bfd_reloc_status_type s
;
975 /* If this is an undefined symbol which was equated to another
976 symbol, then use generate the reloc against the latter symbol
977 rather than the former. */
978 sym
= fixp
->fx_addsy
;
979 while (sym
->sy_value
.X_op
== O_symbol
980 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
981 sym
= sym
->sy_value
.X_add_symbol
;
982 fixp
->fx_addsy
= sym
;
984 reloc
= tc_gen_reloc (sec
, fixp
);
986 for (j
= 0; reloc
[j
]; j
++)
988 relocs
[i
++] = reloc
[j
];
991 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
992 if (fixp
->fx_where
+ fixp
->fx_size
993 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
994 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
995 "internal error: fixup not contained within frag");
996 for (j
= 0; reloc
[j
]; j
++)
998 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
999 fixp
->fx_frag
->fr_literal
,
1000 fixp
->fx_frag
->fr_address
,
1006 case bfd_reloc_overflow
:
1007 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
1008 "relocation overflow");
1011 as_fatal ("%s:%u: bad return from bfd_install_relocation",
1012 fixp
->fx_file
, fixp
->fx_line
);
1023 sympp
= bfd_get_outsymbols (stdoutput
);
1024 nsyms
= bfd_get_symcount (stdoutput
);
1025 for (i
= 0; i
< n
; i
++)
1026 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1028 for (j
= 0; j
< nsyms
; j
++)
1029 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
1038 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1040 bfd_set_section_flags (abfd
, sec
,
1041 (bfd_get_section_flags (abfd
, sec
)
1042 & (flagword
) ~SEC_RELOC
));
1049 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1050 for (i
= 0; i
< n
; i
++)
1053 s
= *r
->sym_ptr_ptr
;
1054 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1055 i
, r
, r
->address
, s
->name
, r
->addend
);
1062 write_contents (abfd
, sec
, xxx
)
1067 segment_info_type
*seginfo
= seg_info (sec
);
1068 unsigned long offset
= 0;
1071 /* Write out the frags. */
1073 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1076 for (f
= seginfo
->frchainP
->frch_root
;
1081 unsigned long fill_size
;
1085 assert (f
->fr_type
== rs_fill
);
1088 x
= bfd_set_section_contents (stdoutput
, sec
,
1089 f
->fr_literal
, (file_ptr
) offset
,
1090 (bfd_size_type
) f
->fr_fix
);
1093 bfd_perror (stdoutput
->filename
);
1094 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1095 exit (EXIT_FAILURE
);
1097 offset
+= f
->fr_fix
;
1099 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1100 fill_size
= f
->fr_var
;
1101 count
= f
->fr_offset
;
1102 assert (count
>= 0);
1103 if (fill_size
&& count
)
1106 if (fill_size
> sizeof(buf
))
1108 /* Do it the old way. Can this ever happen? */
1111 x
= bfd_set_section_contents (stdoutput
, sec
,
1114 (bfd_size_type
) fill_size
);
1117 bfd_perror (stdoutput
->filename
);
1118 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1119 exit (EXIT_FAILURE
);
1121 offset
+= fill_size
;
1126 /* Build a buffer full of fill objects and output it as
1127 often as necessary. This saves on the overhead of
1128 potentially lots of bfd_set_section_contents calls. */
1132 n_per_buf
= sizeof (buf
);
1133 memset (buf
, *fill_literal
, n_per_buf
);
1138 n_per_buf
= sizeof(buf
)/fill_size
;
1139 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1140 memcpy(bufp
, fill_literal
, fill_size
);
1142 for (; count
> 0; count
-= n_per_buf
)
1144 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1145 x
= bfd_set_section_contents (stdoutput
, sec
,
1146 buf
, (file_ptr
) offset
,
1147 (bfd_size_type
) n_per_buf
* fill_size
);
1149 as_fatal ("Cannot write to output file.");
1150 offset
+= n_per_buf
* fill_size
;
1158 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1160 merge_data_into_text ()
1162 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1163 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1164 seg_info (data_section
)->frchainP
->frch_root
;
1165 seg_info (text_section
)->frchainP
->frch_last
=
1166 seg_info (data_section
)->frchainP
->frch_last
;
1167 seg_info (data_section
)->frchainP
= 0;
1171 text_last_frag
->fr_next
= data_frag_root
;
1172 text_last_frag
= data_last_frag
;
1173 data_last_frag
= NULL
;
1174 data_frag_root
= NULL
;
1177 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1178 tmp
->fx_next
= data_fix_root
;
1179 text_fix_tail
= data_fix_tail
;
1182 text_fix_root
= data_fix_root
;
1183 data_fix_root
= NULL
;
1186 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1188 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1190 relax_and_size_all_segments ()
1194 relax_segment (text_frag_root
, SEG_TEXT
);
1195 relax_segment (data_frag_root
, SEG_DATA
);
1196 relax_segment (bss_frag_root
, SEG_BSS
);
1198 * Now the addresses of frags are correct within the segment.
1201 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1202 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1203 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1206 * Join the 2 segments into 1 huge segment.
1207 * To do this, re-compute every rn_address in the SEG_DATA frags.
1208 * Then join the data frags after the text frags.
1210 * Determine a_data [length of data segment].
1214 register relax_addressT slide
;
1216 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1218 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1219 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1220 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1222 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1223 /* For b.out: If the data section has a strict alignment
1224 requirement, its load address in the .o file will be
1225 rounded up from the size of the text section. These
1226 two values are *not* the same! Similarly for the bss
1228 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1231 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1233 fragP
->fr_address
+= slide
;
1234 } /* for each data frag */
1236 know (text_last_frag
!= 0);
1237 text_last_frag
->fr_next
= data_frag_root
;
1241 H_SET_DATA_SIZE (&headers
, 0);
1245 /* See above comments on b.out data section address. */
1248 if (data_last_frag
== 0)
1249 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1251 bss_vma
= data_last_frag
->fr_address
;
1252 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1253 bss_address_frag
.fr_address
= bss_vma
;
1255 #else /* ! OBJ_BOUT */
1256 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1257 H_GET_DATA_SIZE (&headers
));
1259 #endif /* ! OBJ_BOUT */
1261 /* Slide all the frags */
1264 relax_addressT slide
= bss_address_frag
.fr_address
;
1266 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1268 fragP
->fr_address
+= slide
;
1269 } /* for each bss frag */
1273 H_SET_BSS_SIZE (&headers
,
1274 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1276 H_SET_BSS_SIZE (&headers
, 0);
1278 #endif /* ! BFD_ASSEMBLER && ! BFD */
1280 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1282 #ifdef BFD_ASSEMBLER
1290 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1292 /* Count symbols. We can't rely on a count made by the loop in
1293 write_object_file, because *_frob_file may add a new symbol or
1296 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1303 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1304 nsyms
* sizeof (asymbol
*));
1305 symp
= symbol_rootP
;
1306 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1308 asympp
[i
] = symp
->bsym
;
1314 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1315 assert (result
== true);
1316 symbol_table_frozen
= 1;
1320 /* Finish the subsegments. After every sub-segment, we fake an
1321 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1322 ".fill 0" because that is the kind of frag that requires least
1323 thought. ".align" frags like to have a following frag since that
1324 makes calculating their intended length trivial. */
1326 #ifndef SUB_SEGMENT_ALIGN
1327 #ifdef BFD_ASSEMBLER
1328 #define SUB_SEGMENT_ALIGN(SEG) (0)
1330 #define SUB_SEGMENT_ALIGN(SEG) (2)
1337 struct frchain
*frchainP
;
1339 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1341 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1342 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
, 0);
1344 /* frag_align will have left a new frag.
1345 Use this last frag for an empty ".fill".
1347 For this segment ...
1348 Create a last frag. Do not leave a "being filled in frag". */
1350 frag_wane (frag_now
);
1351 frag_now
->fr_fix
= 0;
1352 know (frag_now
->fr_next
== NULL
);
1356 /* Write the object file. */
1359 write_object_file ()
1361 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1362 fragS
*fragP
; /* Track along all frags. */
1365 /* Do we really want to write it? */
1367 int n_warns
, n_errs
;
1368 n_warns
= had_warnings ();
1369 n_errs
= had_errors ();
1370 /* The -Z flag indicates that an object file should be generated,
1371 regardless of warnings and errors. */
1372 if (flag_always_generate_output
)
1374 if (n_warns
|| n_errs
)
1375 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1376 n_errs
, n_errs
== 1 ? "" : "s",
1377 n_warns
, n_warns
== 1 ? "" : "s");
1382 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1383 n_errs
, n_errs
== 1 ? "" : "s",
1384 n_warns
, n_warns
== 1 ? "" : "s");
1389 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1390 a routine to check for the definition of the procedure "_main",
1391 and if so -- fix it up so that it can be program entry point. */
1392 vms_check_for_main ();
1393 #endif /* OBJ_VMS */
1395 /* From now on, we don't care about sub-segments. Build one frag chain
1396 for each segment. Linked thru fr_next. */
1398 #ifdef BFD_ASSEMBLER
1399 /* Remove the sections created by gas for its own purposes. */
1401 asection
**seclist
, *sec
;
1404 seclist
= &stdoutput
->sections
;
1405 while (seclist
&& *seclist
)
1408 while (sec
== reg_section
|| sec
== expr_section
)
1412 stdoutput
->section_count
--;
1417 seclist
= &(*seclist
)->next
;
1420 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1423 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1425 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1426 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1427 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1430 /* We have two segments. If user gave -R flag, then we must put the
1431 data frags into the text segment. Do this before relaxing so
1432 we know to take advantage of -R and make shorter addresses. */
1433 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1434 if (flag_readonly_data_in_text
)
1436 merge_data_into_text ();
1440 #ifdef BFD_ASSEMBLER
1441 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1443 relax_and_size_all_segments ();
1444 #endif /* BFD_ASSEMBLER */
1446 #ifndef BFD_ASSEMBLER
1449 * Crawl the symbol chain.
1451 * For each symbol whose value depends on a frag, take the address of
1452 * that frag and subsume it into the value of the symbol.
1453 * After this, there is just one way to lookup a symbol value.
1454 * Values are left in their final state for object file emission.
1455 * We adjust the values of 'L' local symbols, even if we do
1456 * not intend to emit them to the object file, because their values
1457 * are needed for fix-ups.
1459 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1460 * from the symbol chain. (They are still pointed to by the fixes.)
1462 * Count the remaining symbols.
1463 * Assign a symbol number to each symbol.
1464 * Count the number of string-table chars we will emit.
1465 * Put this info into the headers as appropriate.
1468 know (zero_address_frag
.fr_address
== 0);
1469 string_byte_count
= sizeof (string_byte_count
);
1471 obj_crawl_symbol_chain (&headers
);
1473 if (string_byte_count
== sizeof (string_byte_count
))
1474 string_byte_count
= 0;
1476 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1479 * Addresses of frags now reflect addresses we use in the object file.
1480 * Symbol values are correct.
1481 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1482 * Also converting any machine-dependent frags using md_convert_frag();
1484 subseg_change (SEG_TEXT
, 0);
1486 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1488 /* At this point we have linked all the frags into a single
1489 chain. However, cvt_frag_to_fill may call md_convert_frag
1490 which may call fix_new. We need to ensure that fix_new adds
1491 the fixup to the right section. */
1492 if (fragP
== data_frag_root
)
1493 subseg_change (SEG_DATA
, 0);
1495 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1497 /* Some assert macros don't work with # directives mixed in. */
1499 if (!(fragP
->fr_next
== NULL
1501 || fragP
->fr_next
== data_frag_root
1503 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1504 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1508 #endif /* ! BFD_ASSEMBLER */
1510 #ifndef WORKING_DOT_WORD
1512 struct broken_word
*lie
;
1513 struct broken_word
**prevP
;
1515 prevP
= &broken_words
;
1516 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1521 exp
.X_op
= O_subtract
;
1522 exp
.X_add_symbol
= lie
->add
;
1523 exp
.X_op_symbol
= lie
->sub
;
1524 exp
.X_add_number
= lie
->addnum
;
1525 #ifdef BFD_ASSEMBLER
1526 #ifdef TC_CONS_FIX_NEW
1527 TC_CONS_FIX_NEW (lie
->frag
,
1528 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1531 fix_new_exp (lie
->frag
,
1532 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1533 2, &exp
, 0, BFD_RELOC_16
);
1536 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1537 fix_new_exp (lie
->frag
,
1538 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1539 2, &exp
, 0, NO_RELOC
);
1542 fix_new_ns32k_exp (lie
->frag
,
1543 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1544 2, &exp
, 0, 0, 2, 0, 0);
1546 fix_new_exp (lie
->frag
,
1547 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1549 #endif /* TC_NS32K */
1550 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1551 #endif /* BFD_ASSEMBLER */
1552 *prevP
= lie
->next_broken_word
;
1555 prevP
= &(lie
->next_broken_word
);
1557 for (lie
= broken_words
; lie
;)
1559 struct broken_word
*untruth
;
1561 addressT table_addr
;
1562 addressT from_addr
, to_addr
;
1565 fragP
= lie
->dispfrag
;
1567 /* Find out how many broken_words go here. */
1569 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1570 if (untruth
->added
== 1)
1573 table_ptr
= lie
->dispfrag
->fr_opcode
;
1574 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1575 /* Create the jump around the long jumps. This is a short
1576 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1577 from_addr
= table_addr
;
1578 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1579 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1580 table_ptr
+= md_short_jump_size
;
1581 table_addr
+= md_short_jump_size
;
1583 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1585 if (lie
->added
== 2)
1587 /* Patch the jump table */
1588 /* This is the offset from ??? to table_ptr+0 */
1589 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1590 #ifdef BFD_ASSEMBLER
1591 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1593 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1594 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1596 if (untruth
->use_jump
== lie
)
1597 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1600 /* Install the long jump */
1601 /* this is a long jump from table_ptr+0 to the final target */
1602 from_addr
= table_addr
;
1603 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1604 #ifdef BFD_ASSEMBLER
1605 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1607 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1608 table_ptr
+= md_long_jump_size
;
1609 table_addr
+= md_long_jump_size
;
1613 #endif /* not WORKING_DOT_WORD */
1615 #ifndef BFD_ASSEMBLER
1618 char *the_object_file
;
1619 long object_file_size
;
1621 * Scan every FixS performing fixups. We had to wait until now to do
1622 * this because md_convert_frag() may have made some fixSs.
1626 subseg_change (SEG_TEXT
, 0);
1627 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1628 subseg_change (SEG_DATA
, 0);
1629 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1630 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1632 /* FIXME move this stuff into the pre-write-hook */
1633 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1634 H_SET_ENTRY_POINT (&headers
, 0);
1636 obj_pre_write_hook (&headers
); /* extra coff stuff */
1638 object_file_size
= H_GET_FILE_SIZE (&headers
);
1639 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1641 output_file_create (out_file_name
);
1643 obj_header_append (&next_object_file_charP
, &headers
);
1645 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1650 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1652 register long count
;
1653 register char *fill_literal
;
1654 register long fill_size
;
1657 know (fragP
->fr_type
== rs_fill
);
1658 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1659 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1660 fill_size
= fragP
->fr_var
;
1661 know (fragP
->fr_offset
>= 0);
1663 for (count
= fragP
->fr_offset
; count
; count
--)
1665 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1668 } /* for each code frag. */
1670 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1675 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1676 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
)));
1678 /* Make addresses in data relocation directives relative to beginning of
1679 * first data fragment, not end of last text fragment: alignment of the
1680 * start of the data segment may place a gap between the segments.
1682 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1684 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1685 #endif /* TC_I960 */
1687 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
) + H_GET_DATA_RELOCATION_SIZE (&headers
)));
1690 * Emit line number entries.
1692 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1693 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
) + H_GET_DATA_RELOCATION_SIZE (&headers
) + H_GET_LINENO_SIZE (&headers
)));
1698 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1699 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
) + H_GET_DATA_RELOCATION_SIZE (&headers
) + H_GET_LINENO_SIZE (&headers
) + H_GET_SYMBOL_TABLE_SIZE (&headers
)));
1705 if (string_byte_count
> 0)
1707 obj_emit_strings (&next_object_file_charP
);
1708 } /* only if we have a string table */
1711 bfd_seek (stdoutput
, 0, 0);
1712 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1715 /* Write the data to the file */
1716 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1717 free (the_object_file
);
1719 } /* non vms output */
1722 * Now do the VMS-dependent part of writing the object file
1724 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1725 H_GET_DATA_SIZE (&headers
),
1726 H_GET_BSS_SIZE (&headers
),
1727 text_frag_root
, data_frag_root
);
1728 #endif /* OBJ_VMS */
1729 #else /* BFD_ASSEMBLER */
1731 /* Resolve symbol values. This needs to be done before processing
1737 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1738 if (!symp
->sy_resolved
)
1739 resolve_symbol_value (symp
, 1);
1744 #ifdef tc_frob_file_before_adjust
1745 tc_frob_file_before_adjust ();
1747 #ifdef obj_frob_file_before_adjust
1748 obj_frob_file_before_adjust ();
1751 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1753 /* Set up symbol table, and write it out. */
1758 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1763 if (symp
->sy_mri_common
)
1765 if (S_IS_EXTERNAL (symp
))
1766 as_bad ("%s: global symbols not supported in common sections",
1768 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1772 name
= S_GET_NAME (symp
);
1775 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1776 /* They only differ if `name' is a fb or dollar local
1778 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1779 as_bad ("local label %s is not defined", name2
);
1782 /* Do it again, because adjust_reloc_syms might introduce
1783 more symbols. They'll probably only be section symbols,
1784 but they'll still need to have the values computed. */
1785 if (! symp
->sy_resolved
)
1787 if (symp
->sy_value
.X_op
== O_constant
)
1789 /* This is the normal case; skip the call. */
1792 + symp
->sy_frag
->fr_address
));
1793 symp
->sy_resolved
= 1;
1796 resolve_symbol_value (symp
, 1);
1799 /* Skip symbols which were equated to undefined or common
1801 if (symp
->sy_value
.X_op
== O_symbol
1802 && (! S_IS_DEFINED (symp
) || S_IS_COMMON (symp
)))
1804 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1808 /* So far, common symbols have been treated like undefined symbols.
1809 Put them in the common section now. */
1810 if (S_IS_DEFINED (symp
) == 0
1811 && S_GET_VALUE (symp
) != 0)
1812 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1814 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1815 S_GET_NAME (symp
), symp
,
1818 segment_name (symp
->bsym
->section
));
1821 #ifdef obj_frob_symbol
1822 obj_frob_symbol (symp
, punt
);
1824 #ifdef tc_frob_symbol
1825 if (! punt
|| symp
->sy_used_in_reloc
)
1826 tc_frob_symbol (symp
, punt
);
1829 /* If we don't want to keep this symbol, splice it out of
1830 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1831 want section symbols. Otherwise, we skip local symbols
1832 and symbols that the frob_symbol macros told us to punt,
1833 but we keep such symbols if they are used in relocs. */
1834 if ((! EMIT_SECTION_SYMBOLS
1835 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1836 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1837 opposites. Sometimes the former checks flags and the
1838 latter examines the name... */
1839 || (!S_IS_EXTERN (symp
)
1840 && (S_IS_LOCAL (symp
) || punt
)
1841 && ! symp
->sy_used_in_reloc
))
1843 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1844 /* After symbol_remove, symbol_next(symp) still returns
1845 the one that came after it in the chain. So we don't
1846 need to do any extra cleanup work here. */
1851 /* Make sure we really got a value for the symbol. */
1852 if (! symp
->sy_resolved
)
1854 as_bad ("can't resolve value for symbol \"%s\"",
1856 symp
->sy_resolved
= 1;
1859 /* Set the value into the BFD symbol. Up til now the value
1860 has only been kept in the gas symbolS struct. */
1861 symp
->bsym
->value
= S_GET_VALUE (symp
);
1867 /* Now do any format-specific adjustments to the symbol table, such
1868 as adding file symbols. */
1869 #ifdef tc_adjust_symtab
1870 tc_adjust_symtab ();
1872 #ifdef obj_adjust_symtab
1873 obj_adjust_symtab ();
1876 /* Now that all the sizes are known, and contents correct, we can
1877 start writing to the file. */
1880 /* If *_frob_file changes the symbol value at this point, it is
1881 responsible for moving the changed value into symp->bsym->value
1882 as well. Hopefully all symbol value changing can be done in
1887 #ifdef obj_frob_file
1891 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1893 #ifdef tc_frob_file_after_relocs
1894 tc_frob_file_after_relocs ();
1896 #ifdef obj_frob_file_after_relocs
1897 obj_frob_file_after_relocs ();
1900 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1901 #endif /* BFD_ASSEMBLER */
1908 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1913 * After this, all frags in this segment have addresses that are correct
1914 * within the segment. Since segments live in different file addresses,
1915 * these frag addresses may not be the same as final object-file addresses.
1918 #ifdef TC_GENERIC_RELAX_TABLE
1920 static int is_dnrange
PARAMS ((fragS
*, fragS
*));
1922 /* Subroutines of relax_segment. */
1928 for (; f1
; f1
= f1
->fr_next
)
1929 if (f1
->fr_next
== f2
)
1934 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1937 relax_frag (fragP
, stretch
)
1941 const relax_typeS
*this_type
;
1942 const relax_typeS
*start_type
;
1943 relax_substateT next_state
;
1944 relax_substateT this_state
;
1945 long aim
, target
, growth
;
1946 symbolS
*symbolP
= fragP
->fr_symbol
;
1947 long offset
= fragP
->fr_offset
;
1948 /* Recompute was_address by undoing "+= stretch" done by relax_segment. */
1949 unsigned long was_address
= fragP
->fr_address
- stretch
;
1950 unsigned long address
= fragP
->fr_address
;
1951 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1953 this_state
= fragP
->fr_subtype
;
1954 start_type
= this_type
= table
+ this_state
;
1959 #ifndef DIFF_EXPR_OK
1960 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1961 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1962 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1963 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1964 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1966 know (symbolP
->sy_frag
);
1968 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1969 || symbolP
->sy_frag
== &zero_address_frag
);
1971 S_GET_VALUE (symbolP
)
1972 + symbolP
->sy_frag
->fr_address
;
1974 /* If frag has yet to be reached on this pass,
1975 assume it will move by STRETCH just as we did.
1976 If this is not so, it will be because some frag
1977 between grows, and that will force another pass.
1979 Beware zero-length frags.
1981 There should be a faster way to do this. */
1983 if (symbolP
->sy_frag
->fr_address
>= was_address
1984 && is_dnrange (fragP
, symbolP
->sy_frag
))
1990 aim
= target
- address
- fragP
->fr_fix
;
1991 #ifdef TC_PCREL_ADJUST
1992 /* Currently only the ns32k family needs this */
1993 aim
+= TC_PCREL_ADJUST(fragP
);
1995 /* This machine doesn't want to use pcrel_adjust.
1996 In that case, pcrel_adjust should be zero. */
1997 /* assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);*/
1999 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2000 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
2005 /* Look backwards. */
2006 for (next_state
= this_type
->rlx_more
; next_state
;)
2007 if (aim
>= this_type
->rlx_backward
)
2011 /* Grow to next state. */
2012 this_state
= next_state
;
2013 this_type
= table
+ this_state
;
2014 next_state
= this_type
->rlx_more
;
2019 /* Look forwards. */
2020 for (next_state
= this_type
->rlx_more
; next_state
;)
2021 if (aim
<= this_type
->rlx_forward
)
2025 /* Grow to next state. */
2026 this_state
= next_state
;
2027 this_type
= table
+ this_state
;
2028 next_state
= this_type
->rlx_more
;
2032 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2034 fragP
->fr_subtype
= this_state
;
2038 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2040 /* Relax_align. Advance location counter to next address that has 'alignment'
2041 lowest order bits all 0s, return size of adjustment made. */
2042 static relax_addressT
2043 relax_align (address
, alignment
)
2044 register relax_addressT address
; /* Address now. */
2045 register int alignment
; /* Alignment (binary). */
2047 relax_addressT mask
;
2048 relax_addressT new_address
;
2050 mask
= ~((~0) << alignment
);
2051 new_address
= (address
+ mask
) & (~mask
);
2052 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2054 /* We must provide lots of padding, so the linker can discard it
2055 when needed. The linker will not add extra space, ever. */
2056 new_address
+= (1 << alignment
);
2058 return (new_address
- address
);
2062 relax_segment (segment_frag_root
, segment
)
2063 struct frag
*segment_frag_root
;
2066 register struct frag
*fragP
;
2067 register relax_addressT address
;
2068 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2069 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
2071 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2072 subseg_change (segment
, 0);
2074 /* For each frag in segment: count and store (a 1st guess of)
2077 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2079 fragP
->fr_address
= address
;
2080 address
+= fragP
->fr_fix
;
2082 switch (fragP
->fr_type
)
2085 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2091 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2093 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2096 if (offset
% fragP
->fr_var
!= 0)
2098 as_bad ("alignment padding (%lu bytes) not a multiple of %ld",
2099 (unsigned long) offset
, (long) fragP
->fr_var
);
2100 offset
-= (offset
% fragP
->fr_var
);
2109 /* Assume .org is nugatory. It will grow with 1st relax. */
2112 case rs_machine_dependent
:
2113 address
+= md_estimate_size_before_relax (fragP
, segment
);
2116 #ifndef WORKING_DOT_WORD
2117 /* Broken words don't concern us yet */
2118 case rs_broken_word
:
2123 /* Initial guess is always 1; doing otherwise can result in
2124 stable solutions that are larger than the minimum. */
2125 address
+= fragP
->fr_offset
= 1;
2129 BAD_CASE (fragP
->fr_type
);
2131 } /* switch(fr_type) */
2132 } /* for each frag in the segment */
2136 long stretch
; /* May be any size, 0 or negative. */
2137 /* Cumulative number of addresses we have */
2138 /* relaxed this pass. */
2139 /* We may have relaxed more than one address. */
2140 long stretched
; /* Have we stretched on this pass? */
2141 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2142 grew, and another shrank. If a branch instruction doesn't fit anymore,
2143 we could be scrod. */
2147 stretch
= stretched
= 0;
2148 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2151 addressT was_address
;
2155 was_address
= fragP
->fr_address
;
2156 address
= fragP
->fr_address
+= stretch
;
2157 symbolP
= fragP
->fr_symbol
;
2158 offset
= fragP
->fr_offset
;
2160 switch (fragP
->fr_type
)
2162 case rs_fill
: /* .fill never relaxes. */
2166 #ifndef WORKING_DOT_WORD
2167 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2168 for it I do not want to write it. I do not want to have
2169 anything to do with it. This is not the proper way to
2170 implement this misfeature. */
2171 case rs_broken_word
:
2173 struct broken_word
*lie
;
2174 struct broken_word
*untruth
;
2176 /* Yes this is ugly (storing the broken_word pointer
2177 in the symbol slot). Still, this whole chunk of
2178 code is ugly, and I don't feel like doing anything
2179 about it. Think of it as stubbornness in action. */
2181 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2182 lie
&& lie
->dispfrag
== fragP
;
2183 lie
= lie
->next_broken_word
)
2189 offset
= (lie
->add
->sy_frag
->fr_address
2190 + S_GET_VALUE (lie
->add
)
2192 - (lie
->sub
->sy_frag
->fr_address
2193 + S_GET_VALUE (lie
->sub
)));
2194 if (offset
<= -32768 || offset
>= 32767)
2196 if (flag_warn_displacement
)
2199 sprint_value (buf
, (addressT
) lie
->addnum
);
2200 as_warn (".word %s-%s+%s didn't fit",
2201 S_GET_NAME (lie
->add
),
2202 S_GET_NAME (lie
->sub
),
2206 if (fragP
->fr_subtype
== 0)
2208 fragP
->fr_subtype
++;
2209 growth
+= md_short_jump_size
;
2211 for (untruth
= lie
->next_broken_word
;
2212 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2213 untruth
= untruth
->next_broken_word
)
2214 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
2215 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
2218 untruth
->use_jump
= lie
;
2220 growth
+= md_long_jump_size
;
2225 } /* case rs_broken_word */
2230 addressT oldoff
, newoff
;
2232 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2234 newoff
= relax_align (address
+ fragP
->fr_fix
,
2237 if (fragP
->fr_subtype
!= 0)
2239 if (oldoff
> fragP
->fr_subtype
)
2241 if (newoff
> fragP
->fr_subtype
)
2245 growth
= newoff
- oldoff
;
2251 long target
= offset
;
2256 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2257 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2258 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2259 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2260 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2261 know (symbolP
->sy_frag
);
2262 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2263 || (symbolP
->sy_frag
== &zero_address_frag
));
2265 target
+= S_GET_VALUE (symbolP
)
2266 + symbolP
->sy_frag
->fr_address
;
2267 } /* if we have a symbol */
2269 know (fragP
->fr_next
);
2270 after
= fragP
->fr_next
->fr_address
;
2271 growth
= target
- after
;
2274 /* Growth may be negative, but variable part of frag
2275 cannot have fewer than 0 chars. That is, we can't
2277 as_bad ("attempt to .org backwards ignored");
2281 growth
-= stretch
; /* This is an absolute growth factor */
2288 growth
= S_GET_VALUE (symbolP
);
2289 if (symbolP
->sy_frag
!= &zero_address_frag
2290 || S_IS_COMMON (symbolP
)
2291 || ! S_IS_DEFINED (symbolP
))
2292 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2293 ".space specifies non-absolute value");
2294 fragP
->fr_symbol
= 0;
2297 as_warn (".space or .fill with negative value, ignored");
2305 case rs_machine_dependent
:
2306 #ifdef md_relax_frag
2307 growth
= md_relax_frag (fragP
, stretch
);
2309 #ifdef TC_GENERIC_RELAX_TABLE
2310 /* The default way to relax a frag is to look through
2311 TC_GENERIC_RELAX_TABLE. */
2312 growth
= relax_frag (fragP
, stretch
);
2313 #endif /* TC_GENERIC_RELAX_TABLE */
2322 value
= resolve_symbol_value (fragP
->fr_symbol
, 0);
2323 size
= sizeof_leb128 (value
, fragP
->fr_subtype
);
2324 growth
= size
- fragP
->fr_offset
;
2325 fragP
->fr_offset
= size
;
2330 BAD_CASE (fragP
->fr_type
);
2338 } /* For each frag in the segment. */
2340 while (stretched
); /* Until nothing further to relax. */
2344 * We now have valid fr_address'es for each frag.
2348 * All fr_address's are correct, relative to their own segment.
2349 * We have made all the fixS we will ever make.
2351 } /* relax_segment() */
2353 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2355 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2356 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2361 Go through all the fixS's in a segment and see which ones can be
2362 handled now. (These consist of fixS where we have since discovered
2363 the value of a symbol, or the address of the frag involved.)
2364 For each one, call md_apply_fix to put the fix into the frag data.
2366 Result is a count of how many relocation structs will be needed to
2367 handle the remaining fixS's that we couldn't completely handle here.
2368 These will be output later by emit_relocations(). */
2371 fixup_segment (fixP
, this_segment_type
)
2372 register fixS
*fixP
;
2373 segT this_segment_type
; /* N_TYPE bits for segment. */
2375 long seg_reloc_count
= 0;
2376 symbolS
*add_symbolP
;
2377 symbolS
*sub_symbolP
;
2384 segT add_symbol_segment
= absolute_section
;
2386 /* If the linker is doing the relaxing, we must not do any fixups.
2388 Well, strictly speaking that's not true -- we could do any that are
2389 PC-relative and don't cross regions that could change size. And for the
2390 i960 (the only machine for which we've got a relaxing linker right now),
2391 we might be able to turn callx/callj into bal anyways in cases where we
2392 know the maximum displacement. */
2395 for (; fixP
; fixP
= fixP
->fx_next
)
2397 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2398 return seg_reloc_count
;
2401 for (; fixP
; fixP
= fixP
->fx_next
)
2404 fprintf (stderr
, "\nprocessing fixup:\n");
2408 fragP
= fixP
->fx_frag
;
2410 where
= fixP
->fx_where
;
2411 place
= fragP
->fr_literal
+ where
;
2412 size
= fixP
->fx_size
;
2413 add_symbolP
= fixP
->fx_addsy
;
2414 #ifdef TC_VALIDATE_FIX
2415 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2417 sub_symbolP
= fixP
->fx_subsy
;
2418 add_number
= fixP
->fx_offset
;
2419 pcrel
= fixP
->fx_pcrel
;
2422 if (add_symbolP
!= NULL
2423 && add_symbolP
->sy_mri_common
)
2425 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2426 add_number
+= S_GET_VALUE (add_symbolP
);
2427 fixP
->fx_offset
= add_number
;
2428 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2432 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2436 resolve_symbol_value (sub_symbolP
, 1);
2437 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2439 if (add_symbolP
!= NULL
)
2441 add_number
+= S_GET_VALUE (add_symbolP
);
2443 fixP
->fx_addsy
= NULL
;
2446 /* It's just -sym */
2447 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2449 add_number
-= S_GET_VALUE (sub_symbolP
);
2450 fixP
->fx_subsy
= NULL
;
2453 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2455 /* Should try converting to a constant. */
2460 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2461 "Negative of non-absolute symbol %s",
2462 S_GET_NAME (sub_symbolP
));
2464 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2465 && SEG_NORMAL (add_symbol_segment
))
2467 /* Difference of 2 symbols from same segment.
2468 Can't make difference of 2 undefineds: 'value' means
2469 something different for N_UNDF. */
2471 /* Makes no sense to use the difference of 2 arbitrary symbols
2472 as the target of a call instruction. */
2474 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2475 "callj to difference of 2 symbols");
2476 #endif /* TC_I960 */
2477 add_number
+= S_GET_VALUE (add_symbolP
) -
2478 S_GET_VALUE (sub_symbolP
);
2481 pcrel
= 0; /* No further pcrel processing. */
2483 /* Let the target machine make the final determination
2484 as to whether or not a relocation will be needed to
2485 handle this fixup. */
2486 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2489 fixP
->fx_addsy
= NULL
;
2490 fixP
->fx_subsy
= NULL
;
2495 /* Different segments in subtraction. */
2496 know (!(S_IS_EXTERNAL (sub_symbolP
)
2497 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2499 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2500 add_number
-= S_GET_VALUE (sub_symbolP
);
2503 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2504 #if 0 /* Do this even if it's already described as pc-relative. For example,
2505 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2506 pc-relative mode. */
2511 /* Make it pc-relative. */
2512 add_number
+= (MD_PCREL_FROM_SECTION (fixP
, this_segment_type
)
2513 - S_GET_VALUE (sub_symbolP
));
2520 #ifdef UNDEFINED_DIFFERENCE_OK
2521 /* The PA needs this for PIC code generation. We basically
2522 don't want to do anything if we have the difference of two
2523 symbols at this point. */
2526 /* Leave it alone. */
2529 #ifdef BFD_ASSEMBLER
2530 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2531 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2533 /* Leave it alone. */
2539 sprint_value (buf
, fragP
->fr_address
+ where
);
2540 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2541 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2542 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2543 S_GET_NAME (sub_symbolP
), buf
);
2550 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2551 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2554 * This fixup was made when the symbol's segment was
2555 * SEG_UNKNOWN, but it is now in the local segment.
2556 * So we know how to do the address without relocation.
2559 /* reloc_callj() may replace a 'call' with a 'calls' or a
2560 'bal', in which cases it modifies *fixP as appropriate.
2561 In the case of a 'calls', no further work is required,
2562 and *fixP has been set up to make the rest of the code
2565 #endif /* TC_I960 */
2567 add_number
+= S_GET_VALUE (add_symbolP
);
2568 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2569 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2571 /* Let the target machine make the final determination
2572 as to whether or not a relocation will be needed to
2573 handle this fixup. */
2574 if (!TC_FORCE_RELOCATION (fixP
))
2577 fixP
->fx_addsy
= NULL
;
2582 if (add_symbol_segment
== absolute_section
2586 /* See comment about reloc_callj() above. */
2588 #endif /* TC_I960 */
2589 add_number
+= S_GET_VALUE (add_symbolP
);
2591 /* Let the target machine make the final determination
2592 as to whether or not a relocation will be needed to
2593 handle this fixup. */
2595 if (!TC_FORCE_RELOCATION (fixP
))
2597 fixP
->fx_addsy
= NULL
;
2601 else if (add_symbol_segment
== undefined_section
2602 #ifdef BFD_ASSEMBLER
2603 || bfd_is_com_section (add_symbol_segment
)
2608 if ((int) fixP
->fx_bit_fixP
== 13)
2610 /* This is a COBR instruction. They have only a
2611 * 13-bit displacement and are only to be used
2612 * for local branches: flag as error, don't generate
2615 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2616 "can't use COBR format with external label");
2617 fixP
->fx_addsy
= NULL
;
2621 #endif /* TC_I960 */
2625 if (S_IS_COMMON (add_symbolP
))
2626 add_number
+= S_GET_VALUE (add_symbolP
);
2627 #endif /* TE_I386AIX */
2628 #endif /* OBJ_COFF */
2634 #if !(defined (TC_V850) && defined (OBJ_ELF))
2635 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2636 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF)) || defined (TE_PE)
2637 add_number
+= S_GET_VALUE (add_symbolP
);
2647 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2648 if (add_symbolP
== 0)
2650 #ifndef BFD_ASSEMBLER
2651 fixP
->fx_addsy
= &abs_symbol
;
2653 fixP
->fx_addsy
= section_symbol (absolute_section
);
2655 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2660 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2662 if (size
< sizeof (valueT
))
2666 /* set all bits to one */
2669 /* Technically, combining these produces an undefined result
2670 if size is sizeof (valueT), though I think these two
2671 half-way operations should both be defined. And the
2672 compiler should be able to combine them if it's valid on
2673 the host architecture. */
2676 hibit
= (valueT
) 1 << (size
* 8 - 1);
2677 if (((add_number
& mask
) != 0
2679 && (add_number
& hibit
) != 0))
2680 && ((add_number
& mask
) != mask
2681 || (add_number
& hibit
) == 0))
2683 char buf
[50], buf2
[50];
2684 sprint_value (buf
, fragP
->fr_address
+ where
);
2685 if (add_number
> 1000)
2686 sprint_value (buf2
, add_number
);
2688 sprintf (buf2
, "%ld", (long) add_number
);
2689 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2690 "Value of %s too large for field of %d bytes at %s",
2692 } /* generic error checking */
2694 #ifdef WARN_SIGNED_OVERFLOW_WORD
2695 /* Warn if a .word value is too large when treated as a signed
2696 number. We already know it is not too negative. This is to
2697 catch over-large switches generated by gcc on the 68k. */
2698 if (!flag_signed_overflow_ok
2700 && add_number
> 0x7fff)
2701 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2702 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2704 (unsigned long) (fragP
->fr_address
+ where
));
2706 } /* not a bit fix */
2710 #ifdef MD_APPLY_FIX3
2711 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2713 #ifdef BFD_ASSEMBLER
2714 md_apply_fix (fixP
, &add_number
);
2716 md_apply_fix (fixP
, add_number
);
2720 #ifndef TC_HANDLES_FX_DONE
2721 /* If the tc-* files haven't been converted, assume it's handling
2722 it the old way, where a null fx_addsy means that the fix has
2723 been applied completely, and no further work is needed. */
2724 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2728 #ifdef TC_VALIDATE_FIX
2732 fprintf (stderr
, "result:\n");
2735 } /* For each fixS in this segment. */
2737 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2738 return seg_reloc_count
;
2741 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2744 number_to_chars_bigendian (buf
, val
, n
)
2749 if (n
> sizeof (val
)|| n
<= 0)
2753 buf
[n
] = val
& 0xff;
2759 number_to_chars_littleendian (buf
, val
, n
)
2764 if (n
> sizeof (val
) || n
<= 0)
2768 *buf
++ = val
& 0xff;
2774 write_print_statistics (file
)
2777 fprintf (stderr
, "fixups: %d\n", n_fixups
);
2781 extern int indent_level
;
2788 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2790 fprintf (stderr
, " pcrel");
2791 if (fixp
->fx_pcrel_adjust
)
2792 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2793 if (fixp
->fx_im_disp
)
2796 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2798 fprintf (stderr
, " im_disp");
2802 fprintf (stderr
, " tcbit");
2804 fprintf (stderr
, " done");
2805 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2806 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2807 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2808 #ifdef BFD_ASSEMBLER
2809 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2812 #ifdef NEED_FX_R_TYPE
2813 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2818 fprintf (stderr
, "\n +<");
2819 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2820 fprintf (stderr
, ">");
2824 fprintf (stderr
, "\n -<");
2825 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2826 fprintf (stderr
, ">");
2828 fprintf (stderr
, "\n");
2831 /* end of write.c */