1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 1994 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This thing should be set up to do byteordering correctly. But... */
25 #include "output-file.h"
27 /* This looks like a good idea. Let's try turning it on always, for now. */
28 #undef BFD_FAST_SECTION_FILL
29 #define BFD_FAST_SECTION_FILL
31 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
32 instruction so that the disassembler does not choke on it. */
34 #define NOP_OPCODE 0x00
37 #ifndef TC_ADJUST_RELOC_COUNT
38 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
41 #ifndef TC_FORCE_RELOCATION
42 #define TC_FORCE_RELOCATION(FIXP) 0
45 #ifndef WORKING_DOT_WORD
46 extern CONST int md_short_jump_size;
47 extern CONST int md_long_jump_size;
50 int symbol_table_frozen;
51 void print_fixup PARAMS ((fixS *));
54 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
56 /* We generally attach relocs to frag chains. However, after we have
57 chained these all together into a segment, any relocs we add after
58 that must be attached to a segment. This will include relocs added
59 in md_estimate_size_for_relax, for example. */
60 static int frags_chained = 0;
66 struct frag *text_frag_root;
67 struct frag *data_frag_root;
68 struct frag *bss_frag_root;
70 struct frag *text_last_frag; /* Last frag in segment. */
71 struct frag *data_last_frag; /* Last frag in segment. */
72 static struct frag *bss_last_frag; /* Last frag in segment. */
76 static object_headers headers;
77 static char *the_object_file;
80 long string_byte_count;
81 char *next_object_file_charP; /* Tracks object file bytes. */
84 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
87 #endif /* BFD_ASSEMBLER */
90 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
91 symbolS *add, symbolS *sub,
92 offsetT offset, int pcrel,
93 bfd_reloc_code_real_type r_type));
95 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
96 symbolS *add, symbolS *sub,
97 offsetT offset, int pcrel,
100 #if defined (BFD_ASSEMBLER) || !defined (BFD)
101 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
103 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
108 * Create a fixS in obstack 'notes'.
111 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
113 fragS *frag; /* Which frag? */
114 int where; /* Where in that frag? */
115 int size; /* 1, 2, or 4 usually. */
116 symbolS *add_symbol; /* X_add_symbol. */
117 symbolS *sub_symbol; /* X_op_symbol. */
118 offsetT offset; /* X_add_number. */
119 int pcrel; /* TRUE if PC-relative relocation. */
121 bfd_reloc_code_real_type r_type; /* Relocation type */
123 int r_type; /* Relocation type */
128 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
130 fixP->fx_frag = frag;
131 fixP->fx_where = where;
132 fixP->fx_size = size;
133 fixP->fx_addsy = add_symbol;
134 fixP->fx_subsy = sub_symbol;
135 fixP->fx_offset = offset;
136 fixP->fx_pcrel = pcrel;
138 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
139 fixP->fx_r_type = r_type;
141 fixP->fx_im_disp = 0;
142 fixP->fx_pcrel_adjust = 0;
143 fixP->fx_bit_fixP = 0;
144 fixP->fx_addnumber = 0;
145 fixP->tc_fix_data = NULL;
153 as_where (&fixP->fx_file, &fixP->fx_line);
155 /* Usually, we want relocs sorted numerically, but while
156 comparing to older versions of gas that have relocs
157 reverse sorted, it is convenient to have this compile
158 time option. xoxorich. */
163 fixS **seg_fix_rootP = (frags_chained
164 ? &seg_info (now_seg)->fix_root
165 : &frchain_now->fix_root);
166 fixS **seg_fix_tailP = (frags_chained
167 ? &seg_info (now_seg)->fix_tail
168 : &frchain_now->fix_tail);
171 #ifdef REVERSE_SORT_RELOCS
173 fixP->fx_next = *seg_fix_rootP;
174 *seg_fix_rootP = fixP;
176 #else /* REVERSE_SORT_RELOCS */
178 fixP->fx_next = NULL;
181 (*seg_fix_tailP)->fx_next = fixP;
183 *seg_fix_rootP = fixP;
184 *seg_fix_tailP = fixP;
186 #endif /* REVERSE_SORT_RELOCS */
193 /* Create a fixup relative to a symbol (plus a constant). */
196 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
197 fragS *frag; /* Which frag? */
198 int where; /* Where in that frag? */
199 short int size; /* 1, 2, or 4 usually. */
200 symbolS *add_symbol; /* X_add_symbol. */
201 offsetT offset; /* X_add_number. */
202 int pcrel; /* TRUE if PC-relative relocation. */
204 bfd_reloc_code_real_type r_type; /* Relocation type */
206 int r_type; /* Relocation type */
209 return fix_new_internal (frag, where, size, add_symbol,
210 (symbolS *) NULL, offset, pcrel, r_type);
213 /* Create a fixup for an expression. Currently we only support fixups
214 for difference expressions. That is itself more than most object
215 file formats support anyhow. */
218 fix_new_exp (frag, where, size, exp, pcrel, r_type)
219 fragS *frag; /* Which frag? */
220 int where; /* Where in that frag? */
221 short int size; /* 1, 2, or 4 usually. */
222 expressionS *exp; /* Expression. */
223 int pcrel; /* TRUE if PC-relative relocation. */
225 bfd_reloc_code_real_type r_type; /* Relocation type */
227 int r_type; /* Relocation type */
240 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
241 the difference expression cannot immediately be reduced. */
243 extern symbolS *make_expr_symbol ();
244 symbolS *stmp = make_expr_symbol (exp);
245 exp->X_op = O_symbol;
246 exp->X_op_symbol = 0;
247 exp->X_add_symbol = stmp;
248 exp->X_add_number = 0;
249 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
253 sub = exp->X_add_symbol;
254 off = exp->X_add_number;
258 sub = exp->X_op_symbol;
261 add = exp->X_add_symbol;
264 off = exp->X_add_number;
268 as_bad ("expression too complex for fixup");
271 return fix_new_internal (frag, where, size, add, sub, off,
275 /* Append a string onto another string, bumping the pointer along. */
277 append (charPP, fromP, length)
280 unsigned long length;
282 /* Don't trust memcpy() of 0 chars. */
286 memcpy (*charPP, fromP, length);
290 #ifndef BFD_ASSEMBLER
291 int section_alignment[SEG_MAXIMUM_ORDINAL];
295 * This routine records the largest alignment seen for each segment.
296 * If the beginning of the segment is aligned on the worst-case
297 * boundary, all of the other alignments within it will work. At
298 * least one object format really uses this info.
301 record_alignment (seg, align)
302 /* Segment to which alignment pertains */
304 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
309 if (align > bfd_get_section_alignment (stdoutput, seg))
310 bfd_set_section_alignment (stdoutput, seg, align);
312 if (align > section_alignment[(int) seg])
313 section_alignment[(int) seg] = align;
319 /* Reset the section indices after removing the gas created sections. */
322 renumber_sections (abfd, sec, countparg)
327 int *countp = (int *) countparg;
329 sec->index = *countp;
333 #endif /* defined (BFD_ASSEMBLER) */
335 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
338 chain_frchains_together_1 (section, frchp)
340 struct frchain *frchp;
342 fragS dummy, *prev_frag = &dummy;
343 fixS fix_dummy, *prev_fix = &fix_dummy;
345 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
347 prev_frag->fr_next = frchp->frch_root;
348 prev_frag = frchp->frch_last;
350 if (frchp->fix_root != (fixS *) NULL)
352 if (seg_info (section)->fix_root == (fixS *) NULL)
353 seg_info (section)->fix_root = frchp->fix_root;
354 prev_fix->fx_next = frchp->fix_root;
355 seg_info (section)->fix_tail = frchp->fix_tail;
356 prev_fix = frchp->fix_tail;
360 prev_frag->fr_next = 0;
369 chain_frchains_together (abfd, section, xxx)
370 bfd *abfd; /* unused */
372 PTR xxx; /* unused */
374 segment_info_type *info;
376 /* BFD may have introduced its own sections without using
377 subseg_new, so it is possible that seg_info is NULL. */
378 info = seg_info (section);
379 if (info != (segment_info_type *) NULL)
380 info->frchainP->frch_last
381 = chain_frchains_together_1 (section, info->frchainP);
383 /* Now that we've chained the frags together, we must add new fixups
384 to the segment, not to the frag chain. */
390 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
393 remove_subsegs (head, seg, root, last)
399 *root = head->frch_root;
400 *last = chain_frchains_together_1 (seg, head);
405 #if defined (BFD_ASSEMBLER) || !defined (BFD)
409 cvt_frag_to_fill (sec, fragP)
414 cvt_frag_to_fill (headers, fragP)
415 object_headers *headers;
419 switch (fragP->fr_type)
424 HANDLE_ALIGN (fragP);
426 fragP->fr_type = rs_fill;
427 know (fragP->fr_next != NULL);
428 fragP->fr_offset = (fragP->fr_next->fr_address
430 - fragP->fr_fix) / fragP->fr_var;
436 case rs_machine_dependent:
438 md_convert_frag (stdoutput, sec, fragP);
440 md_convert_frag (headers, fragP);
443 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
446 * After md_convert_frag, we make the frag into a ".space 0".
447 * Md_convert_frag() should set up any fixSs and constants
453 #ifndef WORKING_DOT_WORD
456 struct broken_word *lie;
458 if (fragP->fr_subtype)
460 fragP->fr_fix += md_short_jump_size;
461 for (lie = (struct broken_word *) (fragP->fr_symbol);
462 lie && lie->dispfrag == fragP;
463 lie = lie->next_broken_word)
465 fragP->fr_fix += md_long_jump_size;
473 BAD_CASE (fragP->fr_type);
478 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
482 relax_and_size_seg (abfd, sec, xxx)
489 segment_info_type *seginfo;
491 valueT size, newsize;
493 flags = bfd_get_section_flags (abfd, sec);
495 seginfo = seg_info (sec);
496 if (seginfo && seginfo->frchainP)
498 relax_segment (seginfo->frchainP->frch_root, sec);
499 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
500 cvt_frag_to_fill (sec, fragp);
501 for (fragp = seginfo->frchainP->frch_root;
503 fragp = fragp->fr_next)
504 /* walk to last elt */;
505 size = fragp->fr_address + fragp->fr_fix;
510 if (size > 0 && ! seginfo->bss)
511 flags |= SEC_HAS_CONTENTS;
513 /* @@ This is just an approximation. */
514 if (seginfo && seginfo->fix_root)
518 x = bfd_set_section_flags (abfd, sec, flags);
521 newsize = md_section_align (sec, size);
522 x = bfd_set_section_size (abfd, sec, newsize);
525 /* If the size had to be rounded up, add some padding in the last
527 assert (newsize >= size);
530 fragS *last = seginfo->frchainP->frch_last;
531 fragp = seginfo->frchainP->frch_root;
532 while (fragp->fr_next != last)
533 fragp = fragp->fr_next;
534 last->fr_address = size;
535 fragp->fr_offset += newsize - size;
538 #ifdef tc_frob_section
539 tc_frob_section (sec);
541 #ifdef obj_frob_section
542 obj_frob_section (sec);
548 dump_section_relocs (abfd, sec, stream_)
553 FILE *stream = (FILE *) stream_;
554 segment_info_type *seginfo = seg_info (sec);
555 fixS *fixp = seginfo->fix_root;
560 fprintf (stream, "sec %s relocs:\n", sec->name);
563 symbolS *s = fixp->fx_addsy;
566 fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
567 s->bsym->section->name);
568 if (s->bsym->flags & BSF_SECTION_SYM)
570 fprintf (stream, " section sym");
572 fprintf (stream, "+%x", S_GET_VALUE (s));
575 fprintf (stream, "+%x", S_GET_VALUE (s));
576 fprintf (stream, ")+%x\n", fixp->fx_offset);
579 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
580 fixp = fixp->fx_next;
584 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
587 #ifndef EMIT_SECTION_SYMBOLS
588 #define EMIT_SECTION_SYMBOLS 1
592 adjust_reloc_syms (abfd, sec, xxx)
597 segment_info_type *seginfo = seg_info (sec);
603 dump_section_relocs (abfd, sec, stderr);
605 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
608 else if (fixp->fx_addsy)
616 fprintf (stderr, "\n\nadjusting fixup:\n");
620 sym = fixp->fx_addsy;
621 symsec = sym->bsym->section;
623 /* If it's one of these sections, assume the symbol is
624 definitely going to be output. The code in
625 md_estimate_size_before_relax in tc-mips.c uses this test
626 as well, so if you change this code you should look at that
628 if (symsec == &bfd_und_section
629 || symsec == &bfd_abs_section
630 || bfd_is_com_section (symsec))
632 fixp->fx_addsy->sy_used_in_reloc = 1;
636 /* Since we're reducing to section symbols, don't attempt to reduce
637 anything that's already using one. */
638 if (sym->bsym->flags & BSF_SECTION_SYM)
640 fixp->fx_addsy->sy_used_in_reloc = 1;
644 /* Is there some other reason we can't adjust this one? (E.g.,
645 call/bal links in i960-bout symbols.) */
646 #ifdef obj_fix_adjustable
647 if (! obj_fix_adjustable (fixp))
649 fixp->fx_addsy->sy_used_in_reloc = 1;
654 /* Is there some other (target cpu dependent) reason we can't adjust
655 this one? (E.g. relocations involving function addresses on
657 #ifdef tc_fix_adjustable
658 if (! tc_fix_adjustable (fixp))
660 fixp->fx_addsy->sy_used_in_reloc = 1;
665 /* For PIC support: We may get expressions like
666 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
667 necessarily have had a fixed difference initially. But now
668 it should be a known constant, so we can reduce it. Since
669 we can't easily handle a symbol value that looks like
670 someUndefinedSymbol+const, though, we convert the fixup to
671 access the undefined symbol directly, and discard the
672 intermediate symbol. */
673 if (S_GET_SEGMENT (sym) == expr_section
674 && sym->sy_value.X_op == O_add
675 && (resolve_symbol_value (sym->sy_value.X_add_symbol),
676 S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
677 && (resolve_symbol_value (sym->sy_value.X_op_symbol),
678 S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
680 fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
681 fixp->fx_offset += sym->sy_value.X_add_number;
682 fixp->fx_addsy = sym->sy_value.X_add_symbol;
686 /* If the section symbol isn't going to be output, the relocs
687 at least should still work. If not, figure out what to do
688 when we run into that case. */
689 fixp->fx_offset += S_GET_VALUE (sym);
690 fixp->fx_addsy = section_symbol (symsec);
691 fixp->fx_addsy->sy_used_in_reloc = 1;
696 #if 1/*def RELOC_REQUIRES_SYMBOL*/
699 /* There was no symbol required by this relocation. However,
700 BFD doesn't really handle relocations without symbols well.
701 (At least, the COFF support doesn't.) So for now we fake up
702 a local symbol in the absolute section. */
704 fixp->fx_addsy = section_symbol (absolute_section);
705 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
709 dump_section_relocs (abfd, sec, stderr);
713 write_relocs (abfd, sec, xxx)
718 segment_info_type *seginfo = seg_info (sec);
725 /* If seginfo is NULL, we did not create this section; don't do
730 fixup_segment (seginfo->fix_root, sec);
733 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
736 #ifndef RELOC_EXPANSION_POSSIBLE
737 /* Set up reloc information as well. */
738 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
739 n * sizeof (arelent *));
740 memset ((char*)relocs, 0, n * sizeof (arelent*));
743 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
746 bfd_reloc_status_type s;
753 reloc = tc_gen_reloc (sec, fixp);
759 if (fixp->fx_where + fixp->fx_size
760 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
763 s = bfd_install_relocation (stdoutput, reloc,
764 fixp->fx_frag->fr_literal,
765 fixp->fx_frag->fr_address,
771 case bfd_reloc_overflow:
772 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
775 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
776 fixp->fx_file, fixp->fx_line);
781 n = n * MAX_RELOC_EXPANSION;
782 /* Set up reloc information as well. */
783 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
784 n * sizeof (arelent *));
787 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
791 bfd_reloc_status_type s;
799 reloc = tc_gen_reloc (sec, fixp);
801 for (j = 0; reloc[j]; j++)
803 relocs[i++] = reloc[j];
806 data = fixp->fx_frag->fr_literal + fixp->fx_where;
807 if (fixp->fx_where + fixp->fx_size
808 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
810 for (j = 0; reloc[j]; j++)
812 s = bfd_install_relocation (stdoutput, reloc[j],
813 fixp->fx_frag->fr_literal,
814 fixp->fx_frag->fr_address,
820 case bfd_reloc_overflow:
821 as_bad_where (fixp->fx_file, fixp->fx_line,
822 "relocation overflow");
825 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
826 fixp->fx_file, fixp->fx_line);
837 sympp = bfd_get_outsymbols (stdoutput);
838 nsyms = bfd_get_symcount (stdoutput);
839 for (i = 0; i < n; i++)
840 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
842 for (j = 0; j < nsyms; j++)
843 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
852 bfd_set_reloc (stdoutput, sec, relocs, n);
854 bfd_set_section_flags (abfd, sec,
855 (bfd_get_section_flags (abfd, sec)
856 & (flagword) ~SEC_RELOC));
863 fprintf (stderr, "relocs for sec %s\n", sec->name);
864 for (i = 0; i < n; i++)
868 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
869 i, r, r->address, s->name, r->addend);
876 write_contents (abfd, sec, xxx)
881 segment_info_type *seginfo = seg_info (sec);
882 unsigned long offset = 0;
885 /* Write out the frags. */
887 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
890 for (f = seginfo->frchainP->frch_root;
895 unsigned long fill_size;
899 assert (f->fr_type == rs_fill);
902 x = bfd_set_section_contents (stdoutput, sec,
903 f->fr_literal, (file_ptr) offset,
904 (bfd_size_type) f->fr_fix);
907 bfd_perror (stdoutput->filename);
908 as_perror ("FATAL: Can't write %s", stdoutput->filename);
913 fill_literal = f->fr_literal + f->fr_fix;
914 fill_size = f->fr_var;
915 count = f->fr_offset;
917 if (fill_size && count)
918 #ifdef BFD_FAST_SECTION_FILL
921 if (fill_size > sizeof(buf)) {
922 /* Do it the old way. Can this ever happen? */
925 x = bfd_set_section_contents (stdoutput, sec,
926 fill_literal, (file_ptr) offset,
927 (bfd_size_type) fill_size);
930 bfd_perror (stdoutput->filename);
931 as_perror ("FATAL: Can't write %s", stdoutput->filename);
938 /* Build a buffer full of fill objects and output it as
939 * often as necessary. This saves on the overhead of potentially
940 * lots of bfd_set_section_contents calls.
942 int n_per_buf, bytes, i;
945 n_per_buf = sizeof (buf);
946 memset (buf, *fill_literal, n_per_buf);
951 n_per_buf = sizeof(buf)/fill_size;
952 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
953 memcpy(bufp, fill_literal, fill_size);
955 for (; count > 0; count -= n_per_buf)
957 n_per_buf = n_per_buf > count ? count : n_per_buf;
958 x = bfd_set_section_contents (stdoutput, sec,
959 buf, (file_ptr) offset,
960 (bfd_size_type) n_per_buf * fill_size);
962 offset += n_per_buf * fill_size;
969 x = bfd_set_section_contents (stdoutput, sec,
970 fill_literal, (file_ptr) offset,
971 (bfd_size_type) fill_size);
980 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
982 merge_data_into_text ()
984 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
985 seg_info (text_section)->frchainP->frch_last->fr_next =
986 seg_info (data_section)->frchainP->frch_root;
987 seg_info (text_section)->frchainP->frch_last =
988 seg_info (data_section)->frchainP->frch_last;
989 seg_info (data_section)->frchainP = 0;
993 text_last_frag->fr_next = data_frag_root;
994 text_last_frag = data_last_frag;
995 data_last_frag = NULL;
996 data_frag_root = NULL;
999 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1000 tmp->fx_next = data_fix_root;
1001 text_fix_tail = data_fix_tail;
1004 text_fix_root = data_fix_root;
1005 data_fix_root = NULL;
1008 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1010 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1012 relax_and_size_all_segments ()
1016 relax_segment (text_frag_root, SEG_TEXT);
1017 relax_segment (data_frag_root, SEG_DATA);
1018 relax_segment (bss_frag_root, SEG_BSS);
1020 * Now the addresses of frags are correct within the segment.
1023 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1024 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1025 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1028 * Join the 2 segments into 1 huge segment.
1029 * To do this, re-compute every rn_address in the SEG_DATA frags.
1030 * Then join the data frags after the text frags.
1032 * Determine a_data [length of data segment].
1036 register relax_addressT slide;
1038 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1040 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1041 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1042 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1044 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1045 /* For b.out: If the data section has a strict alignment
1046 requirement, its load address in the .o file will be
1047 rounded up from the size of the text section. These
1048 two values are *not* the same! Similarly for the bss
1050 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1053 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1055 fragP->fr_address += slide;
1056 } /* for each data frag */
1058 know (text_last_frag != 0);
1059 text_last_frag->fr_next = data_frag_root;
1063 H_SET_DATA_SIZE (&headers, 0);
1067 /* See above comments on b.out data section address. */
1070 if (data_last_frag == 0)
1071 bss_vma = H_GET_TEXT_SIZE (&headers);
1073 bss_vma = data_last_frag->fr_address;
1074 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1075 bss_address_frag.fr_address = bss_vma;
1077 #else /* ! OBJ_BOUT */
1078 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1079 H_GET_DATA_SIZE (&headers));
1081 #endif /* ! OBJ_BOUT */
1083 /* Slide all the frags */
1086 relax_addressT slide = bss_address_frag.fr_address;
1088 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1090 fragP->fr_address += slide;
1091 } /* for each bss frag */
1095 H_SET_BSS_SIZE (&headers,
1096 bss_last_frag->fr_address - bss_frag_root->fr_address);
1098 H_SET_BSS_SIZE (&headers, 0);
1100 #endif /* ! BFD_ASSEMBLER && ! BFD */
1102 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1104 #ifdef BFD_ASSEMBLER
1112 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1114 /* Count symbols. We can't rely on a count made by the loop in
1115 write_object_file, because *_frob_file may add a new symbol or
1118 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1125 asympp = (asymbol **) bfd_alloc (stdoutput,
1126 nsyms * sizeof (asymbol *));
1127 symp = symbol_rootP;
1128 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1130 asympp[i] = symp->bsym;
1136 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1137 assert (result == true);
1138 symbol_table_frozen = 1;
1143 write_object_file ()
1145 struct frchain *frchainP; /* Track along all frchains. */
1146 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1147 fragS *fragP; /* Track along all frags. */
1150 /* Do we really want to write it? */
1152 int n_warns, n_errs;
1153 n_warns = had_warnings ();
1154 n_errs = had_errors ();
1155 /* The -Z flag indicates that an object file should be generated,
1156 regardless of warnings and errors. */
1157 if (flag_always_generate_output)
1159 if (n_warns || n_errs)
1160 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1161 n_errs, n_errs == 1 ? "" : "s",
1162 n_warns, n_warns == 1 ? "" : "s");
1167 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1168 n_errs, n_errs == 1 ? "" : "s",
1169 n_warns, n_warns == 1 ? "" : "s");
1174 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1175 a routine to check for the definition of the procedure "_main",
1176 and if so -- fix it up so that it can be program entry point. */
1177 VMS_Check_For_Main ();
1180 /* After every sub-segment, we fake an ".align ...". This conforms to
1181 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1182 frag that requires least thought. ".align" frags like to have a
1183 following frag since that makes calculating their intended length
1186 @@ Is this really necessary?? */
1187 #ifndef SUB_SEGMENT_ALIGN
1188 #ifdef BFD_ASSEMBLER
1189 #define SUB_SEGMENT_ALIGN(SEG) (0)
1191 #define SUB_SEGMENT_ALIGN(SEG) (2)
1194 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1196 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1197 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1198 /* frag_align will have left a new frag.
1199 Use this last frag for an empty ".fill".
1201 For this segment ...
1202 Create a last frag. Do not leave a "being filled in frag". */
1203 frag_wane (frag_now);
1204 frag_now->fr_fix = 0;
1205 know (frag_now->fr_next == NULL);
1208 /* From now on, we don't care about sub-segments. Build one frag chain
1209 for each segment. Linked thru fr_next. */
1211 #ifdef BFD_ASSEMBLER
1212 /* Remove the sections created by gas for its own purposes. */
1214 asection **seclist, *sec;
1217 seclist = &stdoutput->sections;
1218 while (seclist && *seclist)
1221 while (sec == reg_section || sec == expr_section)
1225 stdoutput->section_count--;
1230 seclist = &(*seclist)->next;
1233 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1236 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1238 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1239 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1240 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1243 /* We have two segments. If user gave -R flag, then we must put the
1244 data frags into the text segment. Do this before relaxing so
1245 we know to take advantage of -R and make shorter addresses. */
1246 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1247 if (flag_readonly_data_in_text)
1249 merge_data_into_text ();
1253 #ifdef BFD_ASSEMBLER
1254 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1256 relax_and_size_all_segments ();
1257 #endif /* BFD_ASSEMBLER */
1259 #ifndef BFD_ASSEMBLER
1262 * Crawl the symbol chain.
1264 * For each symbol whose value depends on a frag, take the address of
1265 * that frag and subsume it into the value of the symbol.
1266 * After this, there is just one way to lookup a symbol value.
1267 * Values are left in their final state for object file emission.
1268 * We adjust the values of 'L' local symbols, even if we do
1269 * not intend to emit them to the object file, because their values
1270 * are needed for fix-ups.
1272 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1273 * from the symbol chain. (They are still pointed to by the fixes.)
1275 * Count the remaining symbols.
1276 * Assign a symbol number to each symbol.
1277 * Count the number of string-table chars we will emit.
1278 * Put this info into the headers as appropriate.
1281 know (zero_address_frag.fr_address == 0);
1282 string_byte_count = sizeof (string_byte_count);
1284 obj_crawl_symbol_chain (&headers);
1286 if (string_byte_count == sizeof (string_byte_count))
1287 string_byte_count = 0;
1289 H_SET_STRING_SIZE (&headers, string_byte_count);
1292 * Addresses of frags now reflect addresses we use in the object file.
1293 * Symbol values are correct.
1294 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1295 * Also converting any machine-dependent frags using md_convert_frag();
1297 subseg_change (SEG_TEXT, 0);
1299 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1301 cvt_frag_to_fill (&headers, fragP);
1303 /* Some assert macros don't work with # directives mixed in. */
1305 if (!(fragP->fr_next == NULL
1307 || fragP->fr_next == data_frag_root
1309 || ((fragP->fr_next->fr_address - fragP->fr_address)
1310 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1314 #endif /* ! BFD_ASSEMBLER */
1316 #ifndef WORKING_DOT_WORD
1318 struct broken_word *lie;
1319 struct broken_word **prevP;
1321 prevP = &broken_words;
1322 for (lie = broken_words; lie; lie = lie->next_broken_word)
1327 exp.X_op = O_subtract;
1328 exp.X_add_symbol = lie->add;
1329 exp.X_op_symbol = lie->sub;
1330 exp.X_add_number = lie->addnum;
1331 #ifdef BFD_ASSEMBLER
1332 #ifdef TC_CONS_FIX_NEW
1333 TC_CONS_FIX_NEW (lie->frag,
1334 lie->word_goes_here - lie->frag->fr_literal,
1337 fix_new_exp (lie->frag,
1338 lie->word_goes_here - lie->frag->fr_literal,
1339 2, &exp, 0, BFD_RELOC_NONE);
1342 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1343 fix_new_exp (lie->frag,
1344 lie->word_goes_here - lie->frag->fr_literal,
1345 2, &exp, 0, NO_RELOC);
1348 fix_new_ns32k_exp (lie->frag,
1349 lie->word_goes_here - lie->frag->fr_literal,
1350 2, &exp, 0, 0, 2, 0, 0);
1352 fix_new_exp (lie->frag,
1353 lie->word_goes_here - lie->frag->fr_literal,
1355 #endif /* TC_NS32K */
1356 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1357 #endif /* BFD_ASSEMBLER */
1358 *prevP = lie->next_broken_word;
1361 prevP = &(lie->next_broken_word);
1363 for (lie = broken_words; lie;)
1365 struct broken_word *untruth;
1367 addressT table_addr;
1368 addressT from_addr, to_addr;
1371 fragP = lie->dispfrag;
1373 /* Find out how many broken_words go here. */
1375 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1376 if (untruth->added == 1)
1379 table_ptr = lie->dispfrag->fr_opcode;
1380 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1381 /* Create the jump around the long jumps. This is a short
1382 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1383 from_addr = table_addr;
1384 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1385 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1386 table_ptr += md_short_jump_size;
1387 table_addr += md_short_jump_size;
1389 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1391 if (lie->added == 2)
1393 /* Patch the jump table */
1394 /* This is the offset from ??? to table_ptr+0 */
1395 to_addr = table_addr - S_GET_VALUE (lie->sub);
1396 #ifdef BFD_ASSEMBLER
1397 to_addr -= lie->sub->sy_frag->fr_address;
1399 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1400 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1402 if (untruth->use_jump == lie)
1403 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1406 /* Install the long jump */
1407 /* this is a long jump from table_ptr+0 to the final target */
1408 from_addr = table_addr;
1409 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1410 #ifdef BFD_ASSEMBLER
1411 to_addr += lie->add->sy_frag->fr_address;
1413 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1414 table_ptr += md_long_jump_size;
1415 table_addr += md_long_jump_size;
1419 #endif /* not WORKING_DOT_WORD */
1421 #ifndef BFD_ASSEMBLER
1424 long object_file_size;
1426 * Scan every FixS performing fixups. We had to wait until now to do
1427 * this because md_convert_frag() may have made some fixSs.
1431 subseg_change (SEG_TEXT, 0);
1432 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1433 subseg_change (SEG_DATA, 0);
1434 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1435 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1437 /* FIXME move this stuff into the pre-write-hook */
1438 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1439 H_SET_ENTRY_POINT (&headers, 0);
1441 obj_pre_write_hook (&headers); /* extra coff stuff */
1443 object_file_size = H_GET_FILE_SIZE (&headers);
1444 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1446 output_file_create (out_file_name);
1448 obj_header_append (&next_object_file_charP, &headers);
1450 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1455 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1457 register long count;
1458 register char *fill_literal;
1459 register long fill_size;
1461 know (fragP->fr_type == rs_fill);
1462 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1463 fill_literal = fragP->fr_literal + fragP->fr_fix;
1464 fill_size = fragP->fr_var;
1465 know (fragP->fr_offset >= 0);
1467 for (count = fragP->fr_offset; count; count--)
1469 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1472 } /* for each code frag. */
1474 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1479 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1480 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)));
1482 /* Make addresses in data relocation directives relative to beginning of
1483 * first data fragment, not end of last text fragment: alignment of the
1484 * start of the data segment may place a gap between the segments.
1486 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1488 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1489 #endif /* TC_I960 */
1491 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)));
1494 * Emit line number entries.
1496 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1497 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)));
1502 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1503 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)));
1509 if (string_byte_count > 0)
1511 obj_emit_strings (&next_object_file_charP);
1512 } /* only if we have a string table */
1515 bfd_seek (stdoutput, 0, 0);
1516 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1519 /* Write the data to the file */
1520 output_file_append (the_object_file, object_file_size, out_file_name);
1522 } /* non vms output */
1525 * Now do the VMS-dependent part of writing the object file
1527 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1528 H_GET_DATA_SIZE (&headers),
1529 H_GET_BSS_SIZE (&headers),
1530 text_frag_root, data_frag_root);
1532 #else /* BFD_ASSEMBLER */
1534 /* Resolve symbol values. This needs to be done before processing
1540 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1541 if (!symp->sy_resolved)
1542 resolve_symbol_value (symp);
1545 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1547 /* Set up symbol table, and write it out. */
1552 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1556 /* Do it again, because adjust_reloc_syms might introduce
1557 more symbols. They'll probably only be section symbols,
1558 but they'll still need to have the values computed. */
1559 if (! symp->sy_resolved)
1561 if (symp->sy_value.X_op == O_constant)
1563 /* This is the normal case; skip the call. */
1566 + symp->sy_frag->fr_address));
1567 symp->sy_resolved = 1;
1570 resolve_symbol_value (symp);
1573 /* So far, common symbols have been treated like undefined symbols.
1574 Put them in the common section now. */
1575 if (S_IS_DEFINED (symp) == 0
1576 && S_GET_VALUE (symp) != 0)
1577 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1579 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1580 S_GET_NAME (symp), symp,
1583 segment_name (symp->bsym->section));
1586 #ifdef obj_frob_symbol
1587 obj_frob_symbol (symp, punt);
1589 #ifdef tc_frob_symbol
1590 if (! punt || symp->sy_used_in_reloc)
1591 tc_frob_symbol (symp, punt);
1594 /* If we don't want to keep this symbol, splice it out of
1595 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1596 want section symbols. Otherwise, we skip local symbols
1597 and symbols that the frob_symbol macros told us to punt,
1598 but we keep such symbols if they are used in relocs. */
1599 if ((! EMIT_SECTION_SYMBOLS
1600 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1601 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1602 opposites. Sometimes the former checks flags and the
1603 latter examines the name... */
1604 || (!S_IS_EXTERN (symp)
1605 && (S_IS_LOCAL (symp) || punt)
1606 && ! symp->sy_used_in_reloc))
1608 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1609 /* After symbol_remove, symbol_next(symp) still returns
1610 the one that came after it in the chain. So we don't
1611 need to do any extra cleanup work here. */
1616 /* Make sure we really got a value for the symbol. */
1617 if (! symp->sy_resolved)
1619 as_bad ("can't resolve value for symbol \"%s\"",
1621 symp->sy_resolved = 1;
1624 /* Set the value into the BFD symbol. Up til now the value
1625 has only been kept in the gas symbolS struct. */
1626 symp->bsym->value = S_GET_VALUE (symp);
1630 /* Now do any format-specific adjustments to the symbol table, such
1631 as adding file symbols. */
1632 #ifdef obj_adjust_symtab
1633 obj_adjust_symtab ();
1636 /* Now that all the sizes are known, and contents correct, we can
1637 start writing to the file. */
1640 /* If *_frob_file changes the symbol value at this point, it is
1641 responsible for moving the changed value into symp->bsym->value
1642 as well. Hopefully all symbol value changing can be done in
1647 #ifdef obj_frob_file
1651 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1653 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1654 #endif /* BFD_ASSEMBLER */
1661 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1666 * After this, all frags in this segment have addresses that are correct
1667 * within the segment. Since segments live in different file addresses,
1668 * these frag addresses may not be the same as final object-file addresses.
1671 #ifndef md_relax_frag
1673 /* Subroutines of relax_segment. */
1679 for (; f1; f1 = f1->fr_next)
1680 if (f1->fr_next == f2)
1685 #endif /* ! defined (md_relax_frag) */
1687 /* Relax_align. Advance location counter to next address that has 'alignment'
1688 lowest order bits all 0s, return size of adjustment made. */
1689 static relax_addressT
1690 relax_align (address, alignment)
1691 register relax_addressT address; /* Address now. */
1692 register int alignment; /* Alignment (binary). */
1694 relax_addressT mask;
1695 relax_addressT new_address;
1697 mask = ~((~0) << alignment);
1698 new_address = (address + mask) & (~mask);
1700 /* We must provide lots of padding, so the linker can discard it
1701 when needed. The linker will not add extra space, ever. */
1702 new_address += (1 << alignment);
1703 return (new_address - address);
1707 relax_segment (segment_frag_root, segment)
1708 struct frag *segment_frag_root;
1711 register struct frag *fragP;
1712 register relax_addressT address;
1713 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1714 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1716 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1717 subseg_change (segment, 0);
1719 /* For each frag in segment: count and store (a 1st guess of)
1722 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1724 fragP->fr_address = address;
1725 address += fragP->fr_fix;
1727 switch (fragP->fr_type)
1730 address += fragP->fr_offset * fragP->fr_var;
1735 int offset = relax_align (address, (int) fragP->fr_offset);
1736 if (offset % fragP->fr_var != 0)
1738 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1739 offset, (long) fragP->fr_var);
1740 offset -= (offset % fragP->fr_var);
1747 /* Assume .org is nugatory. It will grow with 1st relax. */
1750 case rs_machine_dependent:
1751 address += md_estimate_size_before_relax (fragP, segment);
1754 #ifndef WORKING_DOT_WORD
1755 /* Broken words don't concern us yet */
1756 case rs_broken_word:
1761 BAD_CASE (fragP->fr_type);
1763 } /* switch(fr_type) */
1764 } /* for each frag in the segment */
1768 long stretch; /* May be any size, 0 or negative. */
1769 /* Cumulative number of addresses we have */
1770 /* relaxed this pass. */
1771 /* We may have relaxed more than one address. */
1772 long stretched; /* Have we stretched on this pass? */
1773 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1774 grew, and another shrank. If a branch instruction doesn't fit anymore,
1775 we could be scrod. */
1779 stretch = stretched = 0;
1780 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1783 unsigned long was_address;
1789 was_address = fragP->fr_address;
1790 address = fragP->fr_address += stretch;
1791 symbolP = fragP->fr_symbol;
1792 offset = fragP->fr_offset;
1794 switch (fragP->fr_type)
1796 case rs_fill: /* .fill never relaxes. */
1800 #ifndef WORKING_DOT_WORD
1801 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1802 for it I do not want to write it. I do not want to have
1803 anything to do with it. This is not the proper way to
1804 implement this misfeature. */
1805 case rs_broken_word:
1807 struct broken_word *lie;
1808 struct broken_word *untruth;
1810 /* Yes this is ugly (storing the broken_word pointer
1811 in the symbol slot). Still, this whole chunk of
1812 code is ugly, and I don't feel like doing anything
1813 about it. Think of it as stubbornness in action. */
1815 for (lie = (struct broken_word *) (fragP->fr_symbol);
1816 lie && lie->dispfrag == fragP;
1817 lie = lie->next_broken_word)
1823 offset = (lie->add->sy_frag->fr_address
1824 + S_GET_VALUE (lie->add)
1826 - (lie->sub->sy_frag->fr_address
1827 + S_GET_VALUE (lie->sub)));
1828 if (offset <= -32768 || offset >= 32767)
1830 if (flag_warn_displacement)
1833 sprint_value (buf, (addressT) lie->addnum);
1834 as_warn (".word %s-%s+%s didn't fit",
1835 S_GET_NAME (lie->add),
1836 S_GET_NAME (lie->sub),
1840 if (fragP->fr_subtype == 0)
1842 fragP->fr_subtype++;
1843 growth += md_short_jump_size;
1845 for (untruth = lie->next_broken_word;
1846 untruth && untruth->dispfrag == lie->dispfrag;
1847 untruth = untruth->next_broken_word)
1848 if ((untruth->add->sy_frag == lie->add->sy_frag)
1849 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1852 untruth->use_jump = lie;
1854 growth += md_long_jump_size;
1859 } /* case rs_broken_word */
1862 growth = (relax_align ((relax_addressT) (address
1865 - relax_align ((relax_addressT) (was_address
1875 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1876 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1877 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1878 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1879 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1880 know (symbolP->sy_frag);
1881 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1882 || (symbolP->sy_frag == &zero_address_frag));
1884 target += S_GET_VALUE (symbolP)
1885 + symbolP->sy_frag->fr_address;
1886 } /* if we have a symbol */
1888 know (fragP->fr_next);
1889 after = fragP->fr_next->fr_address;
1890 growth = ((target - after) > 0) ? (target - after) : 0;
1891 /* Growth may be negative, but variable part of frag
1892 cannot have fewer than 0 chars. That is, we can't
1895 growth -= stretch; /* This is an absolute growth factor */
1898 case rs_machine_dependent:
1899 #ifdef md_relax_frag
1900 growth = md_relax_frag (fragP, stretch);
1902 /* The default way to relax a frag is to look through
1905 const relax_typeS *this_type;
1906 const relax_typeS *start_type;
1907 relax_substateT next_state;
1908 relax_substateT this_state;
1911 this_state = fragP->fr_subtype;
1912 start_type = this_type = md_relax_table + this_state;
1917 #ifndef DIFF_EXPR_OK
1918 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1919 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1920 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1921 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1922 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1924 know (symbolP->sy_frag);
1926 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1927 || symbolP->sy_frag == &zero_address_frag);
1929 S_GET_VALUE (symbolP)
1930 + symbolP->sy_frag->fr_address;
1932 /* If frag has yet to be reached on this pass,
1933 assume it will move by STRETCH just as we did.
1934 If this is not so, it will be because some frag
1935 between grows, and that will force another pass.
1937 Beware zero-length frags.
1939 There should be a faster way to do this. */
1941 if (symbolP->sy_frag->fr_address >= was_address
1942 && is_dnrange (fragP, symbolP->sy_frag))
1948 aim = target - address - fragP->fr_fix;
1949 #ifdef TC_PCREL_ADJUST
1950 /* Currently only the ns32k family needs this */
1951 aim += TC_PCREL_ADJUST(fragP);
1953 /* This machine doesn't want to use pcrel_adjust.
1954 In that case, pcrel_adjust should be zero. */
1955 assert (fragP->fr_pcrel_adjust == 0);
1960 /* Look backwards. */
1961 for (next_state = this_type->rlx_more; next_state;)
1962 if (aim >= this_type->rlx_backward)
1966 /* Grow to next state. */
1967 this_state = next_state;
1968 this_type = md_relax_table + this_state;
1969 next_state = this_type->rlx_more;
1974 #ifdef M68K_AIM_KLUDGE
1975 M68K_AIM_KLUDGE (aim, this_state, this_type);
1977 /* Look forwards. */
1978 for (next_state = this_type->rlx_more; next_state;)
1979 if (aim <= this_type->rlx_forward)
1983 /* Grow to next state. */
1984 this_state = next_state;
1985 this_type = md_relax_table + this_state;
1986 next_state = this_type->rlx_more;
1990 growth = this_type->rlx_length - start_type->rlx_length;
1992 fragP->fr_subtype = this_state;
1998 BAD_CASE (fragP->fr_type);
2006 } /* For each frag in the segment. */
2008 while (stretched); /* Until nothing further to relax. */
2012 * We now have valid fr_address'es for each frag.
2016 * All fr_address's are correct, relative to their own segment.
2017 * We have made all the fixS we will ever make.
2019 } /* relax_segment() */
2021 #if defined (BFD_ASSEMBLER) || !defined (BFD)
2023 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2024 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2029 Go through all the fixS's in a segment and see which ones can be
2030 handled now. (These consist of fixS where we have since discovered
2031 the value of a symbol, or the address of the frag involved.)
2032 For each one, call md_apply_fix to put the fix into the frag data.
2034 Result is a count of how many relocation structs will be needed to
2035 handle the remaining fixS's that we couldn't completely handle here.
2036 These will be output later by emit_relocations(). */
2039 fixup_segment (fixP, this_segment_type)
2040 register fixS *fixP;
2041 segT this_segment_type; /* N_TYPE bits for segment. */
2043 long seg_reloc_count = 0;
2044 symbolS *add_symbolP;
2045 symbolS *sub_symbolP;
2052 segT add_symbol_segment = absolute_section;
2054 /* If the linker is doing the relaxing, we must not do any fixups.
2056 Well, strictly speaking that's not true -- we could do any that are
2057 PC-relative and don't cross regions that could change size. And for the
2058 i960 (the only machine for which we've got a relaxing linker right now),
2059 we might be able to turn callx/callj into bal anyways in cases where we
2060 know the maximum displacement. */
2063 for (; fixP; fixP = fixP->fx_next)
2065 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2066 return seg_reloc_count;
2069 for (; fixP; fixP = fixP->fx_next)
2072 fprintf (stderr, "\nprocessing fixup:\n");
2076 fragP = fixP->fx_frag;
2078 where = fixP->fx_where;
2079 place = fragP->fr_literal + where;
2080 size = fixP->fx_size;
2081 add_symbolP = fixP->fx_addsy;
2082 #ifdef TC_VALIDATE_FIX
2083 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2085 sub_symbolP = fixP->fx_subsy;
2086 add_number = fixP->fx_offset;
2087 pcrel = fixP->fx_pcrel;
2091 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2098 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2099 add_number -= S_GET_VALUE (sub_symbolP);
2101 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2103 /* Should try converting to a constant. */
2108 as_bad_where (fixP->fx_file, fixP->fx_line,
2109 "Negative of non-absolute symbol %s",
2110 S_GET_NAME (sub_symbolP));
2112 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
2113 && (SEG_NORMAL (add_symbol_segment)
2114 || (add_symbol_segment == absolute_section)))
2116 /* Difference of 2 symbols from same segment.
2117 Can't make difference of 2 undefineds: 'value' means
2118 something different for N_UNDF. */
2120 /* Makes no sense to use the difference of 2 arbitrary symbols
2121 as the target of a call instruction. */
2123 as_bad_where (fixP->fx_file, fixP->fx_line,
2124 "callj to difference of 2 symbols");
2125 #endif /* TC_I960 */
2126 add_number += S_GET_VALUE (add_symbolP) -
2127 S_GET_VALUE (sub_symbolP);
2131 /* Let the target machine make the final determination
2132 as to whether or not a relocation will be needed to
2133 handle this fixup. */
2134 if (!TC_FORCE_RELOCATION (fixP))
2136 fixP->fx_addsy = NULL;
2141 /* Different segments in subtraction. */
2142 know (!(S_IS_EXTERNAL (sub_symbolP)
2143 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2145 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2146 add_number -= S_GET_VALUE (sub_symbolP);
2149 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2150 #if 0 /* Do this even if it's already described as pc-relative. For example,
2151 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2152 pc-relative mode. */
2157 /* Make it pc-relative. */
2158 add_number += (md_pcrel_from (fixP)
2159 - S_GET_VALUE (sub_symbolP));
2166 #ifdef BFD_ASSEMBLER
2167 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2168 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2170 /* Leave it alone. */
2176 sprint_value (buf, fragP->fr_address + where);
2177 as_bad_where (fixP->fx_file, fixP->fx_line,
2178 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2179 segment_name (S_GET_SEGMENT (sub_symbolP)),
2180 S_GET_NAME (sub_symbolP), buf);
2187 if (add_symbol_segment == this_segment_type && pcrel && !plt
2188 && TC_RELOC_RTSYM_LOC_FIXUP (fixP->fx_r_type))
2191 * This fixup was made when the symbol's segment was
2192 * SEG_UNKNOWN, but it is now in the local segment.
2193 * So we know how to do the address without relocation.
2196 /* reloc_callj() may replace a 'call' with a 'calls' or a
2197 'bal', in which cases it modifies *fixP as appropriate.
2198 In the case of a 'calls', no further work is required,
2199 and *fixP has been set up to make the rest of the code
2202 #endif /* TC_I960 */
2204 add_number += S_GET_VALUE (add_symbolP);
2205 add_number -= md_pcrel_from (fixP);
2206 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2208 /* Let the target machine make the final determination
2209 as to whether or not a relocation will be needed to
2210 handle this fixup. */
2211 if (!TC_FORCE_RELOCATION (fixP))
2214 fixP->fx_addsy = NULL;
2219 if (add_symbol_segment == absolute_section)
2222 /* See comment about reloc_callj() above. */
2224 #endif /* TC_I960 */
2225 add_number += S_GET_VALUE (add_symbolP);
2227 /* Let the target machine make the final determination
2228 as to whether or not a relocation will be needed to
2229 handle this fixup. */
2230 if (!TC_FORCE_RELOCATION (fixP))
2232 fixP->fx_addsy = NULL;
2236 else if (add_symbol_segment == undefined_section
2237 #ifdef BFD_ASSEMBLER
2238 || bfd_is_com_section (add_symbol_segment)
2243 if ((int) fixP->fx_bit_fixP == 13)
2245 /* This is a COBR instruction. They have only a
2246 * 13-bit displacement and are only to be used
2247 * for local branches: flag as error, don't generate
2250 as_bad_where (fixP->fx_file, fixP->fx_line,
2251 "can't use COBR format with external label");
2252 fixP->fx_addsy = NULL;
2256 #endif /* TC_I960 */
2260 if (S_IS_COMMON (add_symbolP))
2261 add_number += S_GET_VALUE (add_symbolP);
2262 #endif /* TE_I386AIX */
2263 #endif /* OBJ_COFF */
2269 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2270 add_number += S_GET_VALUE (add_symbolP);
2278 add_number -= md_pcrel_from (fixP);
2279 if (add_symbolP == 0)
2281 #ifndef BFD_ASSEMBLER
2282 fixP->fx_addsy = &abs_symbol;
2284 fixP->fx_addsy = section_symbol (absolute_section);
2286 fixP->fx_addsy->sy_used_in_reloc = 1;
2291 if (!fixP->fx_bit_fixP && size > 0)
2294 if (size < sizeof (mask))
2296 /* set all bits to one */
2298 /* Technically, combining these produces an undefined result
2299 if size is sizeof (valueT), though I think these two
2300 half-way operations should both be defined. And the
2301 compiler should be able to combine them if it's valid on
2302 the host architecture. */
2305 if ((add_number & mask) != 0
2306 && (add_number & mask) != mask)
2308 char buf[50], buf2[50];
2309 sprint_value (buf, fragP->fr_address + where);
2310 if (add_number > 1000)
2311 sprint_value (buf2, add_number);
2313 sprintf (buf2, "%ld", (long) add_number);
2314 as_bad_where (fixP->fx_file, fixP->fx_line,
2315 "Value of %s too large for field of %d bytes at %s",
2317 } /* generic error checking */
2319 #ifdef WARN_SIGNED_OVERFLOW_WORD
2320 /* Warn if a .word value is too large when treated as a signed
2321 number. We already know it is not too negative. This is to
2322 catch over-large switches generated by gcc on the 68k. */
2323 if (!flag_signed_overflow_ok
2325 && add_number > 0x7fff)
2326 as_bad_where (fixP->fx_file, fixP->fx_line,
2327 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2329 (unsigned long) (fragP->fr_address + where));
2331 } /* not a bit fix */
2335 #ifdef BFD_ASSEMBLER
2336 md_apply_fix (fixP, &add_number);
2338 md_apply_fix (fixP, add_number);
2341 #ifndef TC_HANDLES_FX_DONE
2342 /* If the tc-* files haven't been converted, assume it's handling
2343 it the old way, where a null fx_addsy means that the fix has
2344 been applied completely, and no further work is needed. */
2345 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2349 #ifdef TC_VALIDATE_FIX
2353 fprintf (stderr, "result:\n");
2356 } /* For each fixS in this segment. */
2358 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2359 return seg_reloc_count;
2362 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2365 number_to_chars_bigendian (buf, val, n)
2370 if (n > sizeof (val)|| n <= 0)
2374 buf[n] = val & 0xff;
2380 number_to_chars_littleendian (buf, val, n)
2385 if (n > sizeof (val) || n <= 0)
2389 *buf++ = val & 0xff;
2395 extern int indent_level;
2402 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2404 fprintf (stderr, " pcrel");
2405 if (fixp->fx_pcrel_adjust)
2406 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2407 if (fixp->fx_im_disp)
2410 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2412 fprintf (stderr, " im_disp");
2416 fprintf (stderr, " tcbit");
2418 fprintf (stderr, " done");
2419 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2420 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2421 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2422 #ifdef BFD_ASSEMBLER
2423 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2426 #ifdef NEED_FX_R_TYPE
2427 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2432 fprintf (stderr, "\n +<");
2433 print_symbol_value_1 (stderr, fixp->fx_addsy);
2434 fprintf (stderr, ">");
2438 fprintf (stderr, "\n -<");
2439 print_symbol_value_1 (stderr, fixp->fx_subsy);
2440 fprintf (stderr, ">");
2442 fprintf (stderr, "\n");
2445 /* end of write.c */