1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 96, 1997
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 the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This thing should be set up to do byteordering correctly. But... */
27 #include "output-file.h"
29 /* This looks like a good idea. Let's try turning it on always, for now. */
30 #undef BFD_FAST_SECTION_FILL
31 #define BFD_FAST_SECTION_FILL
33 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
34 instruction so that the disassembler does not choke on it. */
36 #define NOP_OPCODE 0x00
39 #ifndef TC_ADJUST_RELOC_COUNT
40 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
43 #ifndef TC_FORCE_RELOCATION
44 #define TC_FORCE_RELOCATION(FIXP) 0
47 #ifndef TC_FORCE_RELOCATION_SECTION
48 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
51 #ifndef MD_PCREL_FROM_SECTION
52 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
55 #ifndef WORKING_DOT_WORD
56 extern CONST int md_short_jump_size;
57 extern CONST int md_long_jump_size;
60 int symbol_table_frozen;
61 void print_fixup PARAMS ((fixS *));
64 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
66 /* We generally attach relocs to frag chains. However, after we have
67 chained these all together into a segment, any relocs we add after
68 that must be attached to a segment. This will include relocs added
69 in md_estimate_size_for_relax, for example. */
70 static int frags_chained = 0;
76 struct frag *text_frag_root;
77 struct frag *data_frag_root;
78 struct frag *bss_frag_root;
80 struct frag *text_last_frag; /* Last frag in segment. */
81 struct frag *data_last_frag; /* Last frag in segment. */
82 static struct frag *bss_last_frag; /* Last frag in segment. */
86 static object_headers headers;
89 long string_byte_count;
90 char *next_object_file_charP; /* Tracks object file bytes. */
93 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
96 #endif /* BFD_ASSEMBLER */
101 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
102 symbolS *add, symbolS *sub,
103 offsetT offset, int pcrel,
104 bfd_reloc_code_real_type r_type));
106 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
107 symbolS *add, symbolS *sub,
108 offsetT offset, int pcrel,
111 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
112 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
114 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
119 * Create a fixS in obstack 'notes'.
122 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
124 fragS *frag; /* Which frag? */
125 int where; /* Where in that frag? */
126 int size; /* 1, 2, or 4 usually. */
127 symbolS *add_symbol; /* X_add_symbol. */
128 symbolS *sub_symbol; /* X_op_symbol. */
129 offsetT offset; /* X_add_number. */
130 int pcrel; /* TRUE if PC-relative relocation. */
132 bfd_reloc_code_real_type r_type; /* Relocation type */
134 int r_type; /* Relocation type */
141 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
143 fixP->fx_frag = frag;
144 fixP->fx_where = where;
145 fixP->fx_size = size;
146 /* We've made fx_size a narrow field; check that it's wide enough. */
147 if (fixP->fx_size != size)
149 as_bad ("field fx_size too small to hold %d", size);
152 fixP->fx_addsy = add_symbol;
153 fixP->fx_subsy = sub_symbol;
154 fixP->fx_offset = offset;
155 fixP->fx_pcrel = pcrel;
157 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
158 fixP->fx_r_type = r_type;
160 fixP->fx_im_disp = 0;
161 fixP->fx_pcrel_adjust = 0;
162 fixP->fx_bit_fixP = 0;
163 fixP->fx_addnumber = 0;
166 fixP->fx_no_overflow = 0;
170 TC_INIT_FIX_DATA(fixP);
173 as_where (&fixP->fx_file, &fixP->fx_line);
175 /* Usually, we want relocs sorted numerically, but while
176 comparing to older versions of gas that have relocs
177 reverse sorted, it is convenient to have this compile
178 time option. xoxorich. */
183 fixS **seg_fix_rootP = (frags_chained
184 ? &seg_info (now_seg)->fix_root
185 : &frchain_now->fix_root);
186 fixS **seg_fix_tailP = (frags_chained
187 ? &seg_info (now_seg)->fix_tail
188 : &frchain_now->fix_tail);
191 #ifdef REVERSE_SORT_RELOCS
193 fixP->fx_next = *seg_fix_rootP;
194 *seg_fix_rootP = fixP;
196 #else /* REVERSE_SORT_RELOCS */
198 fixP->fx_next = NULL;
201 (*seg_fix_tailP)->fx_next = fixP;
203 *seg_fix_rootP = fixP;
204 *seg_fix_tailP = fixP;
206 #endif /* REVERSE_SORT_RELOCS */
213 /* Create a fixup relative to a symbol (plus a constant). */
216 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
217 fragS *frag; /* Which frag? */
218 int where; /* Where in that frag? */
219 int size; /* 1, 2, or 4 usually. */
220 symbolS *add_symbol; /* X_add_symbol. */
221 offsetT offset; /* X_add_number. */
222 int pcrel; /* TRUE if PC-relative relocation. */
224 bfd_reloc_code_real_type r_type; /* Relocation type */
226 int r_type; /* Relocation type */
229 return fix_new_internal (frag, where, size, add_symbol,
230 (symbolS *) NULL, offset, pcrel, r_type);
233 /* Create a fixup for an expression. Currently we only support fixups
234 for difference expressions. That is itself more than most object
235 file formats support anyhow. */
238 fix_new_exp (frag, where, size, exp, pcrel, r_type)
239 fragS *frag; /* Which frag? */
240 int where; /* Where in that frag? */
241 int size; /* 1, 2, or 4 usually. */
242 expressionS *exp; /* Expression. */
243 int pcrel; /* TRUE if PC-relative relocation. */
245 bfd_reloc_code_real_type r_type; /* Relocation type */
247 int r_type; /* Relocation type */
260 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
261 the difference expression cannot immediately be reduced. */
263 extern symbolS *make_expr_symbol ();
264 symbolS *stmp = make_expr_symbol (exp);
265 exp->X_op = O_symbol;
266 exp->X_op_symbol = 0;
267 exp->X_add_symbol = stmp;
268 exp->X_add_number = 0;
269 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
273 add = exp->X_add_symbol;
274 off = exp->X_add_number;
276 #if defined(BFD_ASSEMBLER)
277 r_type = BFD_RELOC_RVA;
279 #if defined(TC_RVA_RELOC)
280 r_type = TC_RVA_RELOC;
282 as_fatal("rva not supported");
288 sub = exp->X_add_symbol;
289 off = exp->X_add_number;
293 sub = exp->X_op_symbol;
296 add = exp->X_add_symbol;
299 off = exp->X_add_number;
303 add = make_expr_symbol (exp);
307 return fix_new_internal (frag, where, size, add, sub, off,
311 /* Append a string onto another string, bumping the pointer along. */
313 append (charPP, fromP, length)
316 unsigned long length;
318 /* Don't trust memcpy() of 0 chars. */
322 memcpy (*charPP, fromP, length);
326 #ifndef BFD_ASSEMBLER
327 int section_alignment[SEG_MAXIMUM_ORDINAL];
331 * This routine records the largest alignment seen for each segment.
332 * If the beginning of the segment is aligned on the worst-case
333 * boundary, all of the other alignments within it will work. At
334 * least one object format really uses this info.
337 record_alignment (seg, align)
338 /* Segment to which alignment pertains */
340 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
344 if (seg == absolute_section)
347 if (align > bfd_get_section_alignment (stdoutput, seg))
348 bfd_set_section_alignment (stdoutput, seg, align);
350 if (align > section_alignment[(int) seg])
351 section_alignment[(int) seg] = align;
357 /* Reset the section indices after removing the gas created sections. */
360 renumber_sections (abfd, sec, countparg)
365 int *countp = (int *) countparg;
367 sec->index = *countp;
371 #endif /* defined (BFD_ASSEMBLER) */
373 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
376 chain_frchains_together_1 (section, frchp)
378 struct frchain *frchp;
380 fragS dummy, *prev_frag = &dummy;
382 fixS fix_dummy, *prev_fix = &fix_dummy;
385 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
387 prev_frag->fr_next = frchp->frch_root;
388 prev_frag = frchp->frch_last;
389 assert (prev_frag->fr_type != 0);
391 if (frchp->fix_root != (fixS *) NULL)
393 if (seg_info (section)->fix_root == (fixS *) NULL)
394 seg_info (section)->fix_root = frchp->fix_root;
395 prev_fix->fx_next = frchp->fix_root;
396 seg_info (section)->fix_tail = frchp->fix_tail;
397 prev_fix = frchp->fix_tail;
401 assert (prev_frag->fr_type != 0);
402 prev_frag->fr_next = 0;
411 chain_frchains_together (abfd, section, xxx)
412 bfd *abfd; /* unused */
414 PTR xxx; /* unused */
416 segment_info_type *info;
418 /* BFD may have introduced its own sections without using
419 subseg_new, so it is possible that seg_info is NULL. */
420 info = seg_info (section);
421 if (info != (segment_info_type *) NULL)
422 info->frchainP->frch_last
423 = chain_frchains_together_1 (section, info->frchainP);
425 /* Now that we've chained the frags together, we must add new fixups
426 to the segment, not to the frag chain. */
432 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
435 remove_subsegs (head, seg, root, last)
441 *root = head->frch_root;
442 *last = chain_frchains_together_1 (seg, head);
447 #if defined (BFD_ASSEMBLER) || !defined (BFD)
451 cvt_frag_to_fill (sec, fragP)
456 cvt_frag_to_fill (headersP, sec, fragP)
457 object_headers *headersP;
462 switch (fragP->fr_type)
469 HANDLE_ALIGN (fragP);
471 know (fragP->fr_next != NULL);
472 fragP->fr_offset = (fragP->fr_next->fr_address
474 - fragP->fr_fix) / fragP->fr_var;
475 if (fragP->fr_offset < 0)
477 as_bad ("attempt to .org/.space backwards? (%ld)",
478 (long) fragP->fr_offset);
480 fragP->fr_type = rs_fill;
486 case rs_machine_dependent:
488 md_convert_frag (stdoutput, sec, fragP);
490 md_convert_frag (headersP, sec, fragP);
493 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
496 * After md_convert_frag, we make the frag into a ".space 0".
497 * Md_convert_frag() should set up any fixSs and constants
503 #ifndef WORKING_DOT_WORD
506 struct broken_word *lie;
508 if (fragP->fr_subtype)
510 fragP->fr_fix += md_short_jump_size;
511 for (lie = (struct broken_word *) (fragP->fr_symbol);
512 lie && lie->dispfrag == fragP;
513 lie = lie->next_broken_word)
515 fragP->fr_fix += md_long_jump_size;
523 BAD_CASE (fragP->fr_type);
528 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
532 relax_and_size_seg (abfd, sec, xxx)
539 segment_info_type *seginfo;
541 valueT size, newsize;
543 subseg_change (sec, 0);
545 flags = bfd_get_section_flags (abfd, sec);
547 seginfo = seg_info (sec);
548 if (seginfo && seginfo->frchainP)
550 relax_segment (seginfo->frchainP->frch_root, sec);
551 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
552 cvt_frag_to_fill (sec, fragp);
553 for (fragp = seginfo->frchainP->frch_root;
555 fragp = fragp->fr_next)
556 /* walk to last elt */;
557 size = fragp->fr_address + fragp->fr_fix;
562 if (size > 0 && ! seginfo->bss)
563 flags |= SEC_HAS_CONTENTS;
565 /* @@ This is just an approximation. */
566 if (seginfo && seginfo->fix_root)
570 x = bfd_set_section_flags (abfd, sec, flags);
573 newsize = md_section_align (sec, size);
574 x = bfd_set_section_size (abfd, sec, newsize);
577 /* If the size had to be rounded up, add some padding in the last
579 assert (newsize >= size);
582 fragS *last = seginfo->frchainP->frch_last;
583 fragp = seginfo->frchainP->frch_root;
584 while (fragp->fr_next != last)
585 fragp = fragp->fr_next;
586 last->fr_address = size;
587 fragp->fr_offset += newsize - size;
590 #ifdef tc_frob_section
591 tc_frob_section (sec);
593 #ifdef obj_frob_section
594 obj_frob_section (sec);
600 dump_section_relocs (abfd, sec, stream_)
605 FILE *stream = (FILE *) stream_;
606 segment_info_type *seginfo = seg_info (sec);
607 fixS *fixp = seginfo->fix_root;
612 fprintf (stream, "sec %s relocs:\n", sec->name);
615 symbolS *s = fixp->fx_addsy;
618 fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
619 s->bsym->section->name);
620 if (s->bsym->flags & BSF_SECTION_SYM)
622 fprintf (stream, " section sym");
624 fprintf (stream, "+%x", S_GET_VALUE (s));
627 fprintf (stream, "+%x", S_GET_VALUE (s));
628 fprintf (stream, ")+%x\n", fixp->fx_offset);
631 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
632 fixp = fixp->fx_next;
636 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
639 #ifndef EMIT_SECTION_SYMBOLS
640 #define EMIT_SECTION_SYMBOLS 1
644 adjust_reloc_syms (abfd, sec, xxx)
649 segment_info_type *seginfo = seg_info (sec);
655 dump_section_relocs (abfd, sec, stderr);
657 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
660 else if (fixp->fx_addsy)
668 fprintf (stderr, "\n\nadjusting fixup:\n");
672 sym = fixp->fx_addsy;
674 /* All symbols should have already been resolved at this
675 point. It is possible to see unresolved expression
676 symbols, though, since they are not in the regular symbol
678 if (sym != NULL && ! sym->sy_resolved)
679 resolve_symbol_value (sym);
680 if (fixp->fx_subsy != NULL && ! fixp->fx_subsy->sy_resolved)
681 resolve_symbol_value (fixp->fx_subsy);
683 /* If this symbol is equated to an undefined symbol, convert
684 the fixup to being against that symbol. */
685 if (sym->sy_value.X_op == O_symbol
686 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
688 fixp->fx_offset += sym->sy_value.X_add_number;
689 sym = sym->sy_value.X_add_symbol;
690 fixp->fx_addsy = sym;
693 symsec = S_GET_SEGMENT (sym);
695 if (sym != NULL && sym->sy_mri_common)
697 /* These symbols are handled specially in fixup_segment. */
701 if (bfd_is_abs_section (symsec))
703 /* The fixup_segment routine will not use this symbol in a
704 relocation unless TC_FORCE_RELOCATION returns 1. */
705 if (TC_FORCE_RELOCATION (fixp))
707 fixp->fx_addsy->sy_used_in_reloc = 1;
708 #ifdef UNDEFINED_DIFFERENCE_OK
709 if (fixp->fx_subsy != NULL)
710 fixp->fx_subsy->sy_used_in_reloc = 1;
716 /* If it's one of these sections, assume the symbol is
717 definitely going to be output. The code in
718 md_estimate_size_before_relax in tc-mips.c uses this test
719 as well, so if you change this code you should look at that
721 if (bfd_is_und_section (symsec)
722 || bfd_is_com_section (symsec))
724 fixp->fx_addsy->sy_used_in_reloc = 1;
725 #ifdef UNDEFINED_DIFFERENCE_OK
726 /* We have the difference of an undefined symbol and some
727 other symbol. Make sure to mark the other symbol as used
728 in a relocation so that it will always be output. */
730 fixp->fx_subsy->sy_used_in_reloc = 1;
735 /* Don't try to reduce relocs which refer to .linkonce
736 sections. It can lead to confusion when a debugging
737 section refers to a .linkonce section. I hope this will
738 always be correct. */
745 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
750 /* The GNU toolchain uses an extension for ELF: a section
751 beginning with the magic string .gnu.linkonce is a
753 if (strncmp (segment_name (symsec), ".gnu.linkonce",
754 sizeof ".gnu.linkonce" - 1) == 0)
760 fixp->fx_addsy->sy_used_in_reloc = 1;
761 #ifdef UNDEFINED_DIFFERENCE_OK
762 if (fixp->fx_subsy != NULL)
763 fixp->fx_subsy->sy_used_in_reloc = 1;
769 /* Since we're reducing to section symbols, don't attempt to reduce
770 anything that's already using one. */
771 if (sym->bsym->flags & BSF_SECTION_SYM)
773 fixp->fx_addsy->sy_used_in_reloc = 1;
777 /* Is there some other reason we can't adjust this one? (E.g.,
778 call/bal links in i960-bout symbols.) */
779 #ifdef obj_fix_adjustable
780 if (! obj_fix_adjustable (fixp))
782 fixp->fx_addsy->sy_used_in_reloc = 1;
787 /* Is there some other (target cpu dependent) reason we can't adjust
788 this one? (E.g. relocations involving function addresses on
790 #ifdef tc_fix_adjustable
791 if (! tc_fix_adjustable (fixp))
793 fixp->fx_addsy->sy_used_in_reloc = 1;
798 /* If the section symbol isn't going to be output, the relocs
799 at least should still work. If not, figure out what to do
800 when we run into that case.
802 We refetch the segment when calling section_symbol, rather
803 than using symsec, because S_GET_VALUE may wind up changing
804 the section when it calls resolve_symbol_value. */
805 fixp->fx_offset += S_GET_VALUE (sym);
806 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
807 fixp->fx_addsy->sy_used_in_reloc = 1;
812 #if 1/*def RELOC_REQUIRES_SYMBOL*/
815 /* There was no symbol required by this relocation. However,
816 BFD doesn't really handle relocations without symbols well.
817 (At least, the COFF support doesn't.) So for now we fake up
818 a local symbol in the absolute section. */
820 fixp->fx_addsy = section_symbol (absolute_section);
821 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
825 dump_section_relocs (abfd, sec, stderr);
829 write_relocs (abfd, sec, xxx)
834 segment_info_type *seginfo = seg_info (sec);
841 /* If seginfo is NULL, we did not create this section; don't do
846 fixup_segment (seginfo->fix_root, sec);
849 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
852 #ifndef RELOC_EXPANSION_POSSIBLE
853 /* Set up reloc information as well. */
854 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
855 n * sizeof (arelent *));
856 memset ((char*)relocs, 0, n * sizeof (arelent*));
859 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
862 bfd_reloc_status_type s;
871 /* If this is an undefined symbol which was equated to another
872 symbol, then use generate the reloc against the latter symbol
873 rather than the former. */
874 sym = fixp->fx_addsy;
875 while (sym->sy_value.X_op == O_symbol
876 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
877 sym = sym->sy_value.X_add_symbol;
878 fixp->fx_addsy = sym;
880 reloc = tc_gen_reloc (sec, fixp);
888 /* This test is triggered inappropriately for the SH. */
889 if (fixp->fx_where + fixp->fx_size
890 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
894 s = bfd_install_relocation (stdoutput, reloc,
895 fixp->fx_frag->fr_literal,
896 fixp->fx_frag->fr_address,
902 case bfd_reloc_overflow:
903 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
906 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
907 fixp->fx_file, fixp->fx_line);
912 n = n * MAX_RELOC_EXPANSION;
913 /* Set up reloc information as well. */
914 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
915 n * sizeof (arelent *));
918 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
922 bfd_reloc_status_type s;
932 /* If this is an undefined symbol which was equated to another
933 symbol, then use generate the reloc against the latter symbol
934 rather than the former. */
935 sym = fixp->fx_addsy;
936 while (sym->sy_value.X_op == O_symbol
937 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
938 sym = sym->sy_value.X_add_symbol;
939 fixp->fx_addsy = sym;
941 reloc = tc_gen_reloc (sec, fixp);
943 for (j = 0; reloc[j]; j++)
945 relocs[i++] = reloc[j];
948 data = fixp->fx_frag->fr_literal + fixp->fx_where;
949 if (fixp->fx_where + fixp->fx_size
950 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
951 as_bad_where (fixp->fx_file, fixp->fx_line,
952 "internal error: fixup not contained within frag");
953 for (j = 0; reloc[j]; j++)
955 s = bfd_install_relocation (stdoutput, reloc[j],
956 fixp->fx_frag->fr_literal,
957 fixp->fx_frag->fr_address,
963 case bfd_reloc_overflow:
964 as_bad_where (fixp->fx_file, fixp->fx_line,
965 "relocation overflow");
968 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
969 fixp->fx_file, fixp->fx_line);
980 sympp = bfd_get_outsymbols (stdoutput);
981 nsyms = bfd_get_symcount (stdoutput);
982 for (i = 0; i < n; i++)
983 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
985 for (j = 0; j < nsyms; j++)
986 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
995 bfd_set_reloc (stdoutput, sec, relocs, n);
997 bfd_set_section_flags (abfd, sec,
998 (bfd_get_section_flags (abfd, sec)
999 & (flagword) ~SEC_RELOC));
1006 fprintf (stderr, "relocs for sec %s\n", sec->name);
1007 for (i = 0; i < n; i++)
1010 s = *r->sym_ptr_ptr;
1011 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1012 i, r, r->address, s->name, r->addend);
1019 write_contents (abfd, sec, xxx)
1024 segment_info_type *seginfo = seg_info (sec);
1025 unsigned long offset = 0;
1028 /* Write out the frags. */
1030 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1033 for (f = seginfo->frchainP->frch_root;
1038 unsigned long fill_size;
1042 assert (f->fr_type == rs_fill);
1045 x = bfd_set_section_contents (stdoutput, sec,
1046 f->fr_literal, (file_ptr) offset,
1047 (bfd_size_type) f->fr_fix);
1050 bfd_perror (stdoutput->filename);
1051 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1052 exit (EXIT_FAILURE);
1054 offset += f->fr_fix;
1056 fill_literal = f->fr_literal + f->fr_fix;
1057 fill_size = f->fr_var;
1058 count = f->fr_offset;
1059 assert (count >= 0);
1060 if (fill_size && count)
1063 if (fill_size > sizeof(buf))
1065 /* Do it the old way. Can this ever happen? */
1068 x = bfd_set_section_contents (stdoutput, sec,
1071 (bfd_size_type) fill_size);
1074 bfd_perror (stdoutput->filename);
1075 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1076 exit (EXIT_FAILURE);
1078 offset += fill_size;
1083 /* Build a buffer full of fill objects and output it as
1084 often as necessary. This saves on the overhead of
1085 potentially lots of bfd_set_section_contents calls. */
1089 n_per_buf = sizeof (buf);
1090 memset (buf, *fill_literal, n_per_buf);
1095 n_per_buf = sizeof(buf)/fill_size;
1096 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1097 memcpy(bufp, fill_literal, fill_size);
1099 for (; count > 0; count -= n_per_buf)
1101 n_per_buf = n_per_buf > count ? count : n_per_buf;
1102 x = bfd_set_section_contents (stdoutput, sec,
1103 buf, (file_ptr) offset,
1104 (bfd_size_type) n_per_buf * fill_size);
1106 as_fatal ("Cannot write to output file.");
1107 offset += n_per_buf * fill_size;
1115 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1117 merge_data_into_text ()
1119 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1120 seg_info (text_section)->frchainP->frch_last->fr_next =
1121 seg_info (data_section)->frchainP->frch_root;
1122 seg_info (text_section)->frchainP->frch_last =
1123 seg_info (data_section)->frchainP->frch_last;
1124 seg_info (data_section)->frchainP = 0;
1128 text_last_frag->fr_next = data_frag_root;
1129 text_last_frag = data_last_frag;
1130 data_last_frag = NULL;
1131 data_frag_root = NULL;
1134 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1135 tmp->fx_next = data_fix_root;
1136 text_fix_tail = data_fix_tail;
1139 text_fix_root = data_fix_root;
1140 data_fix_root = NULL;
1143 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1145 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1147 relax_and_size_all_segments ()
1151 relax_segment (text_frag_root, SEG_TEXT);
1152 relax_segment (data_frag_root, SEG_DATA);
1153 relax_segment (bss_frag_root, SEG_BSS);
1155 * Now the addresses of frags are correct within the segment.
1158 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1159 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1160 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1163 * Join the 2 segments into 1 huge segment.
1164 * To do this, re-compute every rn_address in the SEG_DATA frags.
1165 * Then join the data frags after the text frags.
1167 * Determine a_data [length of data segment].
1171 register relax_addressT slide;
1173 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1175 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1176 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1177 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1179 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1180 /* For b.out: If the data section has a strict alignment
1181 requirement, its load address in the .o file will be
1182 rounded up from the size of the text section. These
1183 two values are *not* the same! Similarly for the bss
1185 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1188 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1190 fragP->fr_address += slide;
1191 } /* for each data frag */
1193 know (text_last_frag != 0);
1194 text_last_frag->fr_next = data_frag_root;
1198 H_SET_DATA_SIZE (&headers, 0);
1202 /* See above comments on b.out data section address. */
1205 if (data_last_frag == 0)
1206 bss_vma = H_GET_TEXT_SIZE (&headers);
1208 bss_vma = data_last_frag->fr_address;
1209 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1210 bss_address_frag.fr_address = bss_vma;
1212 #else /* ! OBJ_BOUT */
1213 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1214 H_GET_DATA_SIZE (&headers));
1216 #endif /* ! OBJ_BOUT */
1218 /* Slide all the frags */
1221 relax_addressT slide = bss_address_frag.fr_address;
1223 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1225 fragP->fr_address += slide;
1226 } /* for each bss frag */
1230 H_SET_BSS_SIZE (&headers,
1231 bss_last_frag->fr_address - bss_frag_root->fr_address);
1233 H_SET_BSS_SIZE (&headers, 0);
1235 #endif /* ! BFD_ASSEMBLER && ! BFD */
1237 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1239 #ifdef BFD_ASSEMBLER
1247 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1249 /* Count symbols. We can't rely on a count made by the loop in
1250 write_object_file, because *_frob_file may add a new symbol or
1253 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1260 asympp = (asymbol **) bfd_alloc (stdoutput,
1261 nsyms * sizeof (asymbol *));
1262 symp = symbol_rootP;
1263 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1265 asympp[i] = symp->bsym;
1271 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1272 assert (result == true);
1273 symbol_table_frozen = 1;
1278 write_object_file ()
1280 struct frchain *frchainP; /* Track along all frchains. */
1281 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1282 fragS *fragP; /* Track along all frags. */
1285 /* Do we really want to write it? */
1287 int n_warns, n_errs;
1288 n_warns = had_warnings ();
1289 n_errs = had_errors ();
1290 /* The -Z flag indicates that an object file should be generated,
1291 regardless of warnings and errors. */
1292 if (flag_always_generate_output)
1294 if (n_warns || n_errs)
1295 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1296 n_errs, n_errs == 1 ? "" : "s",
1297 n_warns, n_warns == 1 ? "" : "s");
1302 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1303 n_errs, n_errs == 1 ? "" : "s",
1304 n_warns, n_warns == 1 ? "" : "s");
1309 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1310 a routine to check for the definition of the procedure "_main",
1311 and if so -- fix it up so that it can be program entry point. */
1312 vms_check_for_main ();
1313 #endif /* OBJ_VMS */
1315 /* After every sub-segment, we fake an ".align ...". This conforms to
1316 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1317 frag that requires least thought. ".align" frags like to have a
1318 following frag since that makes calculating their intended length
1321 @@ Is this really necessary?? */
1322 #ifndef SUB_SEGMENT_ALIGN
1323 #ifdef BFD_ASSEMBLER
1324 #define SUB_SEGMENT_ALIGN(SEG) (0)
1326 #define SUB_SEGMENT_ALIGN(SEG) (2)
1329 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1331 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1332 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1333 /* frag_align will have left a new frag.
1334 Use this last frag for an empty ".fill".
1336 For this segment ...
1337 Create a last frag. Do not leave a "being filled in frag". */
1338 frag_wane (frag_now);
1339 frag_now->fr_fix = 0;
1340 know (frag_now->fr_next == NULL);
1343 /* From now on, we don't care about sub-segments. Build one frag chain
1344 for each segment. Linked thru fr_next. */
1346 #ifdef BFD_ASSEMBLER
1347 /* Remove the sections created by gas for its own purposes. */
1349 asection **seclist, *sec;
1352 seclist = &stdoutput->sections;
1353 while (seclist && *seclist)
1356 while (sec == reg_section || sec == expr_section)
1360 stdoutput->section_count--;
1365 seclist = &(*seclist)->next;
1368 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1371 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1373 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1374 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1375 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1378 /* We have two segments. If user gave -R flag, then we must put the
1379 data frags into the text segment. Do this before relaxing so
1380 we know to take advantage of -R and make shorter addresses. */
1381 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1382 if (flag_readonly_data_in_text)
1384 merge_data_into_text ();
1388 #ifdef BFD_ASSEMBLER
1389 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1391 relax_and_size_all_segments ();
1392 #endif /* BFD_ASSEMBLER */
1394 #ifndef BFD_ASSEMBLER
1397 * Crawl the symbol chain.
1399 * For each symbol whose value depends on a frag, take the address of
1400 * that frag and subsume it into the value of the symbol.
1401 * After this, there is just one way to lookup a symbol value.
1402 * Values are left in their final state for object file emission.
1403 * We adjust the values of 'L' local symbols, even if we do
1404 * not intend to emit them to the object file, because their values
1405 * are needed for fix-ups.
1407 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1408 * from the symbol chain. (They are still pointed to by the fixes.)
1410 * Count the remaining symbols.
1411 * Assign a symbol number to each symbol.
1412 * Count the number of string-table chars we will emit.
1413 * Put this info into the headers as appropriate.
1416 know (zero_address_frag.fr_address == 0);
1417 string_byte_count = sizeof (string_byte_count);
1419 obj_crawl_symbol_chain (&headers);
1421 if (string_byte_count == sizeof (string_byte_count))
1422 string_byte_count = 0;
1424 H_SET_STRING_SIZE (&headers, string_byte_count);
1427 * Addresses of frags now reflect addresses we use in the object file.
1428 * Symbol values are correct.
1429 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1430 * Also converting any machine-dependent frags using md_convert_frag();
1432 subseg_change (SEG_TEXT, 0);
1434 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1436 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1438 /* Some assert macros don't work with # directives mixed in. */
1440 if (!(fragP->fr_next == NULL
1442 || fragP->fr_next == data_frag_root
1444 || ((fragP->fr_next->fr_address - fragP->fr_address)
1445 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1449 #endif /* ! BFD_ASSEMBLER */
1451 #ifndef WORKING_DOT_WORD
1453 struct broken_word *lie;
1454 struct broken_word **prevP;
1456 prevP = &broken_words;
1457 for (lie = broken_words; lie; lie = lie->next_broken_word)
1462 exp.X_op = O_subtract;
1463 exp.X_add_symbol = lie->add;
1464 exp.X_op_symbol = lie->sub;
1465 exp.X_add_number = lie->addnum;
1466 #ifdef BFD_ASSEMBLER
1467 #ifdef TC_CONS_FIX_NEW
1468 TC_CONS_FIX_NEW (lie->frag,
1469 lie->word_goes_here - lie->frag->fr_literal,
1472 fix_new_exp (lie->frag,
1473 lie->word_goes_here - lie->frag->fr_literal,
1474 2, &exp, 0, BFD_RELOC_16);
1477 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1478 fix_new_exp (lie->frag,
1479 lie->word_goes_here - lie->frag->fr_literal,
1480 2, &exp, 0, NO_RELOC);
1483 fix_new_ns32k_exp (lie->frag,
1484 lie->word_goes_here - lie->frag->fr_literal,
1485 2, &exp, 0, 0, 2, 0, 0);
1487 fix_new_exp (lie->frag,
1488 lie->word_goes_here - lie->frag->fr_literal,
1490 #endif /* TC_NS32K */
1491 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1492 #endif /* BFD_ASSEMBLER */
1493 *prevP = lie->next_broken_word;
1496 prevP = &(lie->next_broken_word);
1498 for (lie = broken_words; lie;)
1500 struct broken_word *untruth;
1502 addressT table_addr;
1503 addressT from_addr, to_addr;
1506 fragP = lie->dispfrag;
1508 /* Find out how many broken_words go here. */
1510 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1511 if (untruth->added == 1)
1514 table_ptr = lie->dispfrag->fr_opcode;
1515 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1516 /* Create the jump around the long jumps. This is a short
1517 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1518 from_addr = table_addr;
1519 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1520 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1521 table_ptr += md_short_jump_size;
1522 table_addr += md_short_jump_size;
1524 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1526 if (lie->added == 2)
1528 /* Patch the jump table */
1529 /* This is the offset from ??? to table_ptr+0 */
1530 to_addr = table_addr - S_GET_VALUE (lie->sub);
1531 #ifdef BFD_ASSEMBLER
1532 to_addr -= lie->sub->sy_frag->fr_address;
1534 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1535 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1537 if (untruth->use_jump == lie)
1538 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1541 /* Install the long jump */
1542 /* this is a long jump from table_ptr+0 to the final target */
1543 from_addr = table_addr;
1544 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1545 #ifdef BFD_ASSEMBLER
1546 to_addr += lie->add->sy_frag->fr_address;
1548 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1549 table_ptr += md_long_jump_size;
1550 table_addr += md_long_jump_size;
1554 #endif /* not WORKING_DOT_WORD */
1556 #ifndef BFD_ASSEMBLER
1559 char *the_object_file;
1560 long object_file_size;
1562 * Scan every FixS performing fixups. We had to wait until now to do
1563 * this because md_convert_frag() may have made some fixSs.
1567 subseg_change (SEG_TEXT, 0);
1568 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1569 subseg_change (SEG_DATA, 0);
1570 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1571 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1573 /* FIXME move this stuff into the pre-write-hook */
1574 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1575 H_SET_ENTRY_POINT (&headers, 0);
1577 obj_pre_write_hook (&headers); /* extra coff stuff */
1579 object_file_size = H_GET_FILE_SIZE (&headers);
1580 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1582 output_file_create (out_file_name);
1584 obj_header_append (&next_object_file_charP, &headers);
1586 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1591 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1593 register long count;
1594 register char *fill_literal;
1595 register long fill_size;
1598 know (fragP->fr_type == rs_fill);
1599 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1600 fill_literal = fragP->fr_literal + fragP->fr_fix;
1601 fill_size = fragP->fr_var;
1602 know (fragP->fr_offset >= 0);
1604 for (count = fragP->fr_offset; count; count--)
1606 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1609 } /* for each code frag. */
1611 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1616 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1617 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)));
1619 /* Make addresses in data relocation directives relative to beginning of
1620 * first data fragment, not end of last text fragment: alignment of the
1621 * start of the data segment may place a gap between the segments.
1623 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1625 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1626 #endif /* TC_I960 */
1628 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)));
1631 * Emit line number entries.
1633 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1634 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)));
1639 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1640 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)));
1646 if (string_byte_count > 0)
1648 obj_emit_strings (&next_object_file_charP);
1649 } /* only if we have a string table */
1652 bfd_seek (stdoutput, 0, 0);
1653 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1656 /* Write the data to the file */
1657 output_file_append (the_object_file, object_file_size, out_file_name);
1658 free (the_object_file);
1660 } /* non vms output */
1663 * Now do the VMS-dependent part of writing the object file
1665 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1666 H_GET_DATA_SIZE (&headers),
1667 H_GET_BSS_SIZE (&headers),
1668 text_frag_root, data_frag_root);
1669 #endif /* OBJ_VMS */
1670 #else /* BFD_ASSEMBLER */
1672 /* Resolve symbol values. This needs to be done before processing
1678 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1679 if (!symp->sy_resolved)
1680 resolve_symbol_value (symp);
1685 #ifdef tc_frob_file_before_adjust
1686 tc_frob_file_before_adjust ();
1688 #ifdef obj_frob_file_before_adjust
1689 obj_frob_file_before_adjust ();
1692 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1694 /* Set up symbol table, and write it out. */
1699 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1704 if (symp->sy_mri_common)
1706 if (S_IS_EXTERNAL (symp))
1707 as_bad ("%s: global symbols not supported in common sections",
1709 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1713 name = S_GET_NAME (symp);
1716 const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
1717 /* They only differ if `name' is a fb or dollar local
1719 if (name2 != name && ! S_IS_DEFINED (symp))
1720 as_bad ("local label %s is not defined", name2);
1723 /* Do it again, because adjust_reloc_syms might introduce
1724 more symbols. They'll probably only be section symbols,
1725 but they'll still need to have the values computed. */
1726 if (! symp->sy_resolved)
1728 if (symp->sy_value.X_op == O_constant)
1730 /* This is the normal case; skip the call. */
1733 + symp->sy_frag->fr_address));
1734 symp->sy_resolved = 1;
1737 resolve_symbol_value (symp);
1740 /* Skip symbols which were equated to undefined or common
1742 if (symp->sy_value.X_op == O_symbol
1743 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1745 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1749 /* So far, common symbols have been treated like undefined symbols.
1750 Put them in the common section now. */
1751 if (S_IS_DEFINED (symp) == 0
1752 && S_GET_VALUE (symp) != 0)
1753 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1755 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1756 S_GET_NAME (symp), symp,
1759 segment_name (symp->bsym->section));
1762 #ifdef obj_frob_symbol
1763 obj_frob_symbol (symp, punt);
1765 #ifdef tc_frob_symbol
1766 if (! punt || symp->sy_used_in_reloc)
1767 tc_frob_symbol (symp, punt);
1770 /* If we don't want to keep this symbol, splice it out of
1771 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1772 want section symbols. Otherwise, we skip local symbols
1773 and symbols that the frob_symbol macros told us to punt,
1774 but we keep such symbols if they are used in relocs. */
1775 if ((! EMIT_SECTION_SYMBOLS
1776 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1777 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1778 opposites. Sometimes the former checks flags and the
1779 latter examines the name... */
1780 || (!S_IS_EXTERN (symp)
1781 && (S_IS_LOCAL (symp) || punt)
1782 && ! symp->sy_used_in_reloc))
1784 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1785 /* After symbol_remove, symbol_next(symp) still returns
1786 the one that came after it in the chain. So we don't
1787 need to do any extra cleanup work here. */
1792 /* Make sure we really got a value for the symbol. */
1793 if (! symp->sy_resolved)
1795 as_bad ("can't resolve value for symbol \"%s\"",
1797 symp->sy_resolved = 1;
1800 /* Set the value into the BFD symbol. Up til now the value
1801 has only been kept in the gas symbolS struct. */
1802 symp->bsym->value = S_GET_VALUE (symp);
1808 /* Now do any format-specific adjustments to the symbol table, such
1809 as adding file symbols. */
1810 #ifdef tc_adjust_symtab
1811 tc_adjust_symtab ();
1813 #ifdef obj_adjust_symtab
1814 obj_adjust_symtab ();
1817 /* Now that all the sizes are known, and contents correct, we can
1818 start writing to the file. */
1821 /* If *_frob_file changes the symbol value at this point, it is
1822 responsible for moving the changed value into symp->bsym->value
1823 as well. Hopefully all symbol value changing can be done in
1828 #ifdef obj_frob_file
1832 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1834 #ifdef tc_frob_file_after_relocs
1835 tc_frob_file_after_relocs ();
1837 #ifdef obj_frob_file_after_relocs
1838 obj_frob_file_after_relocs ();
1841 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1842 #endif /* BFD_ASSEMBLER */
1849 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1854 * After this, all frags in this segment have addresses that are correct
1855 * within the segment. Since segments live in different file addresses,
1856 * these frag addresses may not be the same as final object-file addresses.
1859 #ifdef TC_GENERIC_RELAX_TABLE
1861 /* Subroutines of relax_segment. */
1867 for (; f1; f1 = f1->fr_next)
1868 if (f1->fr_next == f2)
1873 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1876 relax_frag (fragP, stretch)
1880 const relax_typeS *this_type;
1881 const relax_typeS *start_type;
1882 relax_substateT next_state;
1883 relax_substateT this_state;
1884 long aim, target, growth;
1885 symbolS *symbolP = fragP->fr_symbol;
1886 long offset = fragP->fr_offset;
1887 /* Recompute was_address by undoing "+= stretch" done by relax_segment. */
1888 unsigned long was_address = fragP->fr_address - stretch;
1889 unsigned long address = fragP->fr_address;
1890 const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
1892 this_state = fragP->fr_subtype;
1893 start_type = this_type = table + this_state;
1898 #ifndef DIFF_EXPR_OK
1899 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1900 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1901 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1902 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1903 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1905 know (symbolP->sy_frag);
1907 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1908 || symbolP->sy_frag == &zero_address_frag);
1910 S_GET_VALUE (symbolP)
1911 + symbolP->sy_frag->fr_address;
1913 /* If frag has yet to be reached on this pass,
1914 assume it will move by STRETCH just as we did.
1915 If this is not so, it will be because some frag
1916 between grows, and that will force another pass.
1918 Beware zero-length frags.
1920 There should be a faster way to do this. */
1922 if (symbolP->sy_frag->fr_address >= was_address
1923 && is_dnrange (fragP, symbolP->sy_frag))
1929 aim = target - address - fragP->fr_fix;
1930 #ifdef TC_PCREL_ADJUST
1931 /* Currently only the ns32k family needs this */
1932 aim += TC_PCREL_ADJUST(fragP);
1934 /* This machine doesn't want to use pcrel_adjust.
1935 In that case, pcrel_adjust should be zero. */
1936 /* assert (fragP->fr_pcrel_adjust == 0);*/
1938 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
1939 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
1944 /* Look backwards. */
1945 for (next_state = this_type->rlx_more; next_state;)
1946 if (aim >= this_type->rlx_backward)
1950 /* Grow to next state. */
1951 this_state = next_state;
1952 this_type = table + this_state;
1953 next_state = this_type->rlx_more;
1958 /* Look forwards. */
1959 for (next_state = this_type->rlx_more; next_state;)
1960 if (aim <= this_type->rlx_forward)
1964 /* Grow to next state. */
1965 this_state = next_state;
1966 this_type = table + this_state;
1967 next_state = this_type->rlx_more;
1971 growth = this_type->rlx_length - start_type->rlx_length;
1973 fragP->fr_subtype = this_state;
1977 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1979 /* Relax_align. Advance location counter to next address that has 'alignment'
1980 lowest order bits all 0s, return size of adjustment made. */
1981 static relax_addressT
1982 relax_align (address, alignment)
1983 register relax_addressT address; /* Address now. */
1984 register int alignment; /* Alignment (binary). */
1986 relax_addressT mask;
1987 relax_addressT new_address;
1989 mask = ~((~0) << alignment);
1990 new_address = (address + mask) & (~mask);
1991 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1993 /* We must provide lots of padding, so the linker can discard it
1994 when needed. The linker will not add extra space, ever. */
1995 new_address += (1 << alignment);
1997 return (new_address - address);
2001 relax_segment (segment_frag_root, segment)
2002 struct frag *segment_frag_root;
2005 register struct frag *fragP;
2006 register relax_addressT address;
2007 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2008 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2010 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2011 subseg_change (segment, 0);
2013 /* For each frag in segment: count and store (a 1st guess of)
2016 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2018 fragP->fr_address = address;
2019 address += fragP->fr_fix;
2021 switch (fragP->fr_type)
2024 address += fragP->fr_offset * fragP->fr_var;
2030 int offset = relax_align (address, (int) fragP->fr_offset);
2031 if (offset % fragP->fr_var != 0)
2033 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
2034 offset, (long) fragP->fr_var);
2035 offset -= (offset % fragP->fr_var);
2043 /* Assume .org is nugatory. It will grow with 1st relax. */
2046 case rs_machine_dependent:
2047 address += md_estimate_size_before_relax (fragP, segment);
2050 #ifndef WORKING_DOT_WORD
2051 /* Broken words don't concern us yet */
2052 case rs_broken_word:
2057 BAD_CASE (fragP->fr_type);
2059 } /* switch(fr_type) */
2060 } /* for each frag in the segment */
2064 long stretch; /* May be any size, 0 or negative. */
2065 /* Cumulative number of addresses we have */
2066 /* relaxed this pass. */
2067 /* We may have relaxed more than one address. */
2068 long stretched; /* Have we stretched on this pass? */
2069 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2070 grew, and another shrank. If a branch instruction doesn't fit anymore,
2071 we could be scrod. */
2075 stretch = stretched = 0;
2076 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2079 unsigned long was_address;
2083 was_address = fragP->fr_address;
2084 address = fragP->fr_address += stretch;
2085 symbolP = fragP->fr_symbol;
2086 offset = fragP->fr_offset;
2088 switch (fragP->fr_type)
2090 case rs_fill: /* .fill never relaxes. */
2094 #ifndef WORKING_DOT_WORD
2095 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2096 for it I do not want to write it. I do not want to have
2097 anything to do with it. This is not the proper way to
2098 implement this misfeature. */
2099 case rs_broken_word:
2101 struct broken_word *lie;
2102 struct broken_word *untruth;
2104 /* Yes this is ugly (storing the broken_word pointer
2105 in the symbol slot). Still, this whole chunk of
2106 code is ugly, and I don't feel like doing anything
2107 about it. Think of it as stubbornness in action. */
2109 for (lie = (struct broken_word *) (fragP->fr_symbol);
2110 lie && lie->dispfrag == fragP;
2111 lie = lie->next_broken_word)
2117 offset = (lie->add->sy_frag->fr_address
2118 + S_GET_VALUE (lie->add)
2120 - (lie->sub->sy_frag->fr_address
2121 + S_GET_VALUE (lie->sub)));
2122 if (offset <= -32768 || offset >= 32767)
2124 if (flag_warn_displacement)
2127 sprint_value (buf, (addressT) lie->addnum);
2128 as_warn (".word %s-%s+%s didn't fit",
2129 S_GET_NAME (lie->add),
2130 S_GET_NAME (lie->sub),
2134 if (fragP->fr_subtype == 0)
2136 fragP->fr_subtype++;
2137 growth += md_short_jump_size;
2139 for (untruth = lie->next_broken_word;
2140 untruth && untruth->dispfrag == lie->dispfrag;
2141 untruth = untruth->next_broken_word)
2142 if ((untruth->add->sy_frag == lie->add->sy_frag)
2143 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
2146 untruth->use_jump = lie;
2148 growth += md_long_jump_size;
2153 } /* case rs_broken_word */
2157 growth = (relax_align ((relax_addressT) (address
2160 - relax_align ((relax_addressT) (was_address
2167 long target = offset;
2172 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2173 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2174 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2175 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2176 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2177 know (symbolP->sy_frag);
2178 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2179 || (symbolP->sy_frag == &zero_address_frag));
2181 target += S_GET_VALUE (symbolP)
2182 + symbolP->sy_frag->fr_address;
2183 } /* if we have a symbol */
2185 know (fragP->fr_next);
2186 after = fragP->fr_next->fr_address;
2187 growth = target - after;
2190 /* Growth may be negative, but variable part of frag
2191 cannot have fewer than 0 chars. That is, we can't
2193 as_bad ("attempt to .org backwards ignored");
2197 growth -= stretch; /* This is an absolute growth factor */
2204 growth = S_GET_VALUE (symbolP);
2205 if (symbolP->sy_frag != &zero_address_frag)
2206 as_bad (".space specifies non-absolute value");
2207 fragP->fr_symbol = 0;
2210 as_warn (".space or .fill with negative value, ignored");
2218 case rs_machine_dependent:
2219 #ifdef md_relax_frag
2220 growth = md_relax_frag (fragP, stretch);
2222 #ifdef TC_GENERIC_RELAX_TABLE
2223 /* The default way to relax a frag is to look through
2224 TC_GENERIC_RELAX_TABLE. */
2225 growth = relax_frag (fragP, stretch);
2226 #endif /* TC_GENERIC_RELAX_TABLE */
2231 BAD_CASE (fragP->fr_type);
2239 } /* For each frag in the segment. */
2241 while (stretched); /* Until nothing further to relax. */
2245 * We now have valid fr_address'es for each frag.
2249 * All fr_address's are correct, relative to their own segment.
2250 * We have made all the fixS we will ever make.
2252 } /* relax_segment() */
2254 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2256 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2257 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2262 Go through all the fixS's in a segment and see which ones can be
2263 handled now. (These consist of fixS where we have since discovered
2264 the value of a symbol, or the address of the frag involved.)
2265 For each one, call md_apply_fix to put the fix into the frag data.
2267 Result is a count of how many relocation structs will be needed to
2268 handle the remaining fixS's that we couldn't completely handle here.
2269 These will be output later by emit_relocations(). */
2272 fixup_segment (fixP, this_segment_type)
2273 register fixS *fixP;
2274 segT this_segment_type; /* N_TYPE bits for segment. */
2276 long seg_reloc_count = 0;
2277 symbolS *add_symbolP;
2278 symbolS *sub_symbolP;
2285 segT add_symbol_segment = absolute_section;
2287 /* If the linker is doing the relaxing, we must not do any fixups.
2289 Well, strictly speaking that's not true -- we could do any that are
2290 PC-relative and don't cross regions that could change size. And for the
2291 i960 (the only machine for which we've got a relaxing linker right now),
2292 we might be able to turn callx/callj into bal anyways in cases where we
2293 know the maximum displacement. */
2296 for (; fixP; fixP = fixP->fx_next)
2298 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2299 return seg_reloc_count;
2302 for (; fixP; fixP = fixP->fx_next)
2305 fprintf (stderr, "\nprocessing fixup:\n");
2309 fragP = fixP->fx_frag;
2311 where = fixP->fx_where;
2312 place = fragP->fr_literal + where;
2313 size = fixP->fx_size;
2314 add_symbolP = fixP->fx_addsy;
2315 #ifdef TC_VALIDATE_FIX
2316 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2318 sub_symbolP = fixP->fx_subsy;
2319 add_number = fixP->fx_offset;
2320 pcrel = fixP->fx_pcrel;
2323 if (add_symbolP != NULL
2324 && add_symbolP->sy_mri_common)
2326 know (add_symbolP->sy_value.X_op == O_symbol);
2327 add_number += S_GET_VALUE (add_symbolP);
2328 fixP->fx_offset = add_number;
2329 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
2333 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2337 resolve_symbol_value (sub_symbolP);
2338 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2340 if (add_symbolP != NULL)
2342 add_number += S_GET_VALUE (add_symbolP);
2344 fixP->fx_addsy = NULL;
2347 /* It's just -sym */
2348 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2350 add_number -= S_GET_VALUE (sub_symbolP);
2351 fixP->fx_subsy = NULL;
2354 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2356 /* Should try converting to a constant. */
2361 as_bad_where (fixP->fx_file, fixP->fx_line,
2362 "Negative of non-absolute symbol %s",
2363 S_GET_NAME (sub_symbolP));
2365 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2366 && SEG_NORMAL (add_symbol_segment))
2368 /* Difference of 2 symbols from same segment.
2369 Can't make difference of 2 undefineds: 'value' means
2370 something different for N_UNDF. */
2372 /* Makes no sense to use the difference of 2 arbitrary symbols
2373 as the target of a call instruction. */
2375 as_bad_where (fixP->fx_file, fixP->fx_line,
2376 "callj to difference of 2 symbols");
2377 #endif /* TC_I960 */
2378 add_number += S_GET_VALUE (add_symbolP) -
2379 S_GET_VALUE (sub_symbolP);
2382 pcrel = 0; /* No further pcrel processing. */
2384 /* Let the target machine make the final determination
2385 as to whether or not a relocation will be needed to
2386 handle this fixup. */
2387 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2390 fixP->fx_addsy = NULL;
2391 fixP->fx_subsy = NULL;
2396 /* Different segments in subtraction. */
2397 know (!(S_IS_EXTERNAL (sub_symbolP)
2398 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2400 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2401 add_number -= S_GET_VALUE (sub_symbolP);
2404 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2405 #if 0 /* Do this even if it's already described as pc-relative. For example,
2406 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2407 pc-relative mode. */
2412 /* Make it pc-relative. */
2413 add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
2414 - S_GET_VALUE (sub_symbolP));
2421 #ifdef UNDEFINED_DIFFERENCE_OK
2422 /* The PA needs this for PIC code generation. We basically
2423 don't want to do anything if we have the difference of two
2424 symbols at this point. */
2427 /* Leave it alone. */
2430 #ifdef BFD_ASSEMBLER
2431 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2432 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2434 /* Leave it alone. */
2440 sprint_value (buf, fragP->fr_address + where);
2441 as_bad_where (fixP->fx_file, fixP->fx_line,
2442 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2443 segment_name (S_GET_SEGMENT (sub_symbolP)),
2444 S_GET_NAME (sub_symbolP), buf);
2451 if (add_symbol_segment == this_segment_type && pcrel && !plt
2452 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2455 * This fixup was made when the symbol's segment was
2456 * SEG_UNKNOWN, but it is now in the local segment.
2457 * So we know how to do the address without relocation.
2460 /* reloc_callj() may replace a 'call' with a 'calls' or a
2461 'bal', in which cases it modifies *fixP as appropriate.
2462 In the case of a 'calls', no further work is required,
2463 and *fixP has been set up to make the rest of the code
2466 #endif /* TC_I960 */
2468 add_number += S_GET_VALUE (add_symbolP);
2469 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2470 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2472 /* Let the target machine make the final determination
2473 as to whether or not a relocation will be needed to
2474 handle this fixup. */
2475 if (!TC_FORCE_RELOCATION (fixP))
2478 fixP->fx_addsy = NULL;
2483 if (add_symbol_segment == absolute_section
2487 /* See comment about reloc_callj() above. */
2489 #endif /* TC_I960 */
2490 add_number += S_GET_VALUE (add_symbolP);
2492 /* Let the target machine make the final determination
2493 as to whether or not a relocation will be needed to
2494 handle this fixup. */
2496 if (!TC_FORCE_RELOCATION (fixP))
2498 fixP->fx_addsy = NULL;
2502 else if (add_symbol_segment == undefined_section
2503 #ifdef BFD_ASSEMBLER
2504 || bfd_is_com_section (add_symbol_segment)
2509 if ((int) fixP->fx_bit_fixP == 13)
2511 /* This is a COBR instruction. They have only a
2512 * 13-bit displacement and are only to be used
2513 * for local branches: flag as error, don't generate
2516 as_bad_where (fixP->fx_file, fixP->fx_line,
2517 "can't use COBR format with external label");
2518 fixP->fx_addsy = NULL;
2522 #endif /* TC_I960 */
2526 if (S_IS_COMMON (add_symbolP))
2527 add_number += S_GET_VALUE (add_symbolP);
2528 #endif /* TE_I386AIX */
2529 #endif /* OBJ_COFF */
2535 /* start-sanitize-v850 */
2536 #if !(defined (TC_V850) && defined (OBJ_ELF))
2537 /* end-sanitize-v850 */
2538 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2539 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2540 add_number += S_GET_VALUE (add_symbolP);
2541 /* start-sanitize-v850 */
2543 /* end-sanitize-v850 */
2552 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2553 if (add_symbolP == 0)
2555 #ifndef BFD_ASSEMBLER
2556 fixP->fx_addsy = &abs_symbol;
2558 fixP->fx_addsy = section_symbol (absolute_section);
2560 fixP->fx_addsy->sy_used_in_reloc = 1;
2565 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2567 if (size < sizeof (valueT))
2571 /* set all bits to one */
2574 /* Technically, combining these produces an undefined result
2575 if size is sizeof (valueT), though I think these two
2576 half-way operations should both be defined. And the
2577 compiler should be able to combine them if it's valid on
2578 the host architecture. */
2581 hibit = (valueT) 1 << (size * 8 - 1);
2582 if (((add_number & mask) != 0
2584 && (add_number & hibit) != 0))
2585 && ((add_number & mask) != mask
2586 || (add_number & hibit) == 0))
2588 char buf[50], buf2[50];
2589 sprint_value (buf, fragP->fr_address + where);
2590 if (add_number > 1000)
2591 sprint_value (buf2, add_number);
2593 sprintf (buf2, "%ld", (long) add_number);
2594 as_bad_where (fixP->fx_file, fixP->fx_line,
2595 "Value of %s too large for field of %d bytes at %s",
2597 } /* generic error checking */
2599 #ifdef WARN_SIGNED_OVERFLOW_WORD
2600 /* Warn if a .word value is too large when treated as a signed
2601 number. We already know it is not too negative. This is to
2602 catch over-large switches generated by gcc on the 68k. */
2603 if (!flag_signed_overflow_ok
2605 && add_number > 0x7fff)
2606 as_bad_where (fixP->fx_file, fixP->fx_line,
2607 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2609 (unsigned long) (fragP->fr_address + where));
2611 } /* not a bit fix */
2615 #ifdef MD_APPLY_FIX3
2616 md_apply_fix3 (fixP, &add_number, this_segment_type);
2618 #ifdef BFD_ASSEMBLER
2619 md_apply_fix (fixP, &add_number);
2621 md_apply_fix (fixP, add_number);
2625 #ifndef TC_HANDLES_FX_DONE
2626 /* If the tc-* files haven't been converted, assume it's handling
2627 it the old way, where a null fx_addsy means that the fix has
2628 been applied completely, and no further work is needed. */
2629 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2633 #ifdef TC_VALIDATE_FIX
2637 fprintf (stderr, "result:\n");
2640 } /* For each fixS in this segment. */
2642 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2643 return seg_reloc_count;
2646 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2649 number_to_chars_bigendian (buf, val, n)
2654 if (n > sizeof (val)|| n <= 0)
2658 buf[n] = val & 0xff;
2664 number_to_chars_littleendian (buf, val, n)
2669 if (n > sizeof (val) || n <= 0)
2673 *buf++ = val & 0xff;
2679 write_print_statistics (file)
2682 fprintf (stderr, "fixups: %d\n", n_fixups);
2686 extern int indent_level;
2687 extern void print_symbol_value_1 ();
2694 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2696 fprintf (stderr, " pcrel");
2697 if (fixp->fx_pcrel_adjust)
2698 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2699 if (fixp->fx_im_disp)
2702 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2704 fprintf (stderr, " im_disp");
2708 fprintf (stderr, " tcbit");
2710 fprintf (stderr, " done");
2711 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2712 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2713 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2714 #ifdef BFD_ASSEMBLER
2715 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2718 #ifdef NEED_FX_R_TYPE
2719 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2724 fprintf (stderr, "\n +<");
2725 print_symbol_value_1 (stderr, fixp->fx_addsy);
2726 fprintf (stderr, ">");
2730 fprintf (stderr, "\n -<");
2731 print_symbol_value_1 (stderr, fixp->fx_subsy);
2732 fprintf (stderr, ">");
2734 fprintf (stderr, "\n");
2737 /* end of write.c */