1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
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
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This thing should be set up to do byteordering correctly. But... */
26 #include "output-file.h"
28 /* This looks like a good idea. Let's try turning it on always, for now. */
29 #undef BFD_FAST_SECTION_FILL
30 #define BFD_FAST_SECTION_FILL
32 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
33 instruction so that the disassembler does not choke on it. */
35 #define NOP_OPCODE 0x00
38 #ifndef TC_ADJUST_RELOC_COUNT
39 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
42 #ifndef TC_FORCE_RELOCATION
43 #define TC_FORCE_RELOCATION(FIXP) 0
46 #ifndef TC_FORCE_RELOCATION_SECTION
47 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
50 #ifndef MD_PCREL_FROM_SECTION
51 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
54 #ifndef WORKING_DOT_WORD
55 extern CONST
int md_short_jump_size
;
56 extern CONST
int md_long_jump_size
;
59 int symbol_table_frozen
;
60 void print_fixup
PARAMS ((fixS
*));
63 static void renumber_sections
PARAMS ((bfd
*, asection
*, PTR
));
65 /* We generally attach relocs to frag chains. However, after we have
66 chained these all together into a segment, any relocs we add after
67 that must be attached to a segment. This will include relocs added
68 in md_estimate_size_for_relax, for example. */
69 static int frags_chained
= 0;
75 struct frag
*text_frag_root
;
76 struct frag
*data_frag_root
;
77 struct frag
*bss_frag_root
;
79 struct frag
*text_last_frag
; /* Last frag in segment. */
80 struct frag
*data_last_frag
; /* Last frag in segment. */
81 static struct frag
*bss_last_frag
; /* Last frag in segment. */
85 static object_headers headers
;
88 long string_byte_count
;
89 char *next_object_file_charP
; /* Tracks object file bytes. */
92 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
95 #endif /* BFD_ASSEMBLER */
100 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
101 symbolS
*add
, symbolS
*sub
,
102 offsetT offset
, int pcrel
,
103 bfd_reloc_code_real_type r_type
));
105 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
106 symbolS
*add
, symbolS
*sub
,
107 offsetT offset
, int pcrel
,
110 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
111 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
113 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
118 * Create a fixS in obstack 'notes'.
121 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
123 fragS
*frag
; /* Which frag? */
124 int where
; /* Where in that frag? */
125 int size
; /* 1, 2, or 4 usually. */
126 symbolS
*add_symbol
; /* X_add_symbol. */
127 symbolS
*sub_symbol
; /* X_op_symbol. */
128 offsetT offset
; /* X_add_number. */
129 int pcrel
; /* TRUE if PC-relative relocation. */
131 bfd_reloc_code_real_type r_type
; /* Relocation type */
133 int r_type
; /* Relocation type */
140 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
142 fixP
->fx_frag
= frag
;
143 fixP
->fx_where
= where
;
144 fixP
->fx_size
= size
;
145 /* We've made fx_size a narrow field; check that it's wide enough. */
146 if (fixP
->fx_size
!= size
)
148 as_bad ("field fx_size too small to hold %d", size
);
151 fixP
->fx_addsy
= add_symbol
;
152 fixP
->fx_subsy
= sub_symbol
;
153 fixP
->fx_offset
= offset
;
154 fixP
->fx_pcrel
= pcrel
;
156 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
157 fixP
->fx_r_type
= r_type
;
159 fixP
->fx_im_disp
= 0;
160 fixP
->fx_pcrel_adjust
= 0;
161 fixP
->fx_bit_fixP
= 0;
162 fixP
->fx_addnumber
= 0;
167 TC_INIT_FIX_DATA(fixP
);
170 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
172 /* Usually, we want relocs sorted numerically, but while
173 comparing to older versions of gas that have relocs
174 reverse sorted, it is convenient to have this compile
175 time option. xoxorich. */
180 fixS
**seg_fix_rootP
= (frags_chained
181 ? &seg_info (now_seg
)->fix_root
182 : &frchain_now
->fix_root
);
183 fixS
**seg_fix_tailP
= (frags_chained
184 ? &seg_info (now_seg
)->fix_tail
185 : &frchain_now
->fix_tail
);
188 #ifdef REVERSE_SORT_RELOCS
190 fixP
->fx_next
= *seg_fix_rootP
;
191 *seg_fix_rootP
= fixP
;
193 #else /* REVERSE_SORT_RELOCS */
195 fixP
->fx_next
= NULL
;
198 (*seg_fix_tailP
)->fx_next
= fixP
;
200 *seg_fix_rootP
= fixP
;
201 *seg_fix_tailP
= fixP
;
203 #endif /* REVERSE_SORT_RELOCS */
210 /* Create a fixup relative to a symbol (plus a constant). */
213 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
214 fragS
*frag
; /* Which frag? */
215 int where
; /* Where in that frag? */
216 int size
; /* 1, 2, or 4 usually. */
217 symbolS
*add_symbol
; /* X_add_symbol. */
218 offsetT offset
; /* X_add_number. */
219 int pcrel
; /* TRUE if PC-relative relocation. */
221 bfd_reloc_code_real_type r_type
; /* Relocation type */
223 int r_type
; /* Relocation type */
226 return fix_new_internal (frag
, where
, size
, add_symbol
,
227 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
230 /* Create a fixup for an expression. Currently we only support fixups
231 for difference expressions. That is itself more than most object
232 file formats support anyhow. */
235 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
236 fragS
*frag
; /* Which frag? */
237 int where
; /* Where in that frag? */
238 int size
; /* 1, 2, or 4 usually. */
239 expressionS
*exp
; /* Expression. */
240 int pcrel
; /* TRUE if PC-relative relocation. */
242 bfd_reloc_code_real_type r_type
; /* Relocation type */
244 int r_type
; /* Relocation type */
257 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
258 the difference expression cannot immediately be reduced. */
260 extern symbolS
*make_expr_symbol ();
261 symbolS
*stmp
= make_expr_symbol (exp
);
262 exp
->X_op
= O_symbol
;
263 exp
->X_op_symbol
= 0;
264 exp
->X_add_symbol
= stmp
;
265 exp
->X_add_number
= 0;
266 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
270 add
= exp
->X_add_symbol
;
271 off
= exp
->X_add_number
;
273 #if defined(BFD_ASSEMBLER)
274 r_type
= BFD_RELOC_RVA
;
276 #if defined(TC_RVA_RELOC)
277 r_type
= TC_RVA_RELOC
;
279 as_fatal("rva not supported");
285 sub
= exp
->X_add_symbol
;
286 off
= exp
->X_add_number
;
290 sub
= exp
->X_op_symbol
;
293 add
= exp
->X_add_symbol
;
296 off
= exp
->X_add_number
;
300 add
= make_expr_symbol (exp
);
304 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
308 /* Append a string onto another string, bumping the pointer along. */
310 append (charPP
, fromP
, length
)
313 unsigned long length
;
315 /* Don't trust memcpy() of 0 chars. */
319 memcpy (*charPP
, fromP
, length
);
323 #ifndef BFD_ASSEMBLER
324 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
328 * This routine records the largest alignment seen for each segment.
329 * If the beginning of the segment is aligned on the worst-case
330 * boundary, all of the other alignments within it will work. At
331 * least one object format really uses this info.
334 record_alignment (seg
, align
)
335 /* Segment to which alignment pertains */
337 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
341 if (seg
== absolute_section
)
344 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
345 bfd_set_section_alignment (stdoutput
, seg
, align
);
347 if (align
> section_alignment
[(int) seg
])
348 section_alignment
[(int) seg
] = align
;
354 /* Reset the section indices after removing the gas created sections. */
357 renumber_sections (abfd
, sec
, countparg
)
362 int *countp
= (int *) countparg
;
364 sec
->index
= *countp
;
368 #endif /* defined (BFD_ASSEMBLER) */
370 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
373 chain_frchains_together_1 (section
, frchp
)
375 struct frchain
*frchp
;
377 fragS dummy
, *prev_frag
= &dummy
;
379 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
382 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
384 prev_frag
->fr_next
= frchp
->frch_root
;
385 prev_frag
= frchp
->frch_last
;
386 assert (prev_frag
->fr_type
!= 0);
388 if (frchp
->fix_root
!= (fixS
*) NULL
)
390 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
391 seg_info (section
)->fix_root
= frchp
->fix_root
;
392 prev_fix
->fx_next
= frchp
->fix_root
;
393 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
394 prev_fix
= frchp
->fix_tail
;
398 assert (prev_frag
->fr_type
!= 0);
399 prev_frag
->fr_next
= 0;
408 chain_frchains_together (abfd
, section
, xxx
)
409 bfd
*abfd
; /* unused */
411 PTR xxx
; /* unused */
413 segment_info_type
*info
;
415 /* BFD may have introduced its own sections without using
416 subseg_new, so it is possible that seg_info is NULL. */
417 info
= seg_info (section
);
418 if (info
!= (segment_info_type
*) NULL
)
419 info
->frchainP
->frch_last
420 = chain_frchains_together_1 (section
, info
->frchainP
);
422 /* Now that we've chained the frags together, we must add new fixups
423 to the segment, not to the frag chain. */
429 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
432 remove_subsegs (head
, seg
, root
, last
)
438 *root
= head
->frch_root
;
439 *last
= chain_frchains_together_1 (seg
, head
);
444 #if defined (BFD_ASSEMBLER) || !defined (BFD)
448 cvt_frag_to_fill (sec
, fragP
)
453 cvt_frag_to_fill (headersP
, sec
, fragP
)
454 object_headers
*headersP
;
459 switch (fragP
->fr_type
)
466 HANDLE_ALIGN (fragP
);
468 know (fragP
->fr_next
!= NULL
);
469 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
471 - fragP
->fr_fix
) / fragP
->fr_var
;
472 if (fragP
->fr_offset
< 0)
474 as_bad ("attempt to .org/.space backwards? (%ld)",
475 (long) fragP
->fr_offset
);
477 fragP
->fr_type
= rs_fill
;
483 case rs_machine_dependent
:
485 md_convert_frag (stdoutput
, sec
, fragP
);
487 md_convert_frag (headersP
, sec
, fragP
);
490 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
493 * After md_convert_frag, we make the frag into a ".space 0".
494 * Md_convert_frag() should set up any fixSs and constants
500 #ifndef WORKING_DOT_WORD
503 struct broken_word
*lie
;
505 if (fragP
->fr_subtype
)
507 fragP
->fr_fix
+= md_short_jump_size
;
508 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
509 lie
&& lie
->dispfrag
== fragP
;
510 lie
= lie
->next_broken_word
)
512 fragP
->fr_fix
+= md_long_jump_size
;
520 BAD_CASE (fragP
->fr_type
);
525 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
529 relax_and_size_seg (abfd
, sec
, xxx
)
536 segment_info_type
*seginfo
;
538 valueT size
, newsize
;
540 subseg_change (sec
, 0);
542 flags
= bfd_get_section_flags (abfd
, sec
);
544 seginfo
= seg_info (sec
);
545 if (seginfo
&& seginfo
->frchainP
)
547 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
548 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
549 cvt_frag_to_fill (sec
, fragp
);
550 for (fragp
= seginfo
->frchainP
->frch_root
;
552 fragp
= fragp
->fr_next
)
553 /* walk to last elt */;
554 size
= fragp
->fr_address
+ fragp
->fr_fix
;
559 if (size
> 0 && ! seginfo
->bss
)
560 flags
|= SEC_HAS_CONTENTS
;
562 /* @@ This is just an approximation. */
563 if (seginfo
&& seginfo
->fix_root
)
567 x
= bfd_set_section_flags (abfd
, sec
, flags
);
570 newsize
= md_section_align (sec
, size
);
571 x
= bfd_set_section_size (abfd
, sec
, newsize
);
574 /* If the size had to be rounded up, add some padding in the last
576 assert (newsize
>= size
);
579 fragS
*last
= seginfo
->frchainP
->frch_last
;
580 fragp
= seginfo
->frchainP
->frch_root
;
581 while (fragp
->fr_next
!= last
)
582 fragp
= fragp
->fr_next
;
583 last
->fr_address
= size
;
584 fragp
->fr_offset
+= newsize
- size
;
587 #ifdef tc_frob_section
588 tc_frob_section (sec
);
590 #ifdef obj_frob_section
591 obj_frob_section (sec
);
597 dump_section_relocs (abfd
, sec
, stream_
)
602 FILE *stream
= (FILE *) stream_
;
603 segment_info_type
*seginfo
= seg_info (sec
);
604 fixS
*fixp
= seginfo
->fix_root
;
609 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
612 symbolS
*s
= fixp
->fx_addsy
;
615 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
616 s
->bsym
->section
->name
);
617 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
619 fprintf (stream
, " section sym");
621 fprintf (stream
, "+%x", S_GET_VALUE (s
));
624 fprintf (stream
, "+%x", S_GET_VALUE (s
));
625 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
628 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
629 fixp
= fixp
->fx_next
;
633 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
636 #ifndef EMIT_SECTION_SYMBOLS
637 #define EMIT_SECTION_SYMBOLS 1
641 adjust_reloc_syms (abfd
, sec
, xxx
)
646 segment_info_type
*seginfo
= seg_info (sec
);
652 dump_section_relocs (abfd
, sec
, stderr
);
654 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
657 else if (fixp
->fx_addsy
)
665 fprintf (stderr
, "\n\nadjusting fixup:\n");
669 sym
= fixp
->fx_addsy
;
671 /* All symbols should have already been resolved at this
672 point. It is possible to see unresolved expression
673 symbols, though, since they are not in the regular symbol
675 if (sym
!= NULL
&& ! sym
->sy_resolved
)
676 resolve_symbol_value (sym
);
677 if (fixp
->fx_subsy
!= NULL
&& ! fixp
->fx_subsy
->sy_resolved
)
678 resolve_symbol_value (fixp
->fx_subsy
);
680 /* If this symbol is equated to an undefined symbol, convert
681 the fixup to being against that symbol. */
682 if (sym
->sy_value
.X_op
== O_symbol
683 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
685 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
686 sym
= sym
->sy_value
.X_add_symbol
;
687 fixp
->fx_addsy
= sym
;
690 symsec
= S_GET_SEGMENT (sym
);
692 if (sym
!= NULL
&& sym
->sy_mri_common
)
694 /* These symbols are handled specially in fixup_segment. */
698 if (bfd_is_abs_section (symsec
))
700 /* The fixup_segment routine will not use this symbol in a
701 relocation unless TC_FORCE_RELOCATION returns 1. */
702 if (TC_FORCE_RELOCATION (fixp
))
704 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
705 #ifdef UNDEFINED_DIFFERENCE_OK
706 if (fixp
->fx_subsy
!= NULL
)
707 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
713 /* If it's one of these sections, assume the symbol is
714 definitely going to be output. The code in
715 md_estimate_size_before_relax in tc-mips.c uses this test
716 as well, so if you change this code you should look at that
718 if (bfd_is_und_section (symsec
)
719 || bfd_is_com_section (symsec
))
721 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
722 #ifdef UNDEFINED_DIFFERENCE_OK
723 /* We have the difference of an undefined symbol and some
724 other symbol. Make sure to mark the other symbol as used
725 in a relocation so that it will always be output. */
727 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
732 /* Don't try to reduce relocs which refer to .linkonce
733 sections. It can lead to confusion when a debugging
734 section refers to a .linkonce section. I hope this will
735 always be correct. */
742 if ((bfd_get_section_flags (stdoutput
, symsec
) & SEC_LINK_ONCE
)
747 /* The GNU toolchain uses an extension for ELF: a section
748 beginning with the magic string .gnu.linkonce is a
750 if (strncmp (segment_name (symsec
), ".gnu.linkonce",
751 sizeof ".gnu.linkonce" - 1) == 0)
757 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
758 #ifdef UNDEFINED_DIFFERENCE_OK
759 if (fixp
->fx_subsy
!= NULL
)
760 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
766 /* Since we're reducing to section symbols, don't attempt to reduce
767 anything that's already using one. */
768 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
770 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
774 /* Is there some other reason we can't adjust this one? (E.g.,
775 call/bal links in i960-bout symbols.) */
776 #ifdef obj_fix_adjustable
777 if (! obj_fix_adjustable (fixp
))
779 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
784 /* Is there some other (target cpu dependent) reason we can't adjust
785 this one? (E.g. relocations involving function addresses on
787 #ifdef tc_fix_adjustable
788 if (! tc_fix_adjustable (fixp
))
790 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
795 /* If the section symbol isn't going to be output, the relocs
796 at least should still work. If not, figure out what to do
797 when we run into that case.
799 We refetch the segment when calling section_symbol, rather
800 than using symsec, because S_GET_VALUE may wind up changing
801 the section when it calls resolve_symbol_value. */
802 fixp
->fx_offset
+= S_GET_VALUE (sym
);
803 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
804 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
809 #if 1/*def RELOC_REQUIRES_SYMBOL*/
812 /* There was no symbol required by this relocation. However,
813 BFD doesn't really handle relocations without symbols well.
814 (At least, the COFF support doesn't.) So for now we fake up
815 a local symbol in the absolute section. */
817 fixp
->fx_addsy
= section_symbol (absolute_section
);
818 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
822 dump_section_relocs (abfd
, sec
, stderr
);
826 write_relocs (abfd
, sec
, xxx
)
831 segment_info_type
*seginfo
= seg_info (sec
);
838 /* If seginfo is NULL, we did not create this section; don't do
843 fixup_segment (seginfo
->fix_root
, sec
);
846 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
849 #ifndef RELOC_EXPANSION_POSSIBLE
850 /* Set up reloc information as well. */
851 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
852 n
* sizeof (arelent
*));
853 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
856 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
859 bfd_reloc_status_type s
;
868 /* If this is an undefined symbol which was equated to another
869 symbol, then use generate the reloc against the latter symbol
870 rather than the former. */
871 sym
= fixp
->fx_addsy
;
872 while (sym
->sy_value
.X_op
== O_symbol
873 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
874 sym
= sym
->sy_value
.X_add_symbol
;
875 fixp
->fx_addsy
= sym
;
877 reloc
= tc_gen_reloc (sec
, fixp
);
885 /* This test is triggered inappropriately for the SH. */
886 if (fixp
->fx_where
+ fixp
->fx_size
887 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
891 s
= bfd_install_relocation (stdoutput
, reloc
,
892 fixp
->fx_frag
->fr_literal
,
893 fixp
->fx_frag
->fr_address
,
899 case bfd_reloc_overflow
:
900 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
903 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
904 fixp
->fx_file
, fixp
->fx_line
);
909 n
= n
* MAX_RELOC_EXPANSION
;
910 /* Set up reloc information as well. */
911 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
912 n
* sizeof (arelent
*));
915 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
919 bfd_reloc_status_type s
;
929 /* If this is an undefined symbol which was equated to another
930 symbol, then use generate the reloc against the latter symbol
931 rather than the former. */
932 sym
= fixp
->fx_addsy
;
933 while (sym
->sy_value
.X_op
== O_symbol
934 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
935 sym
= sym
->sy_value
.X_add_symbol
;
936 fixp
->fx_addsy
= sym
;
938 reloc
= tc_gen_reloc (sec
, fixp
);
940 for (j
= 0; reloc
[j
]; j
++)
942 relocs
[i
++] = reloc
[j
];
945 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
946 if (fixp
->fx_where
+ fixp
->fx_size
947 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
948 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
949 "internal error: fixup not contained within frag");
950 for (j
= 0; reloc
[j
]; j
++)
952 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
953 fixp
->fx_frag
->fr_literal
,
954 fixp
->fx_frag
->fr_address
,
960 case bfd_reloc_overflow
:
961 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
962 "relocation overflow");
965 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
966 fixp
->fx_file
, fixp
->fx_line
);
977 sympp
= bfd_get_outsymbols (stdoutput
);
978 nsyms
= bfd_get_symcount (stdoutput
);
979 for (i
= 0; i
< n
; i
++)
980 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
982 for (j
= 0; j
< nsyms
; j
++)
983 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
992 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
994 bfd_set_section_flags (abfd
, sec
,
995 (bfd_get_section_flags (abfd
, sec
)
996 & (flagword
) ~SEC_RELOC
));
1003 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
1004 for (i
= 0; i
< n
; i
++)
1007 s
= *r
->sym_ptr_ptr
;
1008 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1009 i
, r
, r
->address
, s
->name
, r
->addend
);
1016 write_contents (abfd
, sec
, xxx
)
1021 segment_info_type
*seginfo
= seg_info (sec
);
1022 unsigned long offset
= 0;
1025 /* Write out the frags. */
1027 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
1030 for (f
= seginfo
->frchainP
->frch_root
;
1035 unsigned long fill_size
;
1039 assert (f
->fr_type
== rs_fill
);
1042 x
= bfd_set_section_contents (stdoutput
, sec
,
1043 f
->fr_literal
, (file_ptr
) offset
,
1044 (bfd_size_type
) f
->fr_fix
);
1047 bfd_perror (stdoutput
->filename
);
1048 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1049 exit (EXIT_FAILURE
);
1051 offset
+= f
->fr_fix
;
1053 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1054 fill_size
= f
->fr_var
;
1055 count
= f
->fr_offset
;
1056 assert (count
>= 0);
1057 if (fill_size
&& count
)
1060 if (fill_size
> sizeof(buf
))
1062 /* Do it the old way. Can this ever happen? */
1065 x
= bfd_set_section_contents (stdoutput
, sec
,
1068 (bfd_size_type
) fill_size
);
1071 bfd_perror (stdoutput
->filename
);
1072 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1073 exit (EXIT_FAILURE
);
1075 offset
+= fill_size
;
1080 /* Build a buffer full of fill objects and output it as
1081 often as necessary. This saves on the overhead of
1082 potentially lots of bfd_set_section_contents calls. */
1086 n_per_buf
= sizeof (buf
);
1087 memset (buf
, *fill_literal
, n_per_buf
);
1092 n_per_buf
= sizeof(buf
)/fill_size
;
1093 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1094 memcpy(bufp
, fill_literal
, fill_size
);
1096 for (; count
> 0; count
-= n_per_buf
)
1098 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1099 x
= bfd_set_section_contents (stdoutput
, sec
,
1100 buf
, (file_ptr
) offset
,
1101 (bfd_size_type
) n_per_buf
* fill_size
);
1103 as_fatal ("Cannot write to output file.");
1104 offset
+= n_per_buf
* fill_size
;
1112 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1114 merge_data_into_text ()
1116 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1117 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1118 seg_info (data_section
)->frchainP
->frch_root
;
1119 seg_info (text_section
)->frchainP
->frch_last
=
1120 seg_info (data_section
)->frchainP
->frch_last
;
1121 seg_info (data_section
)->frchainP
= 0;
1125 text_last_frag
->fr_next
= data_frag_root
;
1126 text_last_frag
= data_last_frag
;
1127 data_last_frag
= NULL
;
1128 data_frag_root
= NULL
;
1131 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1132 tmp
->fx_next
= data_fix_root
;
1133 text_fix_tail
= data_fix_tail
;
1136 text_fix_root
= data_fix_root
;
1137 data_fix_root
= NULL
;
1140 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1142 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1144 relax_and_size_all_segments ()
1148 relax_segment (text_frag_root
, SEG_TEXT
);
1149 relax_segment (data_frag_root
, SEG_DATA
);
1150 relax_segment (bss_frag_root
, SEG_BSS
);
1152 * Now the addresses of frags are correct within the segment.
1155 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1156 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1157 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1160 * Join the 2 segments into 1 huge segment.
1161 * To do this, re-compute every rn_address in the SEG_DATA frags.
1162 * Then join the data frags after the text frags.
1164 * Determine a_data [length of data segment].
1168 register relax_addressT slide
;
1170 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1172 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1173 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1174 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1176 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1177 /* For b.out: If the data section has a strict alignment
1178 requirement, its load address in the .o file will be
1179 rounded up from the size of the text section. These
1180 two values are *not* the same! Similarly for the bss
1182 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1185 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1187 fragP
->fr_address
+= slide
;
1188 } /* for each data frag */
1190 know (text_last_frag
!= 0);
1191 text_last_frag
->fr_next
= data_frag_root
;
1195 H_SET_DATA_SIZE (&headers
, 0);
1199 /* See above comments on b.out data section address. */
1202 if (data_last_frag
== 0)
1203 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1205 bss_vma
= data_last_frag
->fr_address
;
1206 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1207 bss_address_frag
.fr_address
= bss_vma
;
1209 #else /* ! OBJ_BOUT */
1210 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1211 H_GET_DATA_SIZE (&headers
));
1213 #endif /* ! OBJ_BOUT */
1215 /* Slide all the frags */
1218 relax_addressT slide
= bss_address_frag
.fr_address
;
1220 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1222 fragP
->fr_address
+= slide
;
1223 } /* for each bss frag */
1227 H_SET_BSS_SIZE (&headers
,
1228 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1230 H_SET_BSS_SIZE (&headers
, 0);
1232 #endif /* ! BFD_ASSEMBLER && ! BFD */
1234 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1236 #ifdef BFD_ASSEMBLER
1244 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1246 /* Count symbols. We can't rely on a count made by the loop in
1247 write_object_file, because *_frob_file may add a new symbol or
1250 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1257 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1258 nsyms
* sizeof (asymbol
*));
1259 symp
= symbol_rootP
;
1260 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1262 asympp
[i
] = symp
->bsym
;
1268 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1269 assert (result
== true);
1270 symbol_table_frozen
= 1;
1275 write_object_file ()
1277 struct frchain
*frchainP
; /* Track along all frchains. */
1278 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1279 fragS
*fragP
; /* Track along all frags. */
1282 /* Do we really want to write it? */
1284 int n_warns
, n_errs
;
1285 n_warns
= had_warnings ();
1286 n_errs
= had_errors ();
1287 /* The -Z flag indicates that an object file should be generated,
1288 regardless of warnings and errors. */
1289 if (flag_always_generate_output
)
1291 if (n_warns
|| n_errs
)
1292 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1293 n_errs
, n_errs
== 1 ? "" : "s",
1294 n_warns
, n_warns
== 1 ? "" : "s");
1299 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1300 n_errs
, n_errs
== 1 ? "" : "s",
1301 n_warns
, n_warns
== 1 ? "" : "s");
1306 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1307 a routine to check for the definition of the procedure "_main",
1308 and if so -- fix it up so that it can be program entry point. */
1309 vms_check_for_main ();
1310 #endif /* OBJ_VMS */
1312 /* After every sub-segment, we fake an ".align ...". This conforms to
1313 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1314 frag that requires least thought. ".align" frags like to have a
1315 following frag since that makes calculating their intended length
1318 @@ Is this really necessary?? */
1319 #ifndef SUB_SEGMENT_ALIGN
1320 #ifdef BFD_ASSEMBLER
1321 #define SUB_SEGMENT_ALIGN(SEG) (0)
1323 #define SUB_SEGMENT_ALIGN(SEG) (2)
1326 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1328 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1329 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1330 /* frag_align will have left a new frag.
1331 Use this last frag for an empty ".fill".
1333 For this segment ...
1334 Create a last frag. Do not leave a "being filled in frag". */
1335 frag_wane (frag_now
);
1336 frag_now
->fr_fix
= 0;
1337 know (frag_now
->fr_next
== NULL
);
1340 /* From now on, we don't care about sub-segments. Build one frag chain
1341 for each segment. Linked thru fr_next. */
1343 #ifdef BFD_ASSEMBLER
1344 /* Remove the sections created by gas for its own purposes. */
1346 asection
**seclist
, *sec
;
1349 seclist
= &stdoutput
->sections
;
1350 while (seclist
&& *seclist
)
1353 while (sec
== reg_section
|| sec
== expr_section
)
1357 stdoutput
->section_count
--;
1362 seclist
= &(*seclist
)->next
;
1365 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1368 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1370 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1371 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1372 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1375 /* We have two segments. If user gave -R flag, then we must put the
1376 data frags into the text segment. Do this before relaxing so
1377 we know to take advantage of -R and make shorter addresses. */
1378 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1379 if (flag_readonly_data_in_text
)
1381 merge_data_into_text ();
1385 #ifdef BFD_ASSEMBLER
1386 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1388 relax_and_size_all_segments ();
1389 #endif /* BFD_ASSEMBLER */
1391 #ifndef BFD_ASSEMBLER
1394 * Crawl the symbol chain.
1396 * For each symbol whose value depends on a frag, take the address of
1397 * that frag and subsume it into the value of the symbol.
1398 * After this, there is just one way to lookup a symbol value.
1399 * Values are left in their final state for object file emission.
1400 * We adjust the values of 'L' local symbols, even if we do
1401 * not intend to emit them to the object file, because their values
1402 * are needed for fix-ups.
1404 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1405 * from the symbol chain. (They are still pointed to by the fixes.)
1407 * Count the remaining symbols.
1408 * Assign a symbol number to each symbol.
1409 * Count the number of string-table chars we will emit.
1410 * Put this info into the headers as appropriate.
1413 know (zero_address_frag
.fr_address
== 0);
1414 string_byte_count
= sizeof (string_byte_count
);
1416 obj_crawl_symbol_chain (&headers
);
1418 if (string_byte_count
== sizeof (string_byte_count
))
1419 string_byte_count
= 0;
1421 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1424 * Addresses of frags now reflect addresses we use in the object file.
1425 * Symbol values are correct.
1426 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1427 * Also converting any machine-dependent frags using md_convert_frag();
1429 subseg_change (SEG_TEXT
, 0);
1431 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1433 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1435 /* Some assert macros don't work with # directives mixed in. */
1437 if (!(fragP
->fr_next
== NULL
1439 || fragP
->fr_next
== data_frag_root
1441 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1442 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1446 #endif /* ! BFD_ASSEMBLER */
1448 #ifndef WORKING_DOT_WORD
1450 struct broken_word
*lie
;
1451 struct broken_word
**prevP
;
1453 prevP
= &broken_words
;
1454 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1459 exp
.X_op
= O_subtract
;
1460 exp
.X_add_symbol
= lie
->add
;
1461 exp
.X_op_symbol
= lie
->sub
;
1462 exp
.X_add_number
= lie
->addnum
;
1463 #ifdef BFD_ASSEMBLER
1464 #ifdef TC_CONS_FIX_NEW
1465 TC_CONS_FIX_NEW (lie
->frag
,
1466 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1469 fix_new_exp (lie
->frag
,
1470 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1471 2, &exp
, 0, BFD_RELOC_16
);
1474 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1475 fix_new_exp (lie
->frag
,
1476 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1477 2, &exp
, 0, NO_RELOC
);
1480 fix_new_ns32k_exp (lie
->frag
,
1481 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1482 2, &exp
, 0, 0, 2, 0, 0);
1484 fix_new_exp (lie
->frag
,
1485 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1487 #endif /* TC_NS32K */
1488 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1489 #endif /* BFD_ASSEMBLER */
1490 *prevP
= lie
->next_broken_word
;
1493 prevP
= &(lie
->next_broken_word
);
1495 for (lie
= broken_words
; lie
;)
1497 struct broken_word
*untruth
;
1499 addressT table_addr
;
1500 addressT from_addr
, to_addr
;
1503 fragP
= lie
->dispfrag
;
1505 /* Find out how many broken_words go here. */
1507 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1508 if (untruth
->added
== 1)
1511 table_ptr
= lie
->dispfrag
->fr_opcode
;
1512 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1513 /* Create the jump around the long jumps. This is a short
1514 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1515 from_addr
= table_addr
;
1516 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1517 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1518 table_ptr
+= md_short_jump_size
;
1519 table_addr
+= md_short_jump_size
;
1521 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1523 if (lie
->added
== 2)
1525 /* Patch the jump table */
1526 /* This is the offset from ??? to table_ptr+0 */
1527 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1528 #ifdef BFD_ASSEMBLER
1529 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1531 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1532 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1534 if (untruth
->use_jump
== lie
)
1535 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1538 /* Install the long jump */
1539 /* this is a long jump from table_ptr+0 to the final target */
1540 from_addr
= table_addr
;
1541 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1542 #ifdef BFD_ASSEMBLER
1543 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1545 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1546 table_ptr
+= md_long_jump_size
;
1547 table_addr
+= md_long_jump_size
;
1551 #endif /* not WORKING_DOT_WORD */
1553 #ifndef BFD_ASSEMBLER
1556 char *the_object_file
;
1557 long object_file_size
;
1559 * Scan every FixS performing fixups. We had to wait until now to do
1560 * this because md_convert_frag() may have made some fixSs.
1564 subseg_change (SEG_TEXT
, 0);
1565 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1566 subseg_change (SEG_DATA
, 0);
1567 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1568 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1570 /* FIXME move this stuff into the pre-write-hook */
1571 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1572 H_SET_ENTRY_POINT (&headers
, 0);
1574 obj_pre_write_hook (&headers
); /* extra coff stuff */
1576 object_file_size
= H_GET_FILE_SIZE (&headers
);
1577 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1579 output_file_create (out_file_name
);
1581 obj_header_append (&next_object_file_charP
, &headers
);
1583 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1588 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1590 register long count
;
1591 register char *fill_literal
;
1592 register long fill_size
;
1595 know (fragP
->fr_type
== rs_fill
);
1596 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1597 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1598 fill_size
= fragP
->fr_var
;
1599 know (fragP
->fr_offset
>= 0);
1601 for (count
= fragP
->fr_offset
; count
; count
--)
1603 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1606 } /* for each code frag. */
1608 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1613 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1614 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
)));
1616 /* Make addresses in data relocation directives relative to beginning of
1617 * first data fragment, not end of last text fragment: alignment of the
1618 * start of the data segment may place a gap between the segments.
1620 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1622 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1623 #endif /* TC_I960 */
1625 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
)));
1628 * Emit line number entries.
1630 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1631 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
)));
1636 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1637 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
)));
1643 if (string_byte_count
> 0)
1645 obj_emit_strings (&next_object_file_charP
);
1646 } /* only if we have a string table */
1649 bfd_seek (stdoutput
, 0, 0);
1650 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1653 /* Write the data to the file */
1654 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1655 free (the_object_file
);
1657 } /* non vms output */
1660 * Now do the VMS-dependent part of writing the object file
1662 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1663 H_GET_DATA_SIZE (&headers
),
1664 H_GET_BSS_SIZE (&headers
),
1665 text_frag_root
, data_frag_root
);
1666 #endif /* OBJ_VMS */
1667 #else /* BFD_ASSEMBLER */
1669 /* Resolve symbol values. This needs to be done before processing
1675 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1676 if (!symp
->sy_resolved
)
1677 resolve_symbol_value (symp
);
1682 #ifdef tc_frob_file_before_adjust
1683 tc_frob_file_before_adjust ();
1685 #ifdef obj_frob_file_before_adjust
1686 obj_frob_file_before_adjust ();
1689 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1691 /* Set up symbol table, and write it out. */
1696 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1701 if (symp
->sy_mri_common
)
1703 if (S_IS_EXTERNAL (symp
))
1704 as_bad ("%s: global symbols not supported in common sections",
1706 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1710 name
= S_GET_NAME (symp
);
1713 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1714 /* They only differ if `name' is a fb or dollar local
1716 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1717 as_bad ("local label %s is not defined", name2
);
1720 /* Do it again, because adjust_reloc_syms might introduce
1721 more symbols. They'll probably only be section symbols,
1722 but they'll still need to have the values computed. */
1723 if (! symp
->sy_resolved
)
1725 if (symp
->sy_value
.X_op
== O_constant
)
1727 /* This is the normal case; skip the call. */
1730 + symp
->sy_frag
->fr_address
));
1731 symp
->sy_resolved
= 1;
1734 resolve_symbol_value (symp
);
1737 /* Skip symbols which were equated to undefined or common
1739 if (symp
->sy_value
.X_op
== O_symbol
1740 && (! S_IS_DEFINED (symp
) || S_IS_COMMON (symp
)))
1742 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1746 /* So far, common symbols have been treated like undefined symbols.
1747 Put them in the common section now. */
1748 if (S_IS_DEFINED (symp
) == 0
1749 && S_GET_VALUE (symp
) != 0)
1750 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1752 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1753 S_GET_NAME (symp
), symp
,
1756 segment_name (symp
->bsym
->section
));
1759 #ifdef obj_frob_symbol
1760 obj_frob_symbol (symp
, punt
);
1762 #ifdef tc_frob_symbol
1763 if (! punt
|| symp
->sy_used_in_reloc
)
1764 tc_frob_symbol (symp
, punt
);
1767 /* If we don't want to keep this symbol, splice it out of
1768 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1769 want section symbols. Otherwise, we skip local symbols
1770 and symbols that the frob_symbol macros told us to punt,
1771 but we keep such symbols if they are used in relocs. */
1772 if ((! EMIT_SECTION_SYMBOLS
1773 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1774 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1775 opposites. Sometimes the former checks flags and the
1776 latter examines the name... */
1777 || (!S_IS_EXTERN (symp
)
1778 && (S_IS_LOCAL (symp
) || punt
)
1779 && ! symp
->sy_used_in_reloc
))
1781 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1782 /* After symbol_remove, symbol_next(symp) still returns
1783 the one that came after it in the chain. So we don't
1784 need to do any extra cleanup work here. */
1789 /* Make sure we really got a value for the symbol. */
1790 if (! symp
->sy_resolved
)
1792 as_bad ("can't resolve value for symbol \"%s\"",
1794 symp
->sy_resolved
= 1;
1797 /* Set the value into the BFD symbol. Up til now the value
1798 has only been kept in the gas symbolS struct. */
1799 symp
->bsym
->value
= S_GET_VALUE (symp
);
1805 /* Now do any format-specific adjustments to the symbol table, such
1806 as adding file symbols. */
1807 #ifdef tc_adjust_symtab
1808 tc_adjust_symtab ();
1810 #ifdef obj_adjust_symtab
1811 obj_adjust_symtab ();
1814 /* Now that all the sizes are known, and contents correct, we can
1815 start writing to the file. */
1818 /* If *_frob_file changes the symbol value at this point, it is
1819 responsible for moving the changed value into symp->bsym->value
1820 as well. Hopefully all symbol value changing can be done in
1825 #ifdef obj_frob_file
1829 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1831 #ifdef tc_frob_file_after_relocs
1832 tc_frob_file_after_relocs ();
1834 #ifdef obj_frob_file_after_relocs
1835 obj_frob_file_after_relocs ();
1838 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1839 #endif /* BFD_ASSEMBLER */
1846 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1851 * After this, all frags in this segment have addresses that are correct
1852 * within the segment. Since segments live in different file addresses,
1853 * these frag addresses may not be the same as final object-file addresses.
1856 #ifndef md_relax_frag
1857 #ifdef TC_GENERIC_RELAX_TABLE
1859 /* Subroutines of relax_segment. */
1865 for (; f1
; f1
= f1
->fr_next
)
1866 if (f1
->fr_next
== f2
)
1871 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1872 #endif /* ! defined (md_relax_frag) */
1874 /* Relax_align. Advance location counter to next address that has 'alignment'
1875 lowest order bits all 0s, return size of adjustment made. */
1876 static relax_addressT
1877 relax_align (address
, alignment
)
1878 register relax_addressT address
; /* Address now. */
1879 register int alignment
; /* Alignment (binary). */
1881 relax_addressT mask
;
1882 relax_addressT new_address
;
1884 mask
= ~((~0) << alignment
);
1885 new_address
= (address
+ mask
) & (~mask
);
1886 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1888 /* We must provide lots of padding, so the linker can discard it
1889 when needed. The linker will not add extra space, ever. */
1890 new_address
+= (1 << alignment
);
1892 return (new_address
- address
);
1896 relax_segment (segment_frag_root
, segment
)
1897 struct frag
*segment_frag_root
;
1900 register struct frag
*fragP
;
1901 register relax_addressT address
;
1902 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1903 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1905 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1906 subseg_change (segment
, 0);
1908 /* For each frag in segment: count and store (a 1st guess of)
1911 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1913 fragP
->fr_address
= address
;
1914 address
+= fragP
->fr_fix
;
1916 switch (fragP
->fr_type
)
1919 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1925 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1926 if (offset
% fragP
->fr_var
!= 0)
1928 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1929 offset
, (long) fragP
->fr_var
);
1930 offset
-= (offset
% fragP
->fr_var
);
1938 /* Assume .org is nugatory. It will grow with 1st relax. */
1941 case rs_machine_dependent
:
1942 address
+= md_estimate_size_before_relax (fragP
, segment
);
1945 #ifndef WORKING_DOT_WORD
1946 /* Broken words don't concern us yet */
1947 case rs_broken_word
:
1952 BAD_CASE (fragP
->fr_type
);
1954 } /* switch(fr_type) */
1955 } /* for each frag in the segment */
1959 long stretch
; /* May be any size, 0 or negative. */
1960 /* Cumulative number of addresses we have */
1961 /* relaxed this pass. */
1962 /* We may have relaxed more than one address. */
1963 long stretched
; /* Have we stretched on this pass? */
1964 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1965 grew, and another shrank. If a branch instruction doesn't fit anymore,
1966 we could be scrod. */
1970 stretch
= stretched
= 0;
1971 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1974 unsigned long was_address
;
1980 was_address
= fragP
->fr_address
;
1981 address
= fragP
->fr_address
+= stretch
;
1982 symbolP
= fragP
->fr_symbol
;
1983 offset
= fragP
->fr_offset
;
1985 switch (fragP
->fr_type
)
1987 case rs_fill
: /* .fill never relaxes. */
1991 #ifndef WORKING_DOT_WORD
1992 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1993 for it I do not want to write it. I do not want to have
1994 anything to do with it. This is not the proper way to
1995 implement this misfeature. */
1996 case rs_broken_word
:
1998 struct broken_word
*lie
;
1999 struct broken_word
*untruth
;
2001 /* Yes this is ugly (storing the broken_word pointer
2002 in the symbol slot). Still, this whole chunk of
2003 code is ugly, and I don't feel like doing anything
2004 about it. Think of it as stubbornness in action. */
2006 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
2007 lie
&& lie
->dispfrag
== fragP
;
2008 lie
= lie
->next_broken_word
)
2014 offset
= (lie
->add
->sy_frag
->fr_address
2015 + S_GET_VALUE (lie
->add
)
2017 - (lie
->sub
->sy_frag
->fr_address
2018 + S_GET_VALUE (lie
->sub
)));
2019 if (offset
<= -32768 || offset
>= 32767)
2021 if (flag_warn_displacement
)
2024 sprint_value (buf
, (addressT
) lie
->addnum
);
2025 as_warn (".word %s-%s+%s didn't fit",
2026 S_GET_NAME (lie
->add
),
2027 S_GET_NAME (lie
->sub
),
2031 if (fragP
->fr_subtype
== 0)
2033 fragP
->fr_subtype
++;
2034 growth
+= md_short_jump_size
;
2036 for (untruth
= lie
->next_broken_word
;
2037 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2038 untruth
= untruth
->next_broken_word
)
2039 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
2040 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
2043 untruth
->use_jump
= lie
;
2045 growth
+= md_long_jump_size
;
2050 } /* case rs_broken_word */
2054 growth
= (relax_align ((relax_addressT
) (address
2057 - relax_align ((relax_addressT
) (was_address
2067 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2068 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2069 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2070 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2071 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2072 know (symbolP
->sy_frag
);
2073 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2074 || (symbolP
->sy_frag
== &zero_address_frag
));
2076 target
+= S_GET_VALUE (symbolP
)
2077 + symbolP
->sy_frag
->fr_address
;
2078 } /* if we have a symbol */
2080 know (fragP
->fr_next
);
2081 after
= fragP
->fr_next
->fr_address
;
2082 growth
= target
- after
;
2085 /* Growth may be negative, but variable part of frag
2086 cannot have fewer than 0 chars. That is, we can't
2088 as_bad ("attempt to .org backwards ignored");
2092 growth
-= stretch
; /* This is an absolute growth factor */
2098 growth
= S_GET_VALUE (symbolP
);
2099 if (symbolP
->sy_frag
!= &zero_address_frag
)
2100 as_bad (".space specifies non-absolute value");
2101 fragP
->fr_symbol
= 0;
2104 as_warn (".space or .fill with negative value, ignored");
2112 case rs_machine_dependent
:
2113 #ifdef md_relax_frag
2114 growth
= md_relax_frag (fragP
, stretch
);
2116 #ifdef TC_GENERIC_RELAX_TABLE
2117 /* The default way to relax a frag is to look through
2120 const relax_typeS
*this_type
;
2121 const relax_typeS
*start_type
;
2122 relax_substateT next_state
;
2123 relax_substateT this_state
;
2125 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
2127 this_state
= fragP
->fr_subtype
;
2128 start_type
= this_type
= table
+ this_state
;
2133 #ifndef DIFF_EXPR_OK
2134 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2135 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2136 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2137 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2138 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2140 know (symbolP
->sy_frag
);
2142 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2143 || symbolP
->sy_frag
== &zero_address_frag
);
2145 S_GET_VALUE (symbolP
)
2146 + symbolP
->sy_frag
->fr_address
;
2148 /* If frag has yet to be reached on this pass,
2149 assume it will move by STRETCH just as we did.
2150 If this is not so, it will be because some frag
2151 between grows, and that will force another pass.
2153 Beware zero-length frags.
2155 There should be a faster way to do this. */
2157 if (symbolP
->sy_frag
->fr_address
>= was_address
2158 && is_dnrange (fragP
, symbolP
->sy_frag
))
2164 aim
= target
- address
- fragP
->fr_fix
;
2165 #ifdef TC_PCREL_ADJUST
2166 /* Currently only the ns32k family needs this */
2167 aim
+= TC_PCREL_ADJUST(fragP
);
2169 /* This machine doesn't want to use pcrel_adjust.
2170 In that case, pcrel_adjust should be zero. */
2171 assert (fragP
->fr_pcrel_adjust
== 0);
2176 /* Look backwards. */
2177 for (next_state
= this_type
->rlx_more
; next_state
;)
2178 if (aim
>= this_type
->rlx_backward
)
2182 /* Grow to next state. */
2183 this_state
= next_state
;
2184 this_type
= table
+ this_state
;
2185 next_state
= this_type
->rlx_more
;
2190 #ifdef M68K_AIM_KLUDGE
2191 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2193 /* Look forwards. */
2194 for (next_state
= this_type
->rlx_more
; next_state
;)
2195 if (aim
<= this_type
->rlx_forward
)
2199 /* Grow to next state. */
2200 this_state
= next_state
;
2201 this_type
= table
+ this_state
;
2202 next_state
= this_type
->rlx_more
;
2206 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2208 fragP
->fr_subtype
= this_state
;
2210 #endif /* TC_GENERIC_RELAX_TABLE */
2215 BAD_CASE (fragP
->fr_type
);
2223 } /* For each frag in the segment. */
2225 while (stretched
); /* Until nothing further to relax. */
2229 * We now have valid fr_address'es for each frag.
2233 * All fr_address's are correct, relative to their own segment.
2234 * We have made all the fixS we will ever make.
2236 } /* relax_segment() */
2238 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2240 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2241 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2246 Go through all the fixS's in a segment and see which ones can be
2247 handled now. (These consist of fixS where we have since discovered
2248 the value of a symbol, or the address of the frag involved.)
2249 For each one, call md_apply_fix to put the fix into the frag data.
2251 Result is a count of how many relocation structs will be needed to
2252 handle the remaining fixS's that we couldn't completely handle here.
2253 These will be output later by emit_relocations(). */
2256 fixup_segment (fixP
, this_segment_type
)
2257 register fixS
*fixP
;
2258 segT this_segment_type
; /* N_TYPE bits for segment. */
2260 long seg_reloc_count
= 0;
2261 symbolS
*add_symbolP
;
2262 symbolS
*sub_symbolP
;
2269 segT add_symbol_segment
= absolute_section
;
2271 /* If the linker is doing the relaxing, we must not do any fixups.
2273 Well, strictly speaking that's not true -- we could do any that are
2274 PC-relative and don't cross regions that could change size. And for the
2275 i960 (the only machine for which we've got a relaxing linker right now),
2276 we might be able to turn callx/callj into bal anyways in cases where we
2277 know the maximum displacement. */
2280 for (; fixP
; fixP
= fixP
->fx_next
)
2282 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2283 return seg_reloc_count
;
2286 for (; fixP
; fixP
= fixP
->fx_next
)
2289 fprintf (stderr
, "\nprocessing fixup:\n");
2293 fragP
= fixP
->fx_frag
;
2295 where
= fixP
->fx_where
;
2296 place
= fragP
->fr_literal
+ where
;
2297 size
= fixP
->fx_size
;
2298 add_symbolP
= fixP
->fx_addsy
;
2299 #ifdef TC_VALIDATE_FIX
2300 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2302 sub_symbolP
= fixP
->fx_subsy
;
2303 add_number
= fixP
->fx_offset
;
2304 pcrel
= fixP
->fx_pcrel
;
2307 if (add_symbolP
!= NULL
2308 && add_symbolP
->sy_mri_common
)
2310 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2311 add_number
+= S_GET_VALUE (add_symbolP
);
2312 fixP
->fx_offset
= add_number
;
2313 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2317 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2321 resolve_symbol_value (sub_symbolP
);
2322 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2324 if (add_symbolP
!= NULL
)
2326 add_number
+= S_GET_VALUE (add_symbolP
);
2328 fixP
->fx_addsy
= NULL
;
2331 /* It's just -sym */
2332 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2334 add_number
-= S_GET_VALUE (sub_symbolP
);
2335 fixP
->fx_subsy
= NULL
;
2338 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2340 /* Should try converting to a constant. */
2345 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2346 "Negative of non-absolute symbol %s",
2347 S_GET_NAME (sub_symbolP
));
2349 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2350 && SEG_NORMAL (add_symbol_segment
))
2352 /* Difference of 2 symbols from same segment.
2353 Can't make difference of 2 undefineds: 'value' means
2354 something different for N_UNDF. */
2356 /* Makes no sense to use the difference of 2 arbitrary symbols
2357 as the target of a call instruction. */
2359 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2360 "callj to difference of 2 symbols");
2361 #endif /* TC_I960 */
2362 add_number
+= S_GET_VALUE (add_symbolP
) -
2363 S_GET_VALUE (sub_symbolP
);
2366 pcrel
= 0; /* No further pcrel processing. */
2368 /* Let the target machine make the final determination
2369 as to whether or not a relocation will be needed to
2370 handle this fixup. */
2371 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2374 fixP
->fx_addsy
= NULL
;
2375 fixP
->fx_subsy
= NULL
;
2380 /* Different segments in subtraction. */
2381 know (!(S_IS_EXTERNAL (sub_symbolP
)
2382 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2384 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2385 add_number
-= S_GET_VALUE (sub_symbolP
);
2388 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2389 #if 0 /* Do this even if it's already described as pc-relative. For example,
2390 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2391 pc-relative mode. */
2396 /* Make it pc-relative. */
2397 add_number
+= (MD_PCREL_FROM_SECTION (fixP
, this_segment_type
)
2398 - S_GET_VALUE (sub_symbolP
));
2405 #ifdef UNDEFINED_DIFFERENCE_OK
2406 /* The PA needs this for PIC code generation. We basically
2407 don't want to do anything if we have the difference of two
2408 symbols at this point. */
2411 /* Leave it alone. */
2414 #ifdef BFD_ASSEMBLER
2415 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2416 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2418 /* Leave it alone. */
2424 sprint_value (buf
, fragP
->fr_address
+ where
);
2425 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2426 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2427 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2428 S_GET_NAME (sub_symbolP
), buf
);
2435 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2436 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2439 * This fixup was made when the symbol's segment was
2440 * SEG_UNKNOWN, but it is now in the local segment.
2441 * So we know how to do the address without relocation.
2444 /* reloc_callj() may replace a 'call' with a 'calls' or a
2445 'bal', in which cases it modifies *fixP as appropriate.
2446 In the case of a 'calls', no further work is required,
2447 and *fixP has been set up to make the rest of the code
2450 #endif /* TC_I960 */
2452 add_number
+= S_GET_VALUE (add_symbolP
);
2453 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2454 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2456 /* Let the target machine make the final determination
2457 as to whether or not a relocation will be needed to
2458 handle this fixup. */
2459 if (!TC_FORCE_RELOCATION (fixP
))
2462 fixP
->fx_addsy
= NULL
;
2467 if (add_symbol_segment
== absolute_section
2471 /* See comment about reloc_callj() above. */
2473 #endif /* TC_I960 */
2474 add_number
+= S_GET_VALUE (add_symbolP
);
2476 /* Let the target machine make the final determination
2477 as to whether or not a relocation will be needed to
2478 handle this fixup. */
2480 if (!TC_FORCE_RELOCATION (fixP
))
2482 fixP
->fx_addsy
= NULL
;
2486 else if (add_symbol_segment
== undefined_section
2487 #ifdef BFD_ASSEMBLER
2488 || bfd_is_com_section (add_symbol_segment
)
2493 if ((int) fixP
->fx_bit_fixP
== 13)
2495 /* This is a COBR instruction. They have only a
2496 * 13-bit displacement and are only to be used
2497 * for local branches: flag as error, don't generate
2500 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2501 "can't use COBR format with external label");
2502 fixP
->fx_addsy
= NULL
;
2506 #endif /* TC_I960 */
2510 if (S_IS_COMMON (add_symbolP
))
2511 add_number
+= S_GET_VALUE (add_symbolP
);
2512 #endif /* TE_I386AIX */
2513 #endif /* OBJ_COFF */
2519 /* start-sanitize-v850 */
2520 #if !(defined (TC_V850) && defined (OBJ_ELF))
2521 /* end-sanitize-v850 */
2522 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2523 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2524 add_number
+= S_GET_VALUE (add_symbolP
);
2525 /* start-sanitize-v850 */
2527 /* end-sanitize-v850 */
2536 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2537 if (add_symbolP
== 0)
2539 #ifndef BFD_ASSEMBLER
2540 fixP
->fx_addsy
= &abs_symbol
;
2542 fixP
->fx_addsy
= section_symbol (absolute_section
);
2544 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2549 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2552 if (size
< sizeof (mask
))
2554 /* set all bits to one */
2556 /* Technically, combining these produces an undefined result
2557 if size is sizeof (valueT), though I think these two
2558 half-way operations should both be defined. And the
2559 compiler should be able to combine them if it's valid on
2560 the host architecture. */
2563 if ((add_number
& mask
) != 0
2564 && (add_number
& mask
) != mask
)
2566 char buf
[50], buf2
[50];
2567 sprint_value (buf
, fragP
->fr_address
+ where
);
2568 if (add_number
> 1000)
2569 sprint_value (buf2
, add_number
);
2571 sprintf (buf2
, "%ld", (long) add_number
);
2572 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2573 "Value of %s too large for field of %d bytes at %s",
2575 } /* generic error checking */
2577 #ifdef WARN_SIGNED_OVERFLOW_WORD
2578 /* Warn if a .word value is too large when treated as a signed
2579 number. We already know it is not too negative. This is to
2580 catch over-large switches generated by gcc on the 68k. */
2581 if (!flag_signed_overflow_ok
2583 && add_number
> 0x7fff)
2584 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2585 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2587 (unsigned long) (fragP
->fr_address
+ where
));
2589 } /* not a bit fix */
2593 #ifdef MD_APPLY_FIX3
2594 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2596 #ifdef BFD_ASSEMBLER
2597 md_apply_fix (fixP
, &add_number
);
2599 md_apply_fix (fixP
, add_number
);
2603 #ifndef TC_HANDLES_FX_DONE
2604 /* If the tc-* files haven't been converted, assume it's handling
2605 it the old way, where a null fx_addsy means that the fix has
2606 been applied completely, and no further work is needed. */
2607 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2611 #ifdef TC_VALIDATE_FIX
2615 fprintf (stderr
, "result:\n");
2618 } /* For each fixS in this segment. */
2620 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2621 return seg_reloc_count
;
2624 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2627 number_to_chars_bigendian (buf
, val
, n
)
2632 if (n
> sizeof (val
)|| n
<= 0)
2636 buf
[n
] = val
& 0xff;
2642 number_to_chars_littleendian (buf
, val
, n
)
2647 if (n
> sizeof (val
) || n
<= 0)
2651 *buf
++ = val
& 0xff;
2657 write_print_statistics (file
)
2660 fprintf (stderr
, "fixups: %d\n", n_fixups
);
2664 extern int indent_level
;
2665 extern void print_symbol_value_1 ();
2672 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2674 fprintf (stderr
, " pcrel");
2675 if (fixp
->fx_pcrel_adjust
)
2676 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2677 if (fixp
->fx_im_disp
)
2680 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2682 fprintf (stderr
, " im_disp");
2686 fprintf (stderr
, " tcbit");
2688 fprintf (stderr
, " done");
2689 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2690 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2691 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2692 #ifdef BFD_ASSEMBLER
2693 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2696 #ifdef NEED_FX_R_TYPE
2697 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2702 fprintf (stderr
, "\n +<");
2703 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2704 fprintf (stderr
, ">");
2708 fprintf (stderr
, "\n -<");
2709 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2710 fprintf (stderr
, ">");
2712 fprintf (stderr
, "\n");
2715 /* end of write.c */