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 /* We've made fx_size a narrow field; check that it's wide enough. */
134 if (fixP
->fx_size
!= size
)
136 as_bad ("field fx_size too small to hold %d", size
);
139 fixP
->fx_addsy
= add_symbol
;
140 fixP
->fx_subsy
= sub_symbol
;
141 fixP
->fx_offset
= offset
;
142 fixP
->fx_pcrel
= pcrel
;
144 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
145 fixP
->fx_r_type
= r_type
;
147 fixP
->fx_im_disp
= 0;
148 fixP
->fx_pcrel_adjust
= 0;
149 fixP
->fx_bit_fixP
= 0;
150 fixP
->fx_addnumber
= 0;
155 TC_INIT_FIX_DATA(fixP
);
158 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
160 /* Usually, we want relocs sorted numerically, but while
161 comparing to older versions of gas that have relocs
162 reverse sorted, it is convenient to have this compile
163 time option. xoxorich. */
168 fixS
**seg_fix_rootP
= (frags_chained
169 ? &seg_info (now_seg
)->fix_root
170 : &frchain_now
->fix_root
);
171 fixS
**seg_fix_tailP
= (frags_chained
172 ? &seg_info (now_seg
)->fix_tail
173 : &frchain_now
->fix_tail
);
176 #ifdef REVERSE_SORT_RELOCS
178 fixP
->fx_next
= *seg_fix_rootP
;
179 *seg_fix_rootP
= fixP
;
181 #else /* REVERSE_SORT_RELOCS */
183 fixP
->fx_next
= NULL
;
186 (*seg_fix_tailP
)->fx_next
= fixP
;
188 *seg_fix_rootP
= fixP
;
189 *seg_fix_tailP
= fixP
;
191 #endif /* REVERSE_SORT_RELOCS */
198 /* Create a fixup relative to a symbol (plus a constant). */
201 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
202 fragS
*frag
; /* Which frag? */
203 int where
; /* Where in that frag? */
204 int size
; /* 1, 2, or 4 usually. */
205 symbolS
*add_symbol
; /* X_add_symbol. */
206 offsetT offset
; /* X_add_number. */
207 int pcrel
; /* TRUE if PC-relative relocation. */
209 bfd_reloc_code_real_type r_type
; /* Relocation type */
211 int r_type
; /* Relocation type */
214 return fix_new_internal (frag
, where
, size
, add_symbol
,
215 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
218 /* Create a fixup for an expression. Currently we only support fixups
219 for difference expressions. That is itself more than most object
220 file formats support anyhow. */
223 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
224 fragS
*frag
; /* Which frag? */
225 int where
; /* Where in that frag? */
226 int size
; /* 1, 2, or 4 usually. */
227 expressionS
*exp
; /* Expression. */
228 int pcrel
; /* TRUE if PC-relative relocation. */
230 bfd_reloc_code_real_type r_type
; /* Relocation type */
232 int r_type
; /* Relocation type */
245 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
246 the difference expression cannot immediately be reduced. */
248 extern symbolS
*make_expr_symbol ();
249 symbolS
*stmp
= make_expr_symbol (exp
);
250 exp
->X_op
= O_symbol
;
251 exp
->X_op_symbol
= 0;
252 exp
->X_add_symbol
= stmp
;
253 exp
->X_add_number
= 0;
254 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
258 sub
= exp
->X_add_symbol
;
259 off
= exp
->X_add_number
;
263 sub
= exp
->X_op_symbol
;
266 add
= exp
->X_add_symbol
;
269 off
= exp
->X_add_number
;
273 as_bad ("expression too complex for fixup");
276 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
280 /* Append a string onto another string, bumping the pointer along. */
282 append (charPP
, fromP
, length
)
285 unsigned long length
;
287 /* Don't trust memcpy() of 0 chars. */
291 memcpy (*charPP
, fromP
, length
);
295 #ifndef BFD_ASSEMBLER
296 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
300 * This routine records the largest alignment seen for each segment.
301 * If the beginning of the segment is aligned on the worst-case
302 * boundary, all of the other alignments within it will work. At
303 * least one object format really uses this info.
306 record_alignment (seg
, align
)
307 /* Segment to which alignment pertains */
309 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
313 if (seg
== absolute_section
)
316 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
317 bfd_set_section_alignment (stdoutput
, seg
, align
);
319 if (align
> section_alignment
[(int) seg
])
320 section_alignment
[(int) seg
] = align
;
326 /* Reset the section indices after removing the gas created sections. */
329 renumber_sections (abfd
, sec
, countparg
)
334 int *countp
= (int *) countparg
;
336 sec
->index
= *countp
;
340 #endif /* defined (BFD_ASSEMBLER) */
342 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
345 chain_frchains_together_1 (section
, frchp
)
347 struct frchain
*frchp
;
349 fragS dummy
, *prev_frag
= &dummy
;
351 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
354 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
356 prev_frag
->fr_next
= frchp
->frch_root
;
357 prev_frag
= frchp
->frch_last
;
359 if (frchp
->fix_root
!= (fixS
*) NULL
)
361 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
362 seg_info (section
)->fix_root
= frchp
->fix_root
;
363 prev_fix
->fx_next
= frchp
->fix_root
;
364 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
365 prev_fix
= frchp
->fix_tail
;
369 prev_frag
->fr_next
= 0;
378 chain_frchains_together (abfd
, section
, xxx
)
379 bfd
*abfd
; /* unused */
381 PTR xxx
; /* unused */
383 segment_info_type
*info
;
385 /* BFD may have introduced its own sections without using
386 subseg_new, so it is possible that seg_info is NULL. */
387 info
= seg_info (section
);
388 if (info
!= (segment_info_type
*) NULL
)
389 info
->frchainP
->frch_last
390 = chain_frchains_together_1 (section
, info
->frchainP
);
392 /* Now that we've chained the frags together, we must add new fixups
393 to the segment, not to the frag chain. */
399 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
402 remove_subsegs (head
, seg
, root
, last
)
408 *root
= head
->frch_root
;
409 *last
= chain_frchains_together_1 (seg
, head
);
414 #if defined (BFD_ASSEMBLER) || !defined (BFD)
418 cvt_frag_to_fill (sec
, fragP
)
423 cvt_frag_to_fill (headersP
, sec
, fragP
)
424 object_headers
*headersP
;
429 switch (fragP
->fr_type
)
436 HANDLE_ALIGN (fragP
);
438 know (fragP
->fr_next
!= NULL
);
439 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
441 - fragP
->fr_fix
) / fragP
->fr_var
;
442 if (fragP
->fr_offset
< 0)
444 as_bad ("attempt to .org/.space backwards? (%ld)",
445 (long) fragP
->fr_offset
);
447 fragP
->fr_type
= rs_fill
;
453 case rs_machine_dependent
:
455 md_convert_frag (stdoutput
, sec
, fragP
);
457 md_convert_frag (headersP
, sec
, fragP
);
460 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
463 * After md_convert_frag, we make the frag into a ".space 0".
464 * Md_convert_frag() should set up any fixSs and constants
470 #ifndef WORKING_DOT_WORD
473 struct broken_word
*lie
;
475 if (fragP
->fr_subtype
)
477 fragP
->fr_fix
+= md_short_jump_size
;
478 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
479 lie
&& lie
->dispfrag
== fragP
;
480 lie
= lie
->next_broken_word
)
482 fragP
->fr_fix
+= md_long_jump_size
;
490 BAD_CASE (fragP
->fr_type
);
495 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
499 relax_and_size_seg (abfd
, sec
, xxx
)
506 segment_info_type
*seginfo
;
508 valueT size
, newsize
;
510 subseg_change (sec
, 0);
512 flags
= bfd_get_section_flags (abfd
, sec
);
514 seginfo
= seg_info (sec
);
515 if (seginfo
&& seginfo
->frchainP
)
517 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
518 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
519 cvt_frag_to_fill (sec
, fragp
);
520 for (fragp
= seginfo
->frchainP
->frch_root
;
522 fragp
= fragp
->fr_next
)
523 /* walk to last elt */;
524 size
= fragp
->fr_address
+ fragp
->fr_fix
;
529 if (size
> 0 && ! seginfo
->bss
)
530 flags
|= SEC_HAS_CONTENTS
;
532 /* @@ This is just an approximation. */
533 if (seginfo
&& seginfo
->fix_root
)
537 x
= bfd_set_section_flags (abfd
, sec
, flags
);
540 newsize
= md_section_align (sec
, size
);
541 x
= bfd_set_section_size (abfd
, sec
, newsize
);
544 /* If the size had to be rounded up, add some padding in the last
546 assert (newsize
>= size
);
549 fragS
*last
= seginfo
->frchainP
->frch_last
;
550 fragp
= seginfo
->frchainP
->frch_root
;
551 while (fragp
->fr_next
!= last
)
552 fragp
= fragp
->fr_next
;
553 last
->fr_address
= size
;
554 fragp
->fr_offset
+= newsize
- size
;
557 #ifdef tc_frob_section
558 tc_frob_section (sec
);
560 #ifdef obj_frob_section
561 obj_frob_section (sec
);
567 dump_section_relocs (abfd
, sec
, stream_
)
572 FILE *stream
= (FILE *) stream_
;
573 segment_info_type
*seginfo
= seg_info (sec
);
574 fixS
*fixp
= seginfo
->fix_root
;
579 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
582 symbolS
*s
= fixp
->fx_addsy
;
585 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
586 s
->bsym
->section
->name
);
587 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
589 fprintf (stream
, " section sym");
591 fprintf (stream
, "+%x", S_GET_VALUE (s
));
594 fprintf (stream
, "+%x", S_GET_VALUE (s
));
595 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
598 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
599 fixp
= fixp
->fx_next
;
603 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
606 #ifndef EMIT_SECTION_SYMBOLS
607 #define EMIT_SECTION_SYMBOLS 1
611 adjust_reloc_syms (abfd
, sec
, xxx
)
616 segment_info_type
*seginfo
= seg_info (sec
);
622 dump_section_relocs (abfd
, sec
, stderr
);
624 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
627 else if (fixp
->fx_addsy
)
635 fprintf (stderr
, "\n\nadjusting fixup:\n");
639 sym
= fixp
->fx_addsy
;
640 symsec
= sym
->bsym
->section
;
642 if (sym
!= NULL
&& sym
->sy_mri_common
)
644 /* These symbols are handled specially in fixup_segment. */
648 /* If it's one of these sections, assume the symbol is
649 definitely going to be output. The code in
650 md_estimate_size_before_relax in tc-mips.c uses this test
651 as well, so if you change this code you should look at that
653 if (bfd_is_und_section (symsec
)
654 || bfd_is_abs_section (symsec
)
655 || bfd_is_com_section (symsec
))
657 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
658 #ifdef UNDEFINED_DIFFERENCE_OK
659 /* We have the difference of an undefined symbol and some
660 other symbol. Make sure to mark the other symbol as used
661 in a relocation so that it will always be output. */
663 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
668 /* Since we're reducing to section symbols, don't attempt to reduce
669 anything that's already using one. */
670 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
672 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
676 /* Is there some other reason we can't adjust this one? (E.g.,
677 call/bal links in i960-bout symbols.) */
678 #ifdef obj_fix_adjustable
679 if (! obj_fix_adjustable (fixp
))
681 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
686 /* Is there some other (target cpu dependent) reason we can't adjust
687 this one? (E.g. relocations involving function addresses on
689 #ifdef tc_fix_adjustable
690 if (! tc_fix_adjustable (fixp
))
692 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
697 /* For PIC support: We may get expressions like
698 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
699 necessarily have had a fixed difference initially. But now
700 it should be a known constant, so we can reduce it. Since
701 we can't easily handle a symbol value that looks like
702 someUndefinedSymbol+const, though, we convert the fixup to
703 access the undefined symbol directly, and discard the
704 intermediate symbol. */
705 if (S_GET_SEGMENT (sym
) == expr_section
706 && sym
->sy_value
.X_op
== O_add
707 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
708 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
709 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
710 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
712 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
713 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
714 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
718 /* If the section symbol isn't going to be output, the relocs
719 at least should still work. If not, figure out what to do
720 when we run into that case. */
721 fixp
->fx_offset
+= S_GET_VALUE (sym
);
722 fixp
->fx_addsy
= section_symbol (symsec
);
723 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
728 #if 1/*def RELOC_REQUIRES_SYMBOL*/
731 /* There was no symbol required by this relocation. However,
732 BFD doesn't really handle relocations without symbols well.
733 (At least, the COFF support doesn't.) So for now we fake up
734 a local symbol in the absolute section. */
736 fixp
->fx_addsy
= section_symbol (absolute_section
);
737 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
741 dump_section_relocs (abfd
, sec
, stderr
);
745 write_relocs (abfd
, sec
, xxx
)
750 segment_info_type
*seginfo
= seg_info (sec
);
757 /* If seginfo is NULL, we did not create this section; don't do
762 fixup_segment (seginfo
->fix_root
, sec
);
765 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
768 #ifndef RELOC_EXPANSION_POSSIBLE
769 /* Set up reloc information as well. */
770 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
771 n
* sizeof (arelent
*));
772 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
775 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
778 bfd_reloc_status_type s
;
785 reloc
= tc_gen_reloc (sec
, fixp
);
791 if (fixp
->fx_where
+ fixp
->fx_size
792 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
795 s
= bfd_install_relocation (stdoutput
, reloc
,
796 fixp
->fx_frag
->fr_literal
,
797 fixp
->fx_frag
->fr_address
,
803 case bfd_reloc_overflow
:
804 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
807 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
808 fixp
->fx_file
, fixp
->fx_line
);
813 n
= n
* MAX_RELOC_EXPANSION
;
814 /* Set up reloc information as well. */
815 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
816 n
* sizeof (arelent
*));
819 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
823 bfd_reloc_status_type s
;
831 reloc
= tc_gen_reloc (sec
, fixp
);
833 for (j
= 0; reloc
[j
]; j
++)
835 relocs
[i
++] = reloc
[j
];
838 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
839 if (fixp
->fx_where
+ fixp
->fx_size
840 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
842 for (j
= 0; reloc
[j
]; j
++)
844 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
845 fixp
->fx_frag
->fr_literal
,
846 fixp
->fx_frag
->fr_address
,
852 case bfd_reloc_overflow
:
853 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
854 "relocation overflow");
857 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
858 fixp
->fx_file
, fixp
->fx_line
);
869 sympp
= bfd_get_outsymbols (stdoutput
);
870 nsyms
= bfd_get_symcount (stdoutput
);
871 for (i
= 0; i
< n
; i
++)
872 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
874 for (j
= 0; j
< nsyms
; j
++)
875 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
884 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
886 bfd_set_section_flags (abfd
, sec
,
887 (bfd_get_section_flags (abfd
, sec
)
888 & (flagword
) ~SEC_RELOC
));
895 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
896 for (i
= 0; i
< n
; i
++)
900 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
901 i
, r
, r
->address
, s
->name
, r
->addend
);
908 write_contents (abfd
, sec
, xxx
)
913 segment_info_type
*seginfo
= seg_info (sec
);
914 unsigned long offset
= 0;
917 /* Write out the frags. */
919 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
922 for (f
= seginfo
->frchainP
->frch_root
;
927 unsigned long fill_size
;
931 assert (f
->fr_type
== rs_fill
);
934 x
= bfd_set_section_contents (stdoutput
, sec
,
935 f
->fr_literal
, (file_ptr
) offset
,
936 (bfd_size_type
) f
->fr_fix
);
939 bfd_perror (stdoutput
->filename
);
940 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
945 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
946 fill_size
= f
->fr_var
;
947 count
= f
->fr_offset
;
949 if (fill_size
&& count
)
952 if (fill_size
> sizeof(buf
))
954 /* Do it the old way. Can this ever happen? */
957 x
= bfd_set_section_contents (stdoutput
, sec
,
960 (bfd_size_type
) fill_size
);
963 bfd_perror (stdoutput
->filename
);
964 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
972 /* Build a buffer full of fill objects and output it as
973 often as necessary. This saves on the overhead of
974 potentially lots of bfd_set_section_contents calls. */
978 n_per_buf
= sizeof (buf
);
979 memset (buf
, *fill_literal
, n_per_buf
);
984 n_per_buf
= sizeof(buf
)/fill_size
;
985 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
986 memcpy(bufp
, fill_literal
, fill_size
);
988 for (; count
> 0; count
-= n_per_buf
)
990 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
991 x
= bfd_set_section_contents (stdoutput
, sec
,
992 buf
, (file_ptr
) offset
,
993 (bfd_size_type
) n_per_buf
* fill_size
);
995 as_fatal ("Cannot write to output file.");
996 offset
+= n_per_buf
* fill_size
;
1004 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1006 merge_data_into_text ()
1008 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1009 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1010 seg_info (data_section
)->frchainP
->frch_root
;
1011 seg_info (text_section
)->frchainP
->frch_last
=
1012 seg_info (data_section
)->frchainP
->frch_last
;
1013 seg_info (data_section
)->frchainP
= 0;
1017 text_last_frag
->fr_next
= data_frag_root
;
1018 text_last_frag
= data_last_frag
;
1019 data_last_frag
= NULL
;
1020 data_frag_root
= NULL
;
1023 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1024 tmp
->fx_next
= data_fix_root
;
1025 text_fix_tail
= data_fix_tail
;
1028 text_fix_root
= data_fix_root
;
1029 data_fix_root
= NULL
;
1032 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1034 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1036 relax_and_size_all_segments ()
1040 relax_segment (text_frag_root
, SEG_TEXT
);
1041 relax_segment (data_frag_root
, SEG_DATA
);
1042 relax_segment (bss_frag_root
, SEG_BSS
);
1044 * Now the addresses of frags are correct within the segment.
1047 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1048 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1049 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1052 * Join the 2 segments into 1 huge segment.
1053 * To do this, re-compute every rn_address in the SEG_DATA frags.
1054 * Then join the data frags after the text frags.
1056 * Determine a_data [length of data segment].
1060 register relax_addressT slide
;
1062 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1064 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1065 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1066 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1068 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1069 /* For b.out: If the data section has a strict alignment
1070 requirement, its load address in the .o file will be
1071 rounded up from the size of the text section. These
1072 two values are *not* the same! Similarly for the bss
1074 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1077 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1079 fragP
->fr_address
+= slide
;
1080 } /* for each data frag */
1082 know (text_last_frag
!= 0);
1083 text_last_frag
->fr_next
= data_frag_root
;
1087 H_SET_DATA_SIZE (&headers
, 0);
1091 /* See above comments on b.out data section address. */
1094 if (data_last_frag
== 0)
1095 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1097 bss_vma
= data_last_frag
->fr_address
;
1098 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1099 bss_address_frag
.fr_address
= bss_vma
;
1101 #else /* ! OBJ_BOUT */
1102 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1103 H_GET_DATA_SIZE (&headers
));
1105 #endif /* ! OBJ_BOUT */
1107 /* Slide all the frags */
1110 relax_addressT slide
= bss_address_frag
.fr_address
;
1112 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1114 fragP
->fr_address
+= slide
;
1115 } /* for each bss frag */
1119 H_SET_BSS_SIZE (&headers
,
1120 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1122 H_SET_BSS_SIZE (&headers
, 0);
1124 #endif /* ! BFD_ASSEMBLER && ! BFD */
1126 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1128 #ifdef BFD_ASSEMBLER
1136 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1138 /* Count symbols. We can't rely on a count made by the loop in
1139 write_object_file, because *_frob_file may add a new symbol or
1142 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1149 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1150 nsyms
* sizeof (asymbol
*));
1151 symp
= symbol_rootP
;
1152 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1154 asympp
[i
] = symp
->bsym
;
1160 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1161 assert (result
== true);
1162 symbol_table_frozen
= 1;
1167 write_object_file ()
1169 struct frchain
*frchainP
; /* Track along all frchains. */
1170 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1171 fragS
*fragP
; /* Track along all frags. */
1174 /* Do we really want to write it? */
1176 int n_warns
, n_errs
;
1177 n_warns
= had_warnings ();
1178 n_errs
= had_errors ();
1179 /* The -Z flag indicates that an object file should be generated,
1180 regardless of warnings and errors. */
1181 if (flag_always_generate_output
)
1183 if (n_warns
|| n_errs
)
1184 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1185 n_errs
, n_errs
== 1 ? "" : "s",
1186 n_warns
, n_warns
== 1 ? "" : "s");
1191 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1192 n_errs
, n_errs
== 1 ? "" : "s",
1193 n_warns
, n_warns
== 1 ? "" : "s");
1198 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1199 a routine to check for the definition of the procedure "_main",
1200 and if so -- fix it up so that it can be program entry point. */
1201 vms_check_for_main ();
1202 #endif /* OBJ_VMS */
1204 /* After every sub-segment, we fake an ".align ...". This conforms to
1205 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1206 frag that requires least thought. ".align" frags like to have a
1207 following frag since that makes calculating their intended length
1210 @@ Is this really necessary?? */
1211 #ifndef SUB_SEGMENT_ALIGN
1212 #ifdef BFD_ASSEMBLER
1213 #define SUB_SEGMENT_ALIGN(SEG) (0)
1215 #define SUB_SEGMENT_ALIGN(SEG) (2)
1218 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1220 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1221 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1222 /* frag_align will have left a new frag.
1223 Use this last frag for an empty ".fill".
1225 For this segment ...
1226 Create a last frag. Do not leave a "being filled in frag". */
1227 frag_wane (frag_now
);
1228 frag_now
->fr_fix
= 0;
1229 know (frag_now
->fr_next
== NULL
);
1232 /* From now on, we don't care about sub-segments. Build one frag chain
1233 for each segment. Linked thru fr_next. */
1235 #ifdef BFD_ASSEMBLER
1236 /* Remove the sections created by gas for its own purposes. */
1238 asection
**seclist
, *sec
;
1241 seclist
= &stdoutput
->sections
;
1242 while (seclist
&& *seclist
)
1245 while (sec
== reg_section
|| sec
== expr_section
)
1249 stdoutput
->section_count
--;
1254 seclist
= &(*seclist
)->next
;
1257 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1260 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1262 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1263 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1264 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1267 /* We have two segments. If user gave -R flag, then we must put the
1268 data frags into the text segment. Do this before relaxing so
1269 we know to take advantage of -R and make shorter addresses. */
1270 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1271 if (flag_readonly_data_in_text
)
1273 merge_data_into_text ();
1277 #ifdef BFD_ASSEMBLER
1278 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1280 relax_and_size_all_segments ();
1281 #endif /* BFD_ASSEMBLER */
1283 #ifndef BFD_ASSEMBLER
1286 * Crawl the symbol chain.
1288 * For each symbol whose value depends on a frag, take the address of
1289 * that frag and subsume it into the value of the symbol.
1290 * After this, there is just one way to lookup a symbol value.
1291 * Values are left in their final state for object file emission.
1292 * We adjust the values of 'L' local symbols, even if we do
1293 * not intend to emit them to the object file, because their values
1294 * are needed for fix-ups.
1296 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1297 * from the symbol chain. (They are still pointed to by the fixes.)
1299 * Count the remaining symbols.
1300 * Assign a symbol number to each symbol.
1301 * Count the number of string-table chars we will emit.
1302 * Put this info into the headers as appropriate.
1305 know (zero_address_frag
.fr_address
== 0);
1306 string_byte_count
= sizeof (string_byte_count
);
1308 obj_crawl_symbol_chain (&headers
);
1310 if (string_byte_count
== sizeof (string_byte_count
))
1311 string_byte_count
= 0;
1313 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1316 * Addresses of frags now reflect addresses we use in the object file.
1317 * Symbol values are correct.
1318 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1319 * Also converting any machine-dependent frags using md_convert_frag();
1321 subseg_change (SEG_TEXT
, 0);
1323 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1325 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1327 /* Some assert macros don't work with # directives mixed in. */
1329 if (!(fragP
->fr_next
== NULL
1331 || fragP
->fr_next
== data_frag_root
1333 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1334 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1338 #endif /* ! BFD_ASSEMBLER */
1340 #ifndef WORKING_DOT_WORD
1342 struct broken_word
*lie
;
1343 struct broken_word
**prevP
;
1345 prevP
= &broken_words
;
1346 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1351 exp
.X_op
= O_subtract
;
1352 exp
.X_add_symbol
= lie
->add
;
1353 exp
.X_op_symbol
= lie
->sub
;
1354 exp
.X_add_number
= lie
->addnum
;
1355 #ifdef BFD_ASSEMBLER
1356 #ifdef TC_CONS_FIX_NEW
1357 TC_CONS_FIX_NEW (lie
->frag
,
1358 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1361 fix_new_exp (lie
->frag
,
1362 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1363 2, &exp
, 0, BFD_RELOC_NONE
);
1366 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1367 fix_new_exp (lie
->frag
,
1368 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1369 2, &exp
, 0, NO_RELOC
);
1372 fix_new_ns32k_exp (lie
->frag
,
1373 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1374 2, &exp
, 0, 0, 2, 0, 0);
1376 fix_new_exp (lie
->frag
,
1377 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1379 #endif /* TC_NS32K */
1380 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1381 #endif /* BFD_ASSEMBLER */
1382 *prevP
= lie
->next_broken_word
;
1385 prevP
= &(lie
->next_broken_word
);
1387 for (lie
= broken_words
; lie
;)
1389 struct broken_word
*untruth
;
1391 addressT table_addr
;
1392 addressT from_addr
, to_addr
;
1395 fragP
= lie
->dispfrag
;
1397 /* Find out how many broken_words go here. */
1399 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1400 if (untruth
->added
== 1)
1403 table_ptr
= lie
->dispfrag
->fr_opcode
;
1404 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1405 /* Create the jump around the long jumps. This is a short
1406 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1407 from_addr
= table_addr
;
1408 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1409 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1410 table_ptr
+= md_short_jump_size
;
1411 table_addr
+= md_short_jump_size
;
1413 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1415 if (lie
->added
== 2)
1417 /* Patch the jump table */
1418 /* This is the offset from ??? to table_ptr+0 */
1419 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1420 #ifdef BFD_ASSEMBLER
1421 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1423 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1424 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1426 if (untruth
->use_jump
== lie
)
1427 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1430 /* Install the long jump */
1431 /* this is a long jump from table_ptr+0 to the final target */
1432 from_addr
= table_addr
;
1433 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1434 #ifdef BFD_ASSEMBLER
1435 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1437 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1438 table_ptr
+= md_long_jump_size
;
1439 table_addr
+= md_long_jump_size
;
1443 #endif /* not WORKING_DOT_WORD */
1445 #ifndef BFD_ASSEMBLER
1448 char *the_object_file
;
1449 long object_file_size
;
1451 * Scan every FixS performing fixups. We had to wait until now to do
1452 * this because md_convert_frag() may have made some fixSs.
1456 subseg_change (SEG_TEXT
, 0);
1457 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1458 subseg_change (SEG_DATA
, 0);
1459 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1460 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1462 /* FIXME move this stuff into the pre-write-hook */
1463 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1464 H_SET_ENTRY_POINT (&headers
, 0);
1466 obj_pre_write_hook (&headers
); /* extra coff stuff */
1468 object_file_size
= H_GET_FILE_SIZE (&headers
);
1469 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1471 output_file_create (out_file_name
);
1473 obj_header_append (&next_object_file_charP
, &headers
);
1475 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1480 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1482 register long count
;
1483 register char *fill_literal
;
1484 register long fill_size
;
1487 know (fragP
->fr_type
== rs_fill
);
1488 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1489 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1490 fill_size
= fragP
->fr_var
;
1491 know (fragP
->fr_offset
>= 0);
1493 for (count
= fragP
->fr_offset
; count
; count
--)
1495 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1498 } /* for each code frag. */
1500 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1505 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1506 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
)));
1508 /* Make addresses in data relocation directives relative to beginning of
1509 * first data fragment, not end of last text fragment: alignment of the
1510 * start of the data segment may place a gap between the segments.
1512 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1514 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1515 #endif /* TC_I960 */
1517 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
)));
1520 * Emit line number entries.
1522 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1523 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
)));
1528 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1529 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
)));
1535 if (string_byte_count
> 0)
1537 obj_emit_strings (&next_object_file_charP
);
1538 } /* only if we have a string table */
1541 bfd_seek (stdoutput
, 0, 0);
1542 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1545 /* Write the data to the file */
1546 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1547 free (the_object_file
);
1549 } /* non vms output */
1552 * Now do the VMS-dependent part of writing the object file
1554 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1555 H_GET_DATA_SIZE (&headers
),
1556 H_GET_BSS_SIZE (&headers
),
1557 text_frag_root
, data_frag_root
);
1558 #endif /* OBJ_VMS */
1559 #else /* BFD_ASSEMBLER */
1561 /* Resolve symbol values. This needs to be done before processing
1567 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1568 if (!symp
->sy_resolved
)
1569 resolve_symbol_value (symp
);
1574 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1576 /* Set up symbol table, and write it out. */
1581 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1586 if (symp
->sy_mri_common
)
1588 if (S_IS_EXTERNAL (symp
))
1589 as_bad ("%s: global symbols not supported in common sections",
1591 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1595 name
= S_GET_NAME (symp
);
1598 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1599 /* They only differ if `name' is a fb or dollar local
1601 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1602 as_bad ("local label %s is not defined", name2
);
1605 /* Do it again, because adjust_reloc_syms might introduce
1606 more symbols. They'll probably only be section symbols,
1607 but they'll still need to have the values computed. */
1608 if (! symp
->sy_resolved
)
1610 if (symp
->sy_value
.X_op
== O_constant
)
1612 /* This is the normal case; skip the call. */
1615 + symp
->sy_frag
->fr_address
));
1616 symp
->sy_resolved
= 1;
1619 resolve_symbol_value (symp
);
1622 /* So far, common symbols have been treated like undefined symbols.
1623 Put them in the common section now. */
1624 if (S_IS_DEFINED (symp
) == 0
1625 && S_GET_VALUE (symp
) != 0)
1626 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1628 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1629 S_GET_NAME (symp
), symp
,
1632 segment_name (symp
->bsym
->section
));
1635 #ifdef obj_frob_symbol
1636 obj_frob_symbol (symp
, punt
);
1638 #ifdef tc_frob_symbol
1639 if (! punt
|| symp
->sy_used_in_reloc
)
1640 tc_frob_symbol (symp
, punt
);
1643 /* If we don't want to keep this symbol, splice it out of
1644 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1645 want section symbols. Otherwise, we skip local symbols
1646 and symbols that the frob_symbol macros told us to punt,
1647 but we keep such symbols if they are used in relocs. */
1648 if ((! EMIT_SECTION_SYMBOLS
1649 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1650 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1651 opposites. Sometimes the former checks flags and the
1652 latter examines the name... */
1653 || (!S_IS_EXTERN (symp
)
1654 && (S_IS_LOCAL (symp
) || punt
)
1655 && ! symp
->sy_used_in_reloc
))
1657 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1658 /* After symbol_remove, symbol_next(symp) still returns
1659 the one that came after it in the chain. So we don't
1660 need to do any extra cleanup work here. */
1665 /* Make sure we really got a value for the symbol. */
1666 if (! symp
->sy_resolved
)
1668 as_bad ("can't resolve value for symbol \"%s\"",
1670 symp
->sy_resolved
= 1;
1673 /* Set the value into the BFD symbol. Up til now the value
1674 has only been kept in the gas symbolS struct. */
1675 symp
->bsym
->value
= S_GET_VALUE (symp
);
1681 /* Now do any format-specific adjustments to the symbol table, such
1682 as adding file symbols. */
1683 #ifdef obj_adjust_symtab
1684 obj_adjust_symtab ();
1687 /* Now that all the sizes are known, and contents correct, we can
1688 start writing to the file. */
1691 /* If *_frob_file changes the symbol value at this point, it is
1692 responsible for moving the changed value into symp->bsym->value
1693 as well. Hopefully all symbol value changing can be done in
1698 #ifdef obj_frob_file
1702 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1704 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1705 #endif /* BFD_ASSEMBLER */
1712 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1717 * After this, all frags in this segment have addresses that are correct
1718 * within the segment. Since segments live in different file addresses,
1719 * these frag addresses may not be the same as final object-file addresses.
1722 #ifndef md_relax_frag
1724 /* Subroutines of relax_segment. */
1730 for (; f1
; f1
= f1
->fr_next
)
1731 if (f1
->fr_next
== f2
)
1736 #endif /* ! defined (md_relax_frag) */
1738 /* Relax_align. Advance location counter to next address that has 'alignment'
1739 lowest order bits all 0s, return size of adjustment made. */
1740 static relax_addressT
1741 relax_align (address
, alignment
)
1742 register relax_addressT address
; /* Address now. */
1743 register int alignment
; /* Alignment (binary). */
1745 relax_addressT mask
;
1746 relax_addressT new_address
;
1748 mask
= ~((~0) << alignment
);
1749 new_address
= (address
+ mask
) & (~mask
);
1750 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1752 /* We must provide lots of padding, so the linker can discard it
1753 when needed. The linker will not add extra space, ever. */
1754 new_address
+= (1 << alignment
);
1756 return (new_address
- address
);
1760 relax_segment (segment_frag_root
, segment
)
1761 struct frag
*segment_frag_root
;
1764 register struct frag
*fragP
;
1765 register relax_addressT address
;
1766 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1767 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1769 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1770 subseg_change (segment
, 0);
1772 /* For each frag in segment: count and store (a 1st guess of)
1775 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1777 fragP
->fr_address
= address
;
1778 address
+= fragP
->fr_fix
;
1780 switch (fragP
->fr_type
)
1783 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1789 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1790 if (offset
% fragP
->fr_var
!= 0)
1792 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1793 offset
, (long) fragP
->fr_var
);
1794 offset
-= (offset
% fragP
->fr_var
);
1802 /* Assume .org is nugatory. It will grow with 1st relax. */
1805 case rs_machine_dependent
:
1806 address
+= md_estimate_size_before_relax (fragP
, segment
);
1809 #ifndef WORKING_DOT_WORD
1810 /* Broken words don't concern us yet */
1811 case rs_broken_word
:
1816 BAD_CASE (fragP
->fr_type
);
1818 } /* switch(fr_type) */
1819 } /* for each frag in the segment */
1823 long stretch
; /* May be any size, 0 or negative. */
1824 /* Cumulative number of addresses we have */
1825 /* relaxed this pass. */
1826 /* We may have relaxed more than one address. */
1827 long stretched
; /* Have we stretched on this pass? */
1828 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1829 grew, and another shrank. If a branch instruction doesn't fit anymore,
1830 we could be scrod. */
1834 stretch
= stretched
= 0;
1835 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1838 unsigned long was_address
;
1844 was_address
= fragP
->fr_address
;
1845 address
= fragP
->fr_address
+= stretch
;
1846 symbolP
= fragP
->fr_symbol
;
1847 offset
= fragP
->fr_offset
;
1849 switch (fragP
->fr_type
)
1851 case rs_fill
: /* .fill never relaxes. */
1855 #ifndef WORKING_DOT_WORD
1856 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1857 for it I do not want to write it. I do not want to have
1858 anything to do with it. This is not the proper way to
1859 implement this misfeature. */
1860 case rs_broken_word
:
1862 struct broken_word
*lie
;
1863 struct broken_word
*untruth
;
1865 /* Yes this is ugly (storing the broken_word pointer
1866 in the symbol slot). Still, this whole chunk of
1867 code is ugly, and I don't feel like doing anything
1868 about it. Think of it as stubbornness in action. */
1870 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1871 lie
&& lie
->dispfrag
== fragP
;
1872 lie
= lie
->next_broken_word
)
1878 offset
= (lie
->add
->sy_frag
->fr_address
1879 + S_GET_VALUE (lie
->add
)
1881 - (lie
->sub
->sy_frag
->fr_address
1882 + S_GET_VALUE (lie
->sub
)));
1883 if (offset
<= -32768 || offset
>= 32767)
1885 if (flag_warn_displacement
)
1888 sprint_value (buf
, (addressT
) lie
->addnum
);
1889 as_warn (".word %s-%s+%s didn't fit",
1890 S_GET_NAME (lie
->add
),
1891 S_GET_NAME (lie
->sub
),
1895 if (fragP
->fr_subtype
== 0)
1897 fragP
->fr_subtype
++;
1898 growth
+= md_short_jump_size
;
1900 for (untruth
= lie
->next_broken_word
;
1901 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1902 untruth
= untruth
->next_broken_word
)
1903 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1904 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1907 untruth
->use_jump
= lie
;
1909 growth
+= md_long_jump_size
;
1914 } /* case rs_broken_word */
1918 growth
= (relax_align ((relax_addressT
) (address
1921 - relax_align ((relax_addressT
) (was_address
1931 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1932 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1933 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1934 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1935 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1936 know (symbolP
->sy_frag
);
1937 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1938 || (symbolP
->sy_frag
== &zero_address_frag
));
1940 target
+= S_GET_VALUE (symbolP
)
1941 + symbolP
->sy_frag
->fr_address
;
1942 } /* if we have a symbol */
1944 know (fragP
->fr_next
);
1945 after
= fragP
->fr_next
->fr_address
;
1946 growth
= target
- after
;
1949 /* Growth may be negative, but variable part of frag
1950 cannot have fewer than 0 chars. That is, we can't
1952 as_bad ("attempt to .org backwards ignored");
1956 growth
-= stretch
; /* This is an absolute growth factor */
1962 growth
= S_GET_VALUE (symbolP
);
1963 if (symbolP
->sy_frag
!= &zero_address_frag
)
1964 as_bad (".space specifies non-absolute value");
1965 fragP
->fr_symbol
= 0;
1968 as_warn (".space or .fill with negative value, ignored");
1976 case rs_machine_dependent
:
1977 #ifdef md_relax_frag
1978 growth
= md_relax_frag (fragP
, stretch
);
1980 #ifdef TC_GENERIC_RELAX_TABLE
1981 /* The default way to relax a frag is to look through
1984 const relax_typeS
*this_type
;
1985 const relax_typeS
*start_type
;
1986 relax_substateT next_state
;
1987 relax_substateT this_state
;
1989 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1991 this_state
= fragP
->fr_subtype
;
1992 start_type
= this_type
= table
+ this_state
;
1997 #ifndef DIFF_EXPR_OK
1998 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1999 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2000 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2001 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2002 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2004 know (symbolP
->sy_frag
);
2006 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2007 || symbolP
->sy_frag
== &zero_address_frag
);
2009 S_GET_VALUE (symbolP
)
2010 + symbolP
->sy_frag
->fr_address
;
2012 /* If frag has yet to be reached on this pass,
2013 assume it will move by STRETCH just as we did.
2014 If this is not so, it will be because some frag
2015 between grows, and that will force another pass.
2017 Beware zero-length frags.
2019 There should be a faster way to do this. */
2021 if (symbolP
->sy_frag
->fr_address
>= was_address
2022 && is_dnrange (fragP
, symbolP
->sy_frag
))
2028 aim
= target
- address
- fragP
->fr_fix
;
2029 #ifdef TC_PCREL_ADJUST
2030 /* Currently only the ns32k family needs this */
2031 aim
+= TC_PCREL_ADJUST(fragP
);
2033 /* This machine doesn't want to use pcrel_adjust.
2034 In that case, pcrel_adjust should be zero. */
2035 assert (fragP
->fr_pcrel_adjust
== 0);
2040 /* Look backwards. */
2041 for (next_state
= this_type
->rlx_more
; next_state
;)
2042 if (aim
>= this_type
->rlx_backward
)
2046 /* Grow to next state. */
2047 this_state
= next_state
;
2048 this_type
= table
+ this_state
;
2049 next_state
= this_type
->rlx_more
;
2054 #ifdef M68K_AIM_KLUDGE
2055 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2057 /* Look forwards. */
2058 for (next_state
= this_type
->rlx_more
; next_state
;)
2059 if (aim
<= this_type
->rlx_forward
)
2063 /* Grow to next state. */
2064 this_state
= next_state
;
2065 this_type
= table
+ this_state
;
2066 next_state
= this_type
->rlx_more
;
2070 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2072 fragP
->fr_subtype
= this_state
;
2074 #endif /* TC_GENERIC_RELAX_TABLE */
2079 BAD_CASE (fragP
->fr_type
);
2087 } /* For each frag in the segment. */
2089 while (stretched
); /* Until nothing further to relax. */
2093 * We now have valid fr_address'es for each frag.
2097 * All fr_address's are correct, relative to their own segment.
2098 * We have made all the fixS we will ever make.
2100 } /* relax_segment() */
2102 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2104 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2105 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2110 Go through all the fixS's in a segment and see which ones can be
2111 handled now. (These consist of fixS where we have since discovered
2112 the value of a symbol, or the address of the frag involved.)
2113 For each one, call md_apply_fix to put the fix into the frag data.
2115 Result is a count of how many relocation structs will be needed to
2116 handle the remaining fixS's that we couldn't completely handle here.
2117 These will be output later by emit_relocations(). */
2120 fixup_segment (fixP
, this_segment_type
)
2121 register fixS
*fixP
;
2122 segT this_segment_type
; /* N_TYPE bits for segment. */
2124 long seg_reloc_count
= 0;
2125 symbolS
*add_symbolP
;
2126 symbolS
*sub_symbolP
;
2133 segT add_symbol_segment
= absolute_section
;
2135 /* If the linker is doing the relaxing, we must not do any fixups.
2137 Well, strictly speaking that's not true -- we could do any that are
2138 PC-relative and don't cross regions that could change size. And for the
2139 i960 (the only machine for which we've got a relaxing linker right now),
2140 we might be able to turn callx/callj into bal anyways in cases where we
2141 know the maximum displacement. */
2144 for (; fixP
; fixP
= fixP
->fx_next
)
2146 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2147 return seg_reloc_count
;
2150 for (; fixP
; fixP
= fixP
->fx_next
)
2153 fprintf (stderr
, "\nprocessing fixup:\n");
2157 fragP
= fixP
->fx_frag
;
2159 where
= fixP
->fx_where
;
2160 place
= fragP
->fr_literal
+ where
;
2161 size
= fixP
->fx_size
;
2162 add_symbolP
= fixP
->fx_addsy
;
2163 #ifdef TC_VALIDATE_FIX
2164 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2166 sub_symbolP
= fixP
->fx_subsy
;
2167 add_number
= fixP
->fx_offset
;
2168 pcrel
= fixP
->fx_pcrel
;
2171 if (add_symbolP
!= NULL
2172 && add_symbolP
->sy_mri_common
)
2174 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2175 add_number
+= S_GET_VALUE (add_symbolP
);
2176 fixP
->fx_offset
= add_number
;
2177 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2181 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2185 resolve_symbol_value (sub_symbolP
);
2189 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2190 add_number
-= S_GET_VALUE (sub_symbolP
);
2192 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2194 /* Should try converting to a constant. */
2199 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2200 "Negative of non-absolute symbol %s",
2201 S_GET_NAME (sub_symbolP
));
2203 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2204 && (SEG_NORMAL (add_symbol_segment
)
2205 || (add_symbol_segment
== absolute_section
)))
2207 /* Difference of 2 symbols from same segment.
2208 Can't make difference of 2 undefineds: 'value' means
2209 something different for N_UNDF. */
2211 /* Makes no sense to use the difference of 2 arbitrary symbols
2212 as the target of a call instruction. */
2214 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2215 "callj to difference of 2 symbols");
2216 #endif /* TC_I960 */
2217 add_number
+= S_GET_VALUE (add_symbolP
) -
2218 S_GET_VALUE (sub_symbolP
);
2221 pcrel
= 0; /* No further pcrel processing. */
2223 /* Let the target machine make the final determination
2224 as to whether or not a relocation will be needed to
2225 handle this fixup. */
2226 if (!TC_FORCE_RELOCATION (fixP
))
2229 fixP
->fx_addsy
= NULL
;
2234 /* Different segments in subtraction. */
2235 know (!(S_IS_EXTERNAL (sub_symbolP
)
2236 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2238 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2239 add_number
-= S_GET_VALUE (sub_symbolP
);
2242 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2243 #if 0 /* Do this even if it's already described as pc-relative. For example,
2244 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2245 pc-relative mode. */
2250 /* Make it pc-relative. */
2251 add_number
+= (md_pcrel_from (fixP
)
2252 - S_GET_VALUE (sub_symbolP
));
2259 #ifdef UNDEFINED_DIFFERENCE_OK
2260 /* The PA needs this for PIC code generation. We basically
2261 don't want to do anything if we have the difference of two
2262 symbols at this point. */
2265 /* Leave it alone. */
2268 #ifdef BFD_ASSEMBLER
2269 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2270 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2272 /* Leave it alone. */
2278 sprint_value (buf
, fragP
->fr_address
+ where
);
2279 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2280 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2281 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2282 S_GET_NAME (sub_symbolP
), buf
);
2289 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2290 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2293 * This fixup was made when the symbol's segment was
2294 * SEG_UNKNOWN, but it is now in the local segment.
2295 * So we know how to do the address without relocation.
2298 /* reloc_callj() may replace a 'call' with a 'calls' or a
2299 'bal', in which cases it modifies *fixP as appropriate.
2300 In the case of a 'calls', no further work is required,
2301 and *fixP has been set up to make the rest of the code
2304 #endif /* TC_I960 */
2306 add_number
+= S_GET_VALUE (add_symbolP
);
2307 add_number
-= md_pcrel_from (fixP
);
2308 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2310 /* Let the target machine make the final determination
2311 as to whether or not a relocation will be needed to
2312 handle this fixup. */
2313 if (!TC_FORCE_RELOCATION (fixP
))
2316 fixP
->fx_addsy
= NULL
;
2321 if (add_symbol_segment
== absolute_section
)
2324 /* See comment about reloc_callj() above. */
2326 #endif /* TC_I960 */
2327 add_number
+= S_GET_VALUE (add_symbolP
);
2329 /* Let the target machine make the final determination
2330 as to whether or not a relocation will be needed to
2331 handle this fixup. */
2333 if (!TC_FORCE_RELOCATION (fixP
))
2335 fixP
->fx_addsy
= NULL
;
2339 else if (add_symbol_segment
== undefined_section
2340 #ifdef BFD_ASSEMBLER
2341 || bfd_is_com_section (add_symbol_segment
)
2346 if ((int) fixP
->fx_bit_fixP
== 13)
2348 /* This is a COBR instruction. They have only a
2349 * 13-bit displacement and are only to be used
2350 * for local branches: flag as error, don't generate
2353 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2354 "can't use COBR format with external label");
2355 fixP
->fx_addsy
= NULL
;
2359 #endif /* TC_I960 */
2363 if (S_IS_COMMON (add_symbolP
))
2364 add_number
+= S_GET_VALUE (add_symbolP
);
2365 #endif /* TE_I386AIX */
2366 #endif /* OBJ_COFF */
2372 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2373 add_number
+= S_GET_VALUE (add_symbolP
);
2381 add_number
-= md_pcrel_from (fixP
);
2382 if (add_symbolP
== 0)
2384 #ifndef BFD_ASSEMBLER
2385 fixP
->fx_addsy
= &abs_symbol
;
2387 fixP
->fx_addsy
= section_symbol (absolute_section
);
2389 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2394 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2397 if (size
< sizeof (mask
))
2399 /* set all bits to one */
2401 /* Technically, combining these produces an undefined result
2402 if size is sizeof (valueT), though I think these two
2403 half-way operations should both be defined. And the
2404 compiler should be able to combine them if it's valid on
2405 the host architecture. */
2408 if ((add_number
& mask
) != 0
2409 && (add_number
& mask
) != mask
)
2411 char buf
[50], buf2
[50];
2412 sprint_value (buf
, fragP
->fr_address
+ where
);
2413 if (add_number
> 1000)
2414 sprint_value (buf2
, add_number
);
2416 sprintf (buf2
, "%ld", (long) add_number
);
2417 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2418 "Value of %s too large for field of %d bytes at %s",
2420 } /* generic error checking */
2422 #ifdef WARN_SIGNED_OVERFLOW_WORD
2423 /* Warn if a .word value is too large when treated as a signed
2424 number. We already know it is not too negative. This is to
2425 catch over-large switches generated by gcc on the 68k. */
2426 if (!flag_signed_overflow_ok
2428 && add_number
> 0x7fff)
2429 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2430 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2432 (unsigned long) (fragP
->fr_address
+ where
));
2434 } /* not a bit fix */
2438 #ifdef MD_APPLY_FIX3
2439 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2441 #ifdef BFD_ASSEMBLER
2442 md_apply_fix (fixP
, &add_number
);
2444 md_apply_fix (fixP
, add_number
);
2448 #ifndef TC_HANDLES_FX_DONE
2449 /* If the tc-* files haven't been converted, assume it's handling
2450 it the old way, where a null fx_addsy means that the fix has
2451 been applied completely, and no further work is needed. */
2452 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2456 #ifdef TC_VALIDATE_FIX
2460 fprintf (stderr
, "result:\n");
2463 } /* For each fixS in this segment. */
2465 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2466 return seg_reloc_count
;
2469 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2472 number_to_chars_bigendian (buf
, val
, n
)
2477 if (n
> sizeof (val
)|| n
<= 0)
2481 buf
[n
] = val
& 0xff;
2487 number_to_chars_littleendian (buf
, val
, n
)
2492 if (n
> sizeof (val
) || n
<= 0)
2496 *buf
++ = val
& 0xff;
2502 extern int indent_level
;
2503 extern void print_symbol_value_1 ();
2510 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2512 fprintf (stderr
, " pcrel");
2513 if (fixp
->fx_pcrel_adjust
)
2514 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2515 if (fixp
->fx_im_disp
)
2518 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2520 fprintf (stderr
, " im_disp");
2524 fprintf (stderr
, " tcbit");
2526 fprintf (stderr
, " done");
2527 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2528 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2529 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2530 #ifdef BFD_ASSEMBLER
2531 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2534 #ifdef NEED_FX_R_TYPE
2535 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2540 fprintf (stderr
, "\n +<");
2541 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2542 fprintf (stderr
, ">");
2546 fprintf (stderr
, "\n -<");
2547 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2548 fprintf (stderr
, ">");
2550 fprintf (stderr
, "\n");
2553 /* end of write.c */