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
308 if (seg
== absolute_section
)
311 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
312 bfd_set_section_alignment (stdoutput
, seg
, align
);
314 if (align
> section_alignment
[(int) seg
])
315 section_alignment
[(int) seg
] = align
;
321 /* Reset the section indices after removing the gas created sections. */
324 renumber_sections (abfd
, sec
, countparg
)
329 int *countp
= (int *) countparg
;
331 sec
->index
= *countp
;
335 #endif /* defined (BFD_ASSEMBLER) */
337 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
340 chain_frchains_together_1 (section
, frchp
)
342 struct frchain
*frchp
;
344 fragS dummy
, *prev_frag
= &dummy
;
346 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
349 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
351 prev_frag
->fr_next
= frchp
->frch_root
;
352 prev_frag
= frchp
->frch_last
;
354 if (frchp
->fix_root
!= (fixS
*) NULL
)
356 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
357 seg_info (section
)->fix_root
= frchp
->fix_root
;
358 prev_fix
->fx_next
= frchp
->fix_root
;
359 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
360 prev_fix
= frchp
->fix_tail
;
364 prev_frag
->fr_next
= 0;
373 chain_frchains_together (abfd
, section
, xxx
)
374 bfd
*abfd
; /* unused */
376 PTR xxx
; /* unused */
378 segment_info_type
*info
;
380 /* BFD may have introduced its own sections without using
381 subseg_new, so it is possible that seg_info is NULL. */
382 info
= seg_info (section
);
383 if (info
!= (segment_info_type
*) NULL
)
384 info
->frchainP
->frch_last
385 = chain_frchains_together_1 (section
, info
->frchainP
);
387 /* Now that we've chained the frags together, we must add new fixups
388 to the segment, not to the frag chain. */
394 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
397 remove_subsegs (head
, seg
, root
, last
)
403 *root
= head
->frch_root
;
404 *last
= chain_frchains_together_1 (seg
, head
);
409 #if defined (BFD_ASSEMBLER) || !defined (BFD)
413 cvt_frag_to_fill (sec
, fragP
)
418 cvt_frag_to_fill (headersP
, sec
, fragP
)
419 object_headers
*headersP
;
424 switch (fragP
->fr_type
)
431 HANDLE_ALIGN (fragP
);
433 know (fragP
->fr_next
!= NULL
);
434 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
436 - fragP
->fr_fix
) / fragP
->fr_var
;
437 if (fragP
->fr_offset
< 0)
439 as_bad ("attempt to .org/.space backwards? (%ld)",
440 (long) fragP
->fr_offset
);
442 fragP
->fr_type
= rs_fill
;
448 case rs_machine_dependent
:
450 md_convert_frag (stdoutput
, sec
, fragP
);
452 md_convert_frag (headersP
, sec
, fragP
);
455 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
458 * After md_convert_frag, we make the frag into a ".space 0".
459 * Md_convert_frag() should set up any fixSs and constants
465 #ifndef WORKING_DOT_WORD
468 struct broken_word
*lie
;
470 if (fragP
->fr_subtype
)
472 fragP
->fr_fix
+= md_short_jump_size
;
473 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
474 lie
&& lie
->dispfrag
== fragP
;
475 lie
= lie
->next_broken_word
)
477 fragP
->fr_fix
+= md_long_jump_size
;
485 BAD_CASE (fragP
->fr_type
);
490 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
494 relax_and_size_seg (abfd
, sec
, xxx
)
501 segment_info_type
*seginfo
;
503 valueT size
, newsize
;
505 flags
= bfd_get_section_flags (abfd
, sec
);
507 seginfo
= seg_info (sec
);
508 if (seginfo
&& seginfo
->frchainP
)
510 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
511 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
512 cvt_frag_to_fill (sec
, fragp
);
513 for (fragp
= seginfo
->frchainP
->frch_root
;
515 fragp
= fragp
->fr_next
)
516 /* walk to last elt */;
517 size
= fragp
->fr_address
+ fragp
->fr_fix
;
522 if (size
> 0 && ! seginfo
->bss
)
523 flags
|= SEC_HAS_CONTENTS
;
525 /* @@ This is just an approximation. */
526 if (seginfo
&& seginfo
->fix_root
)
530 x
= bfd_set_section_flags (abfd
, sec
, flags
);
533 newsize
= md_section_align (sec
, size
);
534 x
= bfd_set_section_size (abfd
, sec
, newsize
);
537 /* If the size had to be rounded up, add some padding in the last
539 assert (newsize
>= size
);
542 fragS
*last
= seginfo
->frchainP
->frch_last
;
543 fragp
= seginfo
->frchainP
->frch_root
;
544 while (fragp
->fr_next
!= last
)
545 fragp
= fragp
->fr_next
;
546 last
->fr_address
= size
;
547 fragp
->fr_offset
+= newsize
- size
;
550 #ifdef tc_frob_section
551 tc_frob_section (sec
);
553 #ifdef obj_frob_section
554 obj_frob_section (sec
);
560 dump_section_relocs (abfd
, sec
, stream_
)
565 FILE *stream
= (FILE *) stream_
;
566 segment_info_type
*seginfo
= seg_info (sec
);
567 fixS
*fixp
= seginfo
->fix_root
;
572 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
575 symbolS
*s
= fixp
->fx_addsy
;
578 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
579 s
->bsym
->section
->name
);
580 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
582 fprintf (stream
, " section sym");
584 fprintf (stream
, "+%x", S_GET_VALUE (s
));
587 fprintf (stream
, "+%x", S_GET_VALUE (s
));
588 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
591 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
592 fixp
= fixp
->fx_next
;
596 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
599 #ifndef EMIT_SECTION_SYMBOLS
600 #define EMIT_SECTION_SYMBOLS 1
604 adjust_reloc_syms (abfd
, sec
, xxx
)
609 segment_info_type
*seginfo
= seg_info (sec
);
615 dump_section_relocs (abfd
, sec
, stderr
);
617 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
620 else if (fixp
->fx_addsy
)
628 fprintf (stderr
, "\n\nadjusting fixup:\n");
632 sym
= fixp
->fx_addsy
;
633 symsec
= sym
->bsym
->section
;
635 if (sym
!= NULL
&& sym
->sy_mri_common
)
637 /* These symbols are handled specially in fixup_segment. */
641 /* If it's one of these sections, assume the symbol is
642 definitely going to be output. The code in
643 md_estimate_size_before_relax in tc-mips.c uses this test
644 as well, so if you change this code you should look at that
646 if (bfd_is_und_section (symsec
)
647 || bfd_is_abs_section (symsec
)
648 || bfd_is_com_section (symsec
))
650 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
651 #ifdef UNDEFINED_DIFFERENCE_OK
652 /* We have the difference of an undefined symbol and some
653 other symbol. Make sure to mark the other symbol as used
654 in a relocation so that it will always be output. */
656 fixp
->fx_subsy
->sy_used_in_reloc
= 1;
661 /* Since we're reducing to section symbols, don't attempt to reduce
662 anything that's already using one. */
663 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
665 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
669 /* Is there some other reason we can't adjust this one? (E.g.,
670 call/bal links in i960-bout symbols.) */
671 #ifdef obj_fix_adjustable
672 if (! obj_fix_adjustable (fixp
))
674 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
679 /* Is there some other (target cpu dependent) reason we can't adjust
680 this one? (E.g. relocations involving function addresses on
682 #ifdef tc_fix_adjustable
683 if (! tc_fix_adjustable (fixp
))
685 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
690 /* For PIC support: We may get expressions like
691 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
692 necessarily have had a fixed difference initially. But now
693 it should be a known constant, so we can reduce it. Since
694 we can't easily handle a symbol value that looks like
695 someUndefinedSymbol+const, though, we convert the fixup to
696 access the undefined symbol directly, and discard the
697 intermediate symbol. */
698 if (S_GET_SEGMENT (sym
) == expr_section
699 && sym
->sy_value
.X_op
== O_add
700 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
701 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
702 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
703 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
705 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
706 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
707 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
711 /* If the section symbol isn't going to be output, the relocs
712 at least should still work. If not, figure out what to do
713 when we run into that case. */
714 fixp
->fx_offset
+= S_GET_VALUE (sym
);
715 fixp
->fx_addsy
= section_symbol (symsec
);
716 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
721 #if 1/*def RELOC_REQUIRES_SYMBOL*/
724 /* There was no symbol required by this relocation. However,
725 BFD doesn't really handle relocations without symbols well.
726 (At least, the COFF support doesn't.) So for now we fake up
727 a local symbol in the absolute section. */
729 fixp
->fx_addsy
= section_symbol (absolute_section
);
730 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
734 dump_section_relocs (abfd
, sec
, stderr
);
738 write_relocs (abfd
, sec
, xxx
)
743 segment_info_type
*seginfo
= seg_info (sec
);
750 /* If seginfo is NULL, we did not create this section; don't do
755 fixup_segment (seginfo
->fix_root
, sec
);
758 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
761 #ifndef RELOC_EXPANSION_POSSIBLE
762 /* Set up reloc information as well. */
763 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
764 n
* sizeof (arelent
*));
765 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
768 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
771 bfd_reloc_status_type s
;
778 reloc
= tc_gen_reloc (sec
, fixp
);
784 if (fixp
->fx_where
+ fixp
->fx_size
785 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
788 s
= bfd_install_relocation (stdoutput
, reloc
,
789 fixp
->fx_frag
->fr_literal
,
790 fixp
->fx_frag
->fr_address
,
796 case bfd_reloc_overflow
:
797 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
800 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
801 fixp
->fx_file
, fixp
->fx_line
);
806 n
= n
* MAX_RELOC_EXPANSION
;
807 /* Set up reloc information as well. */
808 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
809 n
* sizeof (arelent
*));
812 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
816 bfd_reloc_status_type s
;
824 reloc
= tc_gen_reloc (sec
, fixp
);
826 for (j
= 0; reloc
[j
]; j
++)
828 relocs
[i
++] = reloc
[j
];
831 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
832 if (fixp
->fx_where
+ fixp
->fx_size
833 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
835 for (j
= 0; reloc
[j
]; j
++)
837 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
838 fixp
->fx_frag
->fr_literal
,
839 fixp
->fx_frag
->fr_address
,
845 case bfd_reloc_overflow
:
846 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
847 "relocation overflow");
850 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
851 fixp
->fx_file
, fixp
->fx_line
);
862 sympp
= bfd_get_outsymbols (stdoutput
);
863 nsyms
= bfd_get_symcount (stdoutput
);
864 for (i
= 0; i
< n
; i
++)
865 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
867 for (j
= 0; j
< nsyms
; j
++)
868 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
877 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
879 bfd_set_section_flags (abfd
, sec
,
880 (bfd_get_section_flags (abfd
, sec
)
881 & (flagword
) ~SEC_RELOC
));
888 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
889 for (i
= 0; i
< n
; i
++)
893 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
894 i
, r
, r
->address
, s
->name
, r
->addend
);
901 write_contents (abfd
, sec
, xxx
)
906 segment_info_type
*seginfo
= seg_info (sec
);
907 unsigned long offset
= 0;
910 /* Write out the frags. */
912 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
915 for (f
= seginfo
->frchainP
->frch_root
;
920 unsigned long fill_size
;
924 assert (f
->fr_type
== rs_fill
);
927 x
= bfd_set_section_contents (stdoutput
, sec
,
928 f
->fr_literal
, (file_ptr
) offset
,
929 (bfd_size_type
) f
->fr_fix
);
932 bfd_perror (stdoutput
->filename
);
933 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
938 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
939 fill_size
= f
->fr_var
;
940 count
= f
->fr_offset
;
942 if (fill_size
&& count
)
943 #ifdef BFD_FAST_SECTION_FILL
946 if (fill_size
> sizeof(buf
)) {
947 /* Do it the old way. Can this ever happen? */
950 x
= bfd_set_section_contents (stdoutput
, sec
,
951 fill_literal
, (file_ptr
) offset
,
952 (bfd_size_type
) fill_size
);
955 bfd_perror (stdoutput
->filename
);
956 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
963 /* Build a buffer full of fill objects and output it as
964 * often as necessary. This saves on the overhead of potentially
965 * lots of bfd_set_section_contents calls.
970 n_per_buf
= sizeof (buf
);
971 memset (buf
, *fill_literal
, n_per_buf
);
976 n_per_buf
= sizeof(buf
)/fill_size
;
977 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
978 memcpy(bufp
, fill_literal
, fill_size
);
980 for (; count
> 0; count
-= n_per_buf
)
982 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
983 x
= bfd_set_section_contents (stdoutput
, sec
,
984 buf
, (file_ptr
) offset
,
985 (bfd_size_type
) n_per_buf
* fill_size
);
987 as_fatal ("Cannot write to output file.");
988 offset
+= n_per_buf
* fill_size
;
995 x
= bfd_set_section_contents (stdoutput
, sec
,
996 fill_literal
, (file_ptr
) offset
,
997 (bfd_size_type
) fill_size
);
999 as_fatal ("Cannot write to output file.");
1000 offset
+= fill_size
;
1007 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1009 merge_data_into_text ()
1011 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1012 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
1013 seg_info (data_section
)->frchainP
->frch_root
;
1014 seg_info (text_section
)->frchainP
->frch_last
=
1015 seg_info (data_section
)->frchainP
->frch_last
;
1016 seg_info (data_section
)->frchainP
= 0;
1020 text_last_frag
->fr_next
= data_frag_root
;
1021 text_last_frag
= data_last_frag
;
1022 data_last_frag
= NULL
;
1023 data_frag_root
= NULL
;
1026 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1027 tmp
->fx_next
= data_fix_root
;
1028 text_fix_tail
= data_fix_tail
;
1031 text_fix_root
= data_fix_root
;
1032 data_fix_root
= NULL
;
1035 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1037 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1039 relax_and_size_all_segments ()
1043 relax_segment (text_frag_root
, SEG_TEXT
);
1044 relax_segment (data_frag_root
, SEG_DATA
);
1045 relax_segment (bss_frag_root
, SEG_BSS
);
1047 * Now the addresses of frags are correct within the segment.
1050 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1051 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1052 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1055 * Join the 2 segments into 1 huge segment.
1056 * To do this, re-compute every rn_address in the SEG_DATA frags.
1057 * Then join the data frags after the text frags.
1059 * Determine a_data [length of data segment].
1063 register relax_addressT slide
;
1065 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1067 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1068 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1069 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1071 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1072 /* For b.out: If the data section has a strict alignment
1073 requirement, its load address in the .o file will be
1074 rounded up from the size of the text section. These
1075 two values are *not* the same! Similarly for the bss
1077 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1080 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1082 fragP
->fr_address
+= slide
;
1083 } /* for each data frag */
1085 know (text_last_frag
!= 0);
1086 text_last_frag
->fr_next
= data_frag_root
;
1090 H_SET_DATA_SIZE (&headers
, 0);
1094 /* See above comments on b.out data section address. */
1097 if (data_last_frag
== 0)
1098 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1100 bss_vma
= data_last_frag
->fr_address
;
1101 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1102 bss_address_frag
.fr_address
= bss_vma
;
1104 #else /* ! OBJ_BOUT */
1105 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1106 H_GET_DATA_SIZE (&headers
));
1108 #endif /* ! OBJ_BOUT */
1110 /* Slide all the frags */
1113 relax_addressT slide
= bss_address_frag
.fr_address
;
1115 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1117 fragP
->fr_address
+= slide
;
1118 } /* for each bss frag */
1122 H_SET_BSS_SIZE (&headers
,
1123 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1125 H_SET_BSS_SIZE (&headers
, 0);
1127 #endif /* ! BFD_ASSEMBLER && ! BFD */
1129 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1131 #ifdef BFD_ASSEMBLER
1139 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1141 /* Count symbols. We can't rely on a count made by the loop in
1142 write_object_file, because *_frob_file may add a new symbol or
1145 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1152 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1153 nsyms
* sizeof (asymbol
*));
1154 symp
= symbol_rootP
;
1155 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1157 asympp
[i
] = symp
->bsym
;
1163 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1164 assert (result
== true);
1165 symbol_table_frozen
= 1;
1170 write_object_file ()
1172 struct frchain
*frchainP
; /* Track along all frchains. */
1173 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1174 fragS
*fragP
; /* Track along all frags. */
1177 /* Do we really want to write it? */
1179 int n_warns
, n_errs
;
1180 n_warns
= had_warnings ();
1181 n_errs
= had_errors ();
1182 /* The -Z flag indicates that an object file should be generated,
1183 regardless of warnings and errors. */
1184 if (flag_always_generate_output
)
1186 if (n_warns
|| n_errs
)
1187 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1188 n_errs
, n_errs
== 1 ? "" : "s",
1189 n_warns
, n_warns
== 1 ? "" : "s");
1194 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1195 n_errs
, n_errs
== 1 ? "" : "s",
1196 n_warns
, n_warns
== 1 ? "" : "s");
1201 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1202 a routine to check for the definition of the procedure "_main",
1203 and if so -- fix it up so that it can be program entry point. */
1204 vms_check_for_main ();
1205 #endif /* OBJ_VMS */
1207 /* After every sub-segment, we fake an ".align ...". This conforms to
1208 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1209 frag that requires least thought. ".align" frags like to have a
1210 following frag since that makes calculating their intended length
1213 @@ Is this really necessary?? */
1214 #ifndef SUB_SEGMENT_ALIGN
1215 #ifdef BFD_ASSEMBLER
1216 #define SUB_SEGMENT_ALIGN(SEG) (0)
1218 #define SUB_SEGMENT_ALIGN(SEG) (2)
1221 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1223 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1224 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1225 /* frag_align will have left a new frag.
1226 Use this last frag for an empty ".fill".
1228 For this segment ...
1229 Create a last frag. Do not leave a "being filled in frag". */
1230 frag_wane (frag_now
);
1231 frag_now
->fr_fix
= 0;
1232 know (frag_now
->fr_next
== NULL
);
1235 /* From now on, we don't care about sub-segments. Build one frag chain
1236 for each segment. Linked thru fr_next. */
1238 #ifdef BFD_ASSEMBLER
1239 /* Remove the sections created by gas for its own purposes. */
1241 asection
**seclist
, *sec
;
1244 seclist
= &stdoutput
->sections
;
1245 while (seclist
&& *seclist
)
1248 while (sec
== reg_section
|| sec
== expr_section
)
1252 stdoutput
->section_count
--;
1257 seclist
= &(*seclist
)->next
;
1260 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1263 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1265 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1266 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1267 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1270 /* We have two segments. If user gave -R flag, then we must put the
1271 data frags into the text segment. Do this before relaxing so
1272 we know to take advantage of -R and make shorter addresses. */
1273 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1274 if (flag_readonly_data_in_text
)
1276 merge_data_into_text ();
1280 #ifdef BFD_ASSEMBLER
1281 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1283 relax_and_size_all_segments ();
1284 #endif /* BFD_ASSEMBLER */
1286 #ifndef BFD_ASSEMBLER
1289 * Crawl the symbol chain.
1291 * For each symbol whose value depends on a frag, take the address of
1292 * that frag and subsume it into the value of the symbol.
1293 * After this, there is just one way to lookup a symbol value.
1294 * Values are left in their final state for object file emission.
1295 * We adjust the values of 'L' local symbols, even if we do
1296 * not intend to emit them to the object file, because their values
1297 * are needed for fix-ups.
1299 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1300 * from the symbol chain. (They are still pointed to by the fixes.)
1302 * Count the remaining symbols.
1303 * Assign a symbol number to each symbol.
1304 * Count the number of string-table chars we will emit.
1305 * Put this info into the headers as appropriate.
1308 know (zero_address_frag
.fr_address
== 0);
1309 string_byte_count
= sizeof (string_byte_count
);
1311 obj_crawl_symbol_chain (&headers
);
1313 if (string_byte_count
== sizeof (string_byte_count
))
1314 string_byte_count
= 0;
1316 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1319 * Addresses of frags now reflect addresses we use in the object file.
1320 * Symbol values are correct.
1321 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1322 * Also converting any machine-dependent frags using md_convert_frag();
1324 subseg_change (SEG_TEXT
, 0);
1326 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1328 cvt_frag_to_fill (&headers
, SEG_TEXT
, fragP
);
1330 /* Some assert macros don't work with # directives mixed in. */
1332 if (!(fragP
->fr_next
== NULL
1334 || fragP
->fr_next
== data_frag_root
1336 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1337 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1341 #endif /* ! BFD_ASSEMBLER */
1343 #ifndef WORKING_DOT_WORD
1345 struct broken_word
*lie
;
1346 struct broken_word
**prevP
;
1348 prevP
= &broken_words
;
1349 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1354 exp
.X_op
= O_subtract
;
1355 exp
.X_add_symbol
= lie
->add
;
1356 exp
.X_op_symbol
= lie
->sub
;
1357 exp
.X_add_number
= lie
->addnum
;
1358 #ifdef BFD_ASSEMBLER
1359 #ifdef TC_CONS_FIX_NEW
1360 TC_CONS_FIX_NEW (lie
->frag
,
1361 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1364 fix_new_exp (lie
->frag
,
1365 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1366 2, &exp
, 0, BFD_RELOC_NONE
);
1369 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1370 fix_new_exp (lie
->frag
,
1371 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1372 2, &exp
, 0, NO_RELOC
);
1375 fix_new_ns32k_exp (lie
->frag
,
1376 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1377 2, &exp
, 0, 0, 2, 0, 0);
1379 fix_new_exp (lie
->frag
,
1380 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1382 #endif /* TC_NS32K */
1383 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1384 #endif /* BFD_ASSEMBLER */
1385 *prevP
= lie
->next_broken_word
;
1388 prevP
= &(lie
->next_broken_word
);
1390 for (lie
= broken_words
; lie
;)
1392 struct broken_word
*untruth
;
1394 addressT table_addr
;
1395 addressT from_addr
, to_addr
;
1398 fragP
= lie
->dispfrag
;
1400 /* Find out how many broken_words go here. */
1402 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1403 if (untruth
->added
== 1)
1406 table_ptr
= lie
->dispfrag
->fr_opcode
;
1407 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1408 /* Create the jump around the long jumps. This is a short
1409 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1410 from_addr
= table_addr
;
1411 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1412 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1413 table_ptr
+= md_short_jump_size
;
1414 table_addr
+= md_short_jump_size
;
1416 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1418 if (lie
->added
== 2)
1420 /* Patch the jump table */
1421 /* This is the offset from ??? to table_ptr+0 */
1422 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1423 #ifdef BFD_ASSEMBLER
1424 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1426 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1427 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1429 if (untruth
->use_jump
== lie
)
1430 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1433 /* Install the long jump */
1434 /* this is a long jump from table_ptr+0 to the final target */
1435 from_addr
= table_addr
;
1436 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1437 #ifdef BFD_ASSEMBLER
1438 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1440 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1441 table_ptr
+= md_long_jump_size
;
1442 table_addr
+= md_long_jump_size
;
1446 #endif /* not WORKING_DOT_WORD */
1448 #ifndef BFD_ASSEMBLER
1451 char *the_object_file
;
1452 long object_file_size
;
1454 * Scan every FixS performing fixups. We had to wait until now to do
1455 * this because md_convert_frag() may have made some fixSs.
1459 subseg_change (SEG_TEXT
, 0);
1460 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1461 subseg_change (SEG_DATA
, 0);
1462 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1463 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1465 /* FIXME move this stuff into the pre-write-hook */
1466 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1467 H_SET_ENTRY_POINT (&headers
, 0);
1469 obj_pre_write_hook (&headers
); /* extra coff stuff */
1471 object_file_size
= H_GET_FILE_SIZE (&headers
);
1472 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1474 output_file_create (out_file_name
);
1476 obj_header_append (&next_object_file_charP
, &headers
);
1478 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1483 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1485 register long count
;
1486 register char *fill_literal
;
1487 register long fill_size
;
1490 know (fragP
->fr_type
== rs_fill
);
1491 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1492 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1493 fill_size
= fragP
->fr_var
;
1494 know (fragP
->fr_offset
>= 0);
1496 for (count
= fragP
->fr_offset
; count
; count
--)
1498 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1501 } /* for each code frag. */
1503 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1508 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1509 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
)));
1511 /* Make addresses in data relocation directives relative to beginning of
1512 * first data fragment, not end of last text fragment: alignment of the
1513 * start of the data segment may place a gap between the segments.
1515 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1517 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1518 #endif /* TC_I960 */
1520 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
)));
1523 * Emit line number entries.
1525 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1526 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
)));
1531 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1532 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
)));
1538 if (string_byte_count
> 0)
1540 obj_emit_strings (&next_object_file_charP
);
1541 } /* only if we have a string table */
1544 bfd_seek (stdoutput
, 0, 0);
1545 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1548 /* Write the data to the file */
1549 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1550 free (the_object_file
);
1552 } /* non vms output */
1555 * Now do the VMS-dependent part of writing the object file
1557 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1558 H_GET_DATA_SIZE (&headers
),
1559 H_GET_BSS_SIZE (&headers
),
1560 text_frag_root
, data_frag_root
);
1561 #endif /* OBJ_VMS */
1562 #else /* BFD_ASSEMBLER */
1564 /* Resolve symbol values. This needs to be done before processing
1570 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1571 if (!symp
->sy_resolved
)
1572 resolve_symbol_value (symp
);
1577 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1579 /* Set up symbol table, and write it out. */
1584 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1589 if (symp
->sy_mri_common
)
1591 if (S_IS_EXTERNAL (symp
))
1592 as_bad ("%s: global symbols not supported in common sections",
1594 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1598 name
= S_GET_NAME (symp
);
1601 const char *name2
= decode_local_label_name ((char *)S_GET_NAME (symp
));
1602 /* They only differ if `name' is a fb or dollar local
1604 if (name2
!= name
&& ! S_IS_DEFINED (symp
))
1605 as_bad ("local label %s is not defined", name2
);
1608 /* Do it again, because adjust_reloc_syms might introduce
1609 more symbols. They'll probably only be section symbols,
1610 but they'll still need to have the values computed. */
1611 if (! symp
->sy_resolved
)
1613 if (symp
->sy_value
.X_op
== O_constant
)
1615 /* This is the normal case; skip the call. */
1618 + symp
->sy_frag
->fr_address
));
1619 symp
->sy_resolved
= 1;
1622 resolve_symbol_value (symp
);
1625 /* So far, common symbols have been treated like undefined symbols.
1626 Put them in the common section now. */
1627 if (S_IS_DEFINED (symp
) == 0
1628 && S_GET_VALUE (symp
) != 0)
1629 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1631 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1632 S_GET_NAME (symp
), symp
,
1635 segment_name (symp
->bsym
->section
));
1638 #ifdef obj_frob_symbol
1639 obj_frob_symbol (symp
, punt
);
1641 #ifdef tc_frob_symbol
1642 if (! punt
|| symp
->sy_used_in_reloc
)
1643 tc_frob_symbol (symp
, punt
);
1646 /* If we don't want to keep this symbol, splice it out of
1647 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1648 want section symbols. Otherwise, we skip local symbols
1649 and symbols that the frob_symbol macros told us to punt,
1650 but we keep such symbols if they are used in relocs. */
1651 if ((! EMIT_SECTION_SYMBOLS
1652 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1653 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1654 opposites. Sometimes the former checks flags and the
1655 latter examines the name... */
1656 || (!S_IS_EXTERN (symp
)
1657 && (S_IS_LOCAL (symp
) || punt
)
1658 && ! symp
->sy_used_in_reloc
))
1660 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1661 /* After symbol_remove, symbol_next(symp) still returns
1662 the one that came after it in the chain. So we don't
1663 need to do any extra cleanup work here. */
1668 /* Make sure we really got a value for the symbol. */
1669 if (! symp
->sy_resolved
)
1671 as_bad ("can't resolve value for symbol \"%s\"",
1673 symp
->sy_resolved
= 1;
1676 /* Set the value into the BFD symbol. Up til now the value
1677 has only been kept in the gas symbolS struct. */
1678 symp
->bsym
->value
= S_GET_VALUE (symp
);
1684 /* Now do any format-specific adjustments to the symbol table, such
1685 as adding file symbols. */
1686 #ifdef obj_adjust_symtab
1687 obj_adjust_symtab ();
1690 /* Now that all the sizes are known, and contents correct, we can
1691 start writing to the file. */
1694 /* If *_frob_file changes the symbol value at this point, it is
1695 responsible for moving the changed value into symp->bsym->value
1696 as well. Hopefully all symbol value changing can be done in
1701 #ifdef obj_frob_file
1705 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1707 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1708 #endif /* BFD_ASSEMBLER */
1715 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1720 * After this, all frags in this segment have addresses that are correct
1721 * within the segment. Since segments live in different file addresses,
1722 * these frag addresses may not be the same as final object-file addresses.
1725 #ifndef md_relax_frag
1727 /* Subroutines of relax_segment. */
1733 for (; f1
; f1
= f1
->fr_next
)
1734 if (f1
->fr_next
== f2
)
1739 #endif /* ! defined (md_relax_frag) */
1741 /* Relax_align. Advance location counter to next address that has 'alignment'
1742 lowest order bits all 0s, return size of adjustment made. */
1743 static relax_addressT
1744 relax_align (address
, alignment
)
1745 register relax_addressT address
; /* Address now. */
1746 register int alignment
; /* Alignment (binary). */
1748 relax_addressT mask
;
1749 relax_addressT new_address
;
1751 mask
= ~((~0) << alignment
);
1752 new_address
= (address
+ mask
) & (~mask
);
1753 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1755 /* We must provide lots of padding, so the linker can discard it
1756 when needed. The linker will not add extra space, ever. */
1757 new_address
+= (1 << alignment
);
1759 return (new_address
- address
);
1763 relax_segment (segment_frag_root
, segment
)
1764 struct frag
*segment_frag_root
;
1767 register struct frag
*fragP
;
1768 register relax_addressT address
;
1769 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1770 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1772 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1773 subseg_change (segment
, 0);
1775 /* For each frag in segment: count and store (a 1st guess of)
1778 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1780 fragP
->fr_address
= address
;
1781 address
+= fragP
->fr_fix
;
1783 switch (fragP
->fr_type
)
1786 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1792 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1793 if (offset
% fragP
->fr_var
!= 0)
1795 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1796 offset
, (long) fragP
->fr_var
);
1797 offset
-= (offset
% fragP
->fr_var
);
1805 /* Assume .org is nugatory. It will grow with 1st relax. */
1808 case rs_machine_dependent
:
1809 address
+= md_estimate_size_before_relax (fragP
, segment
);
1812 #ifndef WORKING_DOT_WORD
1813 /* Broken words don't concern us yet */
1814 case rs_broken_word
:
1819 BAD_CASE (fragP
->fr_type
);
1821 } /* switch(fr_type) */
1822 } /* for each frag in the segment */
1826 long stretch
; /* May be any size, 0 or negative. */
1827 /* Cumulative number of addresses we have */
1828 /* relaxed this pass. */
1829 /* We may have relaxed more than one address. */
1830 long stretched
; /* Have we stretched on this pass? */
1831 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1832 grew, and another shrank. If a branch instruction doesn't fit anymore,
1833 we could be scrod. */
1837 stretch
= stretched
= 0;
1838 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1841 unsigned long was_address
;
1847 was_address
= fragP
->fr_address
;
1848 address
= fragP
->fr_address
+= stretch
;
1849 symbolP
= fragP
->fr_symbol
;
1850 offset
= fragP
->fr_offset
;
1852 switch (fragP
->fr_type
)
1854 case rs_fill
: /* .fill never relaxes. */
1858 #ifndef WORKING_DOT_WORD
1859 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1860 for it I do not want to write it. I do not want to have
1861 anything to do with it. This is not the proper way to
1862 implement this misfeature. */
1863 case rs_broken_word
:
1865 struct broken_word
*lie
;
1866 struct broken_word
*untruth
;
1868 /* Yes this is ugly (storing the broken_word pointer
1869 in the symbol slot). Still, this whole chunk of
1870 code is ugly, and I don't feel like doing anything
1871 about it. Think of it as stubbornness in action. */
1873 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1874 lie
&& lie
->dispfrag
== fragP
;
1875 lie
= lie
->next_broken_word
)
1881 offset
= (lie
->add
->sy_frag
->fr_address
1882 + S_GET_VALUE (lie
->add
)
1884 - (lie
->sub
->sy_frag
->fr_address
1885 + S_GET_VALUE (lie
->sub
)));
1886 if (offset
<= -32768 || offset
>= 32767)
1888 if (flag_warn_displacement
)
1891 sprint_value (buf
, (addressT
) lie
->addnum
);
1892 as_warn (".word %s-%s+%s didn't fit",
1893 S_GET_NAME (lie
->add
),
1894 S_GET_NAME (lie
->sub
),
1898 if (fragP
->fr_subtype
== 0)
1900 fragP
->fr_subtype
++;
1901 growth
+= md_short_jump_size
;
1903 for (untruth
= lie
->next_broken_word
;
1904 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1905 untruth
= untruth
->next_broken_word
)
1906 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1907 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1910 untruth
->use_jump
= lie
;
1912 growth
+= md_long_jump_size
;
1917 } /* case rs_broken_word */
1921 growth
= (relax_align ((relax_addressT
) (address
1924 - relax_align ((relax_addressT
) (was_address
1934 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1935 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1936 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1937 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1938 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1939 know (symbolP
->sy_frag
);
1940 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1941 || (symbolP
->sy_frag
== &zero_address_frag
));
1943 target
+= S_GET_VALUE (symbolP
)
1944 + symbolP
->sy_frag
->fr_address
;
1945 } /* if we have a symbol */
1947 know (fragP
->fr_next
);
1948 after
= fragP
->fr_next
->fr_address
;
1949 growth
= target
- after
;
1952 /* Growth may be negative, but variable part of frag
1953 cannot have fewer than 0 chars. That is, we can't
1955 as_bad ("attempt to .org backwards ignored");
1959 growth
-= stretch
; /* This is an absolute growth factor */
1965 growth
= S_GET_VALUE (symbolP
);
1966 if (symbolP
->sy_frag
!= &zero_address_frag
)
1967 as_bad (".space specifies non-absolute value");
1968 fragP
->fr_symbol
= 0;
1971 as_warn (".space or .fill with negative value, ignored");
1979 case rs_machine_dependent
:
1980 #ifdef md_relax_frag
1981 growth
= md_relax_frag (fragP
, stretch
);
1983 #ifdef TC_GENERIC_RELAX_TABLE
1984 /* The default way to relax a frag is to look through
1987 const relax_typeS
*this_type
;
1988 const relax_typeS
*start_type
;
1989 relax_substateT next_state
;
1990 relax_substateT this_state
;
1992 const relax_typeS
*table
= TC_GENERIC_RELAX_TABLE
;
1994 this_state
= fragP
->fr_subtype
;
1995 start_type
= this_type
= table
+ this_state
;
2000 #ifndef DIFF_EXPR_OK
2001 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2002 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
2003 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
2004 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
2005 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
2007 know (symbolP
->sy_frag
);
2009 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
2010 || symbolP
->sy_frag
== &zero_address_frag
);
2012 S_GET_VALUE (symbolP
)
2013 + symbolP
->sy_frag
->fr_address
;
2015 /* If frag has yet to be reached on this pass,
2016 assume it will move by STRETCH just as we did.
2017 If this is not so, it will be because some frag
2018 between grows, and that will force another pass.
2020 Beware zero-length frags.
2022 There should be a faster way to do this. */
2024 if (symbolP
->sy_frag
->fr_address
>= was_address
2025 && is_dnrange (fragP
, symbolP
->sy_frag
))
2031 aim
= target
- address
- fragP
->fr_fix
;
2032 #ifdef TC_PCREL_ADJUST
2033 /* Currently only the ns32k family needs this */
2034 aim
+= TC_PCREL_ADJUST(fragP
);
2036 /* This machine doesn't want to use pcrel_adjust.
2037 In that case, pcrel_adjust should be zero. */
2038 assert (fragP
->fr_pcrel_adjust
== 0);
2043 /* Look backwards. */
2044 for (next_state
= this_type
->rlx_more
; next_state
;)
2045 if (aim
>= this_type
->rlx_backward
)
2049 /* Grow to next state. */
2050 this_state
= next_state
;
2051 this_type
= table
+ this_state
;
2052 next_state
= this_type
->rlx_more
;
2057 #ifdef M68K_AIM_KLUDGE
2058 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2060 /* Look forwards. */
2061 for (next_state
= this_type
->rlx_more
; next_state
;)
2062 if (aim
<= this_type
->rlx_forward
)
2066 /* Grow to next state. */
2067 this_state
= next_state
;
2068 this_type
= table
+ this_state
;
2069 next_state
= this_type
->rlx_more
;
2073 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2075 fragP
->fr_subtype
= this_state
;
2077 #endif /* TC_GENERIC_RELAX_TABLE */
2082 BAD_CASE (fragP
->fr_type
);
2090 } /* For each frag in the segment. */
2092 while (stretched
); /* Until nothing further to relax. */
2096 * We now have valid fr_address'es for each frag.
2100 * All fr_address's are correct, relative to their own segment.
2101 * We have made all the fixS we will ever make.
2103 } /* relax_segment() */
2105 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2107 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2108 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2113 Go through all the fixS's in a segment and see which ones can be
2114 handled now. (These consist of fixS where we have since discovered
2115 the value of a symbol, or the address of the frag involved.)
2116 For each one, call md_apply_fix to put the fix into the frag data.
2118 Result is a count of how many relocation structs will be needed to
2119 handle the remaining fixS's that we couldn't completely handle here.
2120 These will be output later by emit_relocations(). */
2123 fixup_segment (fixP
, this_segment_type
)
2124 register fixS
*fixP
;
2125 segT this_segment_type
; /* N_TYPE bits for segment. */
2127 long seg_reloc_count
= 0;
2128 symbolS
*add_symbolP
;
2129 symbolS
*sub_symbolP
;
2136 segT add_symbol_segment
= absolute_section
;
2138 /* If the linker is doing the relaxing, we must not do any fixups.
2140 Well, strictly speaking that's not true -- we could do any that are
2141 PC-relative and don't cross regions that could change size. And for the
2142 i960 (the only machine for which we've got a relaxing linker right now),
2143 we might be able to turn callx/callj into bal anyways in cases where we
2144 know the maximum displacement. */
2147 for (; fixP
; fixP
= fixP
->fx_next
)
2149 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2150 return seg_reloc_count
;
2153 for (; fixP
; fixP
= fixP
->fx_next
)
2156 fprintf (stderr
, "\nprocessing fixup:\n");
2160 fragP
= fixP
->fx_frag
;
2162 where
= fixP
->fx_where
;
2163 place
= fragP
->fr_literal
+ where
;
2164 size
= fixP
->fx_size
;
2165 add_symbolP
= fixP
->fx_addsy
;
2166 #ifdef TC_VALIDATE_FIX
2167 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2169 sub_symbolP
= fixP
->fx_subsy
;
2170 add_number
= fixP
->fx_offset
;
2171 pcrel
= fixP
->fx_pcrel
;
2174 if (add_symbolP
!= NULL
2175 && add_symbolP
->sy_mri_common
)
2177 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
2178 add_number
+= S_GET_VALUE (add_symbolP
);
2179 fixP
->fx_offset
= add_number
;
2180 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
2184 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2188 resolve_symbol_value (sub_symbolP
);
2192 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2193 add_number
-= S_GET_VALUE (sub_symbolP
);
2195 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2197 /* Should try converting to a constant. */
2202 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2203 "Negative of non-absolute symbol %s",
2204 S_GET_NAME (sub_symbolP
));
2206 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2207 && (SEG_NORMAL (add_symbol_segment
)
2208 || (add_symbol_segment
== absolute_section
)))
2210 /* Difference of 2 symbols from same segment.
2211 Can't make difference of 2 undefineds: 'value' means
2212 something different for N_UNDF. */
2214 /* Makes no sense to use the difference of 2 arbitrary symbols
2215 as the target of a call instruction. */
2217 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2218 "callj to difference of 2 symbols");
2219 #endif /* TC_I960 */
2220 add_number
+= S_GET_VALUE (add_symbolP
) -
2221 S_GET_VALUE (sub_symbolP
);
2224 pcrel
= 0; /* No further pcrel processing. */
2226 /* Let the target machine make the final determination
2227 as to whether or not a relocation will be needed to
2228 handle this fixup. */
2229 if (!TC_FORCE_RELOCATION (fixP
))
2232 fixP
->fx_addsy
= NULL
;
2237 /* Different segments in subtraction. */
2238 know (!(S_IS_EXTERNAL (sub_symbolP
)
2239 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2241 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2242 add_number
-= S_GET_VALUE (sub_symbolP
);
2245 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2246 #if 0 /* Do this even if it's already described as pc-relative. For example,
2247 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2248 pc-relative mode. */
2253 /* Make it pc-relative. */
2254 add_number
+= (md_pcrel_from (fixP
)
2255 - S_GET_VALUE (sub_symbolP
));
2262 #ifdef UNDEFINED_DIFFERENCE_OK
2263 /* The PA needs this for PIC code generation. We basically
2264 don't want to do anything if we have the difference of two
2265 symbols at this point. */
2268 /* Leave it alone. */
2271 #ifdef BFD_ASSEMBLER
2272 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2273 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2275 /* Leave it alone. */
2281 sprint_value (buf
, fragP
->fr_address
+ where
);
2282 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2283 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2284 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2285 S_GET_NAME (sub_symbolP
), buf
);
2292 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2293 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
))
2296 * This fixup was made when the symbol's segment was
2297 * SEG_UNKNOWN, but it is now in the local segment.
2298 * So we know how to do the address without relocation.
2301 /* reloc_callj() may replace a 'call' with a 'calls' or a
2302 'bal', in which cases it modifies *fixP as appropriate.
2303 In the case of a 'calls', no further work is required,
2304 and *fixP has been set up to make the rest of the code
2307 #endif /* TC_I960 */
2309 add_number
+= S_GET_VALUE (add_symbolP
);
2310 add_number
-= md_pcrel_from (fixP
);
2311 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2313 /* Let the target machine make the final determination
2314 as to whether or not a relocation will be needed to
2315 handle this fixup. */
2316 if (!TC_FORCE_RELOCATION (fixP
))
2319 fixP
->fx_addsy
= NULL
;
2324 if (add_symbol_segment
== absolute_section
)
2327 /* See comment about reloc_callj() above. */
2329 #endif /* TC_I960 */
2330 add_number
+= S_GET_VALUE (add_symbolP
);
2332 /* Let the target machine make the final determination
2333 as to whether or not a relocation will be needed to
2334 handle this fixup. */
2335 if (!TC_FORCE_RELOCATION (fixP
))
2337 fixP
->fx_addsy
= NULL
;
2341 else if (add_symbol_segment
== undefined_section
2342 #ifdef BFD_ASSEMBLER
2343 || bfd_is_com_section (add_symbol_segment
)
2348 if ((int) fixP
->fx_bit_fixP
== 13)
2350 /* This is a COBR instruction. They have only a
2351 * 13-bit displacement and are only to be used
2352 * for local branches: flag as error, don't generate
2355 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2356 "can't use COBR format with external label");
2357 fixP
->fx_addsy
= NULL
;
2361 #endif /* TC_I960 */
2365 if (S_IS_COMMON (add_symbolP
))
2366 add_number
+= S_GET_VALUE (add_symbolP
);
2367 #endif /* TE_I386AIX */
2368 #endif /* OBJ_COFF */
2374 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2375 add_number
+= S_GET_VALUE (add_symbolP
);
2383 add_number
-= md_pcrel_from (fixP
);
2384 if (add_symbolP
== 0)
2386 #ifndef BFD_ASSEMBLER
2387 fixP
->fx_addsy
= &abs_symbol
;
2389 fixP
->fx_addsy
= section_symbol (absolute_section
);
2391 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2396 if (!fixP
->fx_bit_fixP
&& !fixP
->fx_no_overflow
&& size
> 0)
2399 if (size
< sizeof (mask
))
2401 /* set all bits to one */
2403 /* Technically, combining these produces an undefined result
2404 if size is sizeof (valueT), though I think these two
2405 half-way operations should both be defined. And the
2406 compiler should be able to combine them if it's valid on
2407 the host architecture. */
2410 if ((add_number
& mask
) != 0
2411 && (add_number
& mask
) != mask
)
2413 char buf
[50], buf2
[50];
2414 sprint_value (buf
, fragP
->fr_address
+ where
);
2415 if (add_number
> 1000)
2416 sprint_value (buf2
, add_number
);
2418 sprintf (buf2
, "%ld", (long) add_number
);
2419 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2420 "Value of %s too large for field of %d bytes at %s",
2422 } /* generic error checking */
2424 #ifdef WARN_SIGNED_OVERFLOW_WORD
2425 /* Warn if a .word value is too large when treated as a signed
2426 number. We already know it is not too negative. This is to
2427 catch over-large switches generated by gcc on the 68k. */
2428 if (!flag_signed_overflow_ok
2430 && add_number
> 0x7fff)
2431 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2432 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2434 (unsigned long) (fragP
->fr_address
+ where
));
2436 } /* not a bit fix */
2440 #ifdef MD_APPLY_FIX3
2441 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2443 #ifdef BFD_ASSEMBLER
2444 md_apply_fix (fixP
, &add_number
);
2446 md_apply_fix (fixP
, add_number
);
2450 #ifndef TC_HANDLES_FX_DONE
2451 /* If the tc-* files haven't been converted, assume it's handling
2452 it the old way, where a null fx_addsy means that the fix has
2453 been applied completely, and no further work is needed. */
2454 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2458 #ifdef TC_VALIDATE_FIX
2462 fprintf (stderr
, "result:\n");
2465 } /* For each fixS in this segment. */
2467 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2468 return seg_reloc_count
;
2471 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2474 number_to_chars_bigendian (buf
, val
, n
)
2479 if (n
> sizeof (val
)|| n
<= 0)
2483 buf
[n
] = val
& 0xff;
2489 number_to_chars_littleendian (buf
, val
, n
)
2494 if (n
> sizeof (val
) || n
<= 0)
2498 *buf
++ = val
& 0xff;
2504 extern int indent_level
;
2505 extern void print_symbol_value_1 ();
2512 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2514 fprintf (stderr
, " pcrel");
2515 if (fixp
->fx_pcrel_adjust
)
2516 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2517 if (fixp
->fx_im_disp
)
2520 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2522 fprintf (stderr
, " im_disp");
2526 fprintf (stderr
, " tcbit");
2528 fprintf (stderr
, " done");
2529 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2530 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2531 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2532 #ifdef BFD_ASSEMBLER
2533 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2536 #ifdef NEED_FX_R_TYPE
2537 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2542 fprintf (stderr
, "\n +<");
2543 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2544 fprintf (stderr
, ">");
2548 fprintf (stderr
, "\n -<");
2549 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2550 fprintf (stderr
, ">");
2552 fprintf (stderr
, "\n");
2555 /* end of write.c */