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 as_bad ("expression too complex for fixup");
303 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
307 /* Append a string onto another string, bumping the pointer along. */
309 append (charPP
, fromP
, length
)
312 unsigned long length
;
314 /* Don't trust memcpy() of 0 chars. */
318 memcpy (*charPP
, fromP
, length
);
322 #ifndef BFD_ASSEMBLER
323 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
327 * This routine records the largest alignment seen for each segment.
328 * If the beginning of the segment is aligned on the worst-case
329 * boundary, all of the other alignments within it will work. At
330 * least one object format really uses this info.
333 record_alignment (seg
, align
)
334 /* Segment to which alignment pertains */
336 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
340 if (seg
== absolute_section
)
343 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
344 bfd_set_section_alignment (stdoutput
, seg
, align
);
346 if (align
> section_alignment
[(int) seg
])
347 section_alignment
[(int) seg
] = align
;
353 /* Reset the section indices after removing the gas created sections. */
356 renumber_sections (abfd
, sec
, countparg
)
361 int *countp
= (int *) countparg
;
363 sec
->index
= *countp
;
367 #endif /* defined (BFD_ASSEMBLER) */
369 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
372 chain_frchains_together_1 (section
, frchp
)
374 struct frchain
*frchp
;
376 fragS dummy
, *prev_frag
= &dummy
;
378 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
381 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
383 prev_frag
->fr_next
= frchp
->frch_root
;
384 prev_frag
= frchp
->frch_last
;
385 assert (prev_frag
->fr_type
!= 0);
387 if (frchp
->fix_root
!= (fixS
*) NULL
)
389 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
390 seg_info (section
)->fix_root
= frchp
->fix_root
;
391 prev_fix
->fx_next
= frchp
->fix_root
;
392 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
393 prev_fix
= frchp
->fix_tail
;
397 assert (prev_frag
->fr_type
!= 0);
398 prev_frag
->fr_next
= 0;
407 chain_frchains_together (abfd
, section
, xxx
)
408 bfd
*abfd
; /* unused */
410 PTR xxx
; /* unused */
412 segment_info_type
*info
;
414 /* BFD may have introduced its own sections without using
415 subseg_new, so it is possible that seg_info is NULL. */
416 info
= seg_info (section
);
417 if (info
!= (segment_info_type
*) NULL
)
418 info
->frchainP
->frch_last
419 = chain_frchains_together_1 (section
, info
->frchainP
);
421 /* Now that we've chained the frags together, we must add new fixups
422 to the segment, not to the frag chain. */
428 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
431 remove_subsegs (head
, seg
, root
, last
)
437 *root
= head
->frch_root
;
438 *last
= chain_frchains_together_1 (seg
, head
);
443 #if defined (BFD_ASSEMBLER) || !defined (BFD)
447 cvt_frag_to_fill (sec
, fragP
)
452 cvt_frag_to_fill (headersP
, sec
, fragP
)
453 object_headers
*headersP
;
458 switch (fragP
->fr_type
)
465 HANDLE_ALIGN (fragP
);
467 know (fragP
->fr_next
!= NULL
);
468 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
470 - fragP
->fr_fix
) / fragP
->fr_var
;
471 if (fragP
->fr_offset
< 0)
473 as_bad ("attempt to .org/.space backwards? (%ld)",
474 (long) fragP
->fr_offset
);
476 fragP
->fr_type
= rs_fill
;
482 case rs_machine_dependent
:
484 md_convert_frag (stdoutput
, sec
, fragP
);
486 md_convert_frag (headersP
, sec
, fragP
);
489 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
492 * After md_convert_frag, we make the frag into a ".space 0".
493 * Md_convert_frag() should set up any fixSs and constants
499 #ifndef WORKING_DOT_WORD
502 struct broken_word
*lie
;
504 if (fragP
->fr_subtype
)
506 fragP
->fr_fix
+= md_short_jump_size
;
507 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
508 lie
&& lie
->dispfrag
== fragP
;
509 lie
= lie
->next_broken_word
)
511 fragP
->fr_fix
+= md_long_jump_size
;
519 BAD_CASE (fragP
->fr_type
);
524 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
528 relax_and_size_seg (abfd
, sec
, xxx
)
535 segment_info_type
*seginfo
;
537 valueT size
, newsize
;
539 subseg_change (sec
, 0);
541 flags
= bfd_get_section_flags (abfd
, sec
);
543 seginfo
= seg_info (sec
);
544 if (seginfo
&& seginfo
->frchainP
)
546 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
547 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
548 cvt_frag_to_fill (sec
, fragp
);
549 for (fragp
= seginfo
->frchainP
->frch_root
;
551 fragp
= fragp
->fr_next
)
552 /* walk to last elt */;
553 size
= fragp
->fr_address
+ fragp
->fr_fix
;
558 if (size
> 0 && ! seginfo
->bss
)
559 flags
|= SEC_HAS_CONTENTS
;
561 /* @@ This is just an approximation. */
562 if (seginfo
&& seginfo
->fix_root
)
566 x
= bfd_set_section_flags (abfd
, sec
, flags
);
569 newsize
= md_section_align (sec
, size
);
570 x
= bfd_set_section_size (abfd
, sec
, newsize
);
573 /* If the size had to be rounded up, add some padding in the last
575 assert (newsize
>= size
);
578 fragS
*last
= seginfo
->frchainP
->frch_last
;
579 fragp
= seginfo
->frchainP
->frch_root
;
580 while (fragp
->fr_next
!= last
)
581 fragp
= fragp
->fr_next
;
582 last
->fr_address
= size
;
583 fragp
->fr_offset
+= newsize
- size
;
586 #ifdef tc_frob_section
587 tc_frob_section (sec
);
589 #ifdef obj_frob_section
590 obj_frob_section (sec
);
596 dump_section_relocs (abfd
, sec
, stream_
)
601 FILE *stream
= (FILE *) stream_
;
602 segment_info_type
*seginfo
= seg_info (sec
);
603 fixS
*fixp
= seginfo
->fix_root
;
608 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
611 symbolS
*s
= fixp
->fx_addsy
;
614 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
615 s
->bsym
->section
->name
);
616 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
618 fprintf (stream
, " section sym");
620 fprintf (stream
, "+%x", S_GET_VALUE (s
));
623 fprintf (stream
, "+%x", S_GET_VALUE (s
));
624 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
627 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
628 fixp
= fixp
->fx_next
;
632 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
635 #ifndef EMIT_SECTION_SYMBOLS
636 #define EMIT_SECTION_SYMBOLS 1
640 adjust_reloc_syms (abfd
, sec
, xxx
)
645 segment_info_type
*seginfo
= seg_info (sec
);
651 dump_section_relocs (abfd
, sec
, stderr
);
653 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
656 else if (fixp
->fx_addsy
)
664 fprintf (stderr
, "\n\nadjusting fixup:\n");
668 sym
= fixp
->fx_addsy
;
669 symsec
= sym
->bsym
->section
;
671 if (sym
!= NULL
&& sym
->sy_mri_common
)
673 /* These symbols are handled specially in fixup_segment. */
677 if (bfd_is_abs_section (symsec
))
679 /* The fixup_segment routine will not use this symbol in a
680 relocation unless TC_FORCE_RELOCATION returns 1. */
681 if (TC_FORCE_RELOCATION (fixp
))
683 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
684 #ifdef UNDEFINED_DIFFERENCE_OK
685 if (fixp
->fx_subsy
!= NULL
)
686 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
692 /* If it's one of these sections, assume the symbol is
693 definitely going to be output. The code in
694 md_estimate_size_before_relax in tc-mips.c uses this test
695 as well, so if you change this code you should look at that
697 if (bfd_is_und_section (symsec
)
698 || bfd_is_com_section (symsec
))
700 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
701 #ifdef UNDEFINED_DIFFERENCE_OK
702 /* We have the difference of an undefined symbol and some
703 other symbol. Make sure to mark the other symbol as used
704 in a relocation so that it will always be output. */
706 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
711 /* Since we're reducing to section symbols, don't attempt to reduce
712 anything that's already using one. */
713 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
715 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
719 /* Is there some other reason we can't adjust this one? (E.g.,
720 call/bal links in i960-bout symbols.) */
721 #ifdef obj_fix_adjustable
722 if (! obj_fix_adjustable (fixp
))
724 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
729 /* Is there some other (target cpu dependent) reason we can't adjust
730 this one? (E.g. relocations involving function addresses on
732 #ifdef tc_fix_adjustable
733 if (! tc_fix_adjustable (fixp
))
735 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
740 /* For PIC support: We may get expressions like
741 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
742 necessarily have had a fixed difference initially. But now
743 it should be a known constant, so we can reduce it. Since
744 we can't easily handle a symbol value that looks like
745 someUndefinedSymbol+const, though, we convert the fixup to
746 access the undefined symbol directly, and discard the
747 intermediate symbol. */
748 if (S_GET_SEGMENT (sym
) == expr_section
749 && sym
->sy_value
.X_op
== O_add
750 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
751 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
752 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
753 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
755 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
756 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
757 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
761 /* If the section symbol isn't going to be output, the relocs
762 at least should still work. If not, figure out what to do
763 when we run into that case.
765 We refetch the segment when calling section_symbol, rather
766 than using symsec, because S_GET_VALUE may wind up changing
767 the section when it calls resolve_symbol_value. */
768 fixp
->fx_offset
+= S_GET_VALUE (sym
);
769 fixp
->fx_addsy
= section_symbol (S_GET_SEGMENT (sym
));
770 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
775 #if 1/*def RELOC_REQUIRES_SYMBOL*/
778 /* There was no symbol required by this relocation. However,
779 BFD doesn't really handle relocations without symbols well.
780 (At least, the COFF support doesn't.) So for now we fake up
781 a local symbol in the absolute section. */
783 fixp
->fx_addsy
= section_symbol (absolute_section
);
784 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
788 dump_section_relocs (abfd
, sec
, stderr
);
792 write_relocs (abfd
, sec
, xxx
)
797 segment_info_type
*seginfo
= seg_info (sec
);
804 /* If seginfo is NULL, we did not create this section; don't do
809 fixup_segment (seginfo
->fix_root
, sec
);
812 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
815 #ifndef RELOC_EXPANSION_POSSIBLE
816 /* Set up reloc information as well. */
817 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
818 n
* sizeof (arelent
*));
819 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
822 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
825 bfd_reloc_status_type s
;
834 /* If this is an undefined symbol which was equated to another
835 symbol, then use generate the reloc against the latter symbol
836 rather than the former. */
837 sym
= fixp
->fx_addsy
;
838 while (sym
->sy_value
.X_op
== O_symbol
839 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
840 sym
= sym
->sy_value
.X_add_symbol
;
841 fixp
->fx_addsy
= sym
;
843 reloc
= tc_gen_reloc (sec
, fixp
);
851 /* This test is triggered inappropriately for the SH. */
852 if (fixp
->fx_where
+ fixp
->fx_size
853 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
857 s
= bfd_install_relocation (stdoutput
, reloc
,
858 fixp
->fx_frag
->fr_literal
,
859 fixp
->fx_frag
->fr_address
,
865 case bfd_reloc_overflow
:
866 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
869 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
870 fixp
->fx_file
, fixp
->fx_line
);
875 n
= n
* MAX_RELOC_EXPANSION
;
876 /* Set up reloc information as well. */
877 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
878 n
* sizeof (arelent
*));
881 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
885 bfd_reloc_status_type s
;
895 /* If this is an undefined symbol which was equated to another
896 symbol, then use generate the reloc against the latter symbol
897 rather than the former. */
898 sym
= fixp
->fx_addsy
;
899 while (sym
->sy_value
.X_op
== O_symbol
900 && (! S_IS_DEFINED (sym
) || S_IS_COMMON (sym
)))
901 sym
= sym
->sy_value
.X_add_symbol
;
902 fixp
->fx_addsy
= sym
;
904 reloc
= tc_gen_reloc (sec
, fixp
);
906 for (j
= 0; reloc
[j
]; j
++)
908 relocs
[i
++] = reloc
[j
];
911 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
912 if (fixp
->fx_where
+ fixp
->fx_size
913 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
915 for (j
= 0; reloc
[j
]; j
++)
917 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
918 fixp
->fx_frag
->fr_literal
,
919 fixp
->fx_frag
->fr_address
,
925 case bfd_reloc_overflow
:
926 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
927 "relocation overflow");
930 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
931 fixp
->fx_file
, fixp
->fx_line
);
942 sympp
= bfd_get_outsymbols (stdoutput
);
943 nsyms
= bfd_get_symcount (stdoutput
);
944 for (i
= 0; i
< n
; i
++)
945 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
947 for (j
= 0; j
< nsyms
; j
++)
948 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
957 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
959 bfd_set_section_flags (abfd
, sec
,
960 (bfd_get_section_flags (abfd
, sec
)
961 & (flagword
) ~SEC_RELOC
));
968 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
969 for (i
= 0; i
< n
; i
++)
973 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
974 i
, r
, r
->address
, s
->name
, r
->addend
);
981 write_contents (abfd
, sec
, xxx
)
986 segment_info_type
*seginfo
= seg_info (sec
);
987 unsigned long offset
= 0;
990 /* Write out the frags. */
992 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
995 for (f
= seginfo
->frchainP
->frch_root
;
1000 unsigned long fill_size
;
1004 assert (f
->fr_type
== rs_fill
);
1007 x
= bfd_set_section_contents (stdoutput
, sec
,
1008 f
->fr_literal
, (file_ptr
) offset
,
1009 (bfd_size_type
) f
->fr_fix
);
1012 bfd_perror (stdoutput
->filename
);
1013 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1014 exit (EXIT_FAILURE
);
1016 offset
+= f
->fr_fix
;
1018 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
1019 fill_size
= f
->fr_var
;
1020 count
= f
->fr_offset
;
1021 assert (count
>= 0);
1022 if (fill_size
&& count
)
1025 if (fill_size
> sizeof(buf
))
1027 /* Do it the old way. Can this ever happen? */
1030 x
= bfd_set_section_contents (stdoutput
, sec
,
1033 (bfd_size_type
) fill_size
);
1036 bfd_perror (stdoutput
->filename
);
1037 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
1038 exit (EXIT_FAILURE
);
1040 offset
+= fill_size
;
1045 /* Build a buffer full of fill objects and output it as
1046 often as necessary. This saves on the overhead of
1047 potentially lots of bfd_set_section_contents calls. */
1051 n_per_buf
= sizeof (buf
);
1052 memset (buf
, *fill_literal
, n_per_buf
);
1057 n_per_buf
= sizeof(buf
)/fill_size
;
1058 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
1059 memcpy(bufp
, fill_literal
, fill_size
);
1061 for (; count
> 0; count
-= n_per_buf
)
1063 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
1064 x
= bfd_set_section_contents (stdoutput
, sec
,
1065 buf
, (file_ptr
) offset
,
1066 (bfd_size_type
) n_per_buf
* fill_size
);
1068 as_fatal ("Cannot write to output file.");
1069 offset
+= n_per_buf
* fill_size
;
1077 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1079 merge_data_into_text ()
1081 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1082 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1083 seg_info (data_section
)->frchainP
->frch_root
;
1084 seg_info (text_section
)->frchainP
->frch_last
=
1085 seg_info (data_section
)->frchainP
->frch_last
;
1086 seg_info (data_section
)->frchainP
= 0;
1090 text_last_frag
->fr_next
= data_frag_root
;
1091 text_last_frag
= data_last_frag
;
1092 data_last_frag
= NULL
;
1093 data_frag_root
= NULL
;
1096 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1097 tmp
->fx_next
= data_fix_root
;
1098 text_fix_tail
= data_fix_tail
;
1101 text_fix_root
= data_fix_root
;
1102 data_fix_root
= NULL
;
1105 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1107 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1109 relax_and_size_all_segments ()
1113 relax_segment (text_frag_root
, SEG_TEXT
);
1114 relax_segment (data_frag_root
, SEG_DATA
);
1115 relax_segment (bss_frag_root
, SEG_BSS
);
1117 * Now the addresses of frags are correct within the segment.
1120 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1121 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1122 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1125 * Join the 2 segments into 1 huge segment.
1126 * To do this, re-compute every rn_address in the SEG_DATA frags.
1127 * Then join the data frags after the text frags.
1129 * Determine a_data [length of data segment].
1133 register relax_addressT slide
;
1135 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1137 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1138 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1139 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1141 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1142 /* For b.out: If the data section has a strict alignment
1143 requirement, its load address in the .o file will be
1144 rounded up from the size of the text section. These
1145 two values are *not* the same! Similarly for the bss
1147 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1150 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1152 fragP
->fr_address
+= slide
;
1153 } /* for each data frag */
1155 know (text_last_frag
!= 0);
1156 text_last_frag
->fr_next
= data_frag_root
;
1160 H_SET_DATA_SIZE (&headers
, 0);
1164 /* See above comments on b.out data section address. */
1167 if (data_last_frag
== 0)
1168 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1170 bss_vma
= data_last_frag
->fr_address
;
1171 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1172 bss_address_frag
.fr_address
= bss_vma
;
1174 #else /* ! OBJ_BOUT */
1175 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1176 H_GET_DATA_SIZE (&headers
));
1178 #endif /* ! OBJ_BOUT */
1180 /* Slide all the frags */
1183 relax_addressT slide
= bss_address_frag
.fr_address
;
1185 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1187 fragP
->fr_address
+= slide
;
1188 } /* for each bss frag */
1192 H_SET_BSS_SIZE (&headers
,
1193 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1195 H_SET_BSS_SIZE (&headers
, 0);
1197 #endif /* ! BFD_ASSEMBLER && ! BFD */
1199 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1201 #ifdef BFD_ASSEMBLER
1209 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1211 /* Count symbols. We can't rely on a count made by the loop in
1212 write_object_file, because *_frob_file may add a new symbol or
1215 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1222 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1223 nsyms
* sizeof (asymbol
*));
1224 symp
= symbol_rootP
;
1225 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1227 asympp
[i
] = symp
->bsym
;
1233 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1234 assert (result
== true);
1235 symbol_table_frozen
= 1;
1240 write_object_file ()
1242 struct frchain
*frchainP
; /* Track along all frchains. */
1243 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1244 fragS
*fragP
; /* Track along all frags. */
1247 /* Do we really want to write it? */
1249 int n_warns
, n_errs
;
1250 n_warns
= had_warnings ();
1251 n_errs
= had_errors ();
1252 /* The -Z flag indicates that an object file should be generated,
1253 regardless of warnings and errors. */
1254 if (flag_always_generate_output
)
1256 if (n_warns
|| n_errs
)
1257 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1258 n_errs
, n_errs
== 1 ? "" : "s",
1259 n_warns
, n_warns
== 1 ? "" : "s");
1264 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1265 n_errs
, n_errs
== 1 ? "" : "s",
1266 n_warns
, n_warns
== 1 ? "" : "s");
1271 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1272 a routine to check for the definition of the procedure "_main",
1273 and if so -- fix it up so that it can be program entry point. */
1274 vms_check_for_main ();
1275 #endif /* OBJ_VMS */
1277 /* After every sub-segment, we fake an ".align ...". This conforms to
1278 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1279 frag that requires least thought. ".align" frags like to have a
1280 following frag since that makes calculating their intended length
1283 @@ Is this really necessary?? */
1284 #ifndef SUB_SEGMENT_ALIGN
1285 #ifdef BFD_ASSEMBLER
1286 #define SUB_SEGMENT_ALIGN(SEG) (0)
1288 #define SUB_SEGMENT_ALIGN(SEG) (2)
1291 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1293 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1294 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1295 /* frag_align will have left a new frag.
1296 Use this last frag for an empty ".fill".
1298 For this segment ...
1299 Create a last frag. Do not leave a "being filled in frag". */
1300 frag_wane (frag_now
);
1301 frag_now
->fr_fix
= 0;
1302 know (frag_now
->fr_next
== NULL
);
1305 /* From now on, we don't care about sub-segments. Build one frag chain
1306 for each segment. Linked thru fr_next. */
1308 #ifdef BFD_ASSEMBLER
1309 /* Remove the sections created by gas for its own purposes. */
1311 asection
**seclist
, *sec
;
1314 seclist
= &stdoutput
->sections
;
1315 while (seclist
&& *seclist
)
1318 while (sec
== reg_section
|| sec
== expr_section
)
1322 stdoutput
->section_count
--;
1327 seclist
= &(*seclist
)->next
;
1330 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1333 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1335 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1336 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1337 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1340 /* We have two segments. If user gave -R flag, then we must put the
1341 data frags into the text segment. Do this before relaxing so
1342 we know to take advantage of -R and make shorter addresses. */
1343 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1344 if (flag_readonly_data_in_text
)
1346 merge_data_into_text ();
1350 #ifdef BFD_ASSEMBLER
1351 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1353 relax_and_size_all_segments ();
1354 #endif /* BFD_ASSEMBLER */
1356 #ifndef BFD_ASSEMBLER
1359 * Crawl the symbol chain.
1361 * For each symbol whose value depends on a frag, take the address of
1362 * that frag and subsume it into the value of the symbol.
1363 * After this, there is just one way to lookup a symbol value.
1364 * Values are left in their final state for object file emission.
1365 * We adjust the values of 'L' local symbols, even if we do
1366 * not intend to emit them to the object file, because their values
1367 * are needed for fix-ups.
1369 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1370 * from the symbol chain. (They are still pointed to by the fixes.)
1372 * Count the remaining symbols.
1373 * Assign a symbol number to each symbol.
1374 * Count the number of string-table chars we will emit.
1375 * Put this info into the headers as appropriate.
1378 know (zero_address_frag
.fr_address
== 0);
1379 string_byte_count
= sizeof (string_byte_count
);
1381 obj_crawl_symbol_chain (&headers
);
1383 if (string_byte_count
== sizeof (string_byte_count
))
1384 string_byte_count
= 0;
1386 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1389 * Addresses of frags now reflect addresses we use in the object file.
1390 * Symbol values are correct.
1391 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1392 * Also converting any machine-dependent frags using md_convert_frag();
1394 subseg_change (SEG_TEXT
, 0);
1396 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1398 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1400 /* Some assert macros don't work with # directives mixed in. */
1402 if (!(fragP
->fr_next
== NULL
1404 || fragP
->fr_next
== data_frag_root
1406 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1407 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1411 #endif /* ! BFD_ASSEMBLER */
1413 #ifndef WORKING_DOT_WORD
1415 struct broken_word
*lie
;
1416 struct broken_word
**prevP
;
1418 prevP
= &broken_words
;
1419 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1424 exp
.X_op
= O_subtract
;
1425 exp
.X_add_symbol
= lie
->add
;
1426 exp
.X_op_symbol
= lie
->sub
;
1427 exp
.X_add_number
= lie
->addnum
;
1428 #ifdef BFD_ASSEMBLER
1429 #ifdef TC_CONS_FIX_NEW
1430 TC_CONS_FIX_NEW (lie
->frag
,
1431 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1434 fix_new_exp (lie
->frag
,
1435 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1436 2, &exp
, 0, BFD_RELOC_16
);
1439 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1440 fix_new_exp (lie
->frag
,
1441 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1442 2, &exp
, 0, NO_RELOC
);
1445 fix_new_ns32k_exp (lie
->frag
,
1446 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1447 2, &exp
, 0, 0, 2, 0, 0);
1449 fix_new_exp (lie
->frag
,
1450 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1452 #endif /* TC_NS32K */
1453 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1454 #endif /* BFD_ASSEMBLER */
1455 *prevP
= lie
->next_broken_word
;
1458 prevP
= &(lie
->next_broken_word
);
1460 for (lie
= broken_words
; lie
;)
1462 struct broken_word
*untruth
;
1464 addressT table_addr
;
1465 addressT from_addr
, to_addr
;
1468 fragP
= lie
->dispfrag
;
1470 /* Find out how many broken_words go here. */
1472 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1473 if (untruth
->added
== 1)
1476 table_ptr
= lie
->dispfrag
->fr_opcode
;
1477 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1478 /* Create the jump around the long jumps. This is a short
1479 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1480 from_addr
= table_addr
;
1481 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1482 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1483 table_ptr
+= md_short_jump_size
;
1484 table_addr
+= md_short_jump_size
;
1486 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1488 if (lie
->added
== 2)
1490 /* Patch the jump table */
1491 /* This is the offset from ??? to table_ptr+0 */
1492 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1493 #ifdef BFD_ASSEMBLER
1494 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1496 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1497 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1499 if (untruth
->use_jump
== lie
)
1500 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1503 /* Install the long jump */
1504 /* this is a long jump from table_ptr+0 to the final target */
1505 from_addr
= table_addr
;
1506 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1507 #ifdef BFD_ASSEMBLER
1508 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1510 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1511 table_ptr
+= md_long_jump_size
;
1512 table_addr
+= md_long_jump_size
;
1516 #endif /* not WORKING_DOT_WORD */
1518 #ifndef BFD_ASSEMBLER
1521 char *the_object_file
;
1522 long object_file_size
;
1524 * Scan every FixS performing fixups. We had to wait until now to do
1525 * this because md_convert_frag() may have made some fixSs.
1529 subseg_change (SEG_TEXT
, 0);
1530 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1531 subseg_change (SEG_DATA
, 0);
1532 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1533 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1535 /* FIXME move this stuff into the pre-write-hook */
1536 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1537 H_SET_ENTRY_POINT (&headers
, 0);
1539 obj_pre_write_hook (&headers
); /* extra coff stuff */
1541 object_file_size
= H_GET_FILE_SIZE (&headers
);
1542 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1544 output_file_create (out_file_name
);
1546 obj_header_append (&next_object_file_charP
, &headers
);
1548 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1553 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1555 register long count
;
1556 register char *fill_literal
;
1557 register long fill_size
;
1560 know (fragP
->fr_type
== rs_fill
);
1561 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1562 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1563 fill_size
= fragP
->fr_var
;
1564 know (fragP
->fr_offset
>= 0);
1566 for (count
= fragP
->fr_offset
; count
; count
--)
1568 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1571 } /* for each code frag. */
1573 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1578 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1579 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
)));
1581 /* Make addresses in data relocation directives relative to beginning of
1582 * first data fragment, not end of last text fragment: alignment of the
1583 * start of the data segment may place a gap between the segments.
1585 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1587 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1588 #endif /* TC_I960 */
1590 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
)));
1593 * Emit line number entries.
1595 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1596 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
)));
1601 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1602 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
)));
1608 if (string_byte_count
> 0)
1610 obj_emit_strings (&next_object_file_charP
);
1611 } /* only if we have a string table */
1614 bfd_seek (stdoutput
, 0, 0);
1615 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1618 /* Write the data to the file */
1619 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1620 free (the_object_file
);
1622 } /* non vms output */
1625 * Now do the VMS-dependent part of writing the object file
1627 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1628 H_GET_DATA_SIZE (&headers
),
1629 H_GET_BSS_SIZE (&headers
),
1630 text_frag_root
, data_frag_root
);
1631 #endif /* OBJ_VMS */
1632 #else /* BFD_ASSEMBLER */
1634 /* Resolve symbol values. This needs to be done before processing
1640 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1641 if (!symp
->sy_resolved
)
1642 resolve_symbol_value (symp
);
1647 #ifdef tc_frob_file_before_adjust
1648 tc_frob_file_before_adjust ();
1650 #ifdef obj_frob_file_before_adjust
1651 obj_frob_file_before_adjust ();
1654 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1656 /* Set up symbol table, and write it out. */
1661 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1666 if (symp
->sy_mri_common
)
1668 if (S_IS_EXTERNAL (symp
))
1669 as_bad ("%s: global symbols not supported in common sections",
1671 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1675 name
= S_GET_NAME (symp
);
1678 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1679 /* They only differ if `name' is a fb or dollar local
1681 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1682 as_bad ("local label %s is not defined", name2
);
1685 /* Do it again, because adjust_reloc_syms might introduce
1686 more symbols. They'll probably only be section symbols,
1687 but they'll still need to have the values computed. */
1688 if (! symp
->sy_resolved
)
1690 if (symp
->sy_value
.X_op
== O_constant
)
1692 /* This is the normal case; skip the call. */
1695 + symp
->sy_frag
->fr_address
));
1696 symp
->sy_resolved
= 1;
1699 resolve_symbol_value (symp
);
1702 /* Skip symbols which were equated to undefined or common
1704 if (symp
->sy_value
.X_op
== O_symbol
1705 && (! S_IS_DEFINED (symp
) || S_IS_COMMON (symp
)))
1707 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1711 /* So far, common symbols have been treated like undefined symbols.
1712 Put them in the common section now. */
1713 if (S_IS_DEFINED (symp
) == 0
1714 && S_GET_VALUE (symp
) != 0)
1715 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1717 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1718 S_GET_NAME (symp
), symp
,
1721 segment_name (symp
->bsym
->section
));
1724 #ifdef obj_frob_symbol
1725 obj_frob_symbol (symp
, punt
);
1727 #ifdef tc_frob_symbol
1728 if (! punt
|| symp
->sy_used_in_reloc
)
1729 tc_frob_symbol (symp
, punt
);
1732 /* If we don't want to keep this symbol, splice it out of
1733 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1734 want section symbols. Otherwise, we skip local symbols
1735 and symbols that the frob_symbol macros told us to punt,
1736 but we keep such symbols if they are used in relocs. */
1737 if ((! EMIT_SECTION_SYMBOLS
1738 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1739 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1740 opposites. Sometimes the former checks flags and the
1741 latter examines the name... */
1742 || (!S_IS_EXTERN (symp
)
1743 && (S_IS_LOCAL (symp
) || punt
)
1744 && ! symp
->sy_used_in_reloc
))
1746 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1747 /* After symbol_remove, symbol_next(symp) still returns
1748 the one that came after it in the chain. So we don't
1749 need to do any extra cleanup work here. */
1754 /* Make sure we really got a value for the symbol. */
1755 if (! symp
->sy_resolved
)
1757 as_bad ("can't resolve value for symbol \"%s\"",
1759 symp
->sy_resolved
= 1;
1762 /* Set the value into the BFD symbol. Up til now the value
1763 has only been kept in the gas symbolS struct. */
1764 symp
->bsym
->value
= S_GET_VALUE (symp
);
1770 /* Now do any format-specific adjustments to the symbol table, such
1771 as adding file symbols. */
1772 #ifdef tc_adjust_symtab
1773 tc_adjust_symtab ();
1775 #ifdef obj_adjust_symtab
1776 obj_adjust_symtab ();
1779 /* Now that all the sizes are known, and contents correct, we can
1780 start writing to the file. */
1783 /* If *_frob_file changes the symbol value at this point, it is
1784 responsible for moving the changed value into symp->bsym->value
1785 as well. Hopefully all symbol value changing can be done in
1790 #ifdef obj_frob_file
1794 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1796 #ifdef tc_frob_file_after_relocs
1797 tc_frob_file_after_relocs ();
1799 #ifdef obj_frob_file_after_relocs
1800 obj_frob_file_after_relocs ();
1803 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1804 #endif /* BFD_ASSEMBLER */
1811 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1816 * After this, all frags in this segment have addresses that are correct
1817 * within the segment. Since segments live in different file addresses,
1818 * these frag addresses may not be the same as final object-file addresses.
1821 #ifndef md_relax_frag
1822 #ifdef TC_GENERIC_RELAX_TABLE
1824 /* Subroutines of relax_segment. */
1830 for (; f1
; f1
= f1
->fr_next
)
1831 if (f1
->fr_next
== f2
)
1836 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1837 #endif /* ! defined (md_relax_frag) */
1839 /* Relax_align. Advance location counter to next address that has 'alignment'
1840 lowest order bits all 0s, return size of adjustment made. */
1841 static relax_addressT
1842 relax_align (address
, alignment
)
1843 register relax_addressT address
; /* Address now. */
1844 register int alignment
; /* Alignment (binary). */
1846 relax_addressT mask
;
1847 relax_addressT new_address
;
1849 mask
= ~((~0) << alignment
);
1850 new_address
= (address
+ mask
) & (~mask
);
1851 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1853 /* We must provide lots of padding, so the linker can discard it
1854 when needed. The linker will not add extra space, ever. */
1855 new_address
+= (1 << alignment
);
1857 return (new_address
- address
);
1861 relax_segment (segment_frag_root
, segment
)
1862 struct frag
*segment_frag_root
;
1865 register struct frag
*fragP
;
1866 register relax_addressT address
;
1867 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1868 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1870 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1871 subseg_change (segment
, 0);
1873 /* For each frag in segment: count and store (a 1st guess of)
1876 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1878 fragP
->fr_address
= address
;
1879 address
+= fragP
->fr_fix
;
1881 switch (fragP
->fr_type
)
1884 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1890 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1891 if (offset
% fragP
->fr_var
!= 0)
1893 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1894 offset
, (long) fragP
->fr_var
);
1895 offset
-= (offset
% fragP
->fr_var
);
1903 /* Assume .org is nugatory. It will grow with 1st relax. */
1906 case rs_machine_dependent
:
1907 address
+= md_estimate_size_before_relax (fragP
, segment
);
1910 #ifndef WORKING_DOT_WORD
1911 /* Broken words don't concern us yet */
1912 case rs_broken_word
:
1917 BAD_CASE (fragP
->fr_type
);
1919 } /* switch(fr_type) */
1920 } /* for each frag in the segment */
1924 long stretch
; /* May be any size, 0 or negative. */
1925 /* Cumulative number of addresses we have */
1926 /* relaxed this pass. */
1927 /* We may have relaxed more than one address. */
1928 long stretched
; /* Have we stretched on this pass? */
1929 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1930 grew, and another shrank. If a branch instruction doesn't fit anymore,
1931 we could be scrod. */
1935 stretch
= stretched
= 0;
1936 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1939 unsigned long was_address
;
1945 was_address
= fragP
->fr_address
;
1946 address
= fragP
->fr_address
+= stretch
;
1947 symbolP
= fragP
->fr_symbol
;
1948 offset
= fragP
->fr_offset
;
1950 switch (fragP
->fr_type
)
1952 case rs_fill
: /* .fill never relaxes. */
1956 #ifndef WORKING_DOT_WORD
1957 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1958 for it I do not want to write it. I do not want to have
1959 anything to do with it. This is not the proper way to
1960 implement this misfeature. */
1961 case rs_broken_word
:
1963 struct broken_word
*lie
;
1964 struct broken_word
*untruth
;
1966 /* Yes this is ugly (storing the broken_word pointer
1967 in the symbol slot). Still, this whole chunk of
1968 code is ugly, and I don't feel like doing anything
1969 about it. Think of it as stubbornness in action. */
1971 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1972 lie
&& lie
->dispfrag
== fragP
;
1973 lie
= lie
->next_broken_word
)
1979 offset
= (lie
->add
->sy_frag
->fr_address
1980 + S_GET_VALUE (lie
->add
)
1982 - (lie
->sub
->sy_frag
->fr_address
1983 + S_GET_VALUE (lie
->sub
)));
1984 if (offset
<= -32768 || offset
>= 32767)
1986 if (flag_warn_displacement
)
1989 sprint_value (buf
, (addressT
) lie
->addnum
);
1990 as_warn (".word %s-%s+%s didn't fit",
1991 S_GET_NAME (lie
->add
),
1992 S_GET_NAME (lie
->sub
),
1996 if (fragP
->fr_subtype
== 0)
1998 fragP
->fr_subtype
++;
1999 growth
+= md_short_jump_size
;
2001 for (untruth
= lie
->next_broken_word
;
2002 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
2003 untruth
= untruth
->next_broken_word
)
2004 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
2005 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
2008 untruth
->use_jump
= lie
;
2010 growth
+= md_long_jump_size
;
2015 } /* case rs_broken_word */
2019 growth
= (relax_align ((relax_addressT
) (address
2022 - relax_align ((relax_addressT
) (was_address
2032 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2033 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2034 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2035 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
2036 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
2037 know (symbolP
->sy_frag
);
2038 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2039 || (symbolP
->sy_frag
== &zero_address_frag
));
2041 target
+= S_GET_VALUE (symbolP
)
2042 + symbolP
->sy_frag
->fr_address
;
2043 } /* if we have a symbol */
2045 know (fragP
->fr_next
);
2046 after
= fragP
->fr_next
->fr_address
;
2047 growth
= target
- after
;
2050 /* Growth may be negative, but variable part of frag
2051 cannot have fewer than 0 chars. That is, we can't
2053 as_bad ("attempt to .org backwards ignored");
2057 growth
-= stretch
; /* This is an absolute growth factor */
2063 growth
= S_GET_VALUE (symbolP
);
2064 if (symbolP
->sy_frag
!= &zero_address_frag
)
2065 as_bad (".space specifies non-absolute value");
2066 fragP
->fr_symbol
= 0;
2069 as_warn (".space or .fill with negative value, ignored");
2077 case rs_machine_dependent
:
2078 #ifdef md_relax_frag
2079 growth
= md_relax_frag (fragP
, stretch
);
2081 #ifdef TC_GENERIC_RELAX_TABLE
2082 /* The default way to relax a frag is to look through
2085 const relax_typeS
*this_type
;
2086 const relax_typeS
*start_type
;
2087 relax_substateT next_state
;
2088 relax_substateT this_state
;
2090 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
2092 this_state
= fragP
->fr_subtype
;
2093 start_type
= this_type
= table
+ this_state
;
2098 #ifndef DIFF_EXPR_OK
2099 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2100 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2101 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2102 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2103 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2105 know (symbolP
->sy_frag
);
2107 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2108 || symbolP
->sy_frag
== &zero_address_frag
);
2110 S_GET_VALUE (symbolP
)
2111 + symbolP
->sy_frag
->fr_address
;
2113 /* If frag has yet to be reached on this pass,
2114 assume it will move by STRETCH just as we did.
2115 If this is not so, it will be because some frag
2116 between grows, and that will force another pass.
2118 Beware zero-length frags.
2120 There should be a faster way to do this. */
2122 if (symbolP
->sy_frag
->fr_address
>= was_address
2123 && is_dnrange (fragP
, symbolP
->sy_frag
))
2129 aim
= target
- address
- fragP
->fr_fix
;
2130 #ifdef TC_PCREL_ADJUST
2131 /* Currently only the ns32k family needs this */
2132 aim
+= TC_PCREL_ADJUST(fragP
);
2134 /* This machine doesn't want to use pcrel_adjust.
2135 In that case, pcrel_adjust should be zero. */
2136 assert (fragP
->fr_pcrel_adjust
== 0);
2141 /* Look backwards. */
2142 for (next_state
= this_type
->rlx_more
; next_state
;)
2143 if (aim
>= this_type
->rlx_backward
)
2147 /* Grow to next state. */
2148 this_state
= next_state
;
2149 this_type
= table
+ this_state
;
2150 next_state
= this_type
->rlx_more
;
2155 #ifdef M68K_AIM_KLUDGE
2156 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2158 /* Look forwards. */
2159 for (next_state
= this_type
->rlx_more
; next_state
;)
2160 if (aim
<= this_type
->rlx_forward
)
2164 /* Grow to next state. */
2165 this_state
= next_state
;
2166 this_type
= table
+ this_state
;
2167 next_state
= this_type
->rlx_more
;
2171 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2173 fragP
->fr_subtype
= this_state
;
2175 #endif /* TC_GENERIC_RELAX_TABLE */
2180 BAD_CASE (fragP
->fr_type
);
2188 } /* For each frag in the segment. */
2190 while (stretched
); /* Until nothing further to relax. */
2194 * We now have valid fr_address'es for each frag.
2198 * All fr_address's are correct, relative to their own segment.
2199 * We have made all the fixS we will ever make.
2201 } /* relax_segment() */
2203 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2205 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2206 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2211 Go through all the fixS's in a segment and see which ones can be
2212 handled now. (These consist of fixS where we have since discovered
2213 the value of a symbol, or the address of the frag involved.)
2214 For each one, call md_apply_fix to put the fix into the frag data.
2216 Result is a count of how many relocation structs will be needed to
2217 handle the remaining fixS's that we couldn't completely handle here.
2218 These will be output later by emit_relocations(). */
2221 fixup_segment (fixP
, this_segment_type
)
2222 register fixS
*fixP
;
2223 segT this_segment_type
; /* N_TYPE bits for segment. */
2225 long seg_reloc_count
= 0;
2226 symbolS
*add_symbolP
;
2227 symbolS
*sub_symbolP
;
2234 segT add_symbol_segment
= absolute_section
;
2236 /* If the linker is doing the relaxing, we must not do any fixups.
2238 Well, strictly speaking that's not true -- we could do any that are
2239 PC-relative and don't cross regions that could change size. And for the
2240 i960 (the only machine for which we've got a relaxing linker right now),
2241 we might be able to turn callx/callj into bal anyways in cases where we
2242 know the maximum displacement. */
2245 for (; fixP
; fixP
= fixP
->fx_next
)
2247 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2248 return seg_reloc_count
;
2251 for (; fixP
; fixP
= fixP
->fx_next
)
2254 fprintf (stderr
, "\nprocessing fixup:\n");
2258 fragP
= fixP
->fx_frag
;
2260 where
= fixP
->fx_where
;
2261 place
= fragP
->fr_literal
+ where
;
2262 size
= fixP
->fx_size
;
2263 add_symbolP
= fixP
->fx_addsy
;
2264 #ifdef TC_VALIDATE_FIX
2265 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2267 sub_symbolP
= fixP
->fx_subsy
;
2268 add_number
= fixP
->fx_offset
;
2269 pcrel
= fixP
->fx_pcrel
;
2272 if (add_symbolP
!= NULL
2273 && add_symbolP
->sy_mri_common
)
2275 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2276 add_number
+= S_GET_VALUE (add_symbolP
);
2277 fixP
->fx_offset
= add_number
;
2278 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2282 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2286 resolve_symbol_value (sub_symbolP
);
2287 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
2289 if (add_symbolP
!= NULL
)
2291 add_number
+= S_GET_VALUE (add_symbolP
);
2293 fixP
->fx_addsy
= NULL
;
2296 /* It's just -sym */
2297 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2299 add_number
-= S_GET_VALUE (sub_symbolP
);
2300 fixP
->fx_subsy
= NULL
;
2303 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2305 /* Should try converting to a constant. */
2310 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2311 "Negative of non-absolute symbol %s",
2312 S_GET_NAME (sub_symbolP
));
2314 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
2315 && SEG_NORMAL (add_symbol_segment
))
2317 /* Difference of 2 symbols from same segment.
2318 Can't make difference of 2 undefineds: 'value' means
2319 something different for N_UNDF. */
2321 /* Makes no sense to use the difference of 2 arbitrary symbols
2322 as the target of a call instruction. */
2324 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2325 "callj to difference of 2 symbols");
2326 #endif /* TC_I960 */
2327 add_number
+= S_GET_VALUE (add_symbolP
) -
2328 S_GET_VALUE (sub_symbolP
);
2331 pcrel
= 0; /* No further pcrel processing. */
2333 /* Let the target machine make the final determination
2334 as to whether or not a relocation will be needed to
2335 handle this fixup. */
2336 if (!TC_FORCE_RELOCATION_SECTION (fixP
, this_segment_type
))
2339 fixP
->fx_addsy
= NULL
;
2340 fixP
->fx_subsy
= NULL
;
2345 /* Different segments in subtraction. */
2346 know (!(S_IS_EXTERNAL (sub_symbolP
)
2347 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2349 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2350 add_number
-= S_GET_VALUE (sub_symbolP
);
2353 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2354 #if 0 /* Do this even if it's already described as pc-relative. For example,
2355 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2356 pc-relative mode. */
2361 /* Make it pc-relative. */
2362 add_number
+= (MD_PCREL_FROM_SECTION (fixP
, this_segment_type
)
2363 - S_GET_VALUE (sub_symbolP
));
2370 #ifdef UNDEFINED_DIFFERENCE_OK
2371 /* The PA needs this for PIC code generation. We basically
2372 don't want to do anything if we have the difference of two
2373 symbols at this point. */
2376 /* Leave it alone. */
2379 #ifdef BFD_ASSEMBLER
2380 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2381 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2383 /* Leave it alone. */
2389 sprint_value (buf
, fragP
->fr_address
+ where
);
2390 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2391 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2392 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2393 S_GET_NAME (sub_symbolP
), buf
);
2400 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2401 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2404 * This fixup was made when the symbol's segment was
2405 * SEG_UNKNOWN, but it is now in the local segment.
2406 * So we know how to do the address without relocation.
2409 /* reloc_callj() may replace a 'call' with a 'calls' or a
2410 'bal', in which cases it modifies *fixP as appropriate.
2411 In the case of a 'calls', no further work is required,
2412 and *fixP has been set up to make the rest of the code
2415 #endif /* TC_I960 */
2417 add_number
+= S_GET_VALUE (add_symbolP
);
2418 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2419 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2421 /* Let the target machine make the final determination
2422 as to whether or not a relocation will be needed to
2423 handle this fixup. */
2424 if (!TC_FORCE_RELOCATION (fixP
))
2427 fixP
->fx_addsy
= NULL
;
2432 if (add_symbol_segment
== absolute_section
)
2435 /* See comment about reloc_callj() above. */
2437 #endif /* TC_I960 */
2438 add_number
+= S_GET_VALUE (add_symbolP
);
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. */
2444 if (!TC_FORCE_RELOCATION (fixP
))
2446 fixP
->fx_addsy
= NULL
;
2450 else if (add_symbol_segment
== undefined_section
2451 #ifdef BFD_ASSEMBLER
2452 || bfd_is_com_section (add_symbol_segment
)
2457 if ((int) fixP
->fx_bit_fixP
== 13)
2459 /* This is a COBR instruction. They have only a
2460 * 13-bit displacement and are only to be used
2461 * for local branches: flag as error, don't generate
2464 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2465 "can't use COBR format with external label");
2466 fixP
->fx_addsy
= NULL
;
2470 #endif /* TC_I960 */
2474 if (S_IS_COMMON (add_symbolP
))
2475 add_number
+= S_GET_VALUE (add_symbolP
);
2476 #endif /* TE_I386AIX */
2477 #endif /* OBJ_COFF */
2483 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2484 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2485 add_number
+= S_GET_VALUE (add_symbolP
);
2494 add_number
-= MD_PCREL_FROM_SECTION (fixP
, this_segment_type
);
2495 if (add_symbolP
== 0)
2497 #ifndef BFD_ASSEMBLER
2498 fixP
->fx_addsy
= &abs_symbol
;
2500 fixP
->fx_addsy
= section_symbol (absolute_section
);
2502 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2507 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2510 if (size
< sizeof (mask
))
2512 /* set all bits to one */
2514 /* Technically, combining these produces an undefined result
2515 if size is sizeof (valueT), though I think these two
2516 half-way operations should both be defined. And the
2517 compiler should be able to combine them if it's valid on
2518 the host architecture. */
2521 if ((add_number
& mask
) != 0
2522 && (add_number
& mask
) != mask
)
2524 char buf
[50], buf2
[50];
2525 sprint_value (buf
, fragP
->fr_address
+ where
);
2526 if (add_number
> 1000)
2527 sprint_value (buf2
, add_number
);
2529 sprintf (buf2
, "%ld", (long) add_number
);
2530 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2531 "Value of %s too large for field of %d bytes at %s",
2533 } /* generic error checking */
2535 #ifdef WARN_SIGNED_OVERFLOW_WORD
2536 /* Warn if a .word value is too large when treated as a signed
2537 number. We already know it is not too negative. This is to
2538 catch over-large switches generated by gcc on the 68k. */
2539 if (!flag_signed_overflow_ok
2541 && add_number
> 0x7fff)
2542 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2543 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2545 (unsigned long) (fragP
->fr_address
+ where
));
2547 } /* not a bit fix */
2551 #ifdef MD_APPLY_FIX3
2552 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2554 #ifdef BFD_ASSEMBLER
2555 md_apply_fix (fixP
, &add_number
);
2557 md_apply_fix (fixP
, add_number
);
2561 #ifndef TC_HANDLES_FX_DONE
2562 /* If the tc-* files haven't been converted, assume it's handling
2563 it the old way, where a null fx_addsy means that the fix has
2564 been applied completely, and no further work is needed. */
2565 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2569 #ifdef TC_VALIDATE_FIX
2573 fprintf (stderr
, "result:\n");
2576 } /* For each fixS in this segment. */
2578 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2579 return seg_reloc_count
;
2582 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2585 number_to_chars_bigendian (buf
, val
, n
)
2590 if (n
> sizeof (val
)|| n
<= 0)
2594 buf
[n
] = val
& 0xff;
2600 number_to_chars_littleendian (buf
, val
, n
)
2605 if (n
> sizeof (val
) || n
<= 0)
2609 *buf
++ = val
& 0xff;
2615 write_print_statistics (file
)
2618 fprintf (stderr
, "fixups: %d\n", n_fixups
);
2622 extern int indent_level
;
2623 extern void print_symbol_value_1 ();
2630 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2632 fprintf (stderr
, " pcrel");
2633 if (fixp
->fx_pcrel_adjust
)
2634 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2635 if (fixp
->fx_im_disp
)
2638 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2640 fprintf (stderr
, " im_disp");
2644 fprintf (stderr
, " tcbit");
2646 fprintf (stderr
, " done");
2647 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2648 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2649 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2650 #ifdef BFD_ASSEMBLER
2651 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2654 #ifdef NEED_FX_R_TYPE
2655 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2660 fprintf (stderr
, "\n +<");
2661 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2662 fprintf (stderr
, ">");
2666 fprintf (stderr
, "\n -<");
2667 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2668 fprintf (stderr
, ">");
2670 fprintf (stderr
, "\n");
2673 /* end of write.c */