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
;
505 case rs_machine_dependent
:
507 md_convert_frag (stdoutput
, sec
, fragP
);
509 md_convert_frag (headersP
, sec
, fragP
);
512 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
515 * After md_convert_frag, we make the frag into a ".space 0".
516 * Md_convert_frag() should set up any fixSs and constants
522 #ifndef WORKING_DOT_WORD
525 struct broken_word
*lie
;
527 if (fragP
->fr_subtype
)
529 fragP
->fr_fix
+= md_short_jump_size
;
530 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
531 lie
&& lie
->dispfrag
== fragP
;
532 lie
= lie
->next_broken_word
)
534 fragP
->fr_fix
+= md_long_jump_size
;
542 BAD_CASE (fragP
->fr_type
);
547 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
551 relax_and_size_seg (abfd
, sec
, xxx
)
558 segment_info_type
*seginfo
;
560 valueT size
, newsize
;
562 subseg_change (sec
, 0);
564 flags
= bfd_get_section_flags (abfd
, sec
);
566 seginfo
= seg_info (sec
);
567 if (seginfo
&& seginfo
->frchainP
)
569 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
570 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
571 cvt_frag_to_fill (sec
, fragp
);
572 for (fragp
= seginfo
->frchainP
->frch_root
;
574 fragp
= fragp
->fr_next
)
575 /* walk to last elt */;
576 size
= fragp
->fr_address
+ fragp
->fr_fix
;
581 if (size
> 0 && ! seginfo
->bss
)
582 flags
|= SEC_HAS_CONTENTS
;
584 /* @@ This is just an approximation. */
585 if (seginfo
&& seginfo
->fix_root
)
589 x
= bfd_set_section_flags (abfd
, sec
, flags
);
592 newsize
= md_section_align (sec
, size
);
593 x
= bfd_set_section_size (abfd
, sec
, newsize
);
596 /* If the size had to be rounded up, add some padding in the last
598 assert (newsize
>= size
);
601 fragS
*last
= seginfo
->frchainP
->frch_last
;
602 fragp
= seginfo
->frchainP
->frch_root
;
603 while (fragp
->fr_next
!= last
)
604 fragp
= fragp
->fr_next
;
605 last
->fr_address
= size
;
606 fragp
->fr_offset
+= newsize
- size
;
609 #ifdef tc_frob_section
610 tc_frob_section (sec
);
612 #ifdef obj_frob_section
613 obj_frob_section (sec
);
619 dump_section_relocs (abfd
, sec
, stream_
)
624 FILE *stream
= (FILE *) stream_
;
625 segment_info_type
*seginfo
= seg_info (sec
);
626 fixS
*fixp
= seginfo
->fix_root
;
631 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
634 symbolS
*s
= fixp
->fx_addsy
;
637 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
638 s
->bsym
->section
->name
);
639 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
641 fprintf (stream
, " section sym");
643 fprintf (stream
, "+%x", S_GET_VALUE (s
));
646 fprintf (stream
, "+%x", S_GET_VALUE (s
));
647 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
650 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
651 fixp
= fixp
->fx_next
;
655 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
658 #ifndef EMIT_SECTION_SYMBOLS
659 #define EMIT_SECTION_SYMBOLS 1
663 adjust_reloc_syms (abfd
, sec
, xxx
)
668 segment_info_type
*seginfo
= seg_info (sec
);
674 dump_section_relocs (abfd
, sec
, stderr
);
676 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
679 else if (fixp
->fx_addsy
)
687 fprintf (stderr
, "\n\nadjusting fixup:\n");
691 sym
= fixp
->fx_addsy
;
693 /* All symbols should have already been resolved at this
694 point. It is possible to see unresolved expression
695 symbols, though, since they are not in the regular symbol
697 if (sym
!= NULL
&& ! sym
->sy_resolved
)
698 resolve_symbol_value (sym
);
699 if (fixp
->fx_subsy
!= NULL
&& ! fixp
->fx_subsy
->sy_resolved
)
700 resolve_symbol_value (fixp
->fx_subsy
);
702 /* If this symbol is equated to an undefined symbol, convert
703 the fixup to being against that symbol. */
704 if (sym
->sy_value
.X_op
== O_symbol
705 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
707 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
708 sym
= sym
->sy_value
.X_add_symbol
;
709 fixp
->fx_addsy
= sym
;
712 symsec
= S_GET_SEGMENT (sym
);
714 if (sym
!= NULL
&& sym
->sy_mri_common
)
716 /* These symbols are handled specially in fixup_segment. */
720 if (bfd_is_abs_section (symsec
))
722 /* The fixup_segment routine will not use this symbol in a
723 relocation unless TC_FORCE_RELOCATION returns 1. */
724 if (TC_FORCE_RELOCATION (fixp
))
726 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
727 #ifdef UNDEFINED_DIFFERENCE_OK
728 if (fixp
->fx_subsy
!= NULL
)
729 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
735 /* If it's one of these sections, assume the symbol is
736 definitely going to be output. The code in
737 md_estimate_size_before_relax in tc-mips.c uses this test
738 as well, so if you change this code you should look at that
740 if (bfd_is_und_section (symsec
)
741 || bfd_is_com_section (symsec
))
743 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
744 #ifdef UNDEFINED_DIFFERENCE_OK
745 /* We have the difference of an undefined symbol and some
746 other symbol. Make sure to mark the other symbol as used
747 in a relocation so that it will always be output. */
749 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
754 /* Don't try to reduce relocs which refer to .linkonce
755 sections. It can lead to confusion when a debugging
756 section refers to a .linkonce section. I hope this will
757 always be correct. */
764 if ((bfd_get_section_flags (stdoutput
, symsec
) & SEC_LINK_ONCE
)
769 /* The GNU toolchain uses an extension for ELF: a section
770 beginning with the magic string .gnu.linkonce is a
772 if (strncmp (segment_name (symsec
), ".gnu.linkonce",
773 sizeof ".gnu.linkonce" - 1) == 0)
779 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
780 #ifdef UNDEFINED_DIFFERENCE_OK
781 if (fixp
->fx_subsy
!= NULL
)
782 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
788 /* Since we're reducing to section symbols, don't attempt to reduce
789 anything that's already using one. */
790 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
792 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
796 /* Is there some other reason we can't adjust this one? (E.g.,
797 call/bal links in i960-bout symbols.) */
798 #ifdef obj_fix_adjustable
799 if (! obj_fix_adjustable (fixp
))
801 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
806 /* Is there some other (target cpu dependent) reason we can't adjust
807 this one? (E.g. relocations involving function addresses on
809 #ifdef tc_fix_adjustable
810 if (! tc_fix_adjustable (fixp
))
812 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
817 /* If the section symbol isn't going to be output, the relocs
818 at least should still work. If not, figure out what to do
819 when we run into that case.
821 We refetch the segment when calling section_symbol, rather
822 than using symsec, because S_GET_VALUE may wind up changing
823 the section when it calls resolve_symbol_value. */
824 fixp
->fx_offset
+= S_GET_VALUE (sym
);
825 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
826 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
831 #if 1/*def RELOC_REQUIRES_SYMBOL*/
834 /* There was no symbol required by this relocation. However,
835 BFD doesn't really handle relocations without symbols well.
836 (At least, the COFF support doesn't.) So for now we fake up
837 a local symbol in the absolute section. */
839 fixp
->fx_addsy
= section_symbol (absolute_section
);
840 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
844 dump_section_relocs (abfd
, sec
, stderr
);
848 write_relocs (abfd
, sec
, xxx
)
853 segment_info_type
*seginfo
= seg_info (sec
);
860 /* If seginfo is NULL, we did not create this section; don't do
865 fixup_segment (seginfo
->fix_root
, sec
);
868 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
871 #ifndef RELOC_EXPANSION_POSSIBLE
872 /* Set up reloc information as well. */
873 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
874 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
877 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
880 bfd_reloc_status_type s
;
889 /* If this is an undefined symbol which was equated to another
890 symbol, then use generate the reloc against the latter symbol
891 rather than the former. */
892 sym
= fixp
->fx_addsy
;
893 while (sym
->sy_value
.X_op
== O_symbol
894 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
898 /* We must avoid looping, as that can occur with a badly
900 n
= sym
->sy_value
.X_add_symbol
;
903 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
906 fixp
->fx_addsy
= sym
;
908 reloc
= tc_gen_reloc (sec
, fixp
);
916 /* This test is triggered inappropriately for the SH. */
917 if (fixp
->fx_where
+ fixp
->fx_size
918 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
922 s
= bfd_install_relocation (stdoutput
, reloc
,
923 fixp
->fx_frag
->fr_literal
,
924 fixp
->fx_frag
->fr_address
,
930 case bfd_reloc_overflow
:
931 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
934 as_fatal ("%s:%u: bad return from bfd_install_relocation",
935 fixp
->fx_file
, fixp
->fx_line
);
940 n
= n
* MAX_RELOC_EXPANSION
;
941 /* Set up reloc information as well. */
942 relocs
= (arelent
**) xmalloc (n
* sizeof (arelent
*));
945 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
949 bfd_reloc_status_type s
;
959 /* If this is an undefined symbol which was equated to another
960 symbol, then use generate the reloc against the latter symbol
961 rather than the former. */
962 sym
= fixp
->fx_addsy
;
963 while (sym
->sy_value
.X_op
== O_symbol
964 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
965 sym
= sym
->sy_value
.X_add_symbol
;
966 fixp
->fx_addsy
= sym
;
968 reloc
= tc_gen_reloc (sec
, fixp
);
970 for (j
= 0; reloc
[j
]; j
++)
972 relocs
[i
++] = reloc
[j
];
975 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
976 if (fixp
->fx_where
+ fixp
->fx_size
977 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
978 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
979 "internal error: fixup not contained within frag");
980 for (j
= 0; reloc
[j
]; j
++)
982 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
983 fixp
->fx_frag
->fr_literal
,
984 fixp
->fx_frag
->fr_address
,
990 case bfd_reloc_overflow
:
991 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
992 "relocation overflow");
995 as_fatal ("%s:%u: bad return from bfd_install_relocation",
996 fixp
->fx_file
, fixp
->fx_line
);
1007 sympp
= bfd_get_outsymbols (stdoutput
);
1008 nsyms
= bfd_get_symcount (stdoutput
);
1009 for (i
= 0; i
< n
; i
++)
1010 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
1012 for (j
= 0; j
< nsyms
; j
++)
1013 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
1022 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
1024 bfd_set_section_flags (abfd
, sec
,
1025 (bfd_get_section_flags (abfd
, sec
)
1026 & (flagword
) ~SEC_RELOC
));
1033 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1034 for (i
= 0; i
< n
; i
++)
1037 s
= *r
->sym_ptr_ptr
;
1038 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1039 i
, r
, r
->address
, s
->name
, r
->addend
);
1046 write_contents (abfd
, sec
, xxx
)
1051 segment_info_type
*seginfo
= seg_info (sec
);
1052 unsigned long offset
= 0;
1055 /* Write out the frags. */
1057 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1060 for (f
= seginfo
->frchainP
->frch_root
;
1065 unsigned long fill_size
;
1069 assert (f
->fr_type
== rs_fill
);
1072 x
= bfd_set_section_contents (stdoutput
, sec
,
1073 f
->fr_literal
, (file_ptr
) offset
,
1074 (bfd_size_type
) f
->fr_fix
);
1077 bfd_perror (stdoutput
->filename
);
1078 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1079 exit (EXIT_FAILURE
);
1081 offset
+= f
->fr_fix
;
1083 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1084 fill_size
= f
->fr_var
;
1085 count
= f
->fr_offset
;
1086 assert (count
>= 0);
1087 if (fill_size
&& count
)
1090 if (fill_size
> sizeof(buf
))
1092 /* Do it the old way. Can this ever happen? */
1095 x
= bfd_set_section_contents (stdoutput
, sec
,
1098 (bfd_size_type
) fill_size
);
1101 bfd_perror (stdoutput
->filename
);
1102 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1103 exit (EXIT_FAILURE
);
1105 offset
+= fill_size
;
1110 /* Build a buffer full of fill objects and output it as
1111 often as necessary. This saves on the overhead of
1112 potentially lots of bfd_set_section_contents calls. */
1116 n_per_buf
= sizeof (buf
);
1117 memset (buf
, *fill_literal
, n_per_buf
);
1122 n_per_buf
= sizeof(buf
)/fill_size
;
1123 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1124 memcpy(bufp
, fill_literal
, fill_size
);
1126 for (; count
> 0; count
-= n_per_buf
)
1128 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1129 x
= bfd_set_section_contents (stdoutput
, sec
,
1130 buf
, (file_ptr
) offset
,
1131 (bfd_size_type
) n_per_buf
* fill_size
);
1133 as_fatal ("Cannot write to output file.");
1134 offset
+= n_per_buf
* fill_size
;
1142 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1144 merge_data_into_text ()
1146 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1147 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1148 seg_info (data_section
)->frchainP
->frch_root
;
1149 seg_info (text_section
)->frchainP
->frch_last
=
1150 seg_info (data_section
)->frchainP
->frch_last
;
1151 seg_info (data_section
)->frchainP
= 0;
1155 text_last_frag
->fr_next
= data_frag_root
;
1156 text_last_frag
= data_last_frag
;
1157 data_last_frag
= NULL
;
1158 data_frag_root
= NULL
;
1161 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1162 tmp
->fx_next
= data_fix_root
;
1163 text_fix_tail
= data_fix_tail
;
1166 text_fix_root
= data_fix_root
;
1167 data_fix_root
= NULL
;
1170 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1172 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1174 relax_and_size_all_segments ()
1178 relax_segment (text_frag_root
, SEG_TEXT
);
1179 relax_segment (data_frag_root
, SEG_DATA
);
1180 relax_segment (bss_frag_root
, SEG_BSS
);
1182 * Now the addresses of frags are correct within the segment.
1185 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1186 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1187 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1190 * Join the 2 segments into 1 huge segment.
1191 * To do this, re-compute every rn_address in the SEG_DATA frags.
1192 * Then join the data frags after the text frags.
1194 * Determine a_data [length of data segment].
1198 register relax_addressT slide
;
1200 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1202 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1203 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1204 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1206 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1207 /* For b.out: If the data section has a strict alignment
1208 requirement, its load address in the .o file will be
1209 rounded up from the size of the text section. These
1210 two values are *not* the same! Similarly for the bss
1212 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1215 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1217 fragP
->fr_address
+= slide
;
1218 } /* for each data frag */
1220 know (text_last_frag
!= 0);
1221 text_last_frag
->fr_next
= data_frag_root
;
1225 H_SET_DATA_SIZE (&headers
, 0);
1229 /* See above comments on b.out data section address. */
1232 if (data_last_frag
== 0)
1233 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1235 bss_vma
= data_last_frag
->fr_address
;
1236 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1237 bss_address_frag
.fr_address
= bss_vma
;
1239 #else /* ! OBJ_BOUT */
1240 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1241 H_GET_DATA_SIZE (&headers
));
1243 #endif /* ! OBJ_BOUT */
1245 /* Slide all the frags */
1248 relax_addressT slide
= bss_address_frag
.fr_address
;
1250 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1252 fragP
->fr_address
+= slide
;
1253 } /* for each bss frag */
1257 H_SET_BSS_SIZE (&headers
,
1258 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1260 H_SET_BSS_SIZE (&headers
, 0);
1262 #endif /* ! BFD_ASSEMBLER && ! BFD */
1264 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1266 #ifdef BFD_ASSEMBLER
1274 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1276 /* Count symbols. We can't rely on a count made by the loop in
1277 write_object_file, because *_frob_file may add a new symbol or
1280 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1287 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1288 nsyms
* sizeof (asymbol
*));
1289 symp
= symbol_rootP
;
1290 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1292 asympp
[i
] = symp
->bsym
;
1298 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1299 assert (result
== true);
1300 symbol_table_frozen
= 1;
1305 write_object_file ()
1307 struct frchain
*frchainP
; /* Track along all frchains. */
1308 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1309 fragS
*fragP
; /* Track along all frags. */
1312 /* Do we really want to write it? */
1314 int n_warns
, n_errs
;
1315 n_warns
= had_warnings ();
1316 n_errs
= had_errors ();
1317 /* The -Z flag indicates that an object file should be generated,
1318 regardless of warnings and errors. */
1319 if (flag_always_generate_output
)
1321 if (n_warns
|| n_errs
)
1322 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1323 n_errs
, n_errs
== 1 ? "" : "s",
1324 n_warns
, n_warns
== 1 ? "" : "s");
1329 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1330 n_errs
, n_errs
== 1 ? "" : "s",
1331 n_warns
, n_warns
== 1 ? "" : "s");
1336 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1337 a routine to check for the definition of the procedure "_main",
1338 and if so -- fix it up so that it can be program entry point. */
1339 vms_check_for_main ();
1340 #endif /* OBJ_VMS */
1342 /* After every sub-segment, we fake an ".align ...". This conforms to
1343 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1344 frag that requires least thought. ".align" frags like to have a
1345 following frag since that makes calculating their intended length
1348 @@ Is this really necessary?? */
1349 #ifndef SUB_SEGMENT_ALIGN
1350 #ifdef BFD_ASSEMBLER
1351 #define SUB_SEGMENT_ALIGN(SEG) (0)
1353 #define SUB_SEGMENT_ALIGN(SEG) (2)
1356 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1358 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1359 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
, 0);
1360 /* frag_align will have left a new frag.
1361 Use this last frag for an empty ".fill".
1363 For this segment ...
1364 Create a last frag. Do not leave a "being filled in frag". */
1365 frag_wane (frag_now
);
1366 frag_now
->fr_fix
= 0;
1367 know (frag_now
->fr_next
== NULL
);
1370 /* From now on, we don't care about sub-segments. Build one frag chain
1371 for each segment. Linked thru fr_next. */
1373 #ifdef BFD_ASSEMBLER
1374 /* Remove the sections created by gas for its own purposes. */
1376 asection
**seclist
, *sec
;
1379 seclist
= &stdoutput
->sections
;
1380 while (seclist
&& *seclist
)
1383 while (sec
== reg_section
|| sec
== expr_section
)
1387 stdoutput
->section_count
--;
1392 seclist
= &(*seclist
)->next
;
1395 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1398 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1400 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1401 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1402 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1405 /* We have two segments. If user gave -R flag, then we must put the
1406 data frags into the text segment. Do this before relaxing so
1407 we know to take advantage of -R and make shorter addresses. */
1408 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1409 if (flag_readonly_data_in_text
)
1411 merge_data_into_text ();
1415 #ifdef BFD_ASSEMBLER
1416 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1418 relax_and_size_all_segments ();
1419 #endif /* BFD_ASSEMBLER */
1421 #ifndef BFD_ASSEMBLER
1424 * Crawl the symbol chain.
1426 * For each symbol whose value depends on a frag, take the address of
1427 * that frag and subsume it into the value of the symbol.
1428 * After this, there is just one way to lookup a symbol value.
1429 * Values are left in their final state for object file emission.
1430 * We adjust the values of 'L' local symbols, even if we do
1431 * not intend to emit them to the object file, because their values
1432 * are needed for fix-ups.
1434 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1435 * from the symbol chain. (They are still pointed to by the fixes.)
1437 * Count the remaining symbols.
1438 * Assign a symbol number to each symbol.
1439 * Count the number of string-table chars we will emit.
1440 * Put this info into the headers as appropriate.
1443 know (zero_address_frag
.fr_address
== 0);
1444 string_byte_count
= sizeof (string_byte_count
);
1446 obj_crawl_symbol_chain (&headers
);
1448 if (string_byte_count
== sizeof (string_byte_count
))
1449 string_byte_count
= 0;
1451 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1454 * Addresses of frags now reflect addresses we use in the object file.
1455 * Symbol values are correct.
1456 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1457 * Also converting any machine-dependent frags using md_convert_frag();
1459 subseg_change (SEG_TEXT
, 0);
1461 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1463 /* At this point we have linked all the frags into a single
1464 chain. However, cvt_frag_to_fill may call md_convert_frag
1465 which may call fix_new. We need to ensure that fix_new adds
1466 the fixup to the right section. */
1467 if (fragP
== data_frag_root
)
1468 subseg_change (SEG_DATA
, 0);
1470 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1472 /* Some assert macros don't work with # directives mixed in. */
1474 if (!(fragP
->fr_next
== NULL
1476 || fragP
->fr_next
== data_frag_root
1478 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1479 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1483 #endif /* ! BFD_ASSEMBLER */
1485 #ifndef WORKING_DOT_WORD
1487 struct broken_word
*lie
;
1488 struct broken_word
**prevP
;
1490 prevP
= &broken_words
;
1491 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1496 exp
.X_op
= O_subtract
;
1497 exp
.X_add_symbol
= lie
->add
;
1498 exp
.X_op_symbol
= lie
->sub
;
1499 exp
.X_add_number
= lie
->addnum
;
1500 #ifdef BFD_ASSEMBLER
1501 #ifdef TC_CONS_FIX_NEW
1502 TC_CONS_FIX_NEW (lie
->frag
,
1503 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1506 fix_new_exp (lie
->frag
,
1507 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1508 2, &exp
, 0, BFD_RELOC_16
);
1511 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1512 fix_new_exp (lie
->frag
,
1513 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1514 2, &exp
, 0, NO_RELOC
);
1517 fix_new_ns32k_exp (lie
->frag
,
1518 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1519 2, &exp
, 0, 0, 2, 0, 0);
1521 fix_new_exp (lie
->frag
,
1522 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1524 #endif /* TC_NS32K */
1525 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1526 #endif /* BFD_ASSEMBLER */
1527 *prevP
= lie
->next_broken_word
;
1530 prevP
= &(lie
->next_broken_word
);
1532 for (lie
= broken_words
; lie
;)
1534 struct broken_word
*untruth
;
1536 addressT table_addr
;
1537 addressT from_addr
, to_addr
;
1540 fragP
= lie
->dispfrag
;
1542 /* Find out how many broken_words go here. */
1544 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1545 if (untruth
->added
== 1)
1548 table_ptr
= lie
->dispfrag
->fr_opcode
;
1549 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1550 /* Create the jump around the long jumps. This is a short
1551 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1552 from_addr
= table_addr
;
1553 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1554 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1555 table_ptr
+= md_short_jump_size
;
1556 table_addr
+= md_short_jump_size
;
1558 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1560 if (lie
->added
== 2)
1562 /* Patch the jump table */
1563 /* This is the offset from ??? to table_ptr+0 */
1564 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1565 #ifdef BFD_ASSEMBLER
1566 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1568 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1569 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1571 if (untruth
->use_jump
== lie
)
1572 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1575 /* Install the long jump */
1576 /* this is a long jump from table_ptr+0 to the final target */
1577 from_addr
= table_addr
;
1578 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1579 #ifdef BFD_ASSEMBLER
1580 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1582 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1583 table_ptr
+= md_long_jump_size
;
1584 table_addr
+= md_long_jump_size
;
1588 #endif /* not WORKING_DOT_WORD */
1590 #ifndef BFD_ASSEMBLER
1593 char *the_object_file
;
1594 long object_file_size
;
1596 * Scan every FixS performing fixups. We had to wait until now to do
1597 * this because md_convert_frag() may have made some fixSs.
1601 subseg_change (SEG_TEXT
, 0);
1602 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1603 subseg_change (SEG_DATA
, 0);
1604 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1605 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1607 /* FIXME move this stuff into the pre-write-hook */
1608 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1609 H_SET_ENTRY_POINT (&headers
, 0);
1611 obj_pre_write_hook (&headers
); /* extra coff stuff */
1613 object_file_size
= H_GET_FILE_SIZE (&headers
);
1614 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1616 output_file_create (out_file_name
);
1618 obj_header_append (&next_object_file_charP
, &headers
);
1620 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1625 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1627 register long count
;
1628 register char *fill_literal
;
1629 register long fill_size
;
1632 know (fragP
->fr_type
== rs_fill
);
1633 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1634 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1635 fill_size
= fragP
->fr_var
;
1636 know (fragP
->fr_offset
>= 0);
1638 for (count
= fragP
->fr_offset
; count
; count
--)
1640 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1643 } /* for each code frag. */
1645 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1650 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1651 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
)));
1653 /* Make addresses in data relocation directives relative to beginning of
1654 * first data fragment, not end of last text fragment: alignment of the
1655 * start of the data segment may place a gap between the segments.
1657 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1659 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1660 #endif /* TC_I960 */
1662 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
)));
1665 * Emit line number entries.
1667 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1668 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
)));
1673 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1674 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
)));
1680 if (string_byte_count
> 0)
1682 obj_emit_strings (&next_object_file_charP
);
1683 } /* only if we have a string table */
1686 bfd_seek (stdoutput
, 0, 0);
1687 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1690 /* Write the data to the file */
1691 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1692 free (the_object_file
);
1694 } /* non vms output */
1697 * Now do the VMS-dependent part of writing the object file
1699 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1700 H_GET_DATA_SIZE (&headers
),
1701 H_GET_BSS_SIZE (&headers
),
1702 text_frag_root
, data_frag_root
);
1703 #endif /* OBJ_VMS */
1704 #else /* BFD_ASSEMBLER */
1706 /* Resolve symbol values. This needs to be done before processing
1712 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1713 if (!symp
->sy_resolved
)
1714 resolve_symbol_value (symp
);
1719 #ifdef tc_frob_file_before_adjust
1720 tc_frob_file_before_adjust ();
1722 #ifdef obj_frob_file_before_adjust
1723 obj_frob_file_before_adjust ();
1726 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1728 /* Set up symbol table, and write it out. */
1733 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1738 if (symp
->sy_mri_common
)
1740 if (S_IS_EXTERNAL (symp
))
1741 as_bad ("%s: global symbols not supported in common sections",
1743 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1747 name
= S_GET_NAME (symp
);
1750 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1751 /* They only differ if `name' is a fb or dollar local
1753 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1754 as_bad ("local label %s is not defined", name2
);
1757 /* Do it again, because adjust_reloc_syms might introduce
1758 more symbols. They'll probably only be section symbols,
1759 but they'll still need to have the values computed. */
1760 if (! symp
->sy_resolved
)
1762 if (symp
->sy_value
.X_op
== O_constant
)
1764 /* This is the normal case; skip the call. */
1767 + symp
->sy_frag
->fr_address
));
1768 symp
->sy_resolved
= 1;
1771 resolve_symbol_value (symp
);
1774 /* Skip symbols which were equated to undefined or common
1776 if (symp
->sy_value
.X_op
== O_symbol
1777 && (! S_IS_DEFINED (symp
) || S_IS_COMMON (symp
)))
1779 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1783 /* So far, common symbols have been treated like undefined symbols.
1784 Put them in the common section now. */
1785 if (S_IS_DEFINED (symp
) == 0
1786 && S_GET_VALUE (symp
) != 0)
1787 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1789 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1790 S_GET_NAME (symp
), symp
,
1793 segment_name (symp
->bsym
->section
));
1796 #ifdef obj_frob_symbol
1797 obj_frob_symbol (symp
, punt
);
1799 #ifdef tc_frob_symbol
1800 if (! punt
|| symp
->sy_used_in_reloc
)
1801 tc_frob_symbol (symp
, punt
);
1804 /* If we don't want to keep this symbol, splice it out of
1805 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1806 want section symbols. Otherwise, we skip local symbols
1807 and symbols that the frob_symbol macros told us to punt,
1808 but we keep such symbols if they are used in relocs. */
1809 if ((! EMIT_SECTION_SYMBOLS
1810 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1811 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1812 opposites. Sometimes the former checks flags and the
1813 latter examines the name... */
1814 || (!S_IS_EXTERN (symp
)
1815 && (S_IS_LOCAL (symp
) || punt
)
1816 && ! symp
->sy_used_in_reloc
))
1818 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1819 /* After symbol_remove, symbol_next(symp) still returns
1820 the one that came after it in the chain. So we don't
1821 need to do any extra cleanup work here. */
1826 /* Make sure we really got a value for the symbol. */
1827 if (! symp
->sy_resolved
)
1829 as_bad ("can't resolve value for symbol \"%s\"",
1831 symp
->sy_resolved
= 1;
1834 /* Set the value into the BFD symbol. Up til now the value
1835 has only been kept in the gas symbolS struct. */
1836 symp
->bsym
->value
= S_GET_VALUE (symp
);
1842 /* Now do any format-specific adjustments to the symbol table, such
1843 as adding file symbols. */
1844 #ifdef tc_adjust_symtab
1845 tc_adjust_symtab ();
1847 #ifdef obj_adjust_symtab
1848 obj_adjust_symtab ();
1851 /* Now that all the sizes are known, and contents correct, we can
1852 start writing to the file. */
1855 /* If *_frob_file changes the symbol value at this point, it is
1856 responsible for moving the changed value into symp->bsym->value
1857 as well. Hopefully all symbol value changing can be done in
1862 #ifdef obj_frob_file
1866 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1868 #ifdef tc_frob_file_after_relocs
1869 tc_frob_file_after_relocs ();
1871 #ifdef obj_frob_file_after_relocs
1872 obj_frob_file_after_relocs ();
1875 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1876 #endif /* BFD_ASSEMBLER */
1883 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1888 * After this, all frags in this segment have addresses that are correct
1889 * within the segment. Since segments live in different file addresses,
1890 * these frag addresses may not be the same as final object-file addresses.
1893 #ifdef TC_GENERIC_RELAX_TABLE
1895 static int is_dnrange
PARAMS ((fragS
*, fragS
*));
1897 /* Subroutines of relax_segment. */
1903 for (; f1
; f1
= f1
->fr_next
)
1904 if (f1
->fr_next
== f2
)
1909 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1912 relax_frag (fragP
, stretch
)
1916 const relax_typeS
*this_type
;
1917 const relax_typeS
*start_type
;
1918 relax_substateT next_state
;
1919 relax_substateT this_state
;
1920 long aim
, target
, growth
;
1921 symbolS
*symbolP
= fragP
->fr_symbol
;
1922 long offset
= fragP
->fr_offset
;
1923 /* Recompute was_address by undoing "+= stretch" done by relax_segment. */
1924 unsigned long was_address
= fragP
->fr_address
- stretch
;
1925 unsigned long address
= fragP
->fr_address
;
1926 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1928 this_state
= fragP
->fr_subtype
;
1929 start_type
= this_type
= table
+ this_state
;
1934 #ifndef DIFF_EXPR_OK
1935 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1936 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1937 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1938 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1939 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1941 know (symbolP
->sy_frag
);
1943 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1944 || symbolP
->sy_frag
== &zero_address_frag
);
1946 S_GET_VALUE (symbolP
)
1947 + symbolP
->sy_frag
->fr_address
;
1949 /* If frag has yet to be reached on this pass,
1950 assume it will move by STRETCH just as we did.
1951 If this is not so, it will be because some frag
1952 between grows, and that will force another pass.
1954 Beware zero-length frags.
1956 There should be a faster way to do this. */
1958 if (symbolP
->sy_frag
->fr_address
>= was_address
1959 && is_dnrange (fragP
, symbolP
->sy_frag
))
1965 aim
= target
- address
- fragP
->fr_fix
;
1966 #ifdef TC_PCREL_ADJUST
1967 /* Currently only the ns32k family needs this */
1968 aim
+= TC_PCREL_ADJUST(fragP
);
1970 /* This machine doesn't want to use pcrel_adjust.
1971 In that case, pcrel_adjust should be zero. */
1972 /* assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);*/
1974 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
1975 md_prepare_relax_scan (fragP
, address
, aim
, this_state
, this_type
);
1980 /* Look backwards. */
1981 for (next_state
= this_type
->rlx_more
; next_state
;)
1982 if (aim
>= this_type
->rlx_backward
)
1986 /* Grow to next state. */
1987 this_state
= next_state
;
1988 this_type
= table
+ this_state
;
1989 next_state
= this_type
->rlx_more
;
1994 /* Look forwards. */
1995 for (next_state
= this_type
->rlx_more
; next_state
;)
1996 if (aim
<= this_type
->rlx_forward
)
2000 /* Grow to next state. */
2001 this_state
= next_state
;
2002 this_type
= table
+ this_state
;
2003 next_state
= this_type
->rlx_more
;
2007 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2009 fragP
->fr_subtype
= this_state
;
2013 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2015 /* Relax_align. Advance location counter to next address that has 'alignment'
2016 lowest order bits all 0s, return size of adjustment made. */
2017 static relax_addressT
2018 relax_align (address
, alignment
)
2019 register relax_addressT address
; /* Address now. */
2020 register int alignment
; /* Alignment (binary). */
2022 relax_addressT mask
;
2023 relax_addressT new_address
;
2025 mask
= ~((~0) << alignment
);
2026 new_address
= (address
+ mask
) & (~mask
);
2027 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2029 /* We must provide lots of padding, so the linker can discard it
2030 when needed. The linker will not add extra space, ever. */
2031 new_address
+= (1 << alignment
);
2033 return (new_address
- address
);
2037 relax_segment (segment_frag_root
, segment
)
2038 struct frag
*segment_frag_root
;
2041 register struct frag
*fragP
;
2042 register relax_addressT address
;
2043 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2044 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
2046 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2047 subseg_change (segment
, 0);
2049 /* For each frag in segment: count and store (a 1st guess of)
2052 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2054 fragP
->fr_address
= address
;
2055 address
+= fragP
->fr_fix
;
2057 switch (fragP
->fr_type
)
2060 address
+= fragP
->fr_offset
* fragP
->fr_var
;
2066 addressT offset
= relax_align (address
, (int) fragP
->fr_offset
);
2068 if (fragP
->fr_subtype
!= 0 && offset
> fragP
->fr_subtype
)
2071 if (offset
% fragP
->fr_var
!= 0)
2073 as_bad ("alignment padding (%lu bytes) not a multiple of %ld",
2074 (unsigned long) offset
, (long) fragP
->fr_var
);
2075 offset
-= (offset
% fragP
->fr_var
);
2084 /* Assume .org is nugatory. It will grow with 1st relax. */
2087 case rs_machine_dependent
:
2088 address
+= md_estimate_size_before_relax (fragP
, segment
);
2091 #ifndef WORKING_DOT_WORD
2092 /* Broken words don't concern us yet */
2093 case rs_broken_word
:
2098 BAD_CASE (fragP
->fr_type
);
2100 } /* switch(fr_type) */
2101 } /* for each frag in the segment */
2105 long stretch
; /* May be any size, 0 or negative. */
2106 /* Cumulative number of addresses we have */
2107 /* relaxed this pass. */
2108 /* We may have relaxed more than one address. */
2109 long stretched
; /* Have we stretched on this pass? */
2110 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2111 grew, and another shrank. If a branch instruction doesn't fit anymore,
2112 we could be scrod. */
2116 stretch
= stretched
= 0;
2117 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
2120 addressT was_address
;
2124 was_address
= fragP
->fr_address
;
2125 address
= fragP
->fr_address
+= stretch
;
2126 symbolP
= fragP
->fr_symbol
;
2127 offset
= fragP
->fr_offset
;
2129 switch (fragP
->fr_type
)
2131 case rs_fill
: /* .fill never relaxes. */
2135 #ifndef WORKING_DOT_WORD
2136 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2137 for it I do not want to write it. I do not want to have
2138 anything to do with it. This is not the proper way to
2139 implement this misfeature. */
2140 case rs_broken_word
:
2142 struct broken_word
*lie
;
2143 struct broken_word
*untruth
;
2145 /* Yes this is ugly (storing the broken_word pointer
2146 in the symbol slot). Still, this whole chunk of
2147 code is ugly, and I don't feel like doing anything
2148 about it. Think of it as stubbornness in action. */
2150 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2151 lie
&& lie
->dispfrag
== fragP
;
2152 lie
= lie
->next_broken_word
)
2158 offset
= (lie
->add
->sy_frag
->fr_address
2159 + S_GET_VALUE (lie
->add
)
2161 - (lie
->sub
->sy_frag
->fr_address
2162 + S_GET_VALUE (lie
->sub
)));
2163 if (offset
<= -32768 || offset
>= 32767)
2165 if (flag_warn_displacement
)
2168 sprint_value (buf
, (addressT
) lie
->addnum
);
2169 as_warn (".word %s-%s+%s didn't fit",
2170 S_GET_NAME (lie
->add
),
2171 S_GET_NAME (lie
->sub
),
2175 if (fragP
->fr_subtype
== 0)
2177 fragP
->fr_subtype
++;
2178 growth
+= md_short_jump_size
;
2180 for (untruth
= lie
->next_broken_word
;
2181 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2182 untruth
= untruth
->next_broken_word
)
2183 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
2184 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
2187 untruth
->use_jump
= lie
;
2189 growth
+= md_long_jump_size
;
2194 } /* case rs_broken_word */
2199 addressT oldoff
, newoff
;
2201 oldoff
= relax_align (was_address
+ fragP
->fr_fix
,
2203 newoff
= relax_align (address
+ fragP
->fr_fix
,
2206 if (fragP
->fr_subtype
!= 0)
2208 if (oldoff
> fragP
->fr_subtype
)
2210 if (newoff
> fragP
->fr_subtype
)
2214 growth
= newoff
- oldoff
;
2220 long target
= offset
;
2225 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2226 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2227 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2228 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2229 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2230 know (symbolP
->sy_frag
);
2231 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2232 || (symbolP
->sy_frag
== &zero_address_frag
));
2234 target
+= S_GET_VALUE (symbolP
)
2235 + symbolP
->sy_frag
->fr_address
;
2236 } /* if we have a symbol */
2238 know (fragP
->fr_next
);
2239 after
= fragP
->fr_next
->fr_address
;
2240 growth
= target
- after
;
2243 /* Growth may be negative, but variable part of frag
2244 cannot have fewer than 0 chars. That is, we can't
2246 as_bad ("attempt to .org backwards ignored");
2250 growth
-= stretch
; /* This is an absolute growth factor */
2257 growth
= S_GET_VALUE (symbolP
);
2258 if (symbolP
->sy_frag
!= &zero_address_frag
2259 || S_IS_COMMON (symbolP
)
2260 || ! S_IS_DEFINED (symbolP
))
2261 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2262 ".space specifies non-absolute value");
2263 fragP
->fr_symbol
= 0;
2266 as_warn (".space or .fill with negative value, ignored");
2274 case rs_machine_dependent
:
2275 #ifdef md_relax_frag
2276 growth
= md_relax_frag (fragP
, stretch
);
2278 #ifdef TC_GENERIC_RELAX_TABLE
2279 /* The default way to relax a frag is to look through
2280 TC_GENERIC_RELAX_TABLE. */
2281 growth
= relax_frag (fragP
, stretch
);
2282 #endif /* TC_GENERIC_RELAX_TABLE */
2287 BAD_CASE (fragP
->fr_type
);
2295 } /* For each frag in the segment. */
2297 while (stretched
); /* Until nothing further to relax. */
2301 * We now have valid fr_address'es for each frag.
2305 * All fr_address's are correct, relative to their own segment.
2306 * We have made all the fixS we will ever make.
2308 } /* relax_segment() */
2310 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2312 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2313 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2318 Go through all the fixS's in a segment and see which ones can be
2319 handled now. (These consist of fixS where we have since discovered
2320 the value of a symbol, or the address of the frag involved.)
2321 For each one, call md_apply_fix to put the fix into the frag data.
2323 Result is a count of how many relocation structs will be needed to
2324 handle the remaining fixS's that we couldn't completely handle here.
2325 These will be output later by emit_relocations(). */
2328 fixup_segment (fixP
, this_segment_type
)
2329 register fixS
*fixP
;
2330 segT this_segment_type
; /* N_TYPE bits for segment. */
2332 long seg_reloc_count
= 0;
2333 symbolS
*add_symbolP
;
2334 symbolS
*sub_symbolP
;
2341 segT add_symbol_segment
= absolute_section
;
2343 /* If the linker is doing the relaxing, we must not do any fixups.
2345 Well, strictly speaking that's not true -- we could do any that are
2346 PC-relative and don't cross regions that could change size. And for the
2347 i960 (the only machine for which we've got a relaxing linker right now),
2348 we might be able to turn callx/callj into bal anyways in cases where we
2349 know the maximum displacement. */
2352 for (; fixP
; fixP
= fixP
->fx_next
)
2354 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2355 return seg_reloc_count
;
2358 for (; fixP
; fixP
= fixP
->fx_next
)
2361 fprintf (stderr
, "\nprocessing fixup:\n");
2365 fragP
= fixP
->fx_frag
;
2367 where
= fixP
->fx_where
;
2368 place
= fragP
->fr_literal
+ where
;
2369 size
= fixP
->fx_size
;
2370 add_symbolP
= fixP
->fx_addsy
;
2371 #ifdef TC_VALIDATE_FIX
2372 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2374 sub_symbolP
= fixP
->fx_subsy
;
2375 add_number
= fixP
->fx_offset
;
2376 pcrel
= fixP
->fx_pcrel
;
2379 if (add_symbolP
!= NULL
2380 && add_symbolP
->sy_mri_common
)
2382 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2383 add_number
+= S_GET_VALUE (add_symbolP
);
2384 fixP
->fx_offset
= add_number
;
2385 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2389 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2393 resolve_symbol_value (sub_symbolP
);
2394 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2396 if (add_symbolP
!= NULL
)
2398 add_number
+= S_GET_VALUE (add_symbolP
);
2400 fixP
->fx_addsy
= NULL
;
2403 /* It's just -sym */
2404 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2406 add_number
-= S_GET_VALUE (sub_symbolP
);
2407 fixP
->fx_subsy
= NULL
;
2410 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2412 /* Should try converting to a constant. */
2417 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2418 "Negative of non-absolute symbol %s",
2419 S_GET_NAME (sub_symbolP
));
2421 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2422 && SEG_NORMAL (add_symbol_segment
))
2424 /* Difference of 2 symbols from same segment.
2425 Can't make difference of 2 undefineds: 'value' means
2426 something different for N_UNDF. */
2428 /* Makes no sense to use the difference of 2 arbitrary symbols
2429 as the target of a call instruction. */
2431 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2432 "callj to difference of 2 symbols");
2433 #endif /* TC_I960 */
2434 add_number
+= S_GET_VALUE (add_symbolP
) -
2435 S_GET_VALUE (sub_symbolP
);
2438 pcrel
= 0; /* No further pcrel processing. */
2440 /* Let the target machine make the final determination
2441 as to whether or not a relocation will be needed to
2442 handle this fixup. */
2443 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2446 fixP
->fx_addsy
= NULL
;
2447 fixP
->fx_subsy
= NULL
;
2452 /* Different segments in subtraction. */
2453 know (!(S_IS_EXTERNAL (sub_symbolP
)
2454 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2456 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2457 add_number
-= S_GET_VALUE (sub_symbolP
);
2460 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2461 #if 0 /* Do this even if it's already described as pc-relative. For example,
2462 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2463 pc-relative mode. */
2468 /* Make it pc-relative. */
2469 add_number
+= (MD_PCREL_FROM_SECTION (fixP
, this_segment_type
)
2470 - S_GET_VALUE (sub_symbolP
));
2477 #ifdef UNDEFINED_DIFFERENCE_OK
2478 /* The PA needs this for PIC code generation. We basically
2479 don't want to do anything if we have the difference of two
2480 symbols at this point. */
2483 /* Leave it alone. */
2486 #ifdef BFD_ASSEMBLER
2487 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2488 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2490 /* Leave it alone. */
2496 sprint_value (buf
, fragP
->fr_address
+ where
);
2497 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2498 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2499 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2500 S_GET_NAME (sub_symbolP
), buf
);
2507 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2508 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2511 * This fixup was made when the symbol's segment was
2512 * SEG_UNKNOWN, but it is now in the local segment.
2513 * So we know how to do the address without relocation.
2516 /* reloc_callj() may replace a 'call' with a 'calls' or a
2517 'bal', in which cases it modifies *fixP as appropriate.
2518 In the case of a 'calls', no further work is required,
2519 and *fixP has been set up to make the rest of the code
2522 #endif /* TC_I960 */
2524 add_number
+= S_GET_VALUE (add_symbolP
);
2525 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2526 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2528 /* Let the target machine make the final determination
2529 as to whether or not a relocation will be needed to
2530 handle this fixup. */
2531 if (!TC_FORCE_RELOCATION (fixP
))
2534 fixP
->fx_addsy
= NULL
;
2539 if (add_symbol_segment
== absolute_section
2543 /* See comment about reloc_callj() above. */
2545 #endif /* TC_I960 */
2546 add_number
+= S_GET_VALUE (add_symbolP
);
2548 /* Let the target machine make the final determination
2549 as to whether or not a relocation will be needed to
2550 handle this fixup. */
2552 if (!TC_FORCE_RELOCATION (fixP
))
2554 fixP
->fx_addsy
= NULL
;
2558 else if (add_symbol_segment
== undefined_section
2559 #ifdef BFD_ASSEMBLER
2560 || bfd_is_com_section (add_symbol_segment
)
2565 if ((int) fixP
->fx_bit_fixP
== 13)
2567 /* This is a COBR instruction. They have only a
2568 * 13-bit displacement and are only to be used
2569 * for local branches: flag as error, don't generate
2572 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2573 "can't use COBR format with external label");
2574 fixP
->fx_addsy
= NULL
;
2578 #endif /* TC_I960 */
2582 if (S_IS_COMMON (add_symbolP
))
2583 add_number
+= S_GET_VALUE (add_symbolP
);
2584 #endif /* TE_I386AIX */
2585 #endif /* OBJ_COFF */
2591 /* start-sanitize-v850 */
2592 #if !(defined (TC_V850) && defined (OBJ_ELF))
2593 /* end-sanitize-v850 */
2594 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2595 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2596 add_number
+= S_GET_VALUE (add_symbolP
);
2597 /* start-sanitize-v850 */
2599 /* end-sanitize-v850 */
2608 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2609 if (add_symbolP
== 0)
2611 #ifndef BFD_ASSEMBLER
2612 fixP
->fx_addsy
= &abs_symbol
;
2614 fixP
->fx_addsy
= section_symbol (absolute_section
);
2616 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2621 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2623 if (size
< sizeof (valueT
))
2627 /* set all bits to one */
2630 /* Technically, combining these produces an undefined result
2631 if size is sizeof (valueT), though I think these two
2632 half-way operations should both be defined. And the
2633 compiler should be able to combine them if it's valid on
2634 the host architecture. */
2637 hibit
= (valueT
) 1 << (size
* 8 - 1);
2638 if (((add_number
& mask
) != 0
2640 && (add_number
& hibit
) != 0))
2641 && ((add_number
& mask
) != mask
2642 || (add_number
& hibit
) == 0))
2644 char buf
[50], buf2
[50];
2645 sprint_value (buf
, fragP
->fr_address
+ where
);
2646 if (add_number
> 1000)
2647 sprint_value (buf2
, add_number
);
2649 sprintf (buf2
, "%ld", (long) add_number
);
2650 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2651 "Value of %s too large for field of %d bytes at %s",
2653 } /* generic error checking */
2655 #ifdef WARN_SIGNED_OVERFLOW_WORD
2656 /* Warn if a .word value is too large when treated as a signed
2657 number. We already know it is not too negative. This is to
2658 catch over-large switches generated by gcc on the 68k. */
2659 if (!flag_signed_overflow_ok
2661 && add_number
> 0x7fff)
2662 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2663 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2665 (unsigned long) (fragP
->fr_address
+ where
));
2667 } /* not a bit fix */
2671 #ifdef MD_APPLY_FIX3
2672 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2674 #ifdef BFD_ASSEMBLER
2675 md_apply_fix (fixP
, &add_number
);
2677 md_apply_fix (fixP
, add_number
);
2681 #ifndef TC_HANDLES_FX_DONE
2682 /* If the tc-* files haven't been converted, assume it's handling
2683 it the old way, where a null fx_addsy means that the fix has
2684 been applied completely, and no further work is needed. */
2685 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2689 #ifdef TC_VALIDATE_FIX
2693 fprintf (stderr
, "result:\n");
2696 } /* For each fixS in this segment. */
2698 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2699 return seg_reloc_count
;
2702 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2705 number_to_chars_bigendian (buf
, val
, n
)
2710 if (n
> sizeof (val
)|| n
<= 0)
2714 buf
[n
] = val
& 0xff;
2720 number_to_chars_littleendian (buf
, val
, n
)
2725 if (n
> sizeof (val
) || n
<= 0)
2729 *buf
++ = val
& 0xff;
2735 write_print_statistics (file
)
2738 fprintf (stderr
, "fixups: %d\n", n_fixups
);
2742 extern int indent_level
;
2749 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2751 fprintf (stderr
, " pcrel");
2752 if (fixp
->fx_pcrel_adjust
)
2753 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2754 if (fixp
->fx_im_disp
)
2757 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2759 fprintf (stderr
, " im_disp");
2763 fprintf (stderr
, " tcbit");
2765 fprintf (stderr
, " done");
2766 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2767 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2768 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2769 #ifdef BFD_ASSEMBLER
2770 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2773 #ifdef NEED_FX_R_TYPE
2774 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2779 fprintf (stderr
, "\n +<");
2780 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2781 fprintf (stderr
, ">");
2785 fprintf (stderr
, "\n -<");
2786 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2787 fprintf (stderr
, ">");
2789 fprintf (stderr
, "\n");
2792 /* end of write.c */