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 (sym
->sy_mri_common
)
635 /* These symbols are handled specially in fixup_segment. */
639 /* If it's one of these sections, assume the symbol is
640 definitely going to be output. The code in
641 md_estimate_size_before_relax in tc-mips.c uses this test
642 as well, so if you change this code you should look at that
644 if (bfd_is_und_section (symsec
)
645 || bfd_is_abs_section (symsec
)
646 || bfd_is_com_section (symsec
))
648 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
649 #ifdef UNDEFINED_DIFFERENCE_OK
650 /* We have the difference of an undefined symbol and some
651 other symbol. Make sure to mark the other symbol as used
652 in a relocation so that it will always be output. */
654 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
659 /* Since we're reducing to section symbols, don't attempt to reduce
660 anything that's already using one. */
661 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
663 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
667 /* Is there some other reason we can't adjust this one? (E.g.,
668 call/bal links in i960-bout symbols.) */
669 #ifdef obj_fix_adjustable
670 if (! obj_fix_adjustable (fixp
))
672 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
677 /* Is there some other (target cpu dependent) reason we can't adjust
678 this one? (E.g. relocations involving function addresses on
680 #ifdef tc_fix_adjustable
681 if (! tc_fix_adjustable (fixp
))
683 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
688 /* For PIC support: We may get expressions like
689 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
690 necessarily have had a fixed difference initially. But now
691 it should be a known constant, so we can reduce it. Since
692 we can't easily handle a symbol value that looks like
693 someUndefinedSymbol+const, though, we convert the fixup to
694 access the undefined symbol directly, and discard the
695 intermediate symbol. */
696 if (S_GET_SEGMENT (sym
) == expr_section
697 && sym
->sy_value
.X_op
== O_add
698 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
699 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
700 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
701 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
703 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
704 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
705 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
709 /* If the section symbol isn't going to be output, the relocs
710 at least should still work. If not, figure out what to do
711 when we run into that case. */
712 fixp
->fx_offset
+= S_GET_VALUE (sym
);
713 fixp
->fx_addsy
= section_symbol (symsec
);
714 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
719 #if 1/*def RELOC_REQUIRES_SYMBOL*/
722 /* There was no symbol required by this relocation. However,
723 BFD doesn't really handle relocations without symbols well.
724 (At least, the COFF support doesn't.) So for now we fake up
725 a local symbol in the absolute section. */
727 fixp
->fx_addsy
= section_symbol (absolute_section
);
728 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
732 dump_section_relocs (abfd
, sec
, stderr
);
736 write_relocs (abfd
, sec
, xxx
)
741 segment_info_type
*seginfo
= seg_info (sec
);
748 /* If seginfo is NULL, we did not create this section; don't do
753 fixup_segment (seginfo
->fix_root
, sec
);
756 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
759 #ifndef RELOC_EXPANSION_POSSIBLE
760 /* Set up reloc information as well. */
761 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
762 n
* sizeof (arelent
*));
763 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
766 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
769 bfd_reloc_status_type s
;
776 reloc
= tc_gen_reloc (sec
, fixp
);
782 if (fixp
->fx_where
+ fixp
->fx_size
783 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
786 s
= bfd_install_relocation (stdoutput
, reloc
,
787 fixp
->fx_frag
->fr_literal
,
788 fixp
->fx_frag
->fr_address
,
794 case bfd_reloc_overflow
:
795 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
798 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
799 fixp
->fx_file
, fixp
->fx_line
);
804 n
= n
* MAX_RELOC_EXPANSION
;
805 /* Set up reloc information as well. */
806 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
807 n
* sizeof (arelent
*));
810 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
814 bfd_reloc_status_type s
;
822 reloc
= tc_gen_reloc (sec
, fixp
);
824 for (j
= 0; reloc
[j
]; j
++)
826 relocs
[i
++] = reloc
[j
];
829 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
830 if (fixp
->fx_where
+ fixp
->fx_size
831 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
833 for (j
= 0; reloc
[j
]; j
++)
835 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
836 fixp
->fx_frag
->fr_literal
,
837 fixp
->fx_frag
->fr_address
,
843 case bfd_reloc_overflow
:
844 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
845 "relocation overflow");
848 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
849 fixp
->fx_file
, fixp
->fx_line
);
860 sympp
= bfd_get_outsymbols (stdoutput
);
861 nsyms
= bfd_get_symcount (stdoutput
);
862 for (i
= 0; i
< n
; i
++)
863 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
865 for (j
= 0; j
< nsyms
; j
++)
866 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
875 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
877 bfd_set_section_flags (abfd
, sec
,
878 (bfd_get_section_flags (abfd
, sec
)
879 & (flagword
) ~SEC_RELOC
));
886 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
887 for (i
= 0; i
< n
; i
++)
891 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
892 i
, r
, r
->address
, s
->name
, r
->addend
);
899 write_contents (abfd
, sec
, xxx
)
904 segment_info_type
*seginfo
= seg_info (sec
);
905 unsigned long offset
= 0;
908 /* Write out the frags. */
910 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
913 for (f
= seginfo
->frchainP
->frch_root
;
918 unsigned long fill_size
;
922 assert (f
->fr_type
== rs_fill
);
925 x
= bfd_set_section_contents (stdoutput
, sec
,
926 f
->fr_literal
, (file_ptr
) offset
,
927 (bfd_size_type
) f
->fr_fix
);
930 bfd_perror (stdoutput
->filename
);
931 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
936 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
937 fill_size
= f
->fr_var
;
938 count
= f
->fr_offset
;
940 if (fill_size
&& count
)
941 #ifdef BFD_FAST_SECTION_FILL
944 if (fill_size
> sizeof(buf
)) {
945 /* Do it the old way. Can this ever happen? */
948 x
= bfd_set_section_contents (stdoutput
, sec
,
949 fill_literal
, (file_ptr
) offset
,
950 (bfd_size_type
) fill_size
);
953 bfd_perror (stdoutput
->filename
);
954 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
961 /* Build a buffer full of fill objects and output it as
962 * often as necessary. This saves on the overhead of potentially
963 * lots of bfd_set_section_contents calls.
968 n_per_buf
= sizeof (buf
);
969 memset (buf
, *fill_literal
, n_per_buf
);
974 n_per_buf
= sizeof(buf
)/fill_size
;
975 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
976 memcpy(bufp
, fill_literal
, fill_size
);
978 for (; count
> 0; count
-= n_per_buf
)
980 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
981 x
= bfd_set_section_contents (stdoutput
, sec
,
982 buf
, (file_ptr
) offset
,
983 (bfd_size_type
) n_per_buf
* fill_size
);
985 as_fatal ("Cannot write to output file.");
986 offset
+= n_per_buf
* fill_size
;
993 x
= bfd_set_section_contents (stdoutput
, sec
,
994 fill_literal
, (file_ptr
) offset
,
995 (bfd_size_type
) fill_size
);
997 as_fatal ("Cannot write to output file.");
1005 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1007 merge_data_into_text ()
1009 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1010 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1011 seg_info (data_section
)->frchainP
->frch_root
;
1012 seg_info (text_section
)->frchainP
->frch_last
=
1013 seg_info (data_section
)->frchainP
->frch_last
;
1014 seg_info (data_section
)->frchainP
= 0;
1018 text_last_frag
->fr_next
= data_frag_root
;
1019 text_last_frag
= data_last_frag
;
1020 data_last_frag
= NULL
;
1021 data_frag_root
= NULL
;
1024 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1025 tmp
->fx_next
= data_fix_root
;
1026 text_fix_tail
= data_fix_tail
;
1029 text_fix_root
= data_fix_root
;
1030 data_fix_root
= NULL
;
1033 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1035 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1037 relax_and_size_all_segments ()
1041 relax_segment (text_frag_root
, SEG_TEXT
);
1042 relax_segment (data_frag_root
, SEG_DATA
);
1043 relax_segment (bss_frag_root
, SEG_BSS
);
1045 * Now the addresses of frags are correct within the segment.
1048 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1049 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1050 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1053 * Join the 2 segments into 1 huge segment.
1054 * To do this, re-compute every rn_address in the SEG_DATA frags.
1055 * Then join the data frags after the text frags.
1057 * Determine a_data [length of data segment].
1061 register relax_addressT slide
;
1063 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1065 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1066 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1067 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1069 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1070 /* For b.out: If the data section has a strict alignment
1071 requirement, its load address in the .o file will be
1072 rounded up from the size of the text section. These
1073 two values are *not* the same! Similarly for the bss
1075 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1078 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1080 fragP
->fr_address
+= slide
;
1081 } /* for each data frag */
1083 know (text_last_frag
!= 0);
1084 text_last_frag
->fr_next
= data_frag_root
;
1088 H_SET_DATA_SIZE (&headers
, 0);
1092 /* See above comments on b.out data section address. */
1095 if (data_last_frag
== 0)
1096 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1098 bss_vma
= data_last_frag
->fr_address
;
1099 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1100 bss_address_frag
.fr_address
= bss_vma
;
1102 #else /* ! OBJ_BOUT */
1103 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1104 H_GET_DATA_SIZE (&headers
));
1106 #endif /* ! OBJ_BOUT */
1108 /* Slide all the frags */
1111 relax_addressT slide
= bss_address_frag
.fr_address
;
1113 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1115 fragP
->fr_address
+= slide
;
1116 } /* for each bss frag */
1120 H_SET_BSS_SIZE (&headers
,
1121 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1123 H_SET_BSS_SIZE (&headers
, 0);
1125 #endif /* ! BFD_ASSEMBLER && ! BFD */
1127 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1129 #ifdef BFD_ASSEMBLER
1137 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1139 /* Count symbols. We can't rely on a count made by the loop in
1140 write_object_file, because *_frob_file may add a new symbol or
1143 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1150 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1151 nsyms
* sizeof (asymbol
*));
1152 symp
= symbol_rootP
;
1153 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1155 asympp
[i
] = symp
->bsym
;
1161 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1162 assert (result
== true);
1163 symbol_table_frozen
= 1;
1168 write_object_file ()
1170 struct frchain
*frchainP
; /* Track along all frchains. */
1171 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1172 fragS
*fragP
; /* Track along all frags. */
1175 /* Do we really want to write it? */
1177 int n_warns
, n_errs
;
1178 n_warns
= had_warnings ();
1179 n_errs
= had_errors ();
1180 /* The -Z flag indicates that an object file should be generated,
1181 regardless of warnings and errors. */
1182 if (flag_always_generate_output
)
1184 if (n_warns
|| n_errs
)
1185 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1186 n_errs
, n_errs
== 1 ? "" : "s",
1187 n_warns
, n_warns
== 1 ? "" : "s");
1192 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1193 n_errs
, n_errs
== 1 ? "" : "s",
1194 n_warns
, n_warns
== 1 ? "" : "s");
1199 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1200 a routine to check for the definition of the procedure "_main",
1201 and if so -- fix it up so that it can be program entry point. */
1202 vms_check_for_main ();
1203 #endif /* OBJ_VMS */
1205 /* After every sub-segment, we fake an ".align ...". This conforms to
1206 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1207 frag that requires least thought. ".align" frags like to have a
1208 following frag since that makes calculating their intended length
1211 @@ Is this really necessary?? */
1212 #ifndef SUB_SEGMENT_ALIGN
1213 #ifdef BFD_ASSEMBLER
1214 #define SUB_SEGMENT_ALIGN(SEG) (0)
1216 #define SUB_SEGMENT_ALIGN(SEG) (2)
1219 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1221 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1222 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1223 /* frag_align will have left a new frag.
1224 Use this last frag for an empty ".fill".
1226 For this segment ...
1227 Create a last frag. Do not leave a "being filled in frag". */
1228 frag_wane (frag_now
);
1229 frag_now
->fr_fix
= 0;
1230 know (frag_now
->fr_next
== NULL
);
1233 /* From now on, we don't care about sub-segments. Build one frag chain
1234 for each segment. Linked thru fr_next. */
1236 #ifdef BFD_ASSEMBLER
1237 /* Remove the sections created by gas for its own purposes. */
1239 asection
**seclist
, *sec
;
1242 seclist
= &stdoutput
->sections
;
1243 while (seclist
&& *seclist
)
1246 while (sec
== reg_section
|| sec
== expr_section
)
1250 stdoutput
->section_count
--;
1255 seclist
= &(*seclist
)->next
;
1258 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1261 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1263 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1264 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1265 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1268 /* We have two segments. If user gave -R flag, then we must put the
1269 data frags into the text segment. Do this before relaxing so
1270 we know to take advantage of -R and make shorter addresses. */
1271 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1272 if (flag_readonly_data_in_text
)
1274 merge_data_into_text ();
1278 #ifdef BFD_ASSEMBLER
1279 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1281 relax_and_size_all_segments ();
1282 #endif /* BFD_ASSEMBLER */
1284 #ifndef BFD_ASSEMBLER
1287 * Crawl the symbol chain.
1289 * For each symbol whose value depends on a frag, take the address of
1290 * that frag and subsume it into the value of the symbol.
1291 * After this, there is just one way to lookup a symbol value.
1292 * Values are left in their final state for object file emission.
1293 * We adjust the values of 'L' local symbols, even if we do
1294 * not intend to emit them to the object file, because their values
1295 * are needed for fix-ups.
1297 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1298 * from the symbol chain. (They are still pointed to by the fixes.)
1300 * Count the remaining symbols.
1301 * Assign a symbol number to each symbol.
1302 * Count the number of string-table chars we will emit.
1303 * Put this info into the headers as appropriate.
1306 know (zero_address_frag
.fr_address
== 0);
1307 string_byte_count
= sizeof (string_byte_count
);
1309 obj_crawl_symbol_chain (&headers
);
1311 if (string_byte_count
== sizeof (string_byte_count
))
1312 string_byte_count
= 0;
1314 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1317 * Addresses of frags now reflect addresses we use in the object file.
1318 * Symbol values are correct.
1319 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1320 * Also converting any machine-dependent frags using md_convert_frag();
1322 subseg_change (SEG_TEXT
, 0);
1324 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1326 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1328 /* Some assert macros don't work with # directives mixed in. */
1330 if (!(fragP
->fr_next
== NULL
1332 || fragP
->fr_next
== data_frag_root
1334 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1335 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1339 #endif /* ! BFD_ASSEMBLER */
1341 #ifndef WORKING_DOT_WORD
1343 struct broken_word
*lie
;
1344 struct broken_word
**prevP
;
1346 prevP
= &broken_words
;
1347 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1352 exp
.X_op
= O_subtract
;
1353 exp
.X_add_symbol
= lie
->add
;
1354 exp
.X_op_symbol
= lie
->sub
;
1355 exp
.X_add_number
= lie
->addnum
;
1356 #ifdef BFD_ASSEMBLER
1357 #ifdef TC_CONS_FIX_NEW
1358 TC_CONS_FIX_NEW (lie
->frag
,
1359 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1362 fix_new_exp (lie
->frag
,
1363 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1364 2, &exp
, 0, BFD_RELOC_NONE
);
1367 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1368 fix_new_exp (lie
->frag
,
1369 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1370 2, &exp
, 0, NO_RELOC
);
1373 fix_new_ns32k_exp (lie
->frag
,
1374 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1375 2, &exp
, 0, 0, 2, 0, 0);
1377 fix_new_exp (lie
->frag
,
1378 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1380 #endif /* TC_NS32K */
1381 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1382 #endif /* BFD_ASSEMBLER */
1383 *prevP
= lie
->next_broken_word
;
1386 prevP
= &(lie
->next_broken_word
);
1388 for (lie
= broken_words
; lie
;)
1390 struct broken_word
*untruth
;
1392 addressT table_addr
;
1393 addressT from_addr
, to_addr
;
1396 fragP
= lie
->dispfrag
;
1398 /* Find out how many broken_words go here. */
1400 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1401 if (untruth
->added
== 1)
1404 table_ptr
= lie
->dispfrag
->fr_opcode
;
1405 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1406 /* Create the jump around the long jumps. This is a short
1407 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1408 from_addr
= table_addr
;
1409 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1410 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1411 table_ptr
+= md_short_jump_size
;
1412 table_addr
+= md_short_jump_size
;
1414 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1416 if (lie
->added
== 2)
1418 /* Patch the jump table */
1419 /* This is the offset from ??? to table_ptr+0 */
1420 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1421 #ifdef BFD_ASSEMBLER
1422 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1424 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1425 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1427 if (untruth
->use_jump
== lie
)
1428 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1431 /* Install the long jump */
1432 /* this is a long jump from table_ptr+0 to the final target */
1433 from_addr
= table_addr
;
1434 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1435 #ifdef BFD_ASSEMBLER
1436 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1438 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1439 table_ptr
+= md_long_jump_size
;
1440 table_addr
+= md_long_jump_size
;
1444 #endif /* not WORKING_DOT_WORD */
1446 #ifndef BFD_ASSEMBLER
1449 char *the_object_file
;
1450 long object_file_size
;
1452 * Scan every FixS performing fixups. We had to wait until now to do
1453 * this because md_convert_frag() may have made some fixSs.
1457 subseg_change (SEG_TEXT
, 0);
1458 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1459 subseg_change (SEG_DATA
, 0);
1460 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1461 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1463 /* FIXME move this stuff into the pre-write-hook */
1464 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1465 H_SET_ENTRY_POINT (&headers
, 0);
1467 obj_pre_write_hook (&headers
); /* extra coff stuff */
1469 object_file_size
= H_GET_FILE_SIZE (&headers
);
1470 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1472 output_file_create (out_file_name
);
1474 obj_header_append (&next_object_file_charP
, &headers
);
1476 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1481 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1483 register long count
;
1484 register char *fill_literal
;
1485 register long fill_size
;
1488 know (fragP
->fr_type
== rs_fill
);
1489 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1490 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1491 fill_size
= fragP
->fr_var
;
1492 know (fragP
->fr_offset
>= 0);
1494 for (count
= fragP
->fr_offset
; count
; count
--)
1496 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1499 } /* for each code frag. */
1501 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1506 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1507 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
)));
1509 /* Make addresses in data relocation directives relative to beginning of
1510 * first data fragment, not end of last text fragment: alignment of the
1511 * start of the data segment may place a gap between the segments.
1513 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1515 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1516 #endif /* TC_I960 */
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
)));
1521 * Emit line number entries.
1523 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
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
)));
1529 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1530 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
)));
1536 if (string_byte_count
> 0)
1538 obj_emit_strings (&next_object_file_charP
);
1539 } /* only if we have a string table */
1542 bfd_seek (stdoutput
, 0, 0);
1543 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1546 /* Write the data to the file */
1547 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1548 free (the_object_file
);
1550 } /* non vms output */
1553 * Now do the VMS-dependent part of writing the object file
1555 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1556 H_GET_DATA_SIZE (&headers
),
1557 H_GET_BSS_SIZE (&headers
),
1558 text_frag_root
, data_frag_root
);
1559 #endif /* OBJ_VMS */
1560 #else /* BFD_ASSEMBLER */
1562 /* Resolve symbol values. This needs to be done before processing
1568 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1569 if (!symp
->sy_resolved
)
1570 resolve_symbol_value (symp
);
1575 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1577 /* Set up symbol table, and write it out. */
1582 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1587 if (symp
->sy_mri_common
)
1589 if (S_IS_EXTERNAL (symp
))
1590 as_bad ("%s: global symbols not supported in common sections",
1592 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1596 name
= S_GET_NAME (symp
);
1599 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1600 /* They only differ if `name' is a fb or dollar local
1602 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1603 as_bad ("local label %s is not defined", name2
);
1606 /* Do it again, because adjust_reloc_syms might introduce
1607 more symbols. They'll probably only be section symbols,
1608 but they'll still need to have the values computed. */
1609 if (! symp
->sy_resolved
)
1611 if (symp
->sy_value
.X_op
== O_constant
)
1613 /* This is the normal case; skip the call. */
1616 + symp
->sy_frag
->fr_address
));
1617 symp
->sy_resolved
= 1;
1620 resolve_symbol_value (symp
);
1623 /* So far, common symbols have been treated like undefined symbols.
1624 Put them in the common section now. */
1625 if (S_IS_DEFINED (symp
) == 0
1626 && S_GET_VALUE (symp
) != 0)
1627 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1629 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1630 S_GET_NAME (symp
), symp
,
1633 segment_name (symp
->bsym
->section
));
1636 #ifdef obj_frob_symbol
1637 obj_frob_symbol (symp
, punt
);
1639 #ifdef tc_frob_symbol
1640 if (! punt
|| symp
->sy_used_in_reloc
)
1641 tc_frob_symbol (symp
, punt
);
1644 /* If we don't want to keep this symbol, splice it out of
1645 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1646 want section symbols. Otherwise, we skip local symbols
1647 and symbols that the frob_symbol macros told us to punt,
1648 but we keep such symbols if they are used in relocs. */
1649 if ((! EMIT_SECTION_SYMBOLS
1650 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1651 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1652 opposites. Sometimes the former checks flags and the
1653 latter examines the name... */
1654 || (!S_IS_EXTERN (symp
)
1655 && (S_IS_LOCAL (symp
) || punt
)
1656 && ! symp
->sy_used_in_reloc
))
1658 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1659 /* After symbol_remove, symbol_next(symp) still returns
1660 the one that came after it in the chain. So we don't
1661 need to do any extra cleanup work here. */
1666 /* Make sure we really got a value for the symbol. */
1667 if (! symp
->sy_resolved
)
1669 as_bad ("can't resolve value for symbol \"%s\"",
1671 symp
->sy_resolved
= 1;
1674 /* Set the value into the BFD symbol. Up til now the value
1675 has only been kept in the gas symbolS struct. */
1676 symp
->bsym
->value
= S_GET_VALUE (symp
);
1682 /* Now do any format-specific adjustments to the symbol table, such
1683 as adding file symbols. */
1684 #ifdef obj_adjust_symtab
1685 obj_adjust_symtab ();
1688 /* Now that all the sizes are known, and contents correct, we can
1689 start writing to the file. */
1692 /* If *_frob_file changes the symbol value at this point, it is
1693 responsible for moving the changed value into symp->bsym->value
1694 as well. Hopefully all symbol value changing can be done in
1699 #ifdef obj_frob_file
1703 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1705 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1706 #endif /* BFD_ASSEMBLER */
1713 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1718 * After this, all frags in this segment have addresses that are correct
1719 * within the segment. Since segments live in different file addresses,
1720 * these frag addresses may not be the same as final object-file addresses.
1723 #ifndef md_relax_frag
1725 /* Subroutines of relax_segment. */
1731 for (; f1
; f1
= f1
->fr_next
)
1732 if (f1
->fr_next
== f2
)
1737 #endif /* ! defined (md_relax_frag) */
1739 /* Relax_align. Advance location counter to next address that has 'alignment'
1740 lowest order bits all 0s, return size of adjustment made. */
1741 static relax_addressT
1742 relax_align (address
, alignment
)
1743 register relax_addressT address
; /* Address now. */
1744 register int alignment
; /* Alignment (binary). */
1746 relax_addressT mask
;
1747 relax_addressT new_address
;
1749 mask
= ~((~0) << alignment
);
1750 new_address
= (address
+ mask
) & (~mask
);
1751 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1753 /* We must provide lots of padding, so the linker can discard it
1754 when needed. The linker will not add extra space, ever. */
1755 new_address
+= (1 << alignment
);
1757 return (new_address
- address
);
1761 relax_segment (segment_frag_root
, segment
)
1762 struct frag
*segment_frag_root
;
1765 register struct frag
*fragP
;
1766 register relax_addressT address
;
1767 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1768 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1770 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1771 subseg_change (segment
, 0);
1773 /* For each frag in segment: count and store (a 1st guess of)
1776 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1778 fragP
->fr_address
= address
;
1779 address
+= fragP
->fr_fix
;
1781 switch (fragP
->fr_type
)
1784 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1790 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1791 if (offset
% fragP
->fr_var
!= 0)
1793 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1794 offset
, (long) fragP
->fr_var
);
1795 offset
-= (offset
% fragP
->fr_var
);
1803 /* Assume .org is nugatory. It will grow with 1st relax. */
1806 case rs_machine_dependent
:
1807 address
+= md_estimate_size_before_relax (fragP
, segment
);
1810 #ifndef WORKING_DOT_WORD
1811 /* Broken words don't concern us yet */
1812 case rs_broken_word
:
1817 BAD_CASE (fragP
->fr_type
);
1819 } /* switch(fr_type) */
1820 } /* for each frag in the segment */
1824 long stretch
; /* May be any size, 0 or negative. */
1825 /* Cumulative number of addresses we have */
1826 /* relaxed this pass. */
1827 /* We may have relaxed more than one address. */
1828 long stretched
; /* Have we stretched on this pass? */
1829 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1830 grew, and another shrank. If a branch instruction doesn't fit anymore,
1831 we could be scrod. */
1835 stretch
= stretched
= 0;
1836 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1839 unsigned long was_address
;
1845 was_address
= fragP
->fr_address
;
1846 address
= fragP
->fr_address
+= stretch
;
1847 symbolP
= fragP
->fr_symbol
;
1848 offset
= fragP
->fr_offset
;
1850 switch (fragP
->fr_type
)
1852 case rs_fill
: /* .fill never relaxes. */
1856 #ifndef WORKING_DOT_WORD
1857 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1858 for it I do not want to write it. I do not want to have
1859 anything to do with it. This is not the proper way to
1860 implement this misfeature. */
1861 case rs_broken_word
:
1863 struct broken_word
*lie
;
1864 struct broken_word
*untruth
;
1866 /* Yes this is ugly (storing the broken_word pointer
1867 in the symbol slot). Still, this whole chunk of
1868 code is ugly, and I don't feel like doing anything
1869 about it. Think of it as stubbornness in action. */
1871 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1872 lie
&& lie
->dispfrag
== fragP
;
1873 lie
= lie
->next_broken_word
)
1879 offset
= (lie
->add
->sy_frag
->fr_address
1880 + S_GET_VALUE (lie
->add
)
1882 - (lie
->sub
->sy_frag
->fr_address
1883 + S_GET_VALUE (lie
->sub
)));
1884 if (offset
<= -32768 || offset
>= 32767)
1886 if (flag_warn_displacement
)
1889 sprint_value (buf
, (addressT
) lie
->addnum
);
1890 as_warn (".word %s-%s+%s didn't fit",
1891 S_GET_NAME (lie
->add
),
1892 S_GET_NAME (lie
->sub
),
1896 if (fragP
->fr_subtype
== 0)
1898 fragP
->fr_subtype
++;
1899 growth
+= md_short_jump_size
;
1901 for (untruth
= lie
->next_broken_word
;
1902 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1903 untruth
= untruth
->next_broken_word
)
1904 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1905 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1908 untruth
->use_jump
= lie
;
1910 growth
+= md_long_jump_size
;
1915 } /* case rs_broken_word */
1919 growth
= (relax_align ((relax_addressT
) (address
1922 - relax_align ((relax_addressT
) (was_address
1932 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1933 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1934 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1935 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1936 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1937 know (symbolP
->sy_frag
);
1938 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1939 || (symbolP
->sy_frag
== &zero_address_frag
));
1941 target
+= S_GET_VALUE (symbolP
)
1942 + symbolP
->sy_frag
->fr_address
;
1943 } /* if we have a symbol */
1945 know (fragP
->fr_next
);
1946 after
= fragP
->fr_next
->fr_address
;
1947 growth
= target
- after
;
1950 /* Growth may be negative, but variable part of frag
1951 cannot have fewer than 0 chars. That is, we can't
1953 as_bad ("attempt to .org backwards ignored");
1957 growth
-= stretch
; /* This is an absolute growth factor */
1963 growth
= S_GET_VALUE (symbolP
);
1964 if (symbolP
->sy_frag
!= &zero_address_frag
)
1965 as_bad (".space specifies non-absolute value");
1966 fragP
->fr_symbol
= 0;
1969 as_warn (".space or .fill with negative value, ignored");
1977 case rs_machine_dependent
:
1978 #ifdef md_relax_frag
1979 growth
= md_relax_frag (fragP
, stretch
);
1981 #ifdef TC_GENERIC_RELAX_TABLE
1982 /* The default way to relax a frag is to look through
1985 const relax_typeS
*this_type
;
1986 const relax_typeS
*start_type
;
1987 relax_substateT next_state
;
1988 relax_substateT this_state
;
1990 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1992 this_state
= fragP
->fr_subtype
;
1993 start_type
= this_type
= table
+ this_state
;
1998 #ifndef DIFF_EXPR_OK
1999 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2000 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2001 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2002 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2003 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2005 know (symbolP
->sy_frag
);
2007 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2008 || symbolP
->sy_frag
== &zero_address_frag
);
2010 S_GET_VALUE (symbolP
)
2011 + symbolP
->sy_frag
->fr_address
;
2013 /* If frag has yet to be reached on this pass,
2014 assume it will move by STRETCH just as we did.
2015 If this is not so, it will be because some frag
2016 between grows, and that will force another pass.
2018 Beware zero-length frags.
2020 There should be a faster way to do this. */
2022 if (symbolP
->sy_frag
->fr_address
>= was_address
2023 && is_dnrange (fragP
, symbolP
->sy_frag
))
2029 aim
= target
- address
- fragP
->fr_fix
;
2030 #ifdef TC_PCREL_ADJUST
2031 /* Currently only the ns32k family needs this */
2032 aim
+= TC_PCREL_ADJUST(fragP
);
2034 /* This machine doesn't want to use pcrel_adjust.
2035 In that case, pcrel_adjust should be zero. */
2036 assert (fragP
->fr_pcrel_adjust
== 0);
2041 /* Look backwards. */
2042 for (next_state
= this_type
->rlx_more
; next_state
;)
2043 if (aim
>= this_type
->rlx_backward
)
2047 /* Grow to next state. */
2048 this_state
= next_state
;
2049 this_type
= table
+ this_state
;
2050 next_state
= this_type
->rlx_more
;
2055 #ifdef M68K_AIM_KLUDGE
2056 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2058 /* Look forwards. */
2059 for (next_state
= this_type
->rlx_more
; next_state
;)
2060 if (aim
<= this_type
->rlx_forward
)
2064 /* Grow to next state. */
2065 this_state
= next_state
;
2066 this_type
= table
+ this_state
;
2067 next_state
= this_type
->rlx_more
;
2071 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2073 fragP
->fr_subtype
= this_state
;
2075 #endif /* TC_GENERIC_RELAX_TABLE */
2080 BAD_CASE (fragP
->fr_type
);
2088 } /* For each frag in the segment. */
2090 while (stretched
); /* Until nothing further to relax. */
2094 * We now have valid fr_address'es for each frag.
2098 * All fr_address's are correct, relative to their own segment.
2099 * We have made all the fixS we will ever make.
2101 } /* relax_segment() */
2103 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2105 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2106 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2111 Go through all the fixS's in a segment and see which ones can be
2112 handled now. (These consist of fixS where we have since discovered
2113 the value of a symbol, or the address of the frag involved.)
2114 For each one, call md_apply_fix to put the fix into the frag data.
2116 Result is a count of how many relocation structs will be needed to
2117 handle the remaining fixS's that we couldn't completely handle here.
2118 These will be output later by emit_relocations(). */
2121 fixup_segment (fixP
, this_segment_type
)
2122 register fixS
*fixP
;
2123 segT this_segment_type
; /* N_TYPE bits for segment. */
2125 long seg_reloc_count
= 0;
2126 symbolS
*add_symbolP
;
2127 symbolS
*sub_symbolP
;
2134 segT add_symbol_segment
= absolute_section
;
2136 /* If the linker is doing the relaxing, we must not do any fixups.
2138 Well, strictly speaking that's not true -- we could do any that are
2139 PC-relative and don't cross regions that could change size. And for the
2140 i960 (the only machine for which we've got a relaxing linker right now),
2141 we might be able to turn callx/callj into bal anyways in cases where we
2142 know the maximum displacement. */
2145 for (; fixP
; fixP
= fixP
->fx_next
)
2147 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2148 return seg_reloc_count
;
2151 for (; fixP
; fixP
= fixP
->fx_next
)
2154 fprintf (stderr
, "\nprocessing fixup:\n");
2158 fragP
= fixP
->fx_frag
;
2160 where
= fixP
->fx_where
;
2161 place
= fragP
->fr_literal
+ where
;
2162 size
= fixP
->fx_size
;
2163 add_symbolP
= fixP
->fx_addsy
;
2164 #ifdef TC_VALIDATE_FIX
2165 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2167 sub_symbolP
= fixP
->fx_subsy
;
2168 add_number
= fixP
->fx_offset
;
2169 pcrel
= fixP
->fx_pcrel
;
2172 if (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. */
2332 if (!TC_FORCE_RELOCATION (fixP
))
2334 fixP
->fx_addsy
= NULL
;
2338 else if (add_symbol_segment
== undefined_section
2339 #ifdef BFD_ASSEMBLER
2340 || bfd_is_com_section (add_symbol_segment
)
2345 if ((int) fixP
->fx_bit_fixP
== 13)
2347 /* This is a COBR instruction. They have only a
2348 * 13-bit displacement and are only to be used
2349 * for local branches: flag as error, don't generate
2352 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2353 "can't use COBR format with external label");
2354 fixP
->fx_addsy
= NULL
;
2358 #endif /* TC_I960 */
2362 if (S_IS_COMMON (add_symbolP
))
2363 add_number
+= S_GET_VALUE (add_symbolP
);
2364 #endif /* TE_I386AIX */
2365 #endif /* OBJ_COFF */
2371 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2372 add_number
+= S_GET_VALUE (add_symbolP
);
2380 add_number
-= md_pcrel_from (fixP
);
2381 if (add_symbolP
== 0)
2383 #ifndef BFD_ASSEMBLER
2384 fixP
->fx_addsy
= &abs_symbol
;
2386 fixP
->fx_addsy
= section_symbol (absolute_section
);
2388 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2393 if (!fixP
->fx_bit_fixP
&& size
> 0)
2396 if (size
< sizeof (mask
))
2398 /* set all bits to one */
2400 /* Technically, combining these produces an undefined result
2401 if size is sizeof (valueT), though I think these two
2402 half-way operations should both be defined. And the
2403 compiler should be able to combine them if it's valid on
2404 the host architecture. */
2407 if ((add_number
& mask
) != 0
2408 && (add_number
& mask
) != mask
)
2410 char buf
[50], buf2
[50];
2411 sprint_value (buf
, fragP
->fr_address
+ where
);
2412 if (add_number
> 1000)
2413 sprint_value (buf2
, add_number
);
2415 sprintf (buf2
, "%ld", (long) add_number
);
2416 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2417 "Value of %s too large for field of %d bytes at %s",
2419 } /* generic error checking */
2421 #ifdef WARN_SIGNED_OVERFLOW_WORD
2422 /* Warn if a .word value is too large when treated as a signed
2423 number. We already know it is not too negative. This is to
2424 catch over-large switches generated by gcc on the 68k. */
2425 if (!flag_signed_overflow_ok
2427 && add_number
> 0x7fff)
2428 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2429 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2431 (unsigned long) (fragP
->fr_address
+ where
));
2433 } /* not a bit fix */
2437 #ifdef MD_APPLY_FIX3
2438 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2440 #ifdef BFD_ASSEMBLER
2441 md_apply_fix (fixP
, &add_number
);
2443 md_apply_fix (fixP
, add_number
);
2447 #ifndef TC_HANDLES_FX_DONE
2448 /* If the tc-* files haven't been converted, assume it's handling
2449 it the old way, where a null fx_addsy means that the fix has
2450 been applied completely, and no further work is needed. */
2451 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2455 #ifdef TC_VALIDATE_FIX
2459 fprintf (stderr
, "result:\n");
2462 } /* For each fixS in this segment. */
2464 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2465 return seg_reloc_count
;
2468 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2471 number_to_chars_bigendian (buf
, val
, n
)
2476 if (n
> sizeof (val
)|| n
<= 0)
2480 buf
[n
] = val
& 0xff;
2486 number_to_chars_littleendian (buf
, val
, n
)
2491 if (n
> sizeof (val
) || n
<= 0)
2495 *buf
++ = val
& 0xff;
2501 extern int indent_level
;
2502 extern void print_symbol_value_1 ();
2509 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2511 fprintf (stderr
, " pcrel");
2512 if (fixp
->fx_pcrel_adjust
)
2513 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2514 if (fixp
->fx_im_disp
)
2517 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2519 fprintf (stderr
, " im_disp");
2523 fprintf (stderr
, " tcbit");
2525 fprintf (stderr
, " done");
2526 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2527 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2528 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2529 #ifdef BFD_ASSEMBLER
2530 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2533 #ifdef NEED_FX_R_TYPE
2534 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2539 fprintf (stderr
, "\n +<");
2540 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2541 fprintf (stderr
, ">");
2545 fprintf (stderr
, "\n -<");
2546 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2547 fprintf (stderr
, ">");
2549 fprintf (stderr
, "\n");
2552 /* end of write.c */