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 /* Since we're reducing to section symbols, don't attempt to reduce
722 anything that's already using one. */
723 if (sym->bsym->flags & BSF_SECTION_SYM)
725 fixp->fx_addsy->sy_used_in_reloc = 1;
729 /* Is there some other reason we can't adjust this one? (E.g.,
730 call/bal links in i960-bout symbols.) */
731 #ifdef obj_fix_adjustable
732 if (! obj_fix_adjustable (fixp))
734 fixp->fx_addsy->sy_used_in_reloc = 1;
739 /* Is there some other (target cpu dependent) reason we can't adjust
740 this one? (E.g. relocations involving function addresses on
742 #ifdef tc_fix_adjustable
743 if (! tc_fix_adjustable (fixp))
745 fixp->fx_addsy->sy_used_in_reloc = 1;
750 /* For PIC support: We may get expressions like
751 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
752 necessarily have had a fixed difference initially. But now
753 it should be a known constant, so we can reduce it. Since
754 we can't easily handle a symbol value that looks like
755 someUndefinedSymbol+const, though, we convert the fixup to
756 access the undefined symbol directly, and discard the
757 intermediate symbol. */
758 if (S_GET_SEGMENT (sym) == expr_section
759 && sym->sy_value.X_op == O_add
760 && (resolve_symbol_value (sym->sy_value.X_add_symbol),
761 S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
762 && (resolve_symbol_value (sym->sy_value.X_op_symbol),
763 S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
765 fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
766 fixp->fx_offset += sym->sy_value.X_add_number;
767 fixp->fx_addsy = sym->sy_value.X_add_symbol;
771 /* If the section symbol isn't going to be output, the relocs
772 at least should still work. If not, figure out what to do
773 when we run into that case.
775 We refetch the segment when calling section_symbol, rather
776 than using symsec, because S_GET_VALUE may wind up changing
777 the section when it calls resolve_symbol_value. */
778 fixp->fx_offset += S_GET_VALUE (sym);
779 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
780 fixp->fx_addsy->sy_used_in_reloc = 1;
785 #if 1/*def RELOC_REQUIRES_SYMBOL*/
788 /* There was no symbol required by this relocation. However,
789 BFD doesn't really handle relocations without symbols well.
790 (At least, the COFF support doesn't.) So for now we fake up
791 a local symbol in the absolute section. */
793 fixp->fx_addsy = section_symbol (absolute_section);
794 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
798 dump_section_relocs (abfd, sec, stderr);
802 write_relocs (abfd, sec, xxx)
807 segment_info_type *seginfo = seg_info (sec);
814 /* If seginfo is NULL, we did not create this section; don't do
819 fixup_segment (seginfo->fix_root, sec);
822 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
825 #ifndef RELOC_EXPANSION_POSSIBLE
826 /* Set up reloc information as well. */
827 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
828 n * sizeof (arelent *));
829 memset ((char*)relocs, 0, n * sizeof (arelent*));
832 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
835 bfd_reloc_status_type s;
844 /* If this is an undefined symbol which was equated to another
845 symbol, then use generate the reloc against the latter symbol
846 rather than the former. */
847 sym = fixp->fx_addsy;
848 while (sym->sy_value.X_op == O_symbol
849 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
850 sym = sym->sy_value.X_add_symbol;
851 fixp->fx_addsy = sym;
853 reloc = tc_gen_reloc (sec, fixp);
861 /* This test is triggered inappropriately for the SH. */
862 if (fixp->fx_where + fixp->fx_size
863 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
867 s = bfd_install_relocation (stdoutput, reloc,
868 fixp->fx_frag->fr_literal,
869 fixp->fx_frag->fr_address,
875 case bfd_reloc_overflow:
876 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
879 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
880 fixp->fx_file, fixp->fx_line);
885 n = n * MAX_RELOC_EXPANSION;
886 /* Set up reloc information as well. */
887 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
888 n * sizeof (arelent *));
891 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
895 bfd_reloc_status_type s;
905 /* If this is an undefined symbol which was equated to another
906 symbol, then use generate the reloc against the latter symbol
907 rather than the former. */
908 sym = fixp->fx_addsy;
909 while (sym->sy_value.X_op == O_symbol
910 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
911 sym = sym->sy_value.X_add_symbol;
912 fixp->fx_addsy = sym;
914 reloc = tc_gen_reloc (sec, fixp);
916 for (j = 0; reloc[j]; j++)
918 relocs[i++] = reloc[j];
921 data = fixp->fx_frag->fr_literal + fixp->fx_where;
922 if (fixp->fx_where + fixp->fx_size
923 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
924 as_bad_where (fixp->fx_file, fixp->fx_line,
925 "internal error: fixup not contained within frag");
926 for (j = 0; reloc[j]; j++)
928 s = bfd_install_relocation (stdoutput, reloc[j],
929 fixp->fx_frag->fr_literal,
930 fixp->fx_frag->fr_address,
936 case bfd_reloc_overflow:
937 as_bad_where (fixp->fx_file, fixp->fx_line,
938 "relocation overflow");
941 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
942 fixp->fx_file, fixp->fx_line);
953 sympp = bfd_get_outsymbols (stdoutput);
954 nsyms = bfd_get_symcount (stdoutput);
955 for (i = 0; i < n; i++)
956 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
958 for (j = 0; j < nsyms; j++)
959 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
968 bfd_set_reloc (stdoutput, sec, relocs, n);
970 bfd_set_section_flags (abfd, sec,
971 (bfd_get_section_flags (abfd, sec)
972 & (flagword) ~SEC_RELOC));
979 fprintf (stderr, "relocs for sec %s\n", sec->name);
980 for (i = 0; i < n; i++)
984 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
985 i, r, r->address, s->name, r->addend);
992 write_contents (abfd, sec, xxx)
997 segment_info_type *seginfo = seg_info (sec);
998 unsigned long offset = 0;
1001 /* Write out the frags. */
1003 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1006 for (f = seginfo->frchainP->frch_root;
1011 unsigned long fill_size;
1015 assert (f->fr_type == rs_fill);
1018 x = bfd_set_section_contents (stdoutput, sec,
1019 f->fr_literal, (file_ptr) offset,
1020 (bfd_size_type) f->fr_fix);
1023 bfd_perror (stdoutput->filename);
1024 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1025 exit (EXIT_FAILURE);
1027 offset += f->fr_fix;
1029 fill_literal = f->fr_literal + f->fr_fix;
1030 fill_size = f->fr_var;
1031 count = f->fr_offset;
1032 assert (count >= 0);
1033 if (fill_size && count)
1036 if (fill_size > sizeof(buf))
1038 /* Do it the old way. Can this ever happen? */
1041 x = bfd_set_section_contents (stdoutput, sec,
1044 (bfd_size_type) fill_size);
1047 bfd_perror (stdoutput->filename);
1048 as_perror ("FATAL: Can't write %s", stdoutput->filename);
1049 exit (EXIT_FAILURE);
1051 offset += fill_size;
1056 /* Build a buffer full of fill objects and output it as
1057 often as necessary. This saves on the overhead of
1058 potentially lots of bfd_set_section_contents calls. */
1062 n_per_buf = sizeof (buf);
1063 memset (buf, *fill_literal, n_per_buf);
1068 n_per_buf = sizeof(buf)/fill_size;
1069 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1070 memcpy(bufp, fill_literal, fill_size);
1072 for (; count > 0; count -= n_per_buf)
1074 n_per_buf = n_per_buf > count ? count : n_per_buf;
1075 x = bfd_set_section_contents (stdoutput, sec,
1076 buf, (file_ptr) offset,
1077 (bfd_size_type) n_per_buf * fill_size);
1079 as_fatal ("Cannot write to output file.");
1080 offset += n_per_buf * fill_size;
1088 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1090 merge_data_into_text ()
1092 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1093 seg_info (text_section)->frchainP->frch_last->fr_next =
1094 seg_info (data_section)->frchainP->frch_root;
1095 seg_info (text_section)->frchainP->frch_last =
1096 seg_info (data_section)->frchainP->frch_last;
1097 seg_info (data_section)->frchainP = 0;
1101 text_last_frag->fr_next = data_frag_root;
1102 text_last_frag = data_last_frag;
1103 data_last_frag = NULL;
1104 data_frag_root = NULL;
1107 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1108 tmp->fx_next = data_fix_root;
1109 text_fix_tail = data_fix_tail;
1112 text_fix_root = data_fix_root;
1113 data_fix_root = NULL;
1116 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1118 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1120 relax_and_size_all_segments ()
1124 relax_segment (text_frag_root, SEG_TEXT);
1125 relax_segment (data_frag_root, SEG_DATA);
1126 relax_segment (bss_frag_root, SEG_BSS);
1128 * Now the addresses of frags are correct within the segment.
1131 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1132 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1133 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1136 * Join the 2 segments into 1 huge segment.
1137 * To do this, re-compute every rn_address in the SEG_DATA frags.
1138 * Then join the data frags after the text frags.
1140 * Determine a_data [length of data segment].
1144 register relax_addressT slide;
1146 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1148 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1149 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1150 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1152 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1153 /* For b.out: If the data section has a strict alignment
1154 requirement, its load address in the .o file will be
1155 rounded up from the size of the text section. These
1156 two values are *not* the same! Similarly for the bss
1158 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1161 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1163 fragP->fr_address += slide;
1164 } /* for each data frag */
1166 know (text_last_frag != 0);
1167 text_last_frag->fr_next = data_frag_root;
1171 H_SET_DATA_SIZE (&headers, 0);
1175 /* See above comments on b.out data section address. */
1178 if (data_last_frag == 0)
1179 bss_vma = H_GET_TEXT_SIZE (&headers);
1181 bss_vma = data_last_frag->fr_address;
1182 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1183 bss_address_frag.fr_address = bss_vma;
1185 #else /* ! OBJ_BOUT */
1186 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1187 H_GET_DATA_SIZE (&headers));
1189 #endif /* ! OBJ_BOUT */
1191 /* Slide all the frags */
1194 relax_addressT slide = bss_address_frag.fr_address;
1196 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1198 fragP->fr_address += slide;
1199 } /* for each bss frag */
1203 H_SET_BSS_SIZE (&headers,
1204 bss_last_frag->fr_address - bss_frag_root->fr_address);
1206 H_SET_BSS_SIZE (&headers, 0);
1208 #endif /* ! BFD_ASSEMBLER && ! BFD */
1210 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1212 #ifdef BFD_ASSEMBLER
1220 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1222 /* Count symbols. We can't rely on a count made by the loop in
1223 write_object_file, because *_frob_file may add a new symbol or
1226 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1233 asympp = (asymbol **) bfd_alloc (stdoutput,
1234 nsyms * sizeof (asymbol *));
1235 symp = symbol_rootP;
1236 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1238 asympp[i] = symp->bsym;
1244 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1245 assert (result == true);
1246 symbol_table_frozen = 1;
1251 write_object_file ()
1253 struct frchain *frchainP; /* Track along all frchains. */
1254 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1255 fragS *fragP; /* Track along all frags. */
1258 /* Do we really want to write it? */
1260 int n_warns, n_errs;
1261 n_warns = had_warnings ();
1262 n_errs = had_errors ();
1263 /* The -Z flag indicates that an object file should be generated,
1264 regardless of warnings and errors. */
1265 if (flag_always_generate_output)
1267 if (n_warns || n_errs)
1268 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1269 n_errs, n_errs == 1 ? "" : "s",
1270 n_warns, n_warns == 1 ? "" : "s");
1275 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1276 n_errs, n_errs == 1 ? "" : "s",
1277 n_warns, n_warns == 1 ? "" : "s");
1282 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1283 a routine to check for the definition of the procedure "_main",
1284 and if so -- fix it up so that it can be program entry point. */
1285 vms_check_for_main ();
1286 #endif /* OBJ_VMS */
1288 /* After every sub-segment, we fake an ".align ...". This conforms to
1289 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1290 frag that requires least thought. ".align" frags like to have a
1291 following frag since that makes calculating their intended length
1294 @@ Is this really necessary?? */
1295 #ifndef SUB_SEGMENT_ALIGN
1296 #ifdef BFD_ASSEMBLER
1297 #define SUB_SEGMENT_ALIGN(SEG) (0)
1299 #define SUB_SEGMENT_ALIGN(SEG) (2)
1302 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1304 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1305 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1306 /* frag_align will have left a new frag.
1307 Use this last frag for an empty ".fill".
1309 For this segment ...
1310 Create a last frag. Do not leave a "being filled in frag". */
1311 frag_wane (frag_now);
1312 frag_now->fr_fix = 0;
1313 know (frag_now->fr_next == NULL);
1316 /* From now on, we don't care about sub-segments. Build one frag chain
1317 for each segment. Linked thru fr_next. */
1319 #ifdef BFD_ASSEMBLER
1320 /* Remove the sections created by gas for its own purposes. */
1322 asection **seclist, *sec;
1325 seclist = &stdoutput->sections;
1326 while (seclist && *seclist)
1329 while (sec == reg_section || sec == expr_section)
1333 stdoutput->section_count--;
1338 seclist = &(*seclist)->next;
1341 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1344 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1346 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1347 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1348 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1351 /* We have two segments. If user gave -R flag, then we must put the
1352 data frags into the text segment. Do this before relaxing so
1353 we know to take advantage of -R and make shorter addresses. */
1354 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1355 if (flag_readonly_data_in_text)
1357 merge_data_into_text ();
1361 #ifdef BFD_ASSEMBLER
1362 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1364 relax_and_size_all_segments ();
1365 #endif /* BFD_ASSEMBLER */
1367 #ifndef BFD_ASSEMBLER
1370 * Crawl the symbol chain.
1372 * For each symbol whose value depends on a frag, take the address of
1373 * that frag and subsume it into the value of the symbol.
1374 * After this, there is just one way to lookup a symbol value.
1375 * Values are left in their final state for object file emission.
1376 * We adjust the values of 'L' local symbols, even if we do
1377 * not intend to emit them to the object file, because their values
1378 * are needed for fix-ups.
1380 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1381 * from the symbol chain. (They are still pointed to by the fixes.)
1383 * Count the remaining symbols.
1384 * Assign a symbol number to each symbol.
1385 * Count the number of string-table chars we will emit.
1386 * Put this info into the headers as appropriate.
1389 know (zero_address_frag.fr_address == 0);
1390 string_byte_count = sizeof (string_byte_count);
1392 obj_crawl_symbol_chain (&headers);
1394 if (string_byte_count == sizeof (string_byte_count))
1395 string_byte_count = 0;
1397 H_SET_STRING_SIZE (&headers, string_byte_count);
1400 * Addresses of frags now reflect addresses we use in the object file.
1401 * Symbol values are correct.
1402 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1403 * Also converting any machine-dependent frags using md_convert_frag();
1405 subseg_change (SEG_TEXT, 0);
1407 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1409 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1411 /* Some assert macros don't work with # directives mixed in. */
1413 if (!(fragP->fr_next == NULL
1415 || fragP->fr_next == data_frag_root
1417 || ((fragP->fr_next->fr_address - fragP->fr_address)
1418 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1422 #endif /* ! BFD_ASSEMBLER */
1424 #ifndef WORKING_DOT_WORD
1426 struct broken_word *lie;
1427 struct broken_word **prevP;
1429 prevP = &broken_words;
1430 for (lie = broken_words; lie; lie = lie->next_broken_word)
1435 exp.X_op = O_subtract;
1436 exp.X_add_symbol = lie->add;
1437 exp.X_op_symbol = lie->sub;
1438 exp.X_add_number = lie->addnum;
1439 #ifdef BFD_ASSEMBLER
1440 #ifdef TC_CONS_FIX_NEW
1441 TC_CONS_FIX_NEW (lie->frag,
1442 lie->word_goes_here - lie->frag->fr_literal,
1445 fix_new_exp (lie->frag,
1446 lie->word_goes_here - lie->frag->fr_literal,
1447 2, &exp, 0, BFD_RELOC_16);
1450 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1451 fix_new_exp (lie->frag,
1452 lie->word_goes_here - lie->frag->fr_literal,
1453 2, &exp, 0, NO_RELOC);
1456 fix_new_ns32k_exp (lie->frag,
1457 lie->word_goes_here - lie->frag->fr_literal,
1458 2, &exp, 0, 0, 2, 0, 0);
1460 fix_new_exp (lie->frag,
1461 lie->word_goes_here - lie->frag->fr_literal,
1463 #endif /* TC_NS32K */
1464 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1465 #endif /* BFD_ASSEMBLER */
1466 *prevP = lie->next_broken_word;
1469 prevP = &(lie->next_broken_word);
1471 for (lie = broken_words; lie;)
1473 struct broken_word *untruth;
1475 addressT table_addr;
1476 addressT from_addr, to_addr;
1479 fragP = lie->dispfrag;
1481 /* Find out how many broken_words go here. */
1483 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1484 if (untruth->added == 1)
1487 table_ptr = lie->dispfrag->fr_opcode;
1488 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1489 /* Create the jump around the long jumps. This is a short
1490 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1491 from_addr = table_addr;
1492 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1493 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1494 table_ptr += md_short_jump_size;
1495 table_addr += md_short_jump_size;
1497 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1499 if (lie->added == 2)
1501 /* Patch the jump table */
1502 /* This is the offset from ??? to table_ptr+0 */
1503 to_addr = table_addr - S_GET_VALUE (lie->sub);
1504 #ifdef BFD_ASSEMBLER
1505 to_addr -= lie->sub->sy_frag->fr_address;
1507 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1508 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1510 if (untruth->use_jump == lie)
1511 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1514 /* Install the long jump */
1515 /* this is a long jump from table_ptr+0 to the final target */
1516 from_addr = table_addr;
1517 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1518 #ifdef BFD_ASSEMBLER
1519 to_addr += lie->add->sy_frag->fr_address;
1521 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1522 table_ptr += md_long_jump_size;
1523 table_addr += md_long_jump_size;
1527 #endif /* not WORKING_DOT_WORD */
1529 #ifndef BFD_ASSEMBLER
1532 char *the_object_file;
1533 long object_file_size;
1535 * Scan every FixS performing fixups. We had to wait until now to do
1536 * this because md_convert_frag() may have made some fixSs.
1540 subseg_change (SEG_TEXT, 0);
1541 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1542 subseg_change (SEG_DATA, 0);
1543 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1544 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1546 /* FIXME move this stuff into the pre-write-hook */
1547 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1548 H_SET_ENTRY_POINT (&headers, 0);
1550 obj_pre_write_hook (&headers); /* extra coff stuff */
1552 object_file_size = H_GET_FILE_SIZE (&headers);
1553 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1555 output_file_create (out_file_name);
1557 obj_header_append (&next_object_file_charP, &headers);
1559 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1564 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1566 register long count;
1567 register char *fill_literal;
1568 register long fill_size;
1571 know (fragP->fr_type == rs_fill);
1572 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1573 fill_literal = fragP->fr_literal + fragP->fr_fix;
1574 fill_size = fragP->fr_var;
1575 know (fragP->fr_offset >= 0);
1577 for (count = fragP->fr_offset; count; count--)
1579 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1582 } /* for each code frag. */
1584 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1589 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1590 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)));
1592 /* Make addresses in data relocation directives relative to beginning of
1593 * first data fragment, not end of last text fragment: alignment of the
1594 * start of the data segment may place a gap between the segments.
1596 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1598 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1599 #endif /* TC_I960 */
1601 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)));
1604 * Emit line number entries.
1606 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1607 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)));
1612 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1613 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)));
1619 if (string_byte_count > 0)
1621 obj_emit_strings (&next_object_file_charP);
1622 } /* only if we have a string table */
1625 bfd_seek (stdoutput, 0, 0);
1626 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1629 /* Write the data to the file */
1630 output_file_append (the_object_file, object_file_size, out_file_name);
1631 free (the_object_file);
1633 } /* non vms output */
1636 * Now do the VMS-dependent part of writing the object file
1638 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1639 H_GET_DATA_SIZE (&headers),
1640 H_GET_BSS_SIZE (&headers),
1641 text_frag_root, data_frag_root);
1642 #endif /* OBJ_VMS */
1643 #else /* BFD_ASSEMBLER */
1645 /* Resolve symbol values. This needs to be done before processing
1651 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1652 if (!symp->sy_resolved)
1653 resolve_symbol_value (symp);
1658 #ifdef tc_frob_file_before_adjust
1659 tc_frob_file_before_adjust ();
1661 #ifdef obj_frob_file_before_adjust
1662 obj_frob_file_before_adjust ();
1665 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1667 /* Set up symbol table, and write it out. */
1672 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1677 if (symp->sy_mri_common)
1679 if (S_IS_EXTERNAL (symp))
1680 as_bad ("%s: global symbols not supported in common sections",
1682 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1686 name = S_GET_NAME (symp);
1689 const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
1690 /* They only differ if `name' is a fb or dollar local
1692 if (name2 != name && ! S_IS_DEFINED (symp))
1693 as_bad ("local label %s is not defined", name2);
1696 /* Do it again, because adjust_reloc_syms might introduce
1697 more symbols. They'll probably only be section symbols,
1698 but they'll still need to have the values computed. */
1699 if (! symp->sy_resolved)
1701 if (symp->sy_value.X_op == O_constant)
1703 /* This is the normal case; skip the call. */
1706 + symp->sy_frag->fr_address));
1707 symp->sy_resolved = 1;
1710 resolve_symbol_value (symp);
1713 /* Skip symbols which were equated to undefined or common
1715 if (symp->sy_value.X_op == O_symbol
1716 && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1718 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1722 /* So far, common symbols have been treated like undefined symbols.
1723 Put them in the common section now. */
1724 if (S_IS_DEFINED (symp) == 0
1725 && S_GET_VALUE (symp) != 0)
1726 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1728 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1729 S_GET_NAME (symp), symp,
1732 segment_name (symp->bsym->section));
1735 #ifdef obj_frob_symbol
1736 obj_frob_symbol (symp, punt);
1738 #ifdef tc_frob_symbol
1739 if (! punt || symp->sy_used_in_reloc)
1740 tc_frob_symbol (symp, punt);
1743 /* If we don't want to keep this symbol, splice it out of
1744 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1745 want section symbols. Otherwise, we skip local symbols
1746 and symbols that the frob_symbol macros told us to punt,
1747 but we keep such symbols if they are used in relocs. */
1748 if ((! EMIT_SECTION_SYMBOLS
1749 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1750 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1751 opposites. Sometimes the former checks flags and the
1752 latter examines the name... */
1753 || (!S_IS_EXTERN (symp)
1754 && (S_IS_LOCAL (symp) || punt)
1755 && ! symp->sy_used_in_reloc))
1757 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1758 /* After symbol_remove, symbol_next(symp) still returns
1759 the one that came after it in the chain. So we don't
1760 need to do any extra cleanup work here. */
1765 /* Make sure we really got a value for the symbol. */
1766 if (! symp->sy_resolved)
1768 as_bad ("can't resolve value for symbol \"%s\"",
1770 symp->sy_resolved = 1;
1773 /* Set the value into the BFD symbol. Up til now the value
1774 has only been kept in the gas symbolS struct. */
1775 symp->bsym->value = S_GET_VALUE (symp);
1781 /* Now do any format-specific adjustments to the symbol table, such
1782 as adding file symbols. */
1783 #ifdef tc_adjust_symtab
1784 tc_adjust_symtab ();
1786 #ifdef obj_adjust_symtab
1787 obj_adjust_symtab ();
1790 /* Now that all the sizes are known, and contents correct, we can
1791 start writing to the file. */
1794 /* If *_frob_file changes the symbol value at this point, it is
1795 responsible for moving the changed value into symp->bsym->value
1796 as well. Hopefully all symbol value changing can be done in
1801 #ifdef obj_frob_file
1805 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1807 #ifdef tc_frob_file_after_relocs
1808 tc_frob_file_after_relocs ();
1810 #ifdef obj_frob_file_after_relocs
1811 obj_frob_file_after_relocs ();
1814 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1815 #endif /* BFD_ASSEMBLER */
1822 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1827 * After this, all frags in this segment have addresses that are correct
1828 * within the segment. Since segments live in different file addresses,
1829 * these frag addresses may not be the same as final object-file addresses.
1832 #ifndef md_relax_frag
1833 #ifdef TC_GENERIC_RELAX_TABLE
1835 /* Subroutines of relax_segment. */
1841 for (; f1; f1 = f1->fr_next)
1842 if (f1->fr_next == f2)
1847 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1848 #endif /* ! defined (md_relax_frag) */
1850 /* Relax_align. Advance location counter to next address that has 'alignment'
1851 lowest order bits all 0s, return size of adjustment made. */
1852 static relax_addressT
1853 relax_align (address, alignment)
1854 register relax_addressT address; /* Address now. */
1855 register int alignment; /* Alignment (binary). */
1857 relax_addressT mask;
1858 relax_addressT new_address;
1860 mask = ~((~0) << alignment);
1861 new_address = (address + mask) & (~mask);
1862 #ifdef LINKER_RELAXING_SHRINKS_ONLY
1864 /* We must provide lots of padding, so the linker can discard it
1865 when needed. The linker will not add extra space, ever. */
1866 new_address += (1 << alignment);
1868 return (new_address - address);
1872 relax_segment (segment_frag_root, segment)
1873 struct frag *segment_frag_root;
1876 register struct frag *fragP;
1877 register relax_addressT address;
1878 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1879 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1881 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1882 subseg_change (segment, 0);
1884 /* For each frag in segment: count and store (a 1st guess of)
1887 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1889 fragP->fr_address = address;
1890 address += fragP->fr_fix;
1892 switch (fragP->fr_type)
1895 address += fragP->fr_offset * fragP->fr_var;
1901 int offset = relax_align (address, (int) fragP->fr_offset);
1902 if (offset % fragP->fr_var != 0)
1904 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1905 offset, (long) fragP->fr_var);
1906 offset -= (offset % fragP->fr_var);
1914 /* Assume .org is nugatory. It will grow with 1st relax. */
1917 case rs_machine_dependent:
1918 address += md_estimate_size_before_relax (fragP, segment);
1921 #ifndef WORKING_DOT_WORD
1922 /* Broken words don't concern us yet */
1923 case rs_broken_word:
1928 BAD_CASE (fragP->fr_type);
1930 } /* switch(fr_type) */
1931 } /* for each frag in the segment */
1935 long stretch; /* May be any size, 0 or negative. */
1936 /* Cumulative number of addresses we have */
1937 /* relaxed this pass. */
1938 /* We may have relaxed more than one address. */
1939 long stretched; /* Have we stretched on this pass? */
1940 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1941 grew, and another shrank. If a branch instruction doesn't fit anymore,
1942 we could be scrod. */
1946 stretch = stretched = 0;
1947 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1950 unsigned long was_address;
1956 was_address = fragP->fr_address;
1957 address = fragP->fr_address += stretch;
1958 symbolP = fragP->fr_symbol;
1959 offset = fragP->fr_offset;
1961 switch (fragP->fr_type)
1963 case rs_fill: /* .fill never relaxes. */
1967 #ifndef WORKING_DOT_WORD
1968 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1969 for it I do not want to write it. I do not want to have
1970 anything to do with it. This is not the proper way to
1971 implement this misfeature. */
1972 case rs_broken_word:
1974 struct broken_word *lie;
1975 struct broken_word *untruth;
1977 /* Yes this is ugly (storing the broken_word pointer
1978 in the symbol slot). Still, this whole chunk of
1979 code is ugly, and I don't feel like doing anything
1980 about it. Think of it as stubbornness in action. */
1982 for (lie = (struct broken_word *) (fragP->fr_symbol);
1983 lie && lie->dispfrag == fragP;
1984 lie = lie->next_broken_word)
1990 offset = (lie->add->sy_frag->fr_address
1991 + S_GET_VALUE (lie->add)
1993 - (lie->sub->sy_frag->fr_address
1994 + S_GET_VALUE (lie->sub)));
1995 if (offset <= -32768 || offset >= 32767)
1997 if (flag_warn_displacement)
2000 sprint_value (buf, (addressT) lie->addnum);
2001 as_warn (".word %s-%s+%s didn't fit",
2002 S_GET_NAME (lie->add),
2003 S_GET_NAME (lie->sub),
2007 if (fragP->fr_subtype == 0)
2009 fragP->fr_subtype++;
2010 growth += md_short_jump_size;
2012 for (untruth = lie->next_broken_word;
2013 untruth && untruth->dispfrag == lie->dispfrag;
2014 untruth = untruth->next_broken_word)
2015 if ((untruth->add->sy_frag == lie->add->sy_frag)
2016 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
2019 untruth->use_jump = lie;
2021 growth += md_long_jump_size;
2026 } /* case rs_broken_word */
2030 growth = (relax_align ((relax_addressT) (address
2033 - relax_align ((relax_addressT) (was_address
2043 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2044 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2045 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2046 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2047 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2048 know (symbolP->sy_frag);
2049 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2050 || (symbolP->sy_frag == &zero_address_frag));
2052 target += S_GET_VALUE (symbolP)
2053 + symbolP->sy_frag->fr_address;
2054 } /* if we have a symbol */
2056 know (fragP->fr_next);
2057 after = fragP->fr_next->fr_address;
2058 growth = target - after;
2061 /* Growth may be negative, but variable part of frag
2062 cannot have fewer than 0 chars. That is, we can't
2064 as_bad ("attempt to .org backwards ignored");
2068 growth -= stretch; /* This is an absolute growth factor */
2074 growth = S_GET_VALUE (symbolP);
2075 if (symbolP->sy_frag != &zero_address_frag)
2076 as_bad (".space specifies non-absolute value");
2077 fragP->fr_symbol = 0;
2080 as_warn (".space or .fill with negative value, ignored");
2088 case rs_machine_dependent:
2089 #ifdef md_relax_frag
2090 growth = md_relax_frag (fragP, stretch);
2092 #ifdef TC_GENERIC_RELAX_TABLE
2093 /* The default way to relax a frag is to look through
2096 const relax_typeS *this_type;
2097 const relax_typeS *start_type;
2098 relax_substateT next_state;
2099 relax_substateT this_state;
2101 const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
2103 this_state = fragP->fr_subtype;
2104 start_type = this_type = table + this_state;
2109 #ifndef DIFF_EXPR_OK
2110 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2111 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2112 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2113 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2114 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2116 know (symbolP->sy_frag);
2118 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
2119 || symbolP->sy_frag == &zero_address_frag);
2121 S_GET_VALUE (symbolP)
2122 + symbolP->sy_frag->fr_address;
2124 /* If frag has yet to be reached on this pass,
2125 assume it will move by STRETCH just as we did.
2126 If this is not so, it will be because some frag
2127 between grows, and that will force another pass.
2129 Beware zero-length frags.
2131 There should be a faster way to do this. */
2133 if (symbolP->sy_frag->fr_address >= was_address
2134 && is_dnrange (fragP, symbolP->sy_frag))
2140 aim = target - address - fragP->fr_fix;
2141 #ifdef TC_PCREL_ADJUST
2142 /* Currently only the ns32k family needs this */
2143 aim += TC_PCREL_ADJUST(fragP);
2145 /* This machine doesn't want to use pcrel_adjust.
2146 In that case, pcrel_adjust should be zero. */
2147 assert (fragP->fr_pcrel_adjust == 0);
2152 /* Look backwards. */
2153 for (next_state = this_type->rlx_more; next_state;)
2154 if (aim >= this_type->rlx_backward)
2158 /* Grow to next state. */
2159 this_state = next_state;
2160 this_type = table + this_state;
2161 next_state = this_type->rlx_more;
2166 #ifdef M68K_AIM_KLUDGE
2167 M68K_AIM_KLUDGE (aim, this_state, this_type);
2169 /* Look forwards. */
2170 for (next_state = this_type->rlx_more; next_state;)
2171 if (aim <= this_type->rlx_forward)
2175 /* Grow to next state. */
2176 this_state = next_state;
2177 this_type = table + this_state;
2178 next_state = this_type->rlx_more;
2182 growth = this_type->rlx_length - start_type->rlx_length;
2184 fragP->fr_subtype = this_state;
2186 #endif /* TC_GENERIC_RELAX_TABLE */
2191 BAD_CASE (fragP->fr_type);
2199 } /* For each frag in the segment. */
2201 while (stretched); /* Until nothing further to relax. */
2205 * We now have valid fr_address'es for each frag.
2209 * All fr_address's are correct, relative to their own segment.
2210 * We have made all the fixS we will ever make.
2212 } /* relax_segment() */
2214 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2216 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2217 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2222 Go through all the fixS's in a segment and see which ones can be
2223 handled now. (These consist of fixS where we have since discovered
2224 the value of a symbol, or the address of the frag involved.)
2225 For each one, call md_apply_fix to put the fix into the frag data.
2227 Result is a count of how many relocation structs will be needed to
2228 handle the remaining fixS's that we couldn't completely handle here.
2229 These will be output later by emit_relocations(). */
2232 fixup_segment (fixP, this_segment_type)
2233 register fixS *fixP;
2234 segT this_segment_type; /* N_TYPE bits for segment. */
2236 long seg_reloc_count = 0;
2237 symbolS *add_symbolP;
2238 symbolS *sub_symbolP;
2245 segT add_symbol_segment = absolute_section;
2247 /* If the linker is doing the relaxing, we must not do any fixups.
2249 Well, strictly speaking that's not true -- we could do any that are
2250 PC-relative and don't cross regions that could change size. And for the
2251 i960 (the only machine for which we've got a relaxing linker right now),
2252 we might be able to turn callx/callj into bal anyways in cases where we
2253 know the maximum displacement. */
2256 for (; fixP; fixP = fixP->fx_next)
2258 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2259 return seg_reloc_count;
2262 for (; fixP; fixP = fixP->fx_next)
2265 fprintf (stderr, "\nprocessing fixup:\n");
2269 fragP = fixP->fx_frag;
2271 where = fixP->fx_where;
2272 place = fragP->fr_literal + where;
2273 size = fixP->fx_size;
2274 add_symbolP = fixP->fx_addsy;
2275 #ifdef TC_VALIDATE_FIX
2276 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2278 sub_symbolP = fixP->fx_subsy;
2279 add_number = fixP->fx_offset;
2280 pcrel = fixP->fx_pcrel;
2283 if (add_symbolP != NULL
2284 && add_symbolP->sy_mri_common)
2286 know (add_symbolP->sy_value.X_op == O_symbol);
2287 add_number += S_GET_VALUE (add_symbolP);
2288 fixP->fx_offset = add_number;
2289 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
2293 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2297 resolve_symbol_value (sub_symbolP);
2298 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2300 if (add_symbolP != NULL)
2302 add_number += S_GET_VALUE (add_symbolP);
2304 fixP->fx_addsy = NULL;
2307 /* It's just -sym */
2308 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2310 add_number -= S_GET_VALUE (sub_symbolP);
2311 fixP->fx_subsy = NULL;
2314 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2316 /* Should try converting to a constant. */
2321 as_bad_where (fixP->fx_file, fixP->fx_line,
2322 "Negative of non-absolute symbol %s",
2323 S_GET_NAME (sub_symbolP));
2325 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2326 && SEG_NORMAL (add_symbol_segment))
2328 /* Difference of 2 symbols from same segment.
2329 Can't make difference of 2 undefineds: 'value' means
2330 something different for N_UNDF. */
2332 /* Makes no sense to use the difference of 2 arbitrary symbols
2333 as the target of a call instruction. */
2335 as_bad_where (fixP->fx_file, fixP->fx_line,
2336 "callj to difference of 2 symbols");
2337 #endif /* TC_I960 */
2338 add_number += S_GET_VALUE (add_symbolP) -
2339 S_GET_VALUE (sub_symbolP);
2342 pcrel = 0; /* No further pcrel processing. */
2344 /* Let the target machine make the final determination
2345 as to whether or not a relocation will be needed to
2346 handle this fixup. */
2347 if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2350 fixP->fx_addsy = NULL;
2351 fixP->fx_subsy = NULL;
2356 /* Different segments in subtraction. */
2357 know (!(S_IS_EXTERNAL (sub_symbolP)
2358 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2360 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2361 add_number -= S_GET_VALUE (sub_symbolP);
2364 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2365 #if 0 /* Do this even if it's already described as pc-relative. For example,
2366 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2367 pc-relative mode. */
2372 /* Make it pc-relative. */
2373 add_number += (MD_PCREL_FROM_SECTION (fixP, this_segment_type)
2374 - S_GET_VALUE (sub_symbolP));
2381 #ifdef UNDEFINED_DIFFERENCE_OK
2382 /* The PA needs this for PIC code generation. We basically
2383 don't want to do anything if we have the difference of two
2384 symbols at this point. */
2387 /* Leave it alone. */
2390 #ifdef BFD_ASSEMBLER
2391 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2392 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2394 /* Leave it alone. */
2400 sprint_value (buf, fragP->fr_address + where);
2401 as_bad_where (fixP->fx_file, fixP->fx_line,
2402 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2403 segment_name (S_GET_SEGMENT (sub_symbolP)),
2404 S_GET_NAME (sub_symbolP), buf);
2411 if (add_symbol_segment == this_segment_type && pcrel && !plt
2412 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2415 * This fixup was made when the symbol's segment was
2416 * SEG_UNKNOWN, but it is now in the local segment.
2417 * So we know how to do the address without relocation.
2420 /* reloc_callj() may replace a 'call' with a 'calls' or a
2421 'bal', in which cases it modifies *fixP as appropriate.
2422 In the case of a 'calls', no further work is required,
2423 and *fixP has been set up to make the rest of the code
2426 #endif /* TC_I960 */
2428 add_number += S_GET_VALUE (add_symbolP);
2429 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2430 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2432 /* Let the target machine make the final determination
2433 as to whether or not a relocation will be needed to
2434 handle this fixup. */
2435 if (!TC_FORCE_RELOCATION (fixP))
2438 fixP->fx_addsy = NULL;
2443 if (add_symbol_segment == absolute_section
2447 /* See comment about reloc_callj() above. */
2449 #endif /* TC_I960 */
2450 add_number += S_GET_VALUE (add_symbolP);
2452 /* Let the target machine make the final determination
2453 as to whether or not a relocation will be needed to
2454 handle this fixup. */
2456 if (!TC_FORCE_RELOCATION (fixP))
2458 fixP->fx_addsy = NULL;
2462 else if (add_symbol_segment == undefined_section
2463 #ifdef BFD_ASSEMBLER
2464 || bfd_is_com_section (add_symbol_segment)
2469 if ((int) fixP->fx_bit_fixP == 13)
2471 /* This is a COBR instruction. They have only a
2472 * 13-bit displacement and are only to be used
2473 * for local branches: flag as error, don't generate
2476 as_bad_where (fixP->fx_file, fixP->fx_line,
2477 "can't use COBR format with external label");
2478 fixP->fx_addsy = NULL;
2482 #endif /* TC_I960 */
2486 if (S_IS_COMMON (add_symbolP))
2487 add_number += S_GET_VALUE (add_symbolP);
2488 #endif /* TE_I386AIX */
2489 #endif /* OBJ_COFF */
2495 /* start-sanitize-v850 */
2496 #if !(defined (TC_V850) && defined (OBJ_ELF))
2497 /* end-sanitize-v850 */
2498 #if !(defined (TC_M68K) && defined (OBJ_ELF))
2499 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2500 add_number += S_GET_VALUE (add_symbolP);
2501 /* start-sanitize-v850 */
2503 /* end-sanitize-v850 */
2512 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2513 if (add_symbolP == 0)
2515 #ifndef BFD_ASSEMBLER
2516 fixP->fx_addsy = &abs_symbol;
2518 fixP->fx_addsy = section_symbol (absolute_section);
2520 fixP->fx_addsy->sy_used_in_reloc = 1;
2525 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2528 if (size < sizeof (mask))
2530 /* set all bits to one */
2532 /* Technically, combining these produces an undefined result
2533 if size is sizeof (valueT), though I think these two
2534 half-way operations should both be defined. And the
2535 compiler should be able to combine them if it's valid on
2536 the host architecture. */
2539 if ((add_number & mask) != 0
2540 && (add_number & mask) != mask)
2542 char buf[50], buf2[50];
2543 sprint_value (buf, fragP->fr_address + where);
2544 if (add_number > 1000)
2545 sprint_value (buf2, add_number);
2547 sprintf (buf2, "%ld", (long) add_number);
2548 as_bad_where (fixP->fx_file, fixP->fx_line,
2549 "Value of %s too large for field of %d bytes at %s",
2551 } /* generic error checking */
2553 #ifdef WARN_SIGNED_OVERFLOW_WORD
2554 /* Warn if a .word value is too large when treated as a signed
2555 number. We already know it is not too negative. This is to
2556 catch over-large switches generated by gcc on the 68k. */
2557 if (!flag_signed_overflow_ok
2559 && add_number > 0x7fff)
2560 as_bad_where (fixP->fx_file, fixP->fx_line,
2561 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2563 (unsigned long) (fragP->fr_address + where));
2565 } /* not a bit fix */
2569 #ifdef MD_APPLY_FIX3
2570 md_apply_fix3 (fixP, &add_number, this_segment_type);
2572 #ifdef BFD_ASSEMBLER
2573 md_apply_fix (fixP, &add_number);
2575 md_apply_fix (fixP, add_number);
2579 #ifndef TC_HANDLES_FX_DONE
2580 /* If the tc-* files haven't been converted, assume it's handling
2581 it the old way, where a null fx_addsy means that the fix has
2582 been applied completely, and no further work is needed. */
2583 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2587 #ifdef TC_VALIDATE_FIX
2591 fprintf (stderr, "result:\n");
2594 } /* For each fixS in this segment. */
2596 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2597 return seg_reloc_count;
2600 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2603 number_to_chars_bigendian (buf, val, n)
2608 if (n > sizeof (val)|| n <= 0)
2612 buf[n] = val & 0xff;
2618 number_to_chars_littleendian (buf, val, n)
2623 if (n > sizeof (val) || n <= 0)
2627 *buf++ = val & 0xff;
2633 write_print_statistics (file)
2636 fprintf (stderr, "fixups: %d\n", n_fixups);
2640 extern int indent_level;
2641 extern void print_symbol_value_1 ();
2648 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2650 fprintf (stderr, " pcrel");
2651 if (fixp->fx_pcrel_adjust)
2652 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2653 if (fixp->fx_im_disp)
2656 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2658 fprintf (stderr, " im_disp");
2662 fprintf (stderr, " tcbit");
2664 fprintf (stderr, " done");
2665 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2666 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2667 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2668 #ifdef BFD_ASSEMBLER
2669 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2672 #ifdef NEED_FX_R_TYPE
2673 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2678 fprintf (stderr, "\n +<");
2679 print_symbol_value_1 (stderr, fixp->fx_addsy);
2680 fprintf (stderr, ">");
2684 fprintf (stderr, "\n -<");
2685 print_symbol_value_1 (stderr, fixp->fx_subsy);
2686 fprintf (stderr, ">");
2688 fprintf (stderr, "\n");
2691 /* end of write.c */