1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 95, 1996
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 TC_FORCE_RELOCATION_SECTION
47 #define TC_FORCE_RELOCATION_SECTION(FIXP,SEG) TC_FORCE_RELOCATION(FIXP)
50 #ifndef MD_PCREL_FROM_SECTION
51 #define MD_PCREL_FROM_SECTION(FIXP, SEC) md_pcrel_from(FIXP)
54 #ifndef WORKING_DOT_WORD
55 extern CONST int md_short_jump_size;
56 extern CONST int md_long_jump_size;
59 int symbol_table_frozen;
60 void print_fixup PARAMS ((fixS *));
63 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
65 /* We generally attach relocs to frag chains. However, after we have
66 chained these all together into a segment, any relocs we add after
67 that must be attached to a segment. This will include relocs added
68 in md_estimate_size_for_relax, for example. */
69 static int frags_chained = 0;
75 struct frag *text_frag_root;
76 struct frag *data_frag_root;
77 struct frag *bss_frag_root;
79 struct frag *text_last_frag; /* Last frag in segment. */
80 struct frag *data_last_frag; /* Last frag in segment. */
81 static struct frag *bss_last_frag; /* Last frag in segment. */
85 static object_headers headers;
88 long string_byte_count;
89 char *next_object_file_charP; /* Tracks object file bytes. */
92 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
95 #endif /* BFD_ASSEMBLER */
100 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
101 symbolS *add, symbolS *sub,
102 offsetT offset, int pcrel,
103 bfd_reloc_code_real_type r_type));
105 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
106 symbolS *add, symbolS *sub,
107 offsetT offset, int pcrel,
110 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
111 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
113 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
118 * Create a fixS in obstack 'notes'.
121 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
123 fragS *frag; /* Which frag? */
124 int where; /* Where in that frag? */
125 int size; /* 1, 2, or 4 usually. */
126 symbolS *add_symbol; /* X_add_symbol. */
127 symbolS *sub_symbol; /* X_op_symbol. */
128 offsetT offset; /* X_add_number. */
129 int pcrel; /* TRUE if PC-relative relocation. */
131 bfd_reloc_code_real_type r_type; /* Relocation type */
133 int r_type; /* Relocation type */
140 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
142 fixP->fx_frag = frag;
143 fixP->fx_where = where;
144 fixP->fx_size = size;
145 /* We've made fx_size a narrow field; check that it's wide enough. */
146 if (fixP->fx_size != size)
148 as_bad ("field fx_size too small to hold %d", size);
151 fixP->fx_addsy = add_symbol;
152 fixP->fx_subsy = sub_symbol;
153 fixP->fx_offset = offset;
154 fixP->fx_pcrel = pcrel;
156 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
157 fixP->fx_r_type = r_type;
159 fixP->fx_im_disp = 0;
160 fixP->fx_pcrel_adjust = 0;
161 fixP->fx_bit_fixP = 0;
162 fixP->fx_addnumber = 0;
167 TC_INIT_FIX_DATA(fixP);
170 as_where (&fixP->fx_file, &fixP->fx_line);
172 /* Usually, we want relocs sorted numerically, but while
173 comparing to older versions of gas that have relocs
174 reverse sorted, it is convenient to have this compile
175 time option. xoxorich. */
180 fixS **seg_fix_rootP = (frags_chained
181 ? &seg_info (now_seg)->fix_root
182 : &frchain_now->fix_root);
183 fixS **seg_fix_tailP = (frags_chained
184 ? &seg_info (now_seg)->fix_tail
185 : &frchain_now->fix_tail);
188 #ifdef REVERSE_SORT_RELOCS
190 fixP->fx_next = *seg_fix_rootP;
191 *seg_fix_rootP = fixP;
193 #else /* REVERSE_SORT_RELOCS */
195 fixP->fx_next = NULL;
198 (*seg_fix_tailP)->fx_next = fixP;
200 *seg_fix_rootP = fixP;
201 *seg_fix_tailP = fixP;
203 #endif /* REVERSE_SORT_RELOCS */
210 /* Create a fixup relative to a symbol (plus a constant). */
213 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
214 fragS *frag; /* Which frag? */
215 int where; /* Where in that frag? */
216 int size; /* 1, 2, or 4 usually. */
217 symbolS *add_symbol; /* X_add_symbol. */
218 offsetT offset; /* X_add_number. */
219 int pcrel; /* TRUE if PC-relative relocation. */
221 bfd_reloc_code_real_type r_type; /* Relocation type */
223 int r_type; /* Relocation type */
226 return fix_new_internal (frag, where, size, add_symbol,
227 (symbolS *) NULL, offset, pcrel, r_type);
230 /* Create a fixup for an expression. Currently we only support fixups
231 for difference expressions. That is itself more than most object
232 file formats support anyhow. */
235 fix_new_exp (frag, where, size, exp, pcrel, r_type)
236 fragS *frag; /* Which frag? */
237 int where; /* Where in that frag? */
238 int size; /* 1, 2, or 4 usually. */
239 expressionS *exp; /* Expression. */
240 int pcrel; /* TRUE if PC-relative relocation. */
242 bfd_reloc_code_real_type r_type; /* Relocation type */
244 int r_type; /* Relocation type */
257 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
258 the difference expression cannot immediately be reduced. */
260 extern symbolS *make_expr_symbol ();
261 symbolS *stmp = make_expr_symbol (exp);
262 exp->X_op = O_symbol;
263 exp->X_op_symbol = 0;
264 exp->X_add_symbol = stmp;
265 exp->X_add_number = 0;
266 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
270 add = exp->X_add_symbol;
271 off = exp->X_add_number;
273 #if defined(BFD_ASSEMBLER)
274 r_type = BFD_RELOC_RVA;
276 #if defined(TC_RVA_RELOC)
277 r_type = TC_RVA_RELOC;
279 as_fatal("rva not supported");
285 sub = exp->X_add_symbol;
286 off = exp->X_add_number;
290 sub = exp->X_op_symbol;
293 add = exp->X_add_symbol;
296 off = exp->X_add_number;
300 add = make_expr_symbol (exp);
304 return fix_new_internal (frag, where, size, add, sub, off,
308 /* Append a string onto another string, bumping the pointer along. */
310 append (charPP, fromP, length)
313 unsigned long length;
315 /* Don't trust memcpy() of 0 chars. */
319 memcpy (*charPP, fromP, length);
323 #ifndef BFD_ASSEMBLER
324 int section_alignment[SEG_MAXIMUM_ORDINAL];
328 * This routine records the largest alignment seen for each segment.
329 * If the beginning of the segment is aligned on the worst-case
330 * boundary, all of the other alignments within it will work. At
331 * least one object format really uses this info.
334 record_alignment (seg, align)
335 /* Segment to which alignment pertains */
337 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
341 if (seg == absolute_section)
344 if (align > bfd_get_section_alignment (stdoutput, seg))
345 bfd_set_section_alignment (stdoutput, seg, align);
347 if (align > section_alignment[(int) seg])
348 section_alignment[(int) seg] = align;
354 /* Reset the section indices after removing the gas created sections. */
357 renumber_sections (abfd, sec, countparg)
362 int *countp = (int *) countparg;
364 sec->index = *countp;
368 #endif /* defined (BFD_ASSEMBLER) */
370 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
373 chain_frchains_together_1 (section, frchp)
375 struct frchain *frchp;
377 fragS dummy, *prev_frag = &dummy;
379 fixS fix_dummy, *prev_fix = &fix_dummy;
382 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
384 prev_frag->fr_next = frchp->frch_root;
385 prev_frag = frchp->frch_last;
386 assert (prev_frag->fr_type != 0);
388 if (frchp->fix_root != (fixS *) NULL)
390 if (seg_info (section)->fix_root == (fixS *) NULL)
391 seg_info (section)->fix_root = frchp->fix_root;
392 prev_fix->fx_next = frchp->fix_root;
393 seg_info (section)->fix_tail = frchp->fix_tail;
394 prev_fix = frchp->fix_tail;
398 assert (prev_frag->fr_type != 0);
399 prev_frag->fr_next = 0;
408 chain_frchains_together (abfd, section, xxx)
409 bfd *abfd; /* unused */
411 PTR xxx; /* unused */
413 segment_info_type *info;
415 /* BFD may have introduced its own sections without using
416 subseg_new, so it is possible that seg_info is NULL. */
417 info = seg_info (section);
418 if (info != (segment_info_type *) NULL)
419 info->frchainP->frch_last
420 = chain_frchains_together_1 (section, info->frchainP);
422 /* Now that we've chained the frags together, we must add new fixups
423 to the segment, not to the frag chain. */
429 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
432 remove_subsegs (head, seg, root, last)
438 *root = head->frch_root;
439 *last = chain_frchains_together_1 (seg, head);
444 #if defined (BFD_ASSEMBLER) || !defined (BFD)
448 cvt_frag_to_fill (sec, fragP)
453 cvt_frag_to_fill (headersP, sec, fragP)
454 object_headers *headersP;
459 switch (fragP->fr_type)
466 HANDLE_ALIGN (fragP);
468 know (fragP->fr_next != NULL);
469 fragP->fr_offset = (fragP->fr_next->fr_address
471 - fragP->fr_fix) / fragP->fr_var;
472 if (fragP->fr_offset < 0)
474 as_bad ("attempt to .org/.space backwards? (%ld)",
475 (long) fragP->fr_offset);
477 fragP->fr_type = rs_fill;
483 case rs_machine_dependent:
485 md_convert_frag (stdoutput, sec, fragP);
487 md_convert_frag (headersP, sec, fragP);
490 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
493 * After md_convert_frag, we make the frag into a ".space 0".
494 * Md_convert_frag() should set up any fixSs and constants
500 #ifndef WORKING_DOT_WORD
503 struct broken_word *lie;
505 if (fragP->fr_subtype)
507 fragP->fr_fix += md_short_jump_size;
508 for (lie = (struct broken_word *) (fragP->fr_symbol);
509 lie && lie->dispfrag == fragP;
510 lie = lie->next_broken_word)
512 fragP->fr_fix += md_long_jump_size;
520 BAD_CASE (fragP->fr_type);
525 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
529 relax_and_size_seg (abfd, sec, xxx)
536 segment_info_type *seginfo;
538 valueT size, newsize;
540 subseg_change (sec, 0);
542 flags = bfd_get_section_flags (abfd, sec);
544 seginfo = seg_info (sec);
545 if (seginfo && seginfo->frchainP)
547 relax_segment (seginfo->frchainP->frch_root, sec);
548 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
549 cvt_frag_to_fill (sec, fragp);
550 for (fragp = seginfo->frchainP->frch_root;
552 fragp = fragp->fr_next)
553 /* walk to last elt */;
554 size = fragp->fr_address + fragp->fr_fix;
559 if (size > 0 && ! seginfo->bss)
560 flags |= SEC_HAS_CONTENTS;
562 /* @@ This is just an approximation. */
563 if (seginfo && seginfo->fix_root)
567 x = bfd_set_section_flags (abfd, sec, flags);
570 newsize = md_section_align (sec, size);
571 x = bfd_set_section_size (abfd, sec, newsize);
574 /* If the size had to be rounded up, add some padding in the last
576 assert (newsize >= size);
579 fragS *last = seginfo->frchainP->frch_last;
580 fragp = seginfo->frchainP->frch_root;
581 while (fragp->fr_next != last)
582 fragp = fragp->fr_next;
583 last->fr_address = size;
584 fragp->fr_offset += newsize - size;
587 #ifdef tc_frob_section
588 tc_frob_section (sec);
590 #ifdef obj_frob_section
591 obj_frob_section (sec);
597 dump_section_relocs (abfd, sec, stream_)
602 FILE *stream = (FILE *) stream_;
603 segment_info_type *seginfo = seg_info (sec);
604 fixS *fixp = seginfo->fix_root;
609 fprintf (stream, "sec %s relocs:\n", sec->name);
612 symbolS *s = fixp->fx_addsy;
615 fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
616 s->bsym->section->name);
617 if (s->bsym->flags & BSF_SECTION_SYM)
619 fprintf (stream, " section sym");
621 fprintf (stream, "+%x", S_GET_VALUE (s));
624 fprintf (stream, "+%x", S_GET_VALUE (s));
625 fprintf (stream, ")+%x\n", fixp->fx_offset);
628 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
629 fixp = fixp->fx_next;
633 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
636 #ifndef EMIT_SECTION_SYMBOLS
637 #define EMIT_SECTION_SYMBOLS 1
641 adjust_reloc_syms (abfd, sec, xxx)
646 segment_info_type *seginfo = seg_info (sec);
652 dump_section_relocs (abfd, sec, stderr);
654 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
657 else if (fixp->fx_addsy)
665 fprintf (stderr, "\n\nadjusting fixup:\n");
669 sym = fixp->fx_addsy;
670 symsec = sym->bsym->section;
672 /* All symbols should have already been resolved at this
673 point. It is possible to see unresolved expression
674 symbols, though, since they are not in the regular symbol
676 if (sym != NULL && ! sym->sy_resolved)
677 resolve_symbol_value (sym);
678 if (fixp->fx_subsy != NULL && ! fixp->fx_subsy->sy_resolved)
679 resolve_symbol_value (fixp->fx_subsy);
681 if (sym != NULL && sym->sy_mri_common)
683 /* These symbols are handled specially in fixup_segment. */
687 if (bfd_is_abs_section (symsec))
689 /* The fixup_segment routine will not use this symbol in a
690 relocation unless TC_FORCE_RELOCATION returns 1. */
691 if (TC_FORCE_RELOCATION (fixp))
693 fixp->fx_addsy->sy_used_in_reloc = 1;
694 #ifdef UNDEFINED_DIFFERENCE_OK
695 if (fixp->fx_subsy != NULL)
696 fixp->fx_subsy->sy_used_in_reloc = 1;
702 /* If it's one of these sections, assume the symbol is
703 definitely going to be output. The code in
704 md_estimate_size_before_relax in tc-mips.c uses this test
705 as well, so if you change this code you should look at that
707 if (bfd_is_und_section (symsec)
708 || bfd_is_com_section (symsec))
710 fixp->fx_addsy->sy_used_in_reloc = 1;
711 #ifdef UNDEFINED_DIFFERENCE_OK
712 /* We have the difference of an undefined symbol and some
713 other symbol. Make sure to mark the other symbol as used
714 in a relocation so that it will always be output. */
716 fixp->fx_subsy->sy_used_in_reloc = 1;
721 /* Don't try to reduce relocs which refer to .linkonce
722 sections. It can lead to confusion when a debugging
723 section refers to a .linkonce section. I hope this will
724 always be correct. */
731 if ((bfd_get_section_flags (stdoutput, symsec) & SEC_LINK_ONCE)
736 /* The GNU toolchain uses an extension for ELF: a section
737 beginning with the magic string .gnu.linkonce is a
739 if (strncmp (segment_name (symsec), ".gnu.linkonce",
740 sizeof ".gnu.linkonce" - 1) == 0)
746 fixp->fx_addsy->sy_used_in_reloc = 1;
747 #ifdef UNDEFINED_DIFFERENCE_OK
748 if (fixp->fx_subsy != NULL)
749 fixp->fx_subsy->sy_used_in_reloc = 1;
755 /* Since we're reducing to section symbols, don't attempt to reduce
756 anything that's already using one. */
757 if (sym->bsym->flags & BSF_SECTION_SYM)
759 fixp->fx_addsy->sy_used_in_reloc = 1;
763 /* Is there some other reason we can't adjust this one? (E.g.,
764 call/bal links in i960-bout symbols.) */
765 #ifdef obj_fix_adjustable
766 if (! obj_fix_adjustable (fixp))
768 fixp->fx_addsy->sy_used_in_reloc = 1;
773 /* Is there some other (target cpu dependent) reason we can't adjust
774 this one? (E.g. relocations involving function addresses on
776 #ifdef tc_fix_adjustable
777 if (! tc_fix_adjustable (fixp))
779 fixp->fx_addsy->sy_used_in_reloc = 1;
784 /* For PIC support: We may get expressions like
785 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
786 necessarily have had a fixed difference initially. But now
787 it should be a known constant, so we can reduce it. Since
788 we can't easily handle a symbol value that looks like
789 someUndefinedSymbol+const, though, we convert the fixup to
790 access the undefined symbol directly, and discard the
791 intermediate symbol. */
792 if (S_GET_SEGMENT (sym) == expr_section
793 && sym->sy_value.X_op == O_add
794 && (resolve_symbol_value (sym->sy_value.X_add_symbol),
795 S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
796 && (resolve_symbol_value (sym->sy_value.X_op_symbol),
797 S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
799 fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
800 fixp->fx_offset += sym->sy_value.X_add_number;
801 fixp->fx_addsy = sym->sy_value.X_add_symbol;
805 /* If the section symbol isn't going to be output, the relocs
806 at least should still work. If not, figure out what to do
807 when we run into that case.
809 We refetch the segment when calling section_symbol, rather
810 than using symsec, because S_GET_VALUE may wind up changing
811 the section when it calls resolve_symbol_value. */
812 fixp->fx_offset += S_GET_VALUE (sym);
813 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
814 fixp->fx_addsy->sy_used_in_reloc = 1;
819 #if 1/*def RELOC_REQUIRES_SYMBOL*/
822 /* There was no symbol required by this relocation. However,
823 BFD doesn't really handle relocations without symbols well.
824 (At least, the COFF support doesn't.) So for now we fake up
825 a local symbol in the absolute section. */
827 fixp->fx_addsy = section_symbol (absolute_section);
828 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
832 dump_section_relocs (abfd, sec, stderr);
836 write_relocs (abfd, sec, xxx)
841 segment_info_type *seginfo = seg_info (sec);
848 /* If seginfo is NULL, we did not create this section; don't do
853 fixup_segment (seginfo->fix_root, sec);
856 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
859 #ifndef RELOC_EXPANSION_POSSIBLE
860 /* Set up reloc information as well. */
861 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
862 n * sizeof (arelent *));
863 memset ((char*)relocs, 0, n * sizeof (arelent*));
866 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
869 bfd_reloc_status_type s;
878 /* If this is an undefined symbol which was equated to another
879 symbol, then use generate the reloc against the latter symbol
880 rather than the former. */
881 sym = fixp->fx_addsy;
882 while (sym->sy_value.X_op == O_symbol
883 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
884 sym = sym->sy_value.X_add_symbol;
885 fixp->fx_addsy = sym;
887 reloc = tc_gen_reloc (sec, fixp);
895 /* This test is triggered inappropriately for the SH. */
896 if (fixp->fx_where + fixp->fx_size
897 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
901 s = bfd_install_relocation (stdoutput, reloc,
902 fixp->fx_frag->fr_literal,
903 fixp->fx_frag->fr_address,
909 case bfd_reloc_overflow:
910 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
913 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
914 fixp->fx_file, fixp->fx_line);
919 n = n * MAX_RELOC_EXPANSION;
920 /* Set up reloc information as well. */
921 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
922 n * sizeof (arelent *));
925 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
929 bfd_reloc_status_type s;
939 /* If this is an undefined symbol which was equated to another
940 symbol, then use generate the reloc against the latter symbol
941 rather than the former. */
942 sym = fixp->fx_addsy;
943 while (sym->sy_value.X_op == O_symbol
944 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
945 sym = sym->sy_value.X_add_symbol;
946 fixp->fx_addsy = sym;
948 reloc = tc_gen_reloc (sec, fixp);
950 for (j = 0; reloc[j]; j++)
952 relocs[i++] = reloc[j];
955 data = fixp->fx_frag->fr_literal + fixp->fx_where;
956 if (fixp->fx_where + fixp->fx_size
957 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
958 as_bad_where (fixp->fx_file, fixp->fx_line,
959 "internal error: fixup not contained within frag");
960 for (j = 0; reloc[j]; j++)
962 s = bfd_install_relocation (stdoutput, reloc[j],
963 fixp->fx_frag->fr_literal,
964 fixp->fx_frag->fr_address,
970 case bfd_reloc_overflow:
971 as_bad_where (fixp->fx_file, fixp->fx_line,
972 "relocation overflow");
975 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
976 fixp->fx_file, fixp->fx_line);
987 sympp = bfd_get_outsymbols (stdoutput);
988 nsyms = bfd_get_symcount (stdoutput);
989 for (i = 0; i < n; i++)
990 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
992 for (j = 0; j < nsyms; j++)
993 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1002 bfd_set_reloc (stdoutput, sec, relocs, n);
1004 bfd_set_section_flags (abfd, sec,
1005 (bfd_get_section_flags (abfd, sec)
1006 & (flagword) ~SEC_RELOC));
1013 fprintf (stderr, "relocs for sec %s\n", sec->name);
1014 for (i = 0; i < n; i++)
1017 s = *r->sym_ptr_ptr;
1018 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1019 i, r, r->address, s->name, r->addend);
1026 write_contents (abfd, sec, xxx)
1031 segment_info_type *seginfo = seg_info (sec);
1032 unsigned long offset = 0;
1035 /* Write out the frags. */
1037 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1040 for (f = seginfo->frchainP->frch_root;
1045 unsigned long fill_size;
1049 assert (f->fr_type == rs_fill);
1052 x = bfd_set_section_contents (stdoutput, sec,
1053 f->fr_literal, (file_ptr) offset,
1054 (bfd_size_type) f->fr_fix);
1057 bfd_perror (stdoutput->filename);
1058 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1059 exit (EXIT_FAILURE);
1061 offset += f->fr_fix;
1063 fill_literal = f->fr_literal + f->fr_fix;
1064 fill_size = f->fr_var;
1065 count = f->fr_offset;
1066 assert (count >= 0);
1067 if (fill_size && count)
1070 if (fill_size > sizeof(buf))
1072 /* Do it the old way. Can this ever happen? */
1075 x = bfd_set_section_contents (stdoutput, sec,
1078 (bfd_size_type) fill_size);
1081 bfd_perror (stdoutput->filename);
1082 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1083 exit (EXIT_FAILURE);
1085 offset += fill_size;
1090 /* Build a buffer full of fill objects and output it as
1091 often as necessary. This saves on the overhead of
1092 potentially lots of bfd_set_section_contents calls. */
1096 n_per_buf = sizeof (buf);
1097 memset (buf, *fill_literal, n_per_buf);
1102 n_per_buf = sizeof(buf)/fill_size;
1103 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1104 memcpy(bufp, fill_literal, fill_size);
1106 for (; count > 0; count -= n_per_buf)
1108 n_per_buf = n_per_buf > count ? count : n_per_buf;
1109 x = bfd_set_section_contents (stdoutput, sec,
1110 buf, (file_ptr) offset,
1111 (bfd_size_type) n_per_buf * fill_size);
1113 as_fatal ("Cannot write to output file.");
1114 offset += n_per_buf * fill_size;
1122 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1124 merge_data_into_text ()
1126 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1127 seg_info (text_section)->frchainP->frch_last->fr_next =
1128 seg_info (data_section)->frchainP->frch_root;
1129 seg_info (text_section)->frchainP->frch_last =
1130 seg_info (data_section)->frchainP->frch_last;
1131 seg_info (data_section)->frchainP = 0;
1135 text_last_frag->fr_next = data_frag_root;
1136 text_last_frag = data_last_frag;
1137 data_last_frag = NULL;
1138 data_frag_root = NULL;
1141 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1142 tmp->fx_next = data_fix_root;
1143 text_fix_tail = data_fix_tail;
1146 text_fix_root = data_fix_root;
1147 data_fix_root = NULL;
1150 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1152 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1154 relax_and_size_all_segments ()
1158 relax_segment (text_frag_root, SEG_TEXT);
1159 relax_segment (data_frag_root, SEG_DATA);
1160 relax_segment (bss_frag_root, SEG_BSS);
1162 * Now the addresses of frags are correct within the segment.
1165 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1166 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1167 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1170 * Join the 2 segments into 1 huge segment.
1171 * To do this, re-compute every rn_address in the SEG_DATA frags.
1172 * Then join the data frags after the text frags.
1174 * Determine a_data [length of data segment].
1178 register relax_addressT slide;
1180 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1182 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1183 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1184 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1186 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1187 /* For b.out: If the data section has a strict alignment
1188 requirement, its load address in the .o file will be
1189 rounded up from the size of the text section. These
1190 two values are *not* the same! Similarly for the bss
1192 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1195 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1197 fragP->fr_address += slide;
1198 } /* for each data frag */
1200 know (text_last_frag != 0);
1201 text_last_frag->fr_next = data_frag_root;
1205 H_SET_DATA_SIZE (&headers, 0);
1209 /* See above comments on b.out data section address. */
1212 if (data_last_frag == 0)
1213 bss_vma = H_GET_TEXT_SIZE (&headers);
1215 bss_vma = data_last_frag->fr_address;
1216 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1217 bss_address_frag.fr_address = bss_vma;
1219 #else /* ! OBJ_BOUT */
1220 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1221 H_GET_DATA_SIZE (&headers));
1223 #endif /* ! OBJ_BOUT */
1225 /* Slide all the frags */
1228 relax_addressT slide = bss_address_frag.fr_address;
1230 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1232 fragP->fr_address += slide;
1233 } /* for each bss frag */
1237 H_SET_BSS_SIZE (&headers,
1238 bss_last_frag->fr_address - bss_frag_root->fr_address);
1240 H_SET_BSS_SIZE (&headers, 0);
1242 #endif /* ! BFD_ASSEMBLER && ! BFD */
1244 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1246 #ifdef BFD_ASSEMBLER
1254 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1256 /* Count symbols. We can't rely on a count made by the loop in
1257 write_object_file, because *_frob_file may add a new symbol or
1260 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1267 asympp = (asymbol **) bfd_alloc (stdoutput,
1268 nsyms * sizeof (asymbol *));
1269 symp = symbol_rootP;
1270 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1272 asympp[i] = symp->bsym;
1278 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1279 assert (result == true);
1280 symbol_table_frozen = 1;
1285 write_object_file ()
1287 struct frchain *frchainP; /* Track along all frchains. */
1288 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1289 fragS *fragP; /* Track along all frags. */
1292 /* Do we really want to write it? */
1294 int n_warns, n_errs;
1295 n_warns = had_warnings ();
1296 n_errs = had_errors ();
1297 /* The -Z flag indicates that an object file should be generated,
1298 regardless of warnings and errors. */
1299 if (flag_always_generate_output)
1301 if (n_warns || n_errs)
1302 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1303 n_errs, n_errs == 1 ? "" : "s",
1304 n_warns, n_warns == 1 ? "" : "s");
1309 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1310 n_errs, n_errs == 1 ? "" : "s",
1311 n_warns, n_warns == 1 ? "" : "s");
1316 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1317 a routine to check for the definition of the procedure "_main",
1318 and if so -- fix it up so that it can be program entry point. */
1319 vms_check_for_main ();
1320 #endif /* OBJ_VMS */
1322 /* After every sub-segment, we fake an ".align ...". This conforms to
1323 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1324 frag that requires least thought. ".align" frags like to have a
1325 following frag since that makes calculating their intended length
1328 @@ Is this really necessary?? */
1329 #ifndef SUB_SEGMENT_ALIGN
1330 #ifdef BFD_ASSEMBLER
1331 #define SUB_SEGMENT_ALIGN(SEG) (0)
1333 #define SUB_SEGMENT_ALIGN(SEG) (2)
1336 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1338 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1339 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1340 /* frag_align will have left a new frag.
1341 Use this last frag for an empty ".fill".
1343 For this segment ...
1344 Create a last frag. Do not leave a "being filled in frag". */
1345 frag_wane (frag_now);
1346 frag_now->fr_fix = 0;
1347 know (frag_now->fr_next == NULL);
1350 /* From now on, we don't care about sub-segments. Build one frag chain
1351 for each segment. Linked thru fr_next. */
1353 #ifdef BFD_ASSEMBLER
1354 /* Remove the sections created by gas for its own purposes. */
1356 asection **seclist, *sec;
1359 seclist = &stdoutput->sections;
1360 while (seclist && *seclist)
1363 while (sec == reg_section || sec == expr_section)
1367 stdoutput->section_count--;
1372 seclist = &(*seclist)->next;
1375 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1378 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1380 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1381 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1382 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1385 /* We have two segments. If user gave -R flag, then we must put the
1386 data frags into the text segment. Do this before relaxing so
1387 we know to take advantage of -R and make shorter addresses. */
1388 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1389 if (flag_readonly_data_in_text)
1391 merge_data_into_text ();
1395 #ifdef BFD_ASSEMBLER
1396 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1398 relax_and_size_all_segments ();
1399 #endif /* BFD_ASSEMBLER */
1401 #ifndef BFD_ASSEMBLER
1404 * Crawl the symbol chain.
1406 * For each symbol whose value depends on a frag, take the address of
1407 * that frag and subsume it into the value of the symbol.
1408 * After this, there is just one way to lookup a symbol value.
1409 * Values are left in their final state for object file emission.
1410 * We adjust the values of 'L' local symbols, even if we do
1411 * not intend to emit them to the object file, because their values
1412 * are needed for fix-ups.
1414 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1415 * from the symbol chain. (They are still pointed to by the fixes.)
1417 * Count the remaining symbols.
1418 * Assign a symbol number to each symbol.
1419 * Count the number of string-table chars we will emit.
1420 * Put this info into the headers as appropriate.
1423 know (zero_address_frag.fr_address == 0);
1424 string_byte_count = sizeof (string_byte_count);
1426 obj_crawl_symbol_chain (&headers);
1428 if (string_byte_count == sizeof (string_byte_count))
1429 string_byte_count = 0;
1431 H_SET_STRING_SIZE (&headers, string_byte_count);
1434 * Addresses of frags now reflect addresses we use in the object file.
1435 * Symbol values are correct.
1436 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1437 * Also converting any machine-dependent frags using md_convert_frag();
1439 subseg_change (SEG_TEXT, 0);
1441 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1443 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1445 /* Some assert macros don't work with # directives mixed in. */
1447 if (!(fragP->fr_next == NULL
1449 || fragP->fr_next == data_frag_root
1451 || ((fragP->fr_next->fr_address - fragP->fr_address)
1452 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1456 #endif /* ! BFD_ASSEMBLER */
1458 #ifndef WORKING_DOT_WORD
1460 struct broken_word *lie;
1461 struct broken_word **prevP;
1463 prevP = &broken_words;
1464 for (lie = broken_words; lie; lie = lie->next_broken_word)
1469 exp.X_op = O_subtract;
1470 exp.X_add_symbol = lie->add;
1471 exp.X_op_symbol = lie->sub;
1472 exp.X_add_number = lie->addnum;
1473 #ifdef BFD_ASSEMBLER
1474 #ifdef TC_CONS_FIX_NEW
1475 TC_CONS_FIX_NEW (lie->frag,
1476 lie->word_goes_here - lie->frag->fr_literal,
1479 fix_new_exp (lie->frag,
1480 lie->word_goes_here - lie->frag->fr_literal,
1481 2, &exp, 0, BFD_RELOC_16);
1484 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1485 fix_new_exp (lie->frag,
1486 lie->word_goes_here - lie->frag->fr_literal,
1487 2, &exp, 0, NO_RELOC);
1490 fix_new_ns32k_exp (lie->frag,
1491 lie->word_goes_here - lie->frag->fr_literal,
1492 2, &exp, 0, 0, 2, 0, 0);
1494 fix_new_exp (lie->frag,
1495 lie->word_goes_here - lie->frag->fr_literal,
1497 #endif /* TC_NS32K */
1498 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1499 #endif /* BFD_ASSEMBLER */
1500 *prevP = lie->next_broken_word;
1503 prevP = &(lie->next_broken_word);
1505 for (lie = broken_words; lie;)
1507 struct broken_word *untruth;
1509 addressT table_addr;
1510 addressT from_addr, to_addr;
1513 fragP = lie->dispfrag;
1515 /* Find out how many broken_words go here. */
1517 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1518 if (untruth->added == 1)
1521 table_ptr = lie->dispfrag->fr_opcode;
1522 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1523 /* Create the jump around the long jumps. This is a short
1524 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1525 from_addr = table_addr;
1526 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1527 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1528 table_ptr += md_short_jump_size;
1529 table_addr += md_short_jump_size;
1531 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1533 if (lie->added == 2)
1535 /* Patch the jump table */
1536 /* This is the offset from ??? to table_ptr+0 */
1537 to_addr = table_addr - S_GET_VALUE (lie->sub);
1538 #ifdef BFD_ASSEMBLER
1539 to_addr -= lie->sub->sy_frag->fr_address;
1541 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1542 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1544 if (untruth->use_jump == lie)
1545 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1548 /* Install the long jump */
1549 /* this is a long jump from table_ptr+0 to the final target */
1550 from_addr = table_addr;
1551 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1552 #ifdef BFD_ASSEMBLER
1553 to_addr += lie->add->sy_frag->fr_address;
1555 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1556 table_ptr += md_long_jump_size;
1557 table_addr += md_long_jump_size;
1561 #endif /* not WORKING_DOT_WORD */
1563 #ifndef BFD_ASSEMBLER
1566 char *the_object_file;
1567 long object_file_size;
1569 * Scan every FixS performing fixups. We had to wait until now to do
1570 * this because md_convert_frag() may have made some fixSs.
1574 subseg_change (SEG_TEXT, 0);
1575 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1576 subseg_change (SEG_DATA, 0);
1577 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1578 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1580 /* FIXME move this stuff into the pre-write-hook */
1581 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1582 H_SET_ENTRY_POINT (&headers, 0);
1584 obj_pre_write_hook (&headers); /* extra coff stuff */
1586 object_file_size = H_GET_FILE_SIZE (&headers);
1587 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1589 output_file_create (out_file_name);
1591 obj_header_append (&next_object_file_charP, &headers);
1593 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1598 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1600 register long count;
1601 register char *fill_literal;
1602 register long fill_size;
1605 know (fragP->fr_type == rs_fill);
1606 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1607 fill_literal = fragP->fr_literal + fragP->fr_fix;
1608 fill_size = fragP->fr_var;
1609 know (fragP->fr_offset >= 0);
1611 for (count = fragP->fr_offset; count; count--)
1613 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1616 } /* for each code frag. */
1618 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1623 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1624 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)));
1626 /* Make addresses in data relocation directives relative to beginning of
1627 * first data fragment, not end of last text fragment: alignment of the
1628 * start of the data segment may place a gap between the segments.
1630 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1632 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1633 #endif /* TC_I960 */
1635 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)));
1638 * Emit line number entries.
1640 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1641 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)));
1646 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1647 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)));
1653 if (string_byte_count > 0)
1655 obj_emit_strings (&next_object_file_charP);
1656 } /* only if we have a string table */
1659 bfd_seek (stdoutput, 0, 0);
1660 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1663 /* Write the data to the file */
1664 output_file_append (the_object_file, object_file_size, out_file_name);
1665 free (the_object_file);
1667 } /* non vms output */
1670 * Now do the VMS-dependent part of writing the object file
1672 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1673 H_GET_DATA_SIZE (&headers),
1674 H_GET_BSS_SIZE (&headers),
1675 text_frag_root, data_frag_root);
1676 #endif /* OBJ_VMS */
1677 #else /* BFD_ASSEMBLER */
1679 /* Resolve symbol values. This needs to be done before processing
1685 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1686 if (!symp->sy_resolved)
1687 resolve_symbol_value (symp);
1692 #ifdef tc_frob_file_before_adjust
1693 tc_frob_file_before_adjust ();
1695 #ifdef obj_frob_file_before_adjust
1696 obj_frob_file_before_adjust ();
1699 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1701 /* Set up symbol table, and write it out. */
1706 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1711 if (symp->sy_mri_common)
1713 if (S_IS_EXTERNAL (symp))
1714 as_bad ("%s: global symbols not supported in common sections",
1716 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1720 name = S_GET_NAME (symp);
1723 const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
1724 /* They only differ if `name' is a fb or dollar local
1726 if (name2 != name && ! S_IS_DEFINED (symp))
1727 as_bad ("local label %s is not defined", name2);
1730 /* Do it again, because adjust_reloc_syms might introduce
1731 more symbols. They'll probably only be section symbols,
1732 but they'll still need to have the values computed. */
1733 if (! symp->sy_resolved)
1735 if (symp->sy_value.X_op == O_constant)
1737 /* This is the normal case; skip the call. */
1740 + symp->sy_frag->fr_address));
1741 symp->sy_resolved = 1;
1744 resolve_symbol_value (symp);
1747 /* Skip symbols which were equated to undefined or common
1749 if (symp->sy_value.X_op == O_symbol
1750 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1752 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1756 /* So far, common symbols have been treated like undefined symbols.
1757 Put them in the common section now. */
1758 if (S_IS_DEFINED (symp) == 0
1759 && S_GET_VALUE (symp) != 0)
1760 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1762 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1763 S_GET_NAME (symp), symp,
1766 segment_name (symp->bsym->section));
1769 #ifdef obj_frob_symbol
1770 obj_frob_symbol (symp, punt);
1772 #ifdef tc_frob_symbol
1773 if (! punt || symp->sy_used_in_reloc)
1774 tc_frob_symbol (symp, punt);
1777 /* If we don't want to keep this symbol, splice it out of
1778 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1779 want section symbols. Otherwise, we skip local symbols
1780 and symbols that the frob_symbol macros told us to punt,
1781 but we keep such symbols if they are used in relocs. */
1782 if ((! EMIT_SECTION_SYMBOLS
1783 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1784 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1785 opposites. Sometimes the former checks flags and the
1786 latter examines the name... */
1787 || (!S_IS_EXTERN (symp)
1788 && (S_IS_LOCAL (symp) || punt)
1789 && ! symp->sy_used_in_reloc))
1791 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1792 /* After symbol_remove, symbol_next(symp) still returns
1793 the one that came after it in the chain. So we don't
1794 need to do any extra cleanup work here. */
1799 /* Make sure we really got a value for the symbol. */
1800 if (! symp->sy_resolved)
1802 as_bad ("can't resolve value for symbol \"%s\"",
1804 symp->sy_resolved = 1;
1807 /* Set the value into the BFD symbol. Up til now the value
1808 has only been kept in the gas symbolS struct. */
1809 symp->bsym->value = S_GET_VALUE (symp);
1815 /* Now do any format-specific adjustments to the symbol table, such
1816 as adding file symbols. */
1817 #ifdef tc_adjust_symtab
1818 tc_adjust_symtab ();
1820 #ifdef obj_adjust_symtab
1821 obj_adjust_symtab ();
1824 /* Now that all the sizes are known, and contents correct, we can
1825 start writing to the file. */
1828 /* If *_frob_file changes the symbol value at this point, it is
1829 responsible for moving the changed value into symp->bsym->value
1830 as well. Hopefully all symbol value changing can be done in
1835 #ifdef obj_frob_file
1839 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1841 #ifdef tc_frob_file_after_relocs
1842 tc_frob_file_after_relocs ();
1844 #ifdef obj_frob_file_after_relocs
1845 obj_frob_file_after_relocs ();
1848 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1849 #endif /* BFD_ASSEMBLER */
1856 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1861 * After this, all frags in this segment have addresses that are correct
1862 * within the segment. Since segments live in different file addresses,
1863 * these frag addresses may not be the same as final object-file addresses.
1866 #ifndef md_relax_frag
1867 #ifdef TC_GENERIC_RELAX_TABLE
1869 /* Subroutines of relax_segment. */
1875 for (; f1; f1 = f1->fr_next)
1876 if (f1->fr_next == f2)
1881 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1882 #endif /* ! defined (md_relax_frag) */
1884 /* Relax_align. Advance location counter to next address that has 'alignment'
1885 lowest order bits all 0s, return size of adjustment made. */
1886 static relax_addressT
1887 relax_align (address, alignment)
1888 register relax_addressT address; /* Address now. */
1889 register int alignment; /* Alignment (binary). */
1891 relax_addressT mask;
1892 relax_addressT new_address;
1894 mask = ~((~0) << alignment);
1895 new_address = (address + mask) & (~mask);
1896 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1898 /* We must provide lots of padding, so the linker can discard it
1899 when needed. The linker will not add extra space, ever. */
1900 new_address += (1 << alignment);
1902 return (new_address - address);
1906 relax_segment (segment_frag_root, segment)
1907 struct frag *segment_frag_root;
1910 register struct frag *fragP;
1911 register relax_addressT address;
1912 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1913 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1915 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1916 subseg_change (segment, 0);
1918 /* For each frag in segment: count and store (a 1st guess of)
1921 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1923 fragP->fr_address = address;
1924 address += fragP->fr_fix;
1926 switch (fragP->fr_type)
1929 address += fragP->fr_offset * fragP->fr_var;
1935 int offset = relax_align (address, (int) fragP->fr_offset);
1936 if (offset % fragP->fr_var != 0)
1938 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1939 offset, (long) fragP->fr_var);
1940 offset -= (offset % fragP->fr_var);
1948 /* Assume .org is nugatory. It will grow with 1st relax. */
1951 case rs_machine_dependent:
1952 address += md_estimate_size_before_relax (fragP, segment);
1955 #ifndef WORKING_DOT_WORD
1956 /* Broken words don't concern us yet */
1957 case rs_broken_word:
1962 BAD_CASE (fragP->fr_type);
1964 } /* switch(fr_type) */
1965 } /* for each frag in the segment */
1969 long stretch; /* May be any size, 0 or negative. */
1970 /* Cumulative number of addresses we have */
1971 /* relaxed this pass. */
1972 /* We may have relaxed more than one address. */
1973 long stretched; /* Have we stretched on this pass? */
1974 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1975 grew, and another shrank. If a branch instruction doesn't fit anymore,
1976 we could be scrod. */
1980 stretch = stretched = 0;
1981 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1984 unsigned long was_address;
1990 was_address = fragP->fr_address;
1991 address = fragP->fr_address += stretch;
1992 symbolP = fragP->fr_symbol;
1993 offset = fragP->fr_offset;
1995 switch (fragP->fr_type)
1997 case rs_fill: /* .fill never relaxes. */
2001 #ifndef WORKING_DOT_WORD
2002 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2003 for it I do not want to write it. I do not want to have
2004 anything to do with it. This is not the proper way to
2005 implement this misfeature. */
2006 case rs_broken_word:
2008 struct broken_word *lie;
2009 struct broken_word *untruth;
2011 /* Yes this is ugly (storing the broken_word pointer
2012 in the symbol slot). Still, this whole chunk of
2013 code is ugly, and I don't feel like doing anything
2014 about it. Think of it as stubbornness in action. */
2016 for (lie = (struct broken_word *) (fragP->fr_symbol);
2017 lie && lie->dispfrag == fragP;
2018 lie = lie->next_broken_word)
2024 offset = (lie->add->sy_frag->fr_address
2025 + S_GET_VALUE (lie->add)
2027 - (lie->sub->sy_frag->fr_address
2028 + S_GET_VALUE (lie->sub)));
2029 if (offset <= -32768 || offset >= 32767)
2031 if (flag_warn_displacement)
2034 sprint_value (buf, (addressT) lie->addnum);
2035 as_warn (".word %s-%s+%s didn't fit",
2036 S_GET_NAME (lie->add),
2037 S_GET_NAME (lie->sub),
2041 if (fragP->fr_subtype == 0)
2043 fragP->fr_subtype++;
2044 growth += md_short_jump_size;
2046 for (untruth = lie->next_broken_word;
2047 untruth && untruth->dispfrag == lie->dispfrag;
2048 untruth = untruth->next_broken_word)
2049 if ((untruth->add->sy_frag == lie->add->sy_frag)
2050 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
2053 untruth->use_jump = lie;
2055 growth += md_long_jump_size;
2060 } /* case rs_broken_word */
2064 growth = (relax_align ((relax_addressT) (address
2067 - relax_align ((relax_addressT) (was_address
2077 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2078 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2079 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2080 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2081 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2082 know (symbolP->sy_frag);
2083 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2084 || (symbolP->sy_frag == &zero_address_frag));
2086 target += S_GET_VALUE (symbolP)
2087 + symbolP->sy_frag->fr_address;
2088 } /* if we have a symbol */
2090 know (fragP->fr_next);
2091 after = fragP->fr_next->fr_address;
2092 growth = target - after;
2095 /* Growth may be negative, but variable part of frag
2096 cannot have fewer than 0 chars. That is, we can't
2098 as_bad ("attempt to .org backwards ignored");
2102 growth -= stretch; /* This is an absolute growth factor */
2108 growth = S_GET_VALUE (symbolP);
2109 if (symbolP->sy_frag != &zero_address_frag)
2110 as_bad (".space specifies non-absolute value");
2111 fragP->fr_symbol = 0;
2114 as_warn (".space or .fill with negative value, ignored");
2122 case rs_machine_dependent:
2123 #ifdef md_relax_frag
2124 growth = md_relax_frag (fragP, stretch);
2126 #ifdef TC_GENERIC_RELAX_TABLE
2127 /* The default way to relax a frag is to look through
2130 const relax_typeS *this_type;
2131 const relax_typeS *start_type;
2132 relax_substateT next_state;
2133 relax_substateT this_state;
2135 const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
2137 this_state = fragP->fr_subtype;
2138 start_type = this_type = table + this_state;
2143 #ifndef DIFF_EXPR_OK
2144 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2145 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2146 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2147 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2148 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2150 know (symbolP->sy_frag);
2152 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
2153 || symbolP->sy_frag == &zero_address_frag);
2155 S_GET_VALUE (symbolP)
2156 + symbolP->sy_frag->fr_address;
2158 /* If frag has yet to be reached on this pass,
2159 assume it will move by STRETCH just as we did.
2160 If this is not so, it will be because some frag
2161 between grows, and that will force another pass.
2163 Beware zero-length frags.
2165 There should be a faster way to do this. */
2167 if (symbolP->sy_frag->fr_address >= was_address
2168 && is_dnrange (fragP, symbolP->sy_frag))
2174 aim = target - address - fragP->fr_fix;
2175 #ifdef TC_PCREL_ADJUST
2176 /* Currently only the ns32k family needs this */
2177 aim += TC_PCREL_ADJUST(fragP);
2179 /* This machine doesn't want to use pcrel_adjust.
2180 In that case, pcrel_adjust should be zero. */
2181 assert (fragP->fr_pcrel_adjust == 0);
2186 /* Look backwards. */
2187 for (next_state = this_type->rlx_more; next_state;)
2188 if (aim >= this_type->rlx_backward)
2192 /* Grow to next state. */
2193 this_state = next_state;
2194 this_type = table + this_state;
2195 next_state = this_type->rlx_more;
2200 #ifdef M68K_AIM_KLUDGE
2201 M68K_AIM_KLUDGE (aim, this_state, this_type);
2203 /* Look forwards. */
2204 for (next_state = this_type->rlx_more; next_state;)
2205 if (aim <= this_type->rlx_forward)
2209 /* Grow to next state. */
2210 this_state = next_state;
2211 this_type = table + this_state;
2212 next_state = this_type->rlx_more;
2216 growth = this_type->rlx_length - start_type->rlx_length;
2218 fragP->fr_subtype = this_state;
2220 #endif /* TC_GENERIC_RELAX_TABLE */
2225 BAD_CASE (fragP->fr_type);
2233 } /* For each frag in the segment. */
2235 while (stretched); /* Until nothing further to relax. */
2239 * We now have valid fr_address'es for each frag.
2243 * All fr_address's are correct, relative to their own segment.
2244 * We have made all the fixS we will ever make.
2246 } /* relax_segment() */
2248 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2250 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2251 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2256 Go through all the fixS's in a segment and see which ones can be
2257 handled now. (These consist of fixS where we have since discovered
2258 the value of a symbol, or the address of the frag involved.)
2259 For each one, call md_apply_fix to put the fix into the frag data.
2261 Result is a count of how many relocation structs will be needed to
2262 handle the remaining fixS's that we couldn't completely handle here.
2263 These will be output later by emit_relocations(). */
2266 fixup_segment (fixP, this_segment_type)
2267 register fixS *fixP;
2268 segT this_segment_type; /* N_TYPE bits for segment. */
2270 long seg_reloc_count = 0;
2271 symbolS *add_symbolP;
2272 symbolS *sub_symbolP;
2279 segT add_symbol_segment = absolute_section;
2281 /* If the linker is doing the relaxing, we must not do any fixups.
2283 Well, strictly speaking that's not true -- we could do any that are
2284 PC-relative and don't cross regions that could change size. And for the
2285 i960 (the only machine for which we've got a relaxing linker right now),
2286 we might be able to turn callx/callj into bal anyways in cases where we
2287 know the maximum displacement. */
2290 for (; fixP; fixP = fixP->fx_next)
2292 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2293 return seg_reloc_count;
2296 for (; fixP; fixP = fixP->fx_next)
2299 fprintf (stderr, "\nprocessing fixup:\n");
2303 fragP = fixP->fx_frag;
2305 where = fixP->fx_where;
2306 place = fragP->fr_literal + where;
2307 size = fixP->fx_size;
2308 add_symbolP = fixP->fx_addsy;
2309 #ifdef TC_VALIDATE_FIX
2310 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2312 sub_symbolP = fixP->fx_subsy;
2313 add_number = fixP->fx_offset;
2314 pcrel = fixP->fx_pcrel;
2317 if (add_symbolP != NULL
2318 && add_symbolP->sy_mri_common)
2320 know (add_symbolP->sy_value.X_op == O_symbol);
2321 add_number += S_GET_VALUE (add_symbolP);
2322 fixP->fx_offset = add_number;
2323 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
2327 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2331 resolve_symbol_value (sub_symbolP);
2332 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2334 if (add_symbolP != NULL)
2336 add_number += S_GET_VALUE (add_symbolP);
2338 fixP->fx_addsy = NULL;
2341 /* It's just -sym */
2342 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2344 add_number -= S_GET_VALUE (sub_symbolP);
2345 fixP->fx_subsy = NULL;
2348 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2350 /* Should try converting to a constant. */
2355 as_bad_where (fixP->fx_file, fixP->fx_line,
2356 "Negative of non-absolute symbol %s",
2357 S_GET_NAME (sub_symbolP));
2359 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2360 && SEG_NORMAL (add_symbol_segment))
2362 /* Difference of 2 symbols from same segment.
2363 Can't make difference of 2 undefineds: 'value' means
2364 something different for N_UNDF. */
2366 /* Makes no sense to use the difference of 2 arbitrary symbols
2367 as the target of a call instruction. */
2369 as_bad_where (fixP->fx_file, fixP->fx_line,
2370 "callj to difference of 2 symbols");
2371 #endif /* TC_I960 */
2372 add_number += S_GET_VALUE (add_symbolP) -
2373 S_GET_VALUE (sub_symbolP);
2376 pcrel = 0; /* No further pcrel processing. */
2378 /* Let the target machine make the final determination
2379 as to whether or not a relocation will be needed to
2380 handle this fixup. */
2381 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2384 fixP->fx_addsy = NULL;
2385 fixP->fx_subsy = NULL;
2390 /* Different segments in subtraction. */
2391 know (!(S_IS_EXTERNAL (sub_symbolP)
2392 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2394 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2395 add_number -= S_GET_VALUE (sub_symbolP);
2398 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2399 #if 0 /* Do this even if it's already described as pc-relative. For example,
2400 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2401 pc-relative mode. */
2406 /* Make it pc-relative. */
2407 add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
2408 - S_GET_VALUE (sub_symbolP));
2415 #ifdef UNDEFINED_DIFFERENCE_OK
2416 /* The PA needs this for PIC code generation. We basically
2417 don't want to do anything if we have the difference of two
2418 symbols at this point. */
2421 /* Leave it alone. */
2424 #ifdef BFD_ASSEMBLER
2425 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2426 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2428 /* Leave it alone. */
2434 sprint_value (buf, fragP->fr_address + where);
2435 as_bad_where (fixP->fx_file, fixP->fx_line,
2436 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2437 segment_name (S_GET_SEGMENT (sub_symbolP)),
2438 S_GET_NAME (sub_symbolP), buf);
2445 if (add_symbol_segment == this_segment_type && pcrel && !plt
2446 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2449 * This fixup was made when the symbol's segment was
2450 * SEG_UNKNOWN, but it is now in the local segment.
2451 * So we know how to do the address without relocation.
2454 /* reloc_callj() may replace a 'call' with a 'calls' or a
2455 'bal', in which cases it modifies *fixP as appropriate.
2456 In the case of a 'calls', no further work is required,
2457 and *fixP has been set up to make the rest of the code
2460 #endif /* TC_I960 */
2462 add_number += S_GET_VALUE (add_symbolP);
2463 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2464 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2466 /* Let the target machine make the final determination
2467 as to whether or not a relocation will be needed to
2468 handle this fixup. */
2469 if (!TC_FORCE_RELOCATION (fixP))
2472 fixP->fx_addsy = NULL;
2477 if (add_symbol_segment == absolute_section
2481 /* See comment about reloc_callj() above. */
2483 #endif /* TC_I960 */
2484 add_number += S_GET_VALUE (add_symbolP);
2486 /* Let the target machine make the final determination
2487 as to whether or not a relocation will be needed to
2488 handle this fixup. */
2490 if (!TC_FORCE_RELOCATION (fixP))
2492 fixP->fx_addsy = NULL;
2496 else if (add_symbol_segment == undefined_section
2497 #ifdef BFD_ASSEMBLER
2498 || bfd_is_com_section (add_symbol_segment)
2503 if ((int) fixP->fx_bit_fixP == 13)
2505 /* This is a COBR instruction. They have only a
2506 * 13-bit displacement and are only to be used
2507 * for local branches: flag as error, don't generate
2510 as_bad_where (fixP->fx_file, fixP->fx_line,
2511 "can't use COBR format with external label");
2512 fixP->fx_addsy = NULL;
2516 #endif /* TC_I960 */
2520 if (S_IS_COMMON (add_symbolP))
2521 add_number += S_GET_VALUE (add_symbolP);
2522 #endif /* TE_I386AIX */
2523 #endif /* OBJ_COFF */
2529 /* start-sanitize-v850 */
2530 #if !(defined (TC_V850) && defined (OBJ_ELF))
2531 /* end-sanitize-v850 */
2532 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2533 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2534 add_number += S_GET_VALUE (add_symbolP);
2535 /* start-sanitize-v850 */
2537 /* end-sanitize-v850 */
2546 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2547 if (add_symbolP == 0)
2549 #ifndef BFD_ASSEMBLER
2550 fixP->fx_addsy = &abs_symbol;
2552 fixP->fx_addsy = section_symbol (absolute_section);
2554 fixP->fx_addsy->sy_used_in_reloc = 1;
2559 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2562 if (size < sizeof (mask))
2564 /* set all bits to one */
2566 /* Technically, combining these produces an undefined result
2567 if size is sizeof (valueT), though I think these two
2568 half-way operations should both be defined. And the
2569 compiler should be able to combine them if it's valid on
2570 the host architecture. */
2573 if ((add_number & mask) != 0
2574 && (add_number & mask) != mask)
2576 char buf[50], buf2[50];
2577 sprint_value (buf, fragP->fr_address + where);
2578 if (add_number > 1000)
2579 sprint_value (buf2, add_number);
2581 sprintf (buf2, "%ld", (long) add_number);
2582 as_bad_where (fixP->fx_file, fixP->fx_line,
2583 "Value of %s too large for field of %d bytes at %s",
2585 } /* generic error checking */
2587 #ifdef WARN_SIGNED_OVERFLOW_WORD
2588 /* Warn if a .word value is too large when treated as a signed
2589 number. We already know it is not too negative. This is to
2590 catch over-large switches generated by gcc on the 68k. */
2591 if (!flag_signed_overflow_ok
2593 && add_number > 0x7fff)
2594 as_bad_where (fixP->fx_file, fixP->fx_line,
2595 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2597 (unsigned long) (fragP->fr_address + where));
2599 } /* not a bit fix */
2603 #ifdef MD_APPLY_FIX3
2604 md_apply_fix3 (fixP, &add_number, this_segment_type);
2606 #ifdef BFD_ASSEMBLER
2607 md_apply_fix (fixP, &add_number);
2609 md_apply_fix (fixP, add_number);
2613 #ifndef TC_HANDLES_FX_DONE
2614 /* If the tc-* files haven't been converted, assume it's handling
2615 it the old way, where a null fx_addsy means that the fix has
2616 been applied completely, and no further work is needed. */
2617 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2621 #ifdef TC_VALIDATE_FIX
2625 fprintf (stderr, "result:\n");
2628 } /* For each fixS in this segment. */
2630 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2631 return seg_reloc_count;
2634 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2637 number_to_chars_bigendian (buf, val, n)
2642 if (n > sizeof (val)|| n <= 0)
2646 buf[n] = val & 0xff;
2652 number_to_chars_littleendian (buf, val, n)
2657 if (n > sizeof (val) || n <= 0)
2661 *buf++ = val & 0xff;
2667 write_print_statistics (file)
2670 fprintf (stderr, "fixups: %d\n", n_fixups);
2674 extern int indent_level;
2675 extern void print_symbol_value_1 ();
2682 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2684 fprintf (stderr, " pcrel");
2685 if (fixp->fx_pcrel_adjust)
2686 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2687 if (fixp->fx_im_disp)
2690 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2692 fprintf (stderr, " im_disp");
2696 fprintf (stderr, " tcbit");
2698 fprintf (stderr, " done");
2699 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2700 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2701 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2702 #ifdef BFD_ASSEMBLER
2703 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2706 #ifdef NEED_FX_R_TYPE
2707 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2712 fprintf (stderr, "\n +<");
2713 print_symbol_value_1 (stderr, fixp->fx_addsy);
2714 fprintf (stderr, ">");
2718 fprintf (stderr, "\n -<");
2719 print_symbol_value_1 (stderr, fixp->fx_subsy);
2720 fprintf (stderr, ">");
2722 fprintf (stderr, "\n");
2725 /* end of write.c */