1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 1995
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 WORKING_DOT_WORD
47 extern CONST
int md_short_jump_size
;
48 extern CONST
int md_long_jump_size
;
51 int symbol_table_frozen
;
52 void print_fixup
PARAMS ((fixS
*));
55 static void renumber_sections
PARAMS ((bfd
*, asection
*, PTR
));
57 /* We generally attach relocs to frag chains. However, after we have
58 chained these all together into a segment, any relocs we add after
59 that must be attached to a segment. This will include relocs added
60 in md_estimate_size_for_relax, for example. */
61 static int frags_chained
= 0;
67 struct frag
*text_frag_root
;
68 struct frag
*data_frag_root
;
69 struct frag
*bss_frag_root
;
71 struct frag
*text_last_frag
; /* Last frag in segment. */
72 struct frag
*data_last_frag
; /* Last frag in segment. */
73 static struct frag
*bss_last_frag
; /* Last frag in segment. */
77 static object_headers headers
;
80 long string_byte_count
;
81 char *next_object_file_charP
; /* Tracks object file bytes. */
84 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
87 #endif /* BFD_ASSEMBLER */
90 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
91 symbolS
*add
, symbolS
*sub
,
92 offsetT offset
, int pcrel
,
93 bfd_reloc_code_real_type r_type
));
95 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
96 symbolS
*add
, symbolS
*sub
,
97 offsetT offset
, int pcrel
,
100 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
101 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
103 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
108 * Create a fixS in obstack 'notes'.
111 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
113 fragS
*frag
; /* Which frag? */
114 int where
; /* Where in that frag? */
115 int size
; /* 1, 2, or 4 usually. */
116 symbolS
*add_symbol
; /* X_add_symbol. */
117 symbolS
*sub_symbol
; /* X_op_symbol. */
118 offsetT offset
; /* X_add_number. */
119 int pcrel
; /* TRUE if PC-relative relocation. */
121 bfd_reloc_code_real_type r_type
; /* Relocation type */
123 int r_type
; /* Relocation type */
128 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
130 fixP
->fx_frag
= frag
;
131 fixP
->fx_where
= where
;
132 fixP
->fx_size
= size
;
133 fixP
->fx_addsy
= add_symbol
;
134 fixP
->fx_subsy
= sub_symbol
;
135 fixP
->fx_offset
= offset
;
136 fixP
->fx_pcrel
= pcrel
;
138 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
139 fixP
->fx_r_type
= r_type
;
141 fixP
->fx_im_disp
= 0;
142 fixP
->fx_pcrel_adjust
= 0;
143 fixP
->fx_bit_fixP
= 0;
144 fixP
->fx_addnumber
= 0;
145 fixP
->tc_fix_data
= NULL
;
149 #if defined (TC_I960) || defined (TC_NS32K)
153 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
155 /* Usually, we want relocs sorted numerically, but while
156 comparing to older versions of gas that have relocs
157 reverse sorted, it is convenient to have this compile
158 time option. xoxorich. */
163 fixS
**seg_fix_rootP
= (frags_chained
164 ? &seg_info (now_seg
)->fix_root
165 : &frchain_now
->fix_root
);
166 fixS
**seg_fix_tailP
= (frags_chained
167 ? &seg_info (now_seg
)->fix_tail
168 : &frchain_now
->fix_tail
);
171 #ifdef REVERSE_SORT_RELOCS
173 fixP
->fx_next
= *seg_fix_rootP
;
174 *seg_fix_rootP
= fixP
;
176 #else /* REVERSE_SORT_RELOCS */
178 fixP
->fx_next
= NULL
;
181 (*seg_fix_tailP
)->fx_next
= fixP
;
183 *seg_fix_rootP
= fixP
;
184 *seg_fix_tailP
= fixP
;
186 #endif /* REVERSE_SORT_RELOCS */
193 /* Create a fixup relative to a symbol (plus a constant). */
196 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
197 fragS
*frag
; /* Which frag? */
198 int where
; /* Where in that frag? */
199 int size
; /* 1, 2, or 4 usually. */
200 symbolS
*add_symbol
; /* X_add_symbol. */
201 offsetT offset
; /* X_add_number. */
202 int pcrel
; /* TRUE if PC-relative relocation. */
204 bfd_reloc_code_real_type r_type
; /* Relocation type */
206 int r_type
; /* Relocation type */
209 return fix_new_internal (frag
, where
, size
, add_symbol
,
210 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
213 /* Create a fixup for an expression. Currently we only support fixups
214 for difference expressions. That is itself more than most object
215 file formats support anyhow. */
218 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
219 fragS
*frag
; /* Which frag? */
220 int where
; /* Where in that frag? */
221 int size
; /* 1, 2, or 4 usually. */
222 expressionS
*exp
; /* Expression. */
223 int pcrel
; /* TRUE if PC-relative relocation. */
225 bfd_reloc_code_real_type r_type
; /* Relocation type */
227 int r_type
; /* Relocation type */
240 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
241 the difference expression cannot immediately be reduced. */
243 extern symbolS
*make_expr_symbol ();
244 symbolS
*stmp
= make_expr_symbol (exp
);
245 exp
->X_op
= O_symbol
;
246 exp
->X_op_symbol
= 0;
247 exp
->X_add_symbol
= stmp
;
248 exp
->X_add_number
= 0;
249 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
253 sub
= exp
->X_add_symbol
;
254 off
= exp
->X_add_number
;
258 sub
= exp
->X_op_symbol
;
261 add
= exp
->X_add_symbol
;
264 off
= exp
->X_add_number
;
268 as_bad ("expression too complex for fixup");
271 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
275 /* Append a string onto another string, bumping the pointer along. */
277 append (charPP
, fromP
, length
)
280 unsigned long length
;
282 /* Don't trust memcpy() of 0 chars. */
286 memcpy (*charPP
, fromP
, length
);
290 #ifndef BFD_ASSEMBLER
291 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
295 * This routine records the largest alignment seen for each segment.
296 * If the beginning of the segment is aligned on the worst-case
297 * boundary, all of the other alignments within it will work. At
298 * least one object format really uses this info.
301 record_alignment (seg
, align
)
302 /* Segment to which alignment pertains */
304 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
309 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
310 bfd_set_section_alignment (stdoutput
, seg
, align
);
312 if (align
> section_alignment
[(int) seg
])
313 section_alignment
[(int) seg
] = align
;
319 /* Reset the section indices after removing the gas created sections. */
322 renumber_sections (abfd
, sec
, countparg
)
327 int *countp
= (int *) countparg
;
329 sec
->index
= *countp
;
333 #endif /* defined (BFD_ASSEMBLER) */
335 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
338 chain_frchains_together_1 (section
, frchp
)
340 struct frchain
*frchp
;
342 fragS dummy
, *prev_frag
= &dummy
;
344 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
347 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
349 prev_frag
->fr_next
= frchp
->frch_root
;
350 prev_frag
= frchp
->frch_last
;
352 if (frchp
->fix_root
!= (fixS
*) NULL
)
354 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
355 seg_info (section
)->fix_root
= frchp
->fix_root
;
356 prev_fix
->fx_next
= frchp
->fix_root
;
357 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
358 prev_fix
= frchp
->fix_tail
;
362 prev_frag
->fr_next
= 0;
371 chain_frchains_together (abfd
, section
, xxx
)
372 bfd
*abfd
; /* unused */
374 PTR xxx
; /* unused */
376 segment_info_type
*info
;
378 /* BFD may have introduced its own sections without using
379 subseg_new, so it is possible that seg_info is NULL. */
380 info
= seg_info (section
);
381 if (info
!= (segment_info_type
*) NULL
)
382 info
->frchainP
->frch_last
383 = chain_frchains_together_1 (section
, info
->frchainP
);
385 /* Now that we've chained the frags together, we must add new fixups
386 to the segment, not to the frag chain. */
392 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
395 remove_subsegs (head
, seg
, root
, last
)
401 *root
= head
->frch_root
;
402 *last
= chain_frchains_together_1 (seg
, head
);
407 #if defined (BFD_ASSEMBLER) || !defined (BFD)
411 cvt_frag_to_fill (sec
, fragP
)
416 cvt_frag_to_fill (headersP
, sec
, fragP
)
417 object_headers
*headersP
;
422 switch (fragP
->fr_type
)
429 HANDLE_ALIGN (fragP
);
431 know (fragP
->fr_next
!= NULL
);
432 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
434 - fragP
->fr_fix
) / fragP
->fr_var
;
435 if (fragP
->fr_offset
< 0)
437 as_bad ("attempt to .org/.space backwards? (%ld)",
438 (long) fragP
->fr_offset
);
440 fragP
->fr_type
= rs_fill
;
446 case rs_machine_dependent
:
448 md_convert_frag (stdoutput
, sec
, fragP
);
450 md_convert_frag (headersP
, sec
, fragP
);
453 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
456 * After md_convert_frag, we make the frag into a ".space 0".
457 * Md_convert_frag() should set up any fixSs and constants
463 #ifndef WORKING_DOT_WORD
466 struct broken_word
*lie
;
468 if (fragP
->fr_subtype
)
470 fragP
->fr_fix
+= md_short_jump_size
;
471 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
472 lie
&& lie
->dispfrag
== fragP
;
473 lie
= lie
->next_broken_word
)
475 fragP
->fr_fix
+= md_long_jump_size
;
483 BAD_CASE (fragP
->fr_type
);
488 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
492 relax_and_size_seg (abfd
, sec
, xxx
)
499 segment_info_type
*seginfo
;
501 valueT size
, newsize
;
503 flags
= bfd_get_section_flags (abfd
, sec
);
505 seginfo
= seg_info (sec
);
506 if (seginfo
&& seginfo
->frchainP
)
508 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
509 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
510 cvt_frag_to_fill (sec
, fragp
);
511 for (fragp
= seginfo
->frchainP
->frch_root
;
513 fragp
= fragp
->fr_next
)
514 /* walk to last elt */;
515 size
= fragp
->fr_address
+ fragp
->fr_fix
;
520 if (size
> 0 && ! seginfo
->bss
)
521 flags
|= SEC_HAS_CONTENTS
;
523 /* @@ This is just an approximation. */
524 if (seginfo
&& seginfo
->fix_root
)
528 x
= bfd_set_section_flags (abfd
, sec
, flags
);
531 newsize
= md_section_align (sec
, size
);
532 x
= bfd_set_section_size (abfd
, sec
, newsize
);
535 /* If the size had to be rounded up, add some padding in the last
537 assert (newsize
>= size
);
540 fragS
*last
= seginfo
->frchainP
->frch_last
;
541 fragp
= seginfo
->frchainP
->frch_root
;
542 while (fragp
->fr_next
!= last
)
543 fragp
= fragp
->fr_next
;
544 last
->fr_address
= size
;
545 fragp
->fr_offset
+= newsize
- size
;
548 #ifdef tc_frob_section
549 tc_frob_section (sec
);
551 #ifdef obj_frob_section
552 obj_frob_section (sec
);
558 dump_section_relocs (abfd
, sec
, stream_
)
563 FILE *stream
= (FILE *) stream_
;
564 segment_info_type
*seginfo
= seg_info (sec
);
565 fixS
*fixp
= seginfo
->fix_root
;
570 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
573 symbolS
*s
= fixp
->fx_addsy
;
576 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
577 s
->bsym
->section
->name
);
578 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
580 fprintf (stream
, " section sym");
582 fprintf (stream
, "+%x", S_GET_VALUE (s
));
585 fprintf (stream
, "+%x", S_GET_VALUE (s
));
586 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
589 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
590 fixp
= fixp
->fx_next
;
594 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
597 #ifndef EMIT_SECTION_SYMBOLS
598 #define EMIT_SECTION_SYMBOLS 1
602 adjust_reloc_syms (abfd
, sec
, xxx
)
607 segment_info_type
*seginfo
= seg_info (sec
);
613 dump_section_relocs (abfd
, sec
, stderr
);
615 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
618 else if (fixp
->fx_addsy
)
626 fprintf (stderr
, "\n\nadjusting fixup:\n");
630 sym
= fixp
->fx_addsy
;
631 symsec
= sym
->bsym
->section
;
633 /* If it's one of these sections, assume the symbol is
634 definitely going to be output. The code in
635 md_estimate_size_before_relax in tc-mips.c uses this test
636 as well, so if you change this code you should look at that
638 if (bfd_is_und_section (symsec
)
639 || bfd_is_abs_section (symsec
)
640 || bfd_is_com_section (symsec
))
642 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
643 #ifdef UNDEFINED_DIFFERENCE_OK
644 /* We have the difference of an undefined symbol and some
645 other symbol. Make sure to mark the other symbol as used
646 in a relocation so that it will always be output. */
648 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
653 /* Since we're reducing to section symbols, don't attempt to reduce
654 anything that's already using one. */
655 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
657 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
661 /* Is there some other reason we can't adjust this one? (E.g.,
662 call/bal links in i960-bout symbols.) */
663 #ifdef obj_fix_adjustable
664 if (! obj_fix_adjustable (fixp
))
666 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
671 /* Is there some other (target cpu dependent) reason we can't adjust
672 this one? (E.g. relocations involving function addresses on
674 #ifdef tc_fix_adjustable
675 if (! tc_fix_adjustable (fixp
))
677 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
682 /* For PIC support: We may get expressions like
683 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
684 necessarily have had a fixed difference initially. But now
685 it should be a known constant, so we can reduce it. Since
686 we can't easily handle a symbol value that looks like
687 someUndefinedSymbol+const, though, we convert the fixup to
688 access the undefined symbol directly, and discard the
689 intermediate symbol. */
690 if (S_GET_SEGMENT (sym
) == expr_section
691 && sym
->sy_value
.X_op
== O_add
692 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
693 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
694 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
695 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
697 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
698 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
699 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
703 /* If the section symbol isn't going to be output, the relocs
704 at least should still work. If not, figure out what to do
705 when we run into that case. */
706 fixp
->fx_offset
+= S_GET_VALUE (sym
);
707 fixp
->fx_addsy
= section_symbol (symsec
);
708 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
713 #if 1/*def RELOC_REQUIRES_SYMBOL*/
716 /* There was no symbol required by this relocation. However,
717 BFD doesn't really handle relocations without symbols well.
718 (At least, the COFF support doesn't.) So for now we fake up
719 a local symbol in the absolute section. */
721 fixp
->fx_addsy
= section_symbol (absolute_section
);
722 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
726 dump_section_relocs (abfd
, sec
, stderr
);
730 write_relocs (abfd
, sec
, xxx
)
735 segment_info_type
*seginfo
= seg_info (sec
);
742 /* If seginfo is NULL, we did not create this section; don't do
747 fixup_segment (seginfo
->fix_root
, sec
);
750 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
753 #ifndef RELOC_EXPANSION_POSSIBLE
754 /* Set up reloc information as well. */
755 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
756 n
* sizeof (arelent
*));
757 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
760 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
763 bfd_reloc_status_type s
;
770 reloc
= tc_gen_reloc (sec
, fixp
);
776 if (fixp
->fx_where
+ fixp
->fx_size
777 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
780 s
= bfd_install_relocation (stdoutput
, reloc
,
781 fixp
->fx_frag
->fr_literal
,
782 fixp
->fx_frag
->fr_address
,
788 case bfd_reloc_overflow
:
789 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
792 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
793 fixp
->fx_file
, fixp
->fx_line
);
798 n
= n
* MAX_RELOC_EXPANSION
;
799 /* Set up reloc information as well. */
800 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
801 n
* sizeof (arelent
*));
804 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
808 bfd_reloc_status_type s
;
816 reloc
= tc_gen_reloc (sec
, fixp
);
818 for (j
= 0; reloc
[j
]; j
++)
820 relocs
[i
++] = reloc
[j
];
823 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
824 if (fixp
->fx_where
+ fixp
->fx_size
825 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
827 for (j
= 0; reloc
[j
]; j
++)
829 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
830 fixp
->fx_frag
->fr_literal
,
831 fixp
->fx_frag
->fr_address
,
837 case bfd_reloc_overflow
:
838 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
839 "relocation overflow");
842 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
843 fixp
->fx_file
, fixp
->fx_line
);
854 sympp
= bfd_get_outsymbols (stdoutput
);
855 nsyms
= bfd_get_symcount (stdoutput
);
856 for (i
= 0; i
< n
; i
++)
857 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
859 for (j
= 0; j
< nsyms
; j
++)
860 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
869 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
871 bfd_set_section_flags (abfd
, sec
,
872 (bfd_get_section_flags (abfd
, sec
)
873 & (flagword
) ~SEC_RELOC
));
880 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
881 for (i
= 0; i
< n
; i
++)
885 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
886 i
, r
, r
->address
, s
->name
, r
->addend
);
893 write_contents (abfd
, sec
, xxx
)
898 segment_info_type
*seginfo
= seg_info (sec
);
899 unsigned long offset
= 0;
902 /* Write out the frags. */
904 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
907 for (f
= seginfo
->frchainP
->frch_root
;
912 unsigned long fill_size
;
916 assert (f
->fr_type
== rs_fill
);
919 x
= bfd_set_section_contents (stdoutput
, sec
,
920 f
->fr_literal
, (file_ptr
) offset
,
921 (bfd_size_type
) f
->fr_fix
);
924 bfd_perror (stdoutput
->filename
);
925 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
930 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
931 fill_size
= f
->fr_var
;
932 count
= f
->fr_offset
;
934 if (fill_size
&& count
)
935 #ifdef BFD_FAST_SECTION_FILL
938 if (fill_size
> sizeof(buf
)) {
939 /* Do it the old way. Can this ever happen? */
942 x
= bfd_set_section_contents (stdoutput
, sec
,
943 fill_literal
, (file_ptr
) offset
,
944 (bfd_size_type
) fill_size
);
947 bfd_perror (stdoutput
->filename
);
948 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
955 /* Build a buffer full of fill objects and output it as
956 * often as necessary. This saves on the overhead of potentially
957 * lots of bfd_set_section_contents calls.
962 n_per_buf
= sizeof (buf
);
963 memset (buf
, *fill_literal
, n_per_buf
);
968 n_per_buf
= sizeof(buf
)/fill_size
;
969 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
970 memcpy(bufp
, fill_literal
, fill_size
);
972 for (; count
> 0; count
-= n_per_buf
)
974 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
975 x
= bfd_set_section_contents (stdoutput
, sec
,
976 buf
, (file_ptr
) offset
,
977 (bfd_size_type
) n_per_buf
* fill_size
);
979 as_fatal ("Cannot write to output file.");
980 offset
+= n_per_buf
* fill_size
;
987 x
= bfd_set_section_contents (stdoutput
, sec
,
988 fill_literal
, (file_ptr
) offset
,
989 (bfd_size_type
) fill_size
);
991 as_fatal ("Cannot write to output file.");
999 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1001 merge_data_into_text ()
1003 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1004 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1005 seg_info (data_section
)->frchainP
->frch_root
;
1006 seg_info (text_section
)->frchainP
->frch_last
=
1007 seg_info (data_section
)->frchainP
->frch_last
;
1008 seg_info (data_section
)->frchainP
= 0;
1012 text_last_frag
->fr_next
= data_frag_root
;
1013 text_last_frag
= data_last_frag
;
1014 data_last_frag
= NULL
;
1015 data_frag_root
= NULL
;
1018 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1019 tmp
->fx_next
= data_fix_root
;
1020 text_fix_tail
= data_fix_tail
;
1023 text_fix_root
= data_fix_root
;
1024 data_fix_root
= NULL
;
1027 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1029 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1031 relax_and_size_all_segments ()
1035 relax_segment (text_frag_root
, SEG_TEXT
);
1036 relax_segment (data_frag_root
, SEG_DATA
);
1037 relax_segment (bss_frag_root
, SEG_BSS
);
1039 * Now the addresses of frags are correct within the segment.
1042 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1043 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1044 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1047 * Join the 2 segments into 1 huge segment.
1048 * To do this, re-compute every rn_address in the SEG_DATA frags.
1049 * Then join the data frags after the text frags.
1051 * Determine a_data [length of data segment].
1055 register relax_addressT slide
;
1057 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1059 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1060 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1061 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1063 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1064 /* For b.out: If the data section has a strict alignment
1065 requirement, its load address in the .o file will be
1066 rounded up from the size of the text section. These
1067 two values are *not* the same! Similarly for the bss
1069 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1072 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1074 fragP
->fr_address
+= slide
;
1075 } /* for each data frag */
1077 know (text_last_frag
!= 0);
1078 text_last_frag
->fr_next
= data_frag_root
;
1082 H_SET_DATA_SIZE (&headers
, 0);
1086 /* See above comments on b.out data section address. */
1089 if (data_last_frag
== 0)
1090 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1092 bss_vma
= data_last_frag
->fr_address
;
1093 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1094 bss_address_frag
.fr_address
= bss_vma
;
1096 #else /* ! OBJ_BOUT */
1097 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1098 H_GET_DATA_SIZE (&headers
));
1100 #endif /* ! OBJ_BOUT */
1102 /* Slide all the frags */
1105 relax_addressT slide
= bss_address_frag
.fr_address
;
1107 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1109 fragP
->fr_address
+= slide
;
1110 } /* for each bss frag */
1114 H_SET_BSS_SIZE (&headers
,
1115 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1117 H_SET_BSS_SIZE (&headers
, 0);
1119 #endif /* ! BFD_ASSEMBLER && ! BFD */
1121 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1123 #ifdef BFD_ASSEMBLER
1131 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1133 /* Count symbols. We can't rely on a count made by the loop in
1134 write_object_file, because *_frob_file may add a new symbol or
1137 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1144 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1145 nsyms
* sizeof (asymbol
*));
1146 symp
= symbol_rootP
;
1147 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1149 asympp
[i
] = symp
->bsym
;
1155 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1156 assert (result
== true);
1157 symbol_table_frozen
= 1;
1162 write_object_file ()
1164 struct frchain
*frchainP
; /* Track along all frchains. */
1165 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1166 fragS
*fragP
; /* Track along all frags. */
1169 /* Do we really want to write it? */
1171 int n_warns
, n_errs
;
1172 n_warns
= had_warnings ();
1173 n_errs
= had_errors ();
1174 /* The -Z flag indicates that an object file should be generated,
1175 regardless of warnings and errors. */
1176 if (flag_always_generate_output
)
1178 if (n_warns
|| n_errs
)
1179 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1180 n_errs
, n_errs
== 1 ? "" : "s",
1181 n_warns
, n_warns
== 1 ? "" : "s");
1186 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1187 n_errs
, n_errs
== 1 ? "" : "s",
1188 n_warns
, n_warns
== 1 ? "" : "s");
1193 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1194 a routine to check for the definition of the procedure "_main",
1195 and if so -- fix it up so that it can be program entry point. */
1196 vms_check_for_main ();
1197 #endif /* OBJ_VMS */
1199 /* After every sub-segment, we fake an ".align ...". This conforms to
1200 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1201 frag that requires least thought. ".align" frags like to have a
1202 following frag since that makes calculating their intended length
1205 @@ Is this really necessary?? */
1206 #ifndef SUB_SEGMENT_ALIGN
1207 #ifdef BFD_ASSEMBLER
1208 #define SUB_SEGMENT_ALIGN(SEG) (0)
1210 #define SUB_SEGMENT_ALIGN(SEG) (2)
1213 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1215 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1216 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1217 /* frag_align will have left a new frag.
1218 Use this last frag for an empty ".fill".
1220 For this segment ...
1221 Create a last frag. Do not leave a "being filled in frag". */
1222 frag_wane (frag_now
);
1223 frag_now
->fr_fix
= 0;
1224 know (frag_now
->fr_next
== NULL
);
1227 /* From now on, we don't care about sub-segments. Build one frag chain
1228 for each segment. Linked thru fr_next. */
1230 #ifdef BFD_ASSEMBLER
1231 /* Remove the sections created by gas for its own purposes. */
1233 asection
**seclist
, *sec
;
1236 seclist
= &stdoutput
->sections
;
1237 while (seclist
&& *seclist
)
1240 while (sec
== reg_section
|| sec
== expr_section
)
1244 stdoutput
->section_count
--;
1249 seclist
= &(*seclist
)->next
;
1252 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1255 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1257 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1258 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1259 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1262 /* We have two segments. If user gave -R flag, then we must put the
1263 data frags into the text segment. Do this before relaxing so
1264 we know to take advantage of -R and make shorter addresses. */
1265 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1266 if (flag_readonly_data_in_text
)
1268 merge_data_into_text ();
1272 #ifdef BFD_ASSEMBLER
1273 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1275 relax_and_size_all_segments ();
1276 #endif /* BFD_ASSEMBLER */
1278 #ifndef BFD_ASSEMBLER
1281 * Crawl the symbol chain.
1283 * For each symbol whose value depends on a frag, take the address of
1284 * that frag and subsume it into the value of the symbol.
1285 * After this, there is just one way to lookup a symbol value.
1286 * Values are left in their final state for object file emission.
1287 * We adjust the values of 'L' local symbols, even if we do
1288 * not intend to emit them to the object file, because their values
1289 * are needed for fix-ups.
1291 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1292 * from the symbol chain. (They are still pointed to by the fixes.)
1294 * Count the remaining symbols.
1295 * Assign a symbol number to each symbol.
1296 * Count the number of string-table chars we will emit.
1297 * Put this info into the headers as appropriate.
1300 know (zero_address_frag
.fr_address
== 0);
1301 string_byte_count
= sizeof (string_byte_count
);
1303 obj_crawl_symbol_chain (&headers
);
1305 if (string_byte_count
== sizeof (string_byte_count
))
1306 string_byte_count
= 0;
1308 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1311 * Addresses of frags now reflect addresses we use in the object file.
1312 * Symbol values are correct.
1313 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1314 * Also converting any machine-dependent frags using md_convert_frag();
1316 subseg_change (SEG_TEXT
, 0);
1318 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1320 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1322 /* Some assert macros don't work with # directives mixed in. */
1324 if (!(fragP
->fr_next
== NULL
1326 || fragP
->fr_next
== data_frag_root
1328 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1329 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1333 #endif /* ! BFD_ASSEMBLER */
1335 #ifndef WORKING_DOT_WORD
1337 struct broken_word
*lie
;
1338 struct broken_word
**prevP
;
1340 prevP
= &broken_words
;
1341 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1346 exp
.X_op
= O_subtract
;
1347 exp
.X_add_symbol
= lie
->add
;
1348 exp
.X_op_symbol
= lie
->sub
;
1349 exp
.X_add_number
= lie
->addnum
;
1350 #ifdef BFD_ASSEMBLER
1351 #ifdef TC_CONS_FIX_NEW
1352 TC_CONS_FIX_NEW (lie
->frag
,
1353 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1356 fix_new_exp (lie
->frag
,
1357 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1358 2, &exp
, 0, BFD_RELOC_NONE
);
1361 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1362 fix_new_exp (lie
->frag
,
1363 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1364 2, &exp
, 0, NO_RELOC
);
1367 fix_new_ns32k_exp (lie
->frag
,
1368 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1369 2, &exp
, 0, 0, 2, 0, 0);
1371 fix_new_exp (lie
->frag
,
1372 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1374 #endif /* TC_NS32K */
1375 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1376 #endif /* BFD_ASSEMBLER */
1377 *prevP
= lie
->next_broken_word
;
1380 prevP
= &(lie
->next_broken_word
);
1382 for (lie
= broken_words
; lie
;)
1384 struct broken_word
*untruth
;
1386 addressT table_addr
;
1387 addressT from_addr
, to_addr
;
1390 fragP
= lie
->dispfrag
;
1392 /* Find out how many broken_words go here. */
1394 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1395 if (untruth
->added
== 1)
1398 table_ptr
= lie
->dispfrag
->fr_opcode
;
1399 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1400 /* Create the jump around the long jumps. This is a short
1401 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1402 from_addr
= table_addr
;
1403 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1404 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1405 table_ptr
+= md_short_jump_size
;
1406 table_addr
+= md_short_jump_size
;
1408 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1410 if (lie
->added
== 2)
1412 /* Patch the jump table */
1413 /* This is the offset from ??? to table_ptr+0 */
1414 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1415 #ifdef BFD_ASSEMBLER
1416 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1418 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1419 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1421 if (untruth
->use_jump
== lie
)
1422 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1425 /* Install the long jump */
1426 /* this is a long jump from table_ptr+0 to the final target */
1427 from_addr
= table_addr
;
1428 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1429 #ifdef BFD_ASSEMBLER
1430 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1432 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1433 table_ptr
+= md_long_jump_size
;
1434 table_addr
+= md_long_jump_size
;
1438 #endif /* not WORKING_DOT_WORD */
1440 #ifndef BFD_ASSEMBLER
1443 char *the_object_file
;
1444 long object_file_size
;
1446 * Scan every FixS performing fixups. We had to wait until now to do
1447 * this because md_convert_frag() may have made some fixSs.
1451 subseg_change (SEG_TEXT
, 0);
1452 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1453 subseg_change (SEG_DATA
, 0);
1454 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1455 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1457 /* FIXME move this stuff into the pre-write-hook */
1458 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1459 H_SET_ENTRY_POINT (&headers
, 0);
1461 obj_pre_write_hook (&headers
); /* extra coff stuff */
1463 object_file_size
= H_GET_FILE_SIZE (&headers
);
1464 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1466 output_file_create (out_file_name
);
1468 obj_header_append (&next_object_file_charP
, &headers
);
1470 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1475 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1477 register long count
;
1478 register char *fill_literal
;
1479 register long fill_size
;
1482 know (fragP
->fr_type
== rs_fill
);
1483 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1484 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1485 fill_size
= fragP
->fr_var
;
1486 know (fragP
->fr_offset
>= 0);
1488 for (count
= fragP
->fr_offset
; count
; count
--)
1490 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1493 } /* for each code frag. */
1495 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1500 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1501 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
)));
1503 /* Make addresses in data relocation directives relative to beginning of
1504 * first data fragment, not end of last text fragment: alignment of the
1505 * start of the data segment may place a gap between the segments.
1507 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1509 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1510 #endif /* TC_I960 */
1512 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
)));
1515 * Emit line number entries.
1517 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1518 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
)));
1523 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1524 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
)));
1530 if (string_byte_count
> 0)
1532 obj_emit_strings (&next_object_file_charP
);
1533 } /* only if we have a string table */
1536 bfd_seek (stdoutput
, 0, 0);
1537 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1540 /* Write the data to the file */
1541 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1542 free (the_object_file
);
1544 } /* non vms output */
1547 * Now do the VMS-dependent part of writing the object file
1549 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1550 H_GET_DATA_SIZE (&headers
),
1551 H_GET_BSS_SIZE (&headers
),
1552 text_frag_root
, data_frag_root
);
1553 #endif /* OBJ_VMS */
1554 #else /* BFD_ASSEMBLER */
1556 /* Resolve symbol values. This needs to be done before processing
1562 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1563 if (!symp
->sy_resolved
)
1564 resolve_symbol_value (symp
);
1569 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1571 /* Set up symbol table, and write it out. */
1576 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1581 name
= S_GET_NAME (symp
);
1584 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1585 /* They only differ if `name' is a fb or dollar local
1587 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1588 as_bad ("local label %s is not defined", name2
);
1591 /* Do it again, because adjust_reloc_syms might introduce
1592 more symbols. They'll probably only be section symbols,
1593 but they'll still need to have the values computed. */
1594 if (! symp
->sy_resolved
)
1596 if (symp
->sy_value
.X_op
== O_constant
)
1598 /* This is the normal case; skip the call. */
1601 + symp
->sy_frag
->fr_address
));
1602 symp
->sy_resolved
= 1;
1605 resolve_symbol_value (symp
);
1608 /* So far, common symbols have been treated like undefined symbols.
1609 Put them in the common section now. */
1610 if (S_IS_DEFINED (symp
) == 0
1611 && S_GET_VALUE (symp
) != 0)
1612 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1614 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1615 S_GET_NAME (symp
), symp
,
1618 segment_name (symp
->bsym
->section
));
1621 #ifdef obj_frob_symbol
1622 obj_frob_symbol (symp
, punt
);
1624 #ifdef tc_frob_symbol
1625 if (! punt
|| symp
->sy_used_in_reloc
)
1626 tc_frob_symbol (symp
, punt
);
1629 /* If we don't want to keep this symbol, splice it out of
1630 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1631 want section symbols. Otherwise, we skip local symbols
1632 and symbols that the frob_symbol macros told us to punt,
1633 but we keep such symbols if they are used in relocs. */
1634 if ((! EMIT_SECTION_SYMBOLS
1635 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1636 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1637 opposites. Sometimes the former checks flags and the
1638 latter examines the name... */
1639 || (!S_IS_EXTERN (symp
)
1640 && (S_IS_LOCAL (symp
) || punt
)
1641 && ! symp
->sy_used_in_reloc
))
1643 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1644 /* After symbol_remove, symbol_next(symp) still returns
1645 the one that came after it in the chain. So we don't
1646 need to do any extra cleanup work here. */
1651 /* Make sure we really got a value for the symbol. */
1652 if (! symp
->sy_resolved
)
1654 as_bad ("can't resolve value for symbol \"%s\"",
1656 symp
->sy_resolved
= 1;
1659 /* Set the value into the BFD symbol. Up til now the value
1660 has only been kept in the gas symbolS struct. */
1661 symp
->bsym
->value
= S_GET_VALUE (symp
);
1667 /* Now do any format-specific adjustments to the symbol table, such
1668 as adding file symbols. */
1669 #ifdef obj_adjust_symtab
1670 obj_adjust_symtab ();
1673 /* Now that all the sizes are known, and contents correct, we can
1674 start writing to the file. */
1677 /* If *_frob_file changes the symbol value at this point, it is
1678 responsible for moving the changed value into symp->bsym->value
1679 as well. Hopefully all symbol value changing can be done in
1684 #ifdef obj_frob_file
1688 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1690 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1691 #endif /* BFD_ASSEMBLER */
1698 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1703 * After this, all frags in this segment have addresses that are correct
1704 * within the segment. Since segments live in different file addresses,
1705 * these frag addresses may not be the same as final object-file addresses.
1708 #ifndef md_relax_frag
1710 /* Subroutines of relax_segment. */
1716 for (; f1
; f1
= f1
->fr_next
)
1717 if (f1
->fr_next
== f2
)
1722 #endif /* ! defined (md_relax_frag) */
1724 /* Relax_align. Advance location counter to next address that has 'alignment'
1725 lowest order bits all 0s, return size of adjustment made. */
1726 static relax_addressT
1727 relax_align (address
, alignment
)
1728 register relax_addressT address
; /* Address now. */
1729 register int alignment
; /* Alignment (binary). */
1731 relax_addressT mask
;
1732 relax_addressT new_address
;
1734 mask
= ~((~0) << alignment
);
1735 new_address
= (address
+ mask
) & (~mask
);
1736 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1738 /* We must provide lots of padding, so the linker can discard it
1739 when needed. The linker will not add extra space, ever. */
1740 new_address
+= (1 << alignment
);
1742 return (new_address
- address
);
1746 relax_segment (segment_frag_root
, segment
)
1747 struct frag
*segment_frag_root
;
1750 register struct frag
*fragP
;
1751 register relax_addressT address
;
1752 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1753 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1755 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1756 subseg_change (segment
, 0);
1758 /* For each frag in segment: count and store (a 1st guess of)
1761 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1763 fragP
->fr_address
= address
;
1764 address
+= fragP
->fr_fix
;
1766 switch (fragP
->fr_type
)
1769 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1775 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1776 if (offset
% fragP
->fr_var
!= 0)
1778 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1779 offset
, (long) fragP
->fr_var
);
1780 offset
-= (offset
% fragP
->fr_var
);
1788 /* Assume .org is nugatory. It will grow with 1st relax. */
1791 case rs_machine_dependent
:
1792 address
+= md_estimate_size_before_relax (fragP
, segment
);
1795 #ifndef WORKING_DOT_WORD
1796 /* Broken words don't concern us yet */
1797 case rs_broken_word
:
1802 BAD_CASE (fragP
->fr_type
);
1804 } /* switch(fr_type) */
1805 } /* for each frag in the segment */
1809 long stretch
; /* May be any size, 0 or negative. */
1810 /* Cumulative number of addresses we have */
1811 /* relaxed this pass. */
1812 /* We may have relaxed more than one address. */
1813 long stretched
; /* Have we stretched on this pass? */
1814 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1815 grew, and another shrank. If a branch instruction doesn't fit anymore,
1816 we could be scrod. */
1820 stretch
= stretched
= 0;
1821 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1824 unsigned long was_address
;
1830 was_address
= fragP
->fr_address
;
1831 address
= fragP
->fr_address
+= stretch
;
1832 symbolP
= fragP
->fr_symbol
;
1833 offset
= fragP
->fr_offset
;
1835 switch (fragP
->fr_type
)
1837 case rs_fill
: /* .fill never relaxes. */
1841 #ifndef WORKING_DOT_WORD
1842 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1843 for it I do not want to write it. I do not want to have
1844 anything to do with it. This is not the proper way to
1845 implement this misfeature. */
1846 case rs_broken_word
:
1848 struct broken_word
*lie
;
1849 struct broken_word
*untruth
;
1851 /* Yes this is ugly (storing the broken_word pointer
1852 in the symbol slot). Still, this whole chunk of
1853 code is ugly, and I don't feel like doing anything
1854 about it. Think of it as stubbornness in action. */
1856 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1857 lie
&& lie
->dispfrag
== fragP
;
1858 lie
= lie
->next_broken_word
)
1864 offset
= (lie
->add
->sy_frag
->fr_address
1865 + S_GET_VALUE (lie
->add
)
1867 - (lie
->sub
->sy_frag
->fr_address
1868 + S_GET_VALUE (lie
->sub
)));
1869 if (offset
<= -32768 || offset
>= 32767)
1871 if (flag_warn_displacement
)
1874 sprint_value (buf
, (addressT
) lie
->addnum
);
1875 as_warn (".word %s-%s+%s didn't fit",
1876 S_GET_NAME (lie
->add
),
1877 S_GET_NAME (lie
->sub
),
1881 if (fragP
->fr_subtype
== 0)
1883 fragP
->fr_subtype
++;
1884 growth
+= md_short_jump_size
;
1886 for (untruth
= lie
->next_broken_word
;
1887 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1888 untruth
= untruth
->next_broken_word
)
1889 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1890 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1893 untruth
->use_jump
= lie
;
1895 growth
+= md_long_jump_size
;
1900 } /* case rs_broken_word */
1904 growth
= (relax_align ((relax_addressT
) (address
1907 - relax_align ((relax_addressT
) (was_address
1917 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1918 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1919 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1920 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1921 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1922 know (symbolP
->sy_frag
);
1923 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1924 || (symbolP
->sy_frag
== &zero_address_frag
));
1926 target
+= S_GET_VALUE (symbolP
)
1927 + symbolP
->sy_frag
->fr_address
;
1928 } /* if we have a symbol */
1930 know (fragP
->fr_next
);
1931 after
= fragP
->fr_next
->fr_address
;
1932 growth
= target
- after
;
1935 /* Growth may be negative, but variable part of frag
1936 cannot have fewer than 0 chars. That is, we can't
1938 as_bad ("attempt to .org backwards ignored");
1942 growth
-= stretch
; /* This is an absolute growth factor */
1948 growth
= S_GET_VALUE (symbolP
);
1949 if (symbolP
->sy_frag
!= &zero_address_frag
)
1950 as_bad (".space specifies non-absolute value");
1951 fragP
->fr_symbol
= 0;
1954 as_warn (".space or .fill with negative value, ignored");
1962 case rs_machine_dependent
:
1963 #ifdef md_relax_frag
1964 growth
= md_relax_frag (fragP
, stretch
);
1966 #ifdef TC_GENERIC_RELAX_TABLE
1967 /* The default way to relax a frag is to look through
1970 const relax_typeS
*this_type
;
1971 const relax_typeS
*start_type
;
1972 relax_substateT next_state
;
1973 relax_substateT this_state
;
1975 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1977 this_state
= fragP
->fr_subtype
;
1978 start_type
= this_type
= table
+ this_state
;
1983 #ifndef DIFF_EXPR_OK
1984 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1985 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1986 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1987 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1988 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1990 know (symbolP
->sy_frag
);
1992 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1993 || symbolP
->sy_frag
== &zero_address_frag
);
1995 S_GET_VALUE (symbolP
)
1996 + symbolP
->sy_frag
->fr_address
;
1998 /* If frag has yet to be reached on this pass,
1999 assume it will move by STRETCH just as we did.
2000 If this is not so, it will be because some frag
2001 between grows, and that will force another pass.
2003 Beware zero-length frags.
2005 There should be a faster way to do this. */
2007 if (symbolP
->sy_frag
->fr_address
>= was_address
2008 && is_dnrange (fragP
, symbolP
->sy_frag
))
2014 aim
= target
- address
- fragP
->fr_fix
;
2015 #ifdef TC_PCREL_ADJUST
2016 /* Currently only the ns32k family needs this */
2017 aim
+= TC_PCREL_ADJUST(fragP
);
2019 /* This machine doesn't want to use pcrel_adjust.
2020 In that case, pcrel_adjust should be zero. */
2021 assert (fragP
->fr_pcrel_adjust
== 0);
2026 /* Look backwards. */
2027 for (next_state
= this_type
->rlx_more
; next_state
;)
2028 if (aim
>= this_type
->rlx_backward
)
2032 /* Grow to next state. */
2033 this_state
= next_state
;
2034 this_type
= table
+ this_state
;
2035 next_state
= this_type
->rlx_more
;
2040 #ifdef M68K_AIM_KLUDGE
2041 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2043 /* Look forwards. */
2044 for (next_state
= this_type
->rlx_more
; next_state
;)
2045 if (aim
<= this_type
->rlx_forward
)
2049 /* Grow to next state. */
2050 this_state
= next_state
;
2051 this_type
= table
+ this_state
;
2052 next_state
= this_type
->rlx_more
;
2056 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2058 fragP
->fr_subtype
= this_state
;
2060 #endif /* TC_GENERIC_RELAX_TABLE */
2065 BAD_CASE (fragP
->fr_type
);
2073 } /* For each frag in the segment. */
2075 while (stretched
); /* Until nothing further to relax. */
2079 * We now have valid fr_address'es for each frag.
2083 * All fr_address's are correct, relative to their own segment.
2084 * We have made all the fixS we will ever make.
2086 } /* relax_segment() */
2088 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2090 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2091 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2096 Go through all the fixS's in a segment and see which ones can be
2097 handled now. (These consist of fixS where we have since discovered
2098 the value of a symbol, or the address of the frag involved.)
2099 For each one, call md_apply_fix to put the fix into the frag data.
2101 Result is a count of how many relocation structs will be needed to
2102 handle the remaining fixS's that we couldn't completely handle here.
2103 These will be output later by emit_relocations(). */
2106 fixup_segment (fixP
, this_segment_type
)
2107 register fixS
*fixP
;
2108 segT this_segment_type
; /* N_TYPE bits for segment. */
2110 long seg_reloc_count
= 0;
2111 symbolS
*add_symbolP
;
2112 symbolS
*sub_symbolP
;
2119 segT add_symbol_segment
= absolute_section
;
2121 /* If the linker is doing the relaxing, we must not do any fixups.
2123 Well, strictly speaking that's not true -- we could do any that are
2124 PC-relative and don't cross regions that could change size. And for the
2125 i960 (the only machine for which we've got a relaxing linker right now),
2126 we might be able to turn callx/callj into bal anyways in cases where we
2127 know the maximum displacement. */
2130 for (; fixP
; fixP
= fixP
->fx_next
)
2132 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2133 return seg_reloc_count
;
2136 for (; fixP
; fixP
= fixP
->fx_next
)
2139 fprintf (stderr
, "\nprocessing fixup:\n");
2143 fragP
= fixP
->fx_frag
;
2145 where
= fixP
->fx_where
;
2146 place
= fragP
->fr_literal
+ where
;
2147 size
= fixP
->fx_size
;
2148 add_symbolP
= fixP
->fx_addsy
;
2149 #ifdef TC_VALIDATE_FIX
2150 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2152 sub_symbolP
= fixP
->fx_subsy
;
2153 add_number
= fixP
->fx_offset
;
2154 pcrel
= fixP
->fx_pcrel
;
2158 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2162 resolve_symbol_value (sub_symbolP
);
2166 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2167 add_number
-= S_GET_VALUE (sub_symbolP
);
2169 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2171 /* Should try converting to a constant. */
2176 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2177 "Negative of non-absolute symbol %s",
2178 S_GET_NAME (sub_symbolP
));
2180 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2181 && (SEG_NORMAL (add_symbol_segment
)
2182 || (add_symbol_segment
== absolute_section
)))
2184 /* Difference of 2 symbols from same segment.
2185 Can't make difference of 2 undefineds: 'value' means
2186 something different for N_UNDF. */
2188 /* Makes no sense to use the difference of 2 arbitrary symbols
2189 as the target of a call instruction. */
2191 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2192 "callj to difference of 2 symbols");
2193 #endif /* TC_I960 */
2194 add_number
+= S_GET_VALUE (add_symbolP
) -
2195 S_GET_VALUE (sub_symbolP
);
2198 pcrel
= 0; /* No further pcrel processing. */
2200 /* Let the target machine make the final determination
2201 as to whether or not a relocation will be needed to
2202 handle this fixup. */
2203 if (!TC_FORCE_RELOCATION (fixP
))
2206 fixP
->fx_addsy
= NULL
;
2211 /* Different segments in subtraction. */
2212 know (!(S_IS_EXTERNAL (sub_symbolP
)
2213 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2215 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2216 add_number
-= S_GET_VALUE (sub_symbolP
);
2219 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2220 #if 0 /* Do this even if it's already described as pc-relative. For example,
2221 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2222 pc-relative mode. */
2227 /* Make it pc-relative. */
2228 add_number
+= (md_pcrel_from (fixP
)
2229 - S_GET_VALUE (sub_symbolP
));
2236 #ifdef UNDEFINED_DIFFERENCE_OK
2237 /* The PA needs this for PIC code generation. We basically
2238 don't want to do anything if we have the difference of two
2239 symbols at this point. */
2242 /* Leave it alone. */
2245 #ifdef BFD_ASSEMBLER
2246 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2247 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2249 /* Leave it alone. */
2255 sprint_value (buf
, fragP
->fr_address
+ where
);
2256 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2257 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2258 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2259 S_GET_NAME (sub_symbolP
), buf
);
2266 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2267 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2270 * This fixup was made when the symbol's segment was
2271 * SEG_UNKNOWN, but it is now in the local segment.
2272 * So we know how to do the address without relocation.
2275 /* reloc_callj() may replace a 'call' with a 'calls' or a
2276 'bal', in which cases it modifies *fixP as appropriate.
2277 In the case of a 'calls', no further work is required,
2278 and *fixP has been set up to make the rest of the code
2281 #endif /* TC_I960 */
2283 add_number
+= S_GET_VALUE (add_symbolP
);
2284 add_number
-= md_pcrel_from (fixP
);
2285 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2287 /* Let the target machine make the final determination
2288 as to whether or not a relocation will be needed to
2289 handle this fixup. */
2290 if (!TC_FORCE_RELOCATION (fixP
))
2293 fixP
->fx_addsy
= NULL
;
2298 if (add_symbol_segment
== absolute_section
)
2301 /* See comment about reloc_callj() above. */
2303 #endif /* TC_I960 */
2304 add_number
+= S_GET_VALUE (add_symbolP
);
2306 /* Let the target machine make the final determination
2307 as to whether or not a relocation will be needed to
2308 handle this fixup. */
2309 if (!TC_FORCE_RELOCATION (fixP
))
2311 fixP
->fx_addsy
= NULL
;
2315 else if (add_symbol_segment
== undefined_section
2316 #ifdef BFD_ASSEMBLER
2317 || bfd_is_com_section (add_symbol_segment
)
2322 if ((int) fixP
->fx_bit_fixP
== 13)
2324 /* This is a COBR instruction. They have only a
2325 * 13-bit displacement and are only to be used
2326 * for local branches: flag as error, don't generate
2329 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2330 "can't use COBR format with external label");
2331 fixP
->fx_addsy
= NULL
;
2335 #endif /* TC_I960 */
2339 if (S_IS_COMMON (add_symbolP
))
2340 add_number
+= S_GET_VALUE (add_symbolP
);
2341 #endif /* TE_I386AIX */
2342 #endif /* OBJ_COFF */
2348 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2349 add_number
+= S_GET_VALUE (add_symbolP
);
2357 add_number
-= md_pcrel_from (fixP
);
2358 if (add_symbolP
== 0)
2360 #ifndef BFD_ASSEMBLER
2361 fixP
->fx_addsy
= &abs_symbol
;
2363 fixP
->fx_addsy
= section_symbol (absolute_section
);
2365 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2370 if (!fixP
->fx_bit_fixP
&& size
> 0)
2373 if (size
< sizeof (mask
))
2375 /* set all bits to one */
2377 /* Technically, combining these produces an undefined result
2378 if size is sizeof (valueT), though I think these two
2379 half-way operations should both be defined. And the
2380 compiler should be able to combine them if it's valid on
2381 the host architecture. */
2384 if ((add_number
& mask
) != 0
2385 && (add_number
& mask
) != mask
)
2387 char buf
[50], buf2
[50];
2388 sprint_value (buf
, fragP
->fr_address
+ where
);
2389 if (add_number
> 1000)
2390 sprint_value (buf2
, add_number
);
2392 sprintf (buf2
, "%ld", (long) add_number
);
2393 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2394 "Value of %s too large for field of %d bytes at %s",
2396 } /* generic error checking */
2398 #ifdef WARN_SIGNED_OVERFLOW_WORD
2399 /* Warn if a .word value is too large when treated as a signed
2400 number. We already know it is not too negative. This is to
2401 catch over-large switches generated by gcc on the 68k. */
2402 if (!flag_signed_overflow_ok
2404 && add_number
> 0x7fff)
2405 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2406 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2408 (unsigned long) (fragP
->fr_address
+ where
));
2410 } /* not a bit fix */
2414 #ifdef MD_APPLY_FIX3
2415 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2417 #ifdef BFD_ASSEMBLER
2418 md_apply_fix (fixP
, &add_number
);
2420 md_apply_fix (fixP
, add_number
);
2424 #ifndef TC_HANDLES_FX_DONE
2425 /* If the tc-* files haven't been converted, assume it's handling
2426 it the old way, where a null fx_addsy means that the fix has
2427 been applied completely, and no further work is needed. */
2428 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2432 #ifdef TC_VALIDATE_FIX
2436 fprintf (stderr
, "result:\n");
2439 } /* For each fixS in this segment. */
2441 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2442 return seg_reloc_count
;
2445 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2448 number_to_chars_bigendian (buf
, val
, n
)
2453 if (n
> sizeof (val
)|| n
<= 0)
2457 buf
[n
] = val
& 0xff;
2463 number_to_chars_littleendian (buf
, val
, n
)
2468 if (n
> sizeof (val
) || n
<= 0)
2472 *buf
++ = val
& 0xff;
2478 extern int indent_level
;
2479 extern void print_symbol_value_1 ();
2486 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2488 fprintf (stderr
, " pcrel");
2489 if (fixp
->fx_pcrel_adjust
)
2490 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2491 if (fixp
->fx_im_disp
)
2494 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2496 fprintf (stderr
, " im_disp");
2500 fprintf (stderr
, " tcbit");
2502 fprintf (stderr
, " done");
2503 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2504 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2505 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2506 #ifdef BFD_ASSEMBLER
2507 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2510 #ifdef NEED_FX_R_TYPE
2511 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2516 fprintf (stderr
, "\n +<");
2517 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2518 fprintf (stderr
, ">");
2522 fprintf (stderr
, "\n -<");
2523 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2524 fprintf (stderr
, ">");
2526 fprintf (stderr
, "\n");
2529 /* end of write.c */