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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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;
79 long string_byte_count;
80 char *next_object_file_charP; /* Tracks object file bytes. */
83 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
86 #endif /* BFD_ASSEMBLER */
89 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
90 symbolS *add, symbolS *sub,
91 offsetT offset, int pcrel,
92 bfd_reloc_code_real_type r_type));
94 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
95 symbolS *add, symbolS *sub,
96 offsetT offset, int pcrel,
99 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
100 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
102 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
107 * Create a fixS in obstack 'notes'.
110 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
112 fragS *frag; /* Which frag? */
113 int where; /* Where in that frag? */
114 int size; /* 1, 2, or 4 usually. */
115 symbolS *add_symbol; /* X_add_symbol. */
116 symbolS *sub_symbol; /* X_op_symbol. */
117 offsetT offset; /* X_add_number. */
118 int pcrel; /* TRUE if PC-relative relocation. */
120 bfd_reloc_code_real_type r_type; /* Relocation type */
122 int r_type; /* Relocation type */
127 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
129 fixP->fx_frag = frag;
130 fixP->fx_where = where;
131 fixP->fx_size = size;
132 fixP->fx_addsy = add_symbol;
133 fixP->fx_subsy = sub_symbol;
134 fixP->fx_offset = offset;
135 fixP->fx_pcrel = pcrel;
137 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
138 fixP->fx_r_type = r_type;
140 fixP->fx_im_disp = 0;
141 fixP->fx_pcrel_adjust = 0;
142 fixP->fx_bit_fixP = 0;
143 fixP->fx_addnumber = 0;
144 fixP->tc_fix_data = NULL;
148 #if defined (TC_I960) || defined (TC_NS32K)
152 as_where (&fixP->fx_file, &fixP->fx_line);
154 /* Usually, we want relocs sorted numerically, but while
155 comparing to older versions of gas that have relocs
156 reverse sorted, it is convenient to have this compile
157 time option. xoxorich. */
162 fixS **seg_fix_rootP = (frags_chained
163 ? &seg_info (now_seg)->fix_root
164 : &frchain_now->fix_root);
165 fixS **seg_fix_tailP = (frags_chained
166 ? &seg_info (now_seg)->fix_tail
167 : &frchain_now->fix_tail);
170 #ifdef REVERSE_SORT_RELOCS
172 fixP->fx_next = *seg_fix_rootP;
173 *seg_fix_rootP = fixP;
175 #else /* REVERSE_SORT_RELOCS */
177 fixP->fx_next = NULL;
180 (*seg_fix_tailP)->fx_next = fixP;
182 *seg_fix_rootP = fixP;
183 *seg_fix_tailP = fixP;
185 #endif /* REVERSE_SORT_RELOCS */
192 /* Create a fixup relative to a symbol (plus a constant). */
195 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
196 fragS *frag; /* Which frag? */
197 int where; /* Where in that frag? */
198 short int size; /* 1, 2, or 4 usually. */
199 symbolS *add_symbol; /* X_add_symbol. */
200 offsetT offset; /* X_add_number. */
201 int pcrel; /* TRUE if PC-relative relocation. */
203 bfd_reloc_code_real_type r_type; /* Relocation type */
205 int r_type; /* Relocation type */
208 return fix_new_internal (frag, where, size, add_symbol,
209 (symbolS *) NULL, offset, pcrel, r_type);
212 /* Create a fixup for an expression. Currently we only support fixups
213 for difference expressions. That is itself more than most object
214 file formats support anyhow. */
217 fix_new_exp (frag, where, size, exp, pcrel, r_type)
218 fragS *frag; /* Which frag? */
219 int where; /* Where in that frag? */
220 short int size; /* 1, 2, or 4 usually. */
221 expressionS *exp; /* Expression. */
222 int pcrel; /* TRUE if PC-relative relocation. */
224 bfd_reloc_code_real_type r_type; /* Relocation type */
226 int r_type; /* Relocation type */
239 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
240 the difference expression cannot immediately be reduced. */
242 extern symbolS *make_expr_symbol ();
243 symbolS *stmp = make_expr_symbol (exp);
244 exp->X_op = O_symbol;
245 exp->X_op_symbol = 0;
246 exp->X_add_symbol = stmp;
247 exp->X_add_number = 0;
248 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
252 sub = exp->X_add_symbol;
253 off = exp->X_add_number;
257 sub = exp->X_op_symbol;
260 add = exp->X_add_symbol;
263 off = exp->X_add_number;
267 as_bad ("expression too complex for fixup");
270 return fix_new_internal (frag, where, size, add, sub, off,
274 /* Append a string onto another string, bumping the pointer along. */
276 append (charPP, fromP, length)
279 unsigned long length;
281 /* Don't trust memcpy() of 0 chars. */
285 memcpy (*charPP, fromP, length);
289 #ifndef BFD_ASSEMBLER
290 int section_alignment[SEG_MAXIMUM_ORDINAL];
294 * This routine records the largest alignment seen for each segment.
295 * If the beginning of the segment is aligned on the worst-case
296 * boundary, all of the other alignments within it will work. At
297 * least one object format really uses this info.
300 record_alignment (seg, align)
301 /* Segment to which alignment pertains */
303 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
308 if (align > bfd_get_section_alignment (stdoutput, seg))
309 bfd_set_section_alignment (stdoutput, seg, align);
311 if (align > section_alignment[(int) seg])
312 section_alignment[(int) seg] = align;
318 /* Reset the section indices after removing the gas created sections. */
321 renumber_sections (abfd, sec, countparg)
326 int *countp = (int *) countparg;
328 sec->index = *countp;
332 #endif /* defined (BFD_ASSEMBLER) */
334 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
337 chain_frchains_together_1 (section, frchp)
339 struct frchain *frchp;
341 fragS dummy, *prev_frag = &dummy;
343 fixS fix_dummy, *prev_fix = &fix_dummy;
346 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
348 prev_frag->fr_next = frchp->frch_root;
349 prev_frag = frchp->frch_last;
351 if (frchp->fix_root != (fixS *) NULL)
353 if (seg_info (section)->fix_root == (fixS *) NULL)
354 seg_info (section)->fix_root = frchp->fix_root;
355 prev_fix->fx_next = frchp->fix_root;
356 seg_info (section)->fix_tail = frchp->fix_tail;
357 prev_fix = frchp->fix_tail;
361 prev_frag->fr_next = 0;
370 chain_frchains_together (abfd, section, xxx)
371 bfd *abfd; /* unused */
373 PTR xxx; /* unused */
375 segment_info_type *info;
377 /* BFD may have introduced its own sections without using
378 subseg_new, so it is possible that seg_info is NULL. */
379 info = seg_info (section);
380 if (info != (segment_info_type *) NULL)
381 info->frchainP->frch_last
382 = chain_frchains_together_1 (section, info->frchainP);
384 /* Now that we've chained the frags together, we must add new fixups
385 to the segment, not to the frag chain. */
391 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
394 remove_subsegs (head, seg, root, last)
400 *root = head->frch_root;
401 *last = chain_frchains_together_1 (seg, head);
406 #if defined (BFD_ASSEMBLER) || !defined (BFD)
410 cvt_frag_to_fill (sec, fragP)
415 cvt_frag_to_fill (headersP, fragP)
416 object_headers *headersP;
420 switch (fragP->fr_type)
427 HANDLE_ALIGN (fragP);
429 know (fragP->fr_next != NULL);
430 fragP->fr_offset = (fragP->fr_next->fr_address
432 - fragP->fr_fix) / fragP->fr_var;
433 if (fragP->fr_offset < 0)
435 as_bad ("attempt to .org/.space backwards? (%ld)",
436 (long) fragP->fr_offset);
438 fragP->fr_type = rs_fill;
444 case rs_machine_dependent:
446 md_convert_frag (stdoutput, sec, fragP);
448 md_convert_frag (headersP, fragP);
451 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
454 * After md_convert_frag, we make the frag into a ".space 0".
455 * Md_convert_frag() should set up any fixSs and constants
461 #ifndef WORKING_DOT_WORD
464 struct broken_word *lie;
466 if (fragP->fr_subtype)
468 fragP->fr_fix += md_short_jump_size;
469 for (lie = (struct broken_word *) (fragP->fr_symbol);
470 lie && lie->dispfrag == fragP;
471 lie = lie->next_broken_word)
473 fragP->fr_fix += md_long_jump_size;
481 BAD_CASE (fragP->fr_type);
486 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
490 relax_and_size_seg (abfd, sec, xxx)
497 segment_info_type *seginfo;
499 valueT size, newsize;
501 flags = bfd_get_section_flags (abfd, sec);
503 seginfo = seg_info (sec);
504 if (seginfo && seginfo->frchainP)
506 relax_segment (seginfo->frchainP->frch_root, sec);
507 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
508 cvt_frag_to_fill (sec, fragp);
509 for (fragp = seginfo->frchainP->frch_root;
511 fragp = fragp->fr_next)
512 /* walk to last elt */;
513 size = fragp->fr_address + fragp->fr_fix;
518 if (size > 0 && ! seginfo->bss)
519 flags |= SEC_HAS_CONTENTS;
521 /* @@ This is just an approximation. */
522 if (seginfo && seginfo->fix_root)
526 x = bfd_set_section_flags (abfd, sec, flags);
529 newsize = md_section_align (sec, size);
530 x = bfd_set_section_size (abfd, sec, newsize);
533 /* If the size had to be rounded up, add some padding in the last
535 assert (newsize >= size);
538 fragS *last = seginfo->frchainP->frch_last;
539 fragp = seginfo->frchainP->frch_root;
540 while (fragp->fr_next != last)
541 fragp = fragp->fr_next;
542 last->fr_address = size;
543 fragp->fr_offset += newsize - size;
546 #ifdef tc_frob_section
547 tc_frob_section (sec);
549 #ifdef obj_frob_section
550 obj_frob_section (sec);
556 dump_section_relocs (abfd, sec, stream_)
561 FILE *stream = (FILE *) stream_;
562 segment_info_type *seginfo = seg_info (sec);
563 fixS *fixp = seginfo->fix_root;
568 fprintf (stream, "sec %s relocs:\n", sec->name);
571 symbolS *s = fixp->fx_addsy;
574 fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
575 s->bsym->section->name);
576 if (s->bsym->flags & BSF_SECTION_SYM)
578 fprintf (stream, " section sym");
580 fprintf (stream, "+%x", S_GET_VALUE (s));
583 fprintf (stream, "+%x", S_GET_VALUE (s));
584 fprintf (stream, ")+%x\n", fixp->fx_offset);
587 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
588 fixp = fixp->fx_next;
592 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
595 #ifndef EMIT_SECTION_SYMBOLS
596 #define EMIT_SECTION_SYMBOLS 1
600 adjust_reloc_syms (abfd, sec, xxx)
605 segment_info_type *seginfo = seg_info (sec);
611 dump_section_relocs (abfd, sec, stderr);
613 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
616 else if (fixp->fx_addsy)
624 fprintf (stderr, "\n\nadjusting fixup:\n");
628 sym = fixp->fx_addsy;
629 symsec = sym->bsym->section;
631 /* If it's one of these sections, assume the symbol is
632 definitely going to be output. The code in
633 md_estimate_size_before_relax in tc-mips.c uses this test
634 as well, so if you change this code you should look at that
636 if (bfd_is_und_section (symsec)
637 || bfd_is_abs_section (symsec)
638 || bfd_is_com_section (symsec))
640 fixp->fx_addsy->sy_used_in_reloc = 1;
644 /* Since we're reducing to section symbols, don't attempt to reduce
645 anything that's already using one. */
646 if (sym->bsym->flags & BSF_SECTION_SYM)
648 fixp->fx_addsy->sy_used_in_reloc = 1;
652 /* Is there some other reason we can't adjust this one? (E.g.,
653 call/bal links in i960-bout symbols.) */
654 #ifdef obj_fix_adjustable
655 if (! obj_fix_adjustable (fixp))
657 fixp->fx_addsy->sy_used_in_reloc = 1;
662 /* Is there some other (target cpu dependent) reason we can't adjust
663 this one? (E.g. relocations involving function addresses on
665 #ifdef tc_fix_adjustable
666 if (! tc_fix_adjustable (fixp))
668 fixp->fx_addsy->sy_used_in_reloc = 1;
673 /* For PIC support: We may get expressions like
674 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
675 necessarily have had a fixed difference initially. But now
676 it should be a known constant, so we can reduce it. Since
677 we can't easily handle a symbol value that looks like
678 someUndefinedSymbol+const, though, we convert the fixup to
679 access the undefined symbol directly, and discard the
680 intermediate symbol. */
681 if (S_GET_SEGMENT (sym) == expr_section
682 && sym->sy_value.X_op == O_add
683 && (resolve_symbol_value (sym->sy_value.X_add_symbol),
684 S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
685 && (resolve_symbol_value (sym->sy_value.X_op_symbol),
686 S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
688 fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
689 fixp->fx_offset += sym->sy_value.X_add_number;
690 fixp->fx_addsy = sym->sy_value.X_add_symbol;
694 /* If the section symbol isn't going to be output, the relocs
695 at least should still work. If not, figure out what to do
696 when we run into that case. */
697 fixp->fx_offset += S_GET_VALUE (sym);
698 fixp->fx_addsy = section_symbol (symsec);
699 fixp->fx_addsy->sy_used_in_reloc = 1;
704 #if 1/*def RELOC_REQUIRES_SYMBOL*/
707 /* There was no symbol required by this relocation. However,
708 BFD doesn't really handle relocations without symbols well.
709 (At least, the COFF support doesn't.) So for now we fake up
710 a local symbol in the absolute section. */
712 fixp->fx_addsy = section_symbol (absolute_section);
713 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
717 dump_section_relocs (abfd, sec, stderr);
721 write_relocs (abfd, sec, xxx)
726 segment_info_type *seginfo = seg_info (sec);
733 /* If seginfo is NULL, we did not create this section; don't do
738 fixup_segment (seginfo->fix_root, sec);
741 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
744 #ifndef RELOC_EXPANSION_POSSIBLE
745 /* Set up reloc information as well. */
746 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
747 n * sizeof (arelent *));
748 memset ((char*)relocs, 0, n * sizeof (arelent*));
751 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
754 bfd_reloc_status_type s;
761 reloc = tc_gen_reloc (sec, fixp);
767 if (fixp->fx_where + fixp->fx_size
768 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
771 s = bfd_install_relocation (stdoutput, reloc,
772 fixp->fx_frag->fr_literal,
773 fixp->fx_frag->fr_address,
779 case bfd_reloc_overflow:
780 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
783 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
784 fixp->fx_file, fixp->fx_line);
789 n = n * MAX_RELOC_EXPANSION;
790 /* Set up reloc information as well. */
791 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
792 n * sizeof (arelent *));
795 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
799 bfd_reloc_status_type s;
807 reloc = tc_gen_reloc (sec, fixp);
809 for (j = 0; reloc[j]; j++)
811 relocs[i++] = reloc[j];
814 data = fixp->fx_frag->fr_literal + fixp->fx_where;
815 if (fixp->fx_where + fixp->fx_size
816 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
818 for (j = 0; reloc[j]; j++)
820 s = bfd_install_relocation (stdoutput, reloc[j],
821 fixp->fx_frag->fr_literal,
822 fixp->fx_frag->fr_address,
828 case bfd_reloc_overflow:
829 as_bad_where (fixp->fx_file, fixp->fx_line,
830 "relocation overflow");
833 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
834 fixp->fx_file, fixp->fx_line);
845 sympp = bfd_get_outsymbols (stdoutput);
846 nsyms = bfd_get_symcount (stdoutput);
847 for (i = 0; i < n; i++)
848 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
850 for (j = 0; j < nsyms; j++)
851 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
860 bfd_set_reloc (stdoutput, sec, relocs, n);
862 bfd_set_section_flags (abfd, sec,
863 (bfd_get_section_flags (abfd, sec)
864 & (flagword) ~SEC_RELOC));
871 fprintf (stderr, "relocs for sec %s\n", sec->name);
872 for (i = 0; i < n; i++)
876 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
877 i, r, r->address, s->name, r->addend);
884 write_contents (abfd, sec, xxx)
889 segment_info_type *seginfo = seg_info (sec);
890 unsigned long offset = 0;
893 /* Write out the frags. */
895 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
898 for (f = seginfo->frchainP->frch_root;
903 unsigned long fill_size;
907 assert (f->fr_type == rs_fill);
910 x = bfd_set_section_contents (stdoutput, sec,
911 f->fr_literal, (file_ptr) offset,
912 (bfd_size_type) f->fr_fix);
915 bfd_perror (stdoutput->filename);
916 as_perror ("FATAL: Can't write %s", stdoutput->filename);
921 fill_literal = f->fr_literal + f->fr_fix;
922 fill_size = f->fr_var;
923 count = f->fr_offset;
925 if (fill_size && count)
926 #ifdef BFD_FAST_SECTION_FILL
929 if (fill_size > sizeof(buf)) {
930 /* Do it the old way. Can this ever happen? */
933 x = bfd_set_section_contents (stdoutput, sec,
934 fill_literal, (file_ptr) offset,
935 (bfd_size_type) fill_size);
938 bfd_perror (stdoutput->filename);
939 as_perror ("FATAL: Can't write %s", stdoutput->filename);
946 /* Build a buffer full of fill objects and output it as
947 * often as necessary. This saves on the overhead of potentially
948 * lots of bfd_set_section_contents calls.
953 n_per_buf = sizeof (buf);
954 memset (buf, *fill_literal, n_per_buf);
959 n_per_buf = sizeof(buf)/fill_size;
960 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
961 memcpy(bufp, fill_literal, fill_size);
963 for (; count > 0; count -= n_per_buf)
965 n_per_buf = n_per_buf > count ? count : n_per_buf;
966 x = bfd_set_section_contents (stdoutput, sec,
967 buf, (file_ptr) offset,
968 (bfd_size_type) n_per_buf * fill_size);
970 as_fatal ("Cannot write to output file.");
971 offset += n_per_buf * fill_size;
978 x = bfd_set_section_contents (stdoutput, sec,
979 fill_literal, (file_ptr) offset,
980 (bfd_size_type) fill_size);
982 as_fatal ("Cannot write to output file.");
990 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
992 merge_data_into_text ()
994 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
995 seg_info (text_section)->frchainP->frch_last->fr_next =
996 seg_info (data_section)->frchainP->frch_root;
997 seg_info (text_section)->frchainP->frch_last =
998 seg_info (data_section)->frchainP->frch_last;
999 seg_info (data_section)->frchainP = 0;
1003 text_last_frag->fr_next = data_frag_root;
1004 text_last_frag = data_last_frag;
1005 data_last_frag = NULL;
1006 data_frag_root = NULL;
1009 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1010 tmp->fx_next = data_fix_root;
1011 text_fix_tail = data_fix_tail;
1014 text_fix_root = data_fix_root;
1015 data_fix_root = NULL;
1018 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1020 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1022 relax_and_size_all_segments ()
1026 relax_segment (text_frag_root, SEG_TEXT);
1027 relax_segment (data_frag_root, SEG_DATA);
1028 relax_segment (bss_frag_root, SEG_BSS);
1030 * Now the addresses of frags are correct within the segment.
1033 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1034 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1035 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1038 * Join the 2 segments into 1 huge segment.
1039 * To do this, re-compute every rn_address in the SEG_DATA frags.
1040 * Then join the data frags after the text frags.
1042 * Determine a_data [length of data segment].
1046 register relax_addressT slide;
1048 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1050 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1051 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1052 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1054 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1055 /* For b.out: If the data section has a strict alignment
1056 requirement, its load address in the .o file will be
1057 rounded up from the size of the text section. These
1058 two values are *not* the same! Similarly for the bss
1060 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1063 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1065 fragP->fr_address += slide;
1066 } /* for each data frag */
1068 know (text_last_frag != 0);
1069 text_last_frag->fr_next = data_frag_root;
1073 H_SET_DATA_SIZE (&headers, 0);
1077 /* See above comments on b.out data section address. */
1080 if (data_last_frag == 0)
1081 bss_vma = H_GET_TEXT_SIZE (&headers);
1083 bss_vma = data_last_frag->fr_address;
1084 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1085 bss_address_frag.fr_address = bss_vma;
1087 #else /* ! OBJ_BOUT */
1088 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1089 H_GET_DATA_SIZE (&headers));
1091 #endif /* ! OBJ_BOUT */
1093 /* Slide all the frags */
1096 relax_addressT slide = bss_address_frag.fr_address;
1098 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1100 fragP->fr_address += slide;
1101 } /* for each bss frag */
1105 H_SET_BSS_SIZE (&headers,
1106 bss_last_frag->fr_address - bss_frag_root->fr_address);
1108 H_SET_BSS_SIZE (&headers, 0);
1110 #endif /* ! BFD_ASSEMBLER && ! BFD */
1112 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1114 #ifdef BFD_ASSEMBLER
1122 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1124 /* Count symbols. We can't rely on a count made by the loop in
1125 write_object_file, because *_frob_file may add a new symbol or
1128 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1135 asympp = (asymbol **) bfd_alloc (stdoutput,
1136 nsyms * sizeof (asymbol *));
1137 symp = symbol_rootP;
1138 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1140 asympp[i] = symp->bsym;
1146 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1147 assert (result == true);
1148 symbol_table_frozen = 1;
1153 write_object_file ()
1155 struct frchain *frchainP; /* Track along all frchains. */
1156 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1157 fragS *fragP; /* Track along all frags. */
1160 /* Do we really want to write it? */
1162 int n_warns, n_errs;
1163 n_warns = had_warnings ();
1164 n_errs = had_errors ();
1165 /* The -Z flag indicates that an object file should be generated,
1166 regardless of warnings and errors. */
1167 if (flag_always_generate_output)
1169 if (n_warns || n_errs)
1170 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1171 n_errs, n_errs == 1 ? "" : "s",
1172 n_warns, n_warns == 1 ? "" : "s");
1177 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1178 n_errs, n_errs == 1 ? "" : "s",
1179 n_warns, n_warns == 1 ? "" : "s");
1184 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1185 a routine to check for the definition of the procedure "_main",
1186 and if so -- fix it up so that it can be program entry point. */
1187 vms_check_for_main ();
1188 #endif /* OBJ_VMS */
1190 /* After every sub-segment, we fake an ".align ...". This conforms to
1191 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1192 frag that requires least thought. ".align" frags like to have a
1193 following frag since that makes calculating their intended length
1196 @@ Is this really necessary?? */
1197 #ifndef SUB_SEGMENT_ALIGN
1198 #ifdef BFD_ASSEMBLER
1199 #define SUB_SEGMENT_ALIGN(SEG) (0)
1201 #define SUB_SEGMENT_ALIGN(SEG) (2)
1204 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1206 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1207 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1208 /* frag_align will have left a new frag.
1209 Use this last frag for an empty ".fill".
1211 For this segment ...
1212 Create a last frag. Do not leave a "being filled in frag". */
1213 frag_wane (frag_now);
1214 frag_now->fr_fix = 0;
1215 know (frag_now->fr_next == NULL);
1218 /* From now on, we don't care about sub-segments. Build one frag chain
1219 for each segment. Linked thru fr_next. */
1221 #ifdef BFD_ASSEMBLER
1222 /* Remove the sections created by gas for its own purposes. */
1224 asection **seclist, *sec;
1227 seclist = &stdoutput->sections;
1228 while (seclist && *seclist)
1231 while (sec == reg_section || sec == expr_section)
1235 stdoutput->section_count--;
1240 seclist = &(*seclist)->next;
1243 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1246 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1248 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1249 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1250 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1253 /* We have two segments. If user gave -R flag, then we must put the
1254 data frags into the text segment. Do this before relaxing so
1255 we know to take advantage of -R and make shorter addresses. */
1256 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1257 if (flag_readonly_data_in_text)
1259 merge_data_into_text ();
1263 #ifdef BFD_ASSEMBLER
1264 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1266 relax_and_size_all_segments ();
1267 #endif /* BFD_ASSEMBLER */
1269 #ifndef BFD_ASSEMBLER
1272 * Crawl the symbol chain.
1274 * For each symbol whose value depends on a frag, take the address of
1275 * that frag and subsume it into the value of the symbol.
1276 * After this, there is just one way to lookup a symbol value.
1277 * Values are left in their final state for object file emission.
1278 * We adjust the values of 'L' local symbols, even if we do
1279 * not intend to emit them to the object file, because their values
1280 * are needed for fix-ups.
1282 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1283 * from the symbol chain. (They are still pointed to by the fixes.)
1285 * Count the remaining symbols.
1286 * Assign a symbol number to each symbol.
1287 * Count the number of string-table chars we will emit.
1288 * Put this info into the headers as appropriate.
1291 know (zero_address_frag.fr_address == 0);
1292 string_byte_count = sizeof (string_byte_count);
1294 obj_crawl_symbol_chain (&headers);
1296 if (string_byte_count == sizeof (string_byte_count))
1297 string_byte_count = 0;
1299 H_SET_STRING_SIZE (&headers, string_byte_count);
1302 * Addresses of frags now reflect addresses we use in the object file.
1303 * Symbol values are correct.
1304 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1305 * Also converting any machine-dependent frags using md_convert_frag();
1307 subseg_change (SEG_TEXT, 0);
1309 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1311 cvt_frag_to_fill (&headers, fragP);
1313 /* Some assert macros don't work with # directives mixed in. */
1315 if (!(fragP->fr_next == NULL
1317 || fragP->fr_next == data_frag_root
1319 || ((fragP->fr_next->fr_address - fragP->fr_address)
1320 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1324 #endif /* ! BFD_ASSEMBLER */
1326 #ifndef WORKING_DOT_WORD
1328 struct broken_word *lie;
1329 struct broken_word **prevP;
1331 prevP = &broken_words;
1332 for (lie = broken_words; lie; lie = lie->next_broken_word)
1337 exp.X_op = O_subtract;
1338 exp.X_add_symbol = lie->add;
1339 exp.X_op_symbol = lie->sub;
1340 exp.X_add_number = lie->addnum;
1341 #ifdef BFD_ASSEMBLER
1342 #ifdef TC_CONS_FIX_NEW
1343 TC_CONS_FIX_NEW (lie->frag,
1344 lie->word_goes_here - lie->frag->fr_literal,
1347 fix_new_exp (lie->frag,
1348 lie->word_goes_here - lie->frag->fr_literal,
1349 2, &exp, 0, BFD_RELOC_NONE);
1352 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1353 fix_new_exp (lie->frag,
1354 lie->word_goes_here - lie->frag->fr_literal,
1355 2, &exp, 0, NO_RELOC);
1358 fix_new_ns32k_exp (lie->frag,
1359 lie->word_goes_here - lie->frag->fr_literal,
1360 2, &exp, 0, 0, 2, 0, 0);
1362 fix_new_exp (lie->frag,
1363 lie->word_goes_here - lie->frag->fr_literal,
1365 #endif /* TC_NS32K */
1366 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1367 #endif /* BFD_ASSEMBLER */
1368 *prevP = lie->next_broken_word;
1371 prevP = &(lie->next_broken_word);
1373 for (lie = broken_words; lie;)
1375 struct broken_word *untruth;
1377 addressT table_addr;
1378 addressT from_addr, to_addr;
1381 fragP = lie->dispfrag;
1383 /* Find out how many broken_words go here. */
1385 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1386 if (untruth->added == 1)
1389 table_ptr = lie->dispfrag->fr_opcode;
1390 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1391 /* Create the jump around the long jumps. This is a short
1392 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1393 from_addr = table_addr;
1394 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1395 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1396 table_ptr += md_short_jump_size;
1397 table_addr += md_short_jump_size;
1399 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1401 if (lie->added == 2)
1403 /* Patch the jump table */
1404 /* This is the offset from ??? to table_ptr+0 */
1405 to_addr = table_addr - S_GET_VALUE (lie->sub);
1406 #ifdef BFD_ASSEMBLER
1407 to_addr -= lie->sub->sy_frag->fr_address;
1409 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1410 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1412 if (untruth->use_jump == lie)
1413 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1416 /* Install the long jump */
1417 /* this is a long jump from table_ptr+0 to the final target */
1418 from_addr = table_addr;
1419 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1420 #ifdef BFD_ASSEMBLER
1421 to_addr += lie->add->sy_frag->fr_address;
1423 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1424 table_ptr += md_long_jump_size;
1425 table_addr += md_long_jump_size;
1429 #endif /* not WORKING_DOT_WORD */
1431 #ifndef BFD_ASSEMBLER
1434 char *the_object_file;
1435 long object_file_size;
1437 * Scan every FixS performing fixups. We had to wait until now to do
1438 * this because md_convert_frag() may have made some fixSs.
1442 subseg_change (SEG_TEXT, 0);
1443 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1444 subseg_change (SEG_DATA, 0);
1445 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1446 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1448 /* FIXME move this stuff into the pre-write-hook */
1449 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1450 H_SET_ENTRY_POINT (&headers, 0);
1452 obj_pre_write_hook (&headers); /* extra coff stuff */
1454 object_file_size = H_GET_FILE_SIZE (&headers);
1455 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1457 output_file_create (out_file_name);
1459 obj_header_append (&next_object_file_charP, &headers);
1461 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1466 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1468 register long count;
1469 register char *fill_literal;
1470 register long fill_size;
1473 know (fragP->fr_type == rs_fill);
1474 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1475 fill_literal = fragP->fr_literal + fragP->fr_fix;
1476 fill_size = fragP->fr_var;
1477 know (fragP->fr_offset >= 0);
1479 for (count = fragP->fr_offset; count; count--)
1481 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1484 } /* for each code frag. */
1486 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1491 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1492 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)));
1494 /* Make addresses in data relocation directives relative to beginning of
1495 * first data fragment, not end of last text fragment: alignment of the
1496 * start of the data segment may place a gap between the segments.
1498 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1500 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1501 #endif /* TC_I960 */
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)));
1506 * Emit line number entries.
1508 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1509 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers)));
1514 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1515 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)));
1521 if (string_byte_count > 0)
1523 obj_emit_strings (&next_object_file_charP);
1524 } /* only if we have a string table */
1527 bfd_seek (stdoutput, 0, 0);
1528 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1531 /* Write the data to the file */
1532 output_file_append (the_object_file, object_file_size, out_file_name);
1533 free (the_object_file);
1535 } /* non vms output */
1538 * Now do the VMS-dependent part of writing the object file
1540 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1541 H_GET_DATA_SIZE (&headers),
1542 H_GET_BSS_SIZE (&headers),
1543 text_frag_root, data_frag_root);
1544 #endif /* OBJ_VMS */
1545 #else /* BFD_ASSEMBLER */
1547 /* Resolve symbol values. This needs to be done before processing
1553 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1554 if (!symp->sy_resolved)
1555 resolve_symbol_value (symp);
1560 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1562 /* Set up symbol table, and write it out. */
1567 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1572 name = S_GET_NAME (symp);
1575 const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
1576 /* They only differ if `name' is a fb or dollar local
1578 if (name2 != name && ! S_IS_DEFINED (symp))
1579 as_bad ("local label %s is not defined", name2);
1582 /* Do it again, because adjust_reloc_syms might introduce
1583 more symbols. They'll probably only be section symbols,
1584 but they'll still need to have the values computed. */
1585 if (! symp->sy_resolved)
1587 if (symp->sy_value.X_op == O_constant)
1589 /* This is the normal case; skip the call. */
1592 + symp->sy_frag->fr_address));
1593 symp->sy_resolved = 1;
1596 resolve_symbol_value (symp);
1599 /* So far, common symbols have been treated like undefined symbols.
1600 Put them in the common section now. */
1601 if (S_IS_DEFINED (symp) == 0
1602 && S_GET_VALUE (symp) != 0)
1603 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1605 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1606 S_GET_NAME (symp), symp,
1609 segment_name (symp->bsym->section));
1612 #ifdef obj_frob_symbol
1613 obj_frob_symbol (symp, punt);
1615 #ifdef tc_frob_symbol
1616 if (! punt || symp->sy_used_in_reloc)
1617 tc_frob_symbol (symp, punt);
1620 /* If we don't want to keep this symbol, splice it out of
1621 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1622 want section symbols. Otherwise, we skip local symbols
1623 and symbols that the frob_symbol macros told us to punt,
1624 but we keep such symbols if they are used in relocs. */
1625 if ((! EMIT_SECTION_SYMBOLS
1626 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1627 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1628 opposites. Sometimes the former checks flags and the
1629 latter examines the name... */
1630 || (!S_IS_EXTERN (symp)
1631 && (S_IS_LOCAL (symp) || punt)
1632 && ! symp->sy_used_in_reloc))
1634 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1635 /* After symbol_remove, symbol_next(symp) still returns
1636 the one that came after it in the chain. So we don't
1637 need to do any extra cleanup work here. */
1642 /* Make sure we really got a value for the symbol. */
1643 if (! symp->sy_resolved)
1645 as_bad ("can't resolve value for symbol \"%s\"",
1647 symp->sy_resolved = 1;
1650 /* Set the value into the BFD symbol. Up til now the value
1651 has only been kept in the gas symbolS struct. */
1652 symp->bsym->value = S_GET_VALUE (symp);
1658 /* Now do any format-specific adjustments to the symbol table, such
1659 as adding file symbols. */
1660 #ifdef obj_adjust_symtab
1661 obj_adjust_symtab ();
1664 /* Now that all the sizes are known, and contents correct, we can
1665 start writing to the file. */
1668 /* If *_frob_file changes the symbol value at this point, it is
1669 responsible for moving the changed value into symp->bsym->value
1670 as well. Hopefully all symbol value changing can be done in
1675 #ifdef obj_frob_file
1679 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1681 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1682 #endif /* BFD_ASSEMBLER */
1689 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1694 * After this, all frags in this segment have addresses that are correct
1695 * within the segment. Since segments live in different file addresses,
1696 * these frag addresses may not be the same as final object-file addresses.
1699 #ifndef md_relax_frag
1701 /* Subroutines of relax_segment. */
1707 for (; f1; f1 = f1->fr_next)
1708 if (f1->fr_next == f2)
1713 #endif /* ! defined (md_relax_frag) */
1715 /* Relax_align. Advance location counter to next address that has 'alignment'
1716 lowest order bits all 0s, return size of adjustment made. */
1717 static relax_addressT
1718 relax_align (address, alignment)
1719 register relax_addressT address; /* Address now. */
1720 register int alignment; /* Alignment (binary). */
1722 relax_addressT mask;
1723 relax_addressT new_address;
1725 mask = ~((~0) << alignment);
1726 new_address = (address + mask) & (~mask);
1728 /* We must provide lots of padding, so the linker can discard it
1729 when needed. The linker will not add extra space, ever. */
1730 new_address += (1 << alignment);
1731 return (new_address - address);
1735 relax_segment (segment_frag_root, segment)
1736 struct frag *segment_frag_root;
1739 register struct frag *fragP;
1740 register relax_addressT address;
1741 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1742 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1744 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1745 subseg_change (segment, 0);
1747 /* For each frag in segment: count and store (a 1st guess of)
1750 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1752 fragP->fr_address = address;
1753 address += fragP->fr_fix;
1755 switch (fragP->fr_type)
1758 address += fragP->fr_offset * fragP->fr_var;
1764 int offset = relax_align (address, (int) fragP->fr_offset);
1765 if (offset % fragP->fr_var != 0)
1767 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1768 offset, (long) fragP->fr_var);
1769 offset -= (offset % fragP->fr_var);
1777 /* Assume .org is nugatory. It will grow with 1st relax. */
1780 case rs_machine_dependent:
1781 address += md_estimate_size_before_relax (fragP, segment);
1784 #ifndef WORKING_DOT_WORD
1785 /* Broken words don't concern us yet */
1786 case rs_broken_word:
1791 BAD_CASE (fragP->fr_type);
1793 } /* switch(fr_type) */
1794 } /* for each frag in the segment */
1798 long stretch; /* May be any size, 0 or negative. */
1799 /* Cumulative number of addresses we have */
1800 /* relaxed this pass. */
1801 /* We may have relaxed more than one address. */
1802 long stretched; /* Have we stretched on this pass? */
1803 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1804 grew, and another shrank. If a branch instruction doesn't fit anymore,
1805 we could be scrod. */
1809 stretch = stretched = 0;
1810 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1813 unsigned long was_address;
1819 was_address = fragP->fr_address;
1820 address = fragP->fr_address += stretch;
1821 symbolP = fragP->fr_symbol;
1822 offset = fragP->fr_offset;
1824 switch (fragP->fr_type)
1826 case rs_fill: /* .fill never relaxes. */
1830 #ifndef WORKING_DOT_WORD
1831 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1832 for it I do not want to write it. I do not want to have
1833 anything to do with it. This is not the proper way to
1834 implement this misfeature. */
1835 case rs_broken_word:
1837 struct broken_word *lie;
1838 struct broken_word *untruth;
1840 /* Yes this is ugly (storing the broken_word pointer
1841 in the symbol slot). Still, this whole chunk of
1842 code is ugly, and I don't feel like doing anything
1843 about it. Think of it as stubbornness in action. */
1845 for (lie = (struct broken_word *) (fragP->fr_symbol);
1846 lie && lie->dispfrag == fragP;
1847 lie = lie->next_broken_word)
1853 offset = (lie->add->sy_frag->fr_address
1854 + S_GET_VALUE (lie->add)
1856 - (lie->sub->sy_frag->fr_address
1857 + S_GET_VALUE (lie->sub)));
1858 if (offset <= -32768 || offset >= 32767)
1860 if (flag_warn_displacement)
1863 sprint_value (buf, (addressT) lie->addnum);
1864 as_warn (".word %s-%s+%s didn't fit",
1865 S_GET_NAME (lie->add),
1866 S_GET_NAME (lie->sub),
1870 if (fragP->fr_subtype == 0)
1872 fragP->fr_subtype++;
1873 growth += md_short_jump_size;
1875 for (untruth = lie->next_broken_word;
1876 untruth && untruth->dispfrag == lie->dispfrag;
1877 untruth = untruth->next_broken_word)
1878 if ((untruth->add->sy_frag == lie->add->sy_frag)
1879 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1882 untruth->use_jump = lie;
1884 growth += md_long_jump_size;
1889 } /* case rs_broken_word */
1893 growth = (relax_align ((relax_addressT) (address
1896 - relax_align ((relax_addressT) (was_address
1906 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1907 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1908 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1909 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1910 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1911 know (symbolP->sy_frag);
1912 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1913 || (symbolP->sy_frag == &zero_address_frag));
1915 target += S_GET_VALUE (symbolP)
1916 + symbolP->sy_frag->fr_address;
1917 } /* if we have a symbol */
1919 know (fragP->fr_next);
1920 after = fragP->fr_next->fr_address;
1921 growth = target - after;
1924 /* Growth may be negative, but variable part of frag
1925 cannot have fewer than 0 chars. That is, we can't
1927 as_bad ("attempt to .org backwards ignored");
1931 growth -= stretch; /* This is an absolute growth factor */
1937 growth = S_GET_VALUE (symbolP);
1938 if (symbolP->sy_frag != &zero_address_frag)
1939 as_bad (".space specifies non-absolute value");
1940 fragP->fr_symbol = 0;
1943 as_warn (".space or .fill with negative value, ignored");
1951 case rs_machine_dependent:
1952 #ifdef md_relax_frag
1953 growth = md_relax_frag (fragP, stretch);
1955 #ifdef TC_GENERIC_RELAX_TABLE
1956 /* The default way to relax a frag is to look through
1959 const relax_typeS *this_type;
1960 const relax_typeS *start_type;
1961 relax_substateT next_state;
1962 relax_substateT this_state;
1964 const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
1966 this_state = fragP->fr_subtype;
1967 start_type = this_type = table + this_state;
1972 #ifndef DIFF_EXPR_OK
1973 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1974 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1975 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1976 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1977 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1979 know (symbolP->sy_frag);
1981 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1982 || symbolP->sy_frag == &zero_address_frag);
1984 S_GET_VALUE (symbolP)
1985 + symbolP->sy_frag->fr_address;
1987 /* If frag has yet to be reached on this pass,
1988 assume it will move by STRETCH just as we did.
1989 If this is not so, it will be because some frag
1990 between grows, and that will force another pass.
1992 Beware zero-length frags.
1994 There should be a faster way to do this. */
1996 if (symbolP->sy_frag->fr_address >= was_address
1997 && is_dnrange (fragP, symbolP->sy_frag))
2003 aim = target - address - fragP->fr_fix;
2004 #ifdef TC_PCREL_ADJUST
2005 /* Currently only the ns32k family needs this */
2006 aim += TC_PCREL_ADJUST(fragP);
2008 /* This machine doesn't want to use pcrel_adjust.
2009 In that case, pcrel_adjust should be zero. */
2010 assert (fragP->fr_pcrel_adjust == 0);
2015 /* Look backwards. */
2016 for (next_state = this_type->rlx_more; next_state;)
2017 if (aim >= this_type->rlx_backward)
2021 /* Grow to next state. */
2022 this_state = next_state;
2023 this_type = table + this_state;
2024 next_state = this_type->rlx_more;
2029 #ifdef M68K_AIM_KLUDGE
2030 M68K_AIM_KLUDGE (aim, this_state, this_type);
2032 /* Look forwards. */
2033 for (next_state = this_type->rlx_more; next_state;)
2034 if (aim <= this_type->rlx_forward)
2038 /* Grow to next state. */
2039 this_state = next_state;
2040 this_type = table + this_state;
2041 next_state = this_type->rlx_more;
2045 growth = this_type->rlx_length - start_type->rlx_length;
2047 fragP->fr_subtype = this_state;
2049 #endif /* TC_GENERIC_RELAX_TABLE */
2054 BAD_CASE (fragP->fr_type);
2062 } /* For each frag in the segment. */
2064 while (stretched); /* Until nothing further to relax. */
2068 * We now have valid fr_address'es for each frag.
2072 * All fr_address's are correct, relative to their own segment.
2073 * We have made all the fixS we will ever make.
2075 } /* relax_segment() */
2077 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2079 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2080 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2085 Go through all the fixS's in a segment and see which ones can be
2086 handled now. (These consist of fixS where we have since discovered
2087 the value of a symbol, or the address of the frag involved.)
2088 For each one, call md_apply_fix to put the fix into the frag data.
2090 Result is a count of how many relocation structs will be needed to
2091 handle the remaining fixS's that we couldn't completely handle here.
2092 These will be output later by emit_relocations(). */
2095 fixup_segment (fixP, this_segment_type)
2096 register fixS *fixP;
2097 segT this_segment_type; /* N_TYPE bits for segment. */
2099 long seg_reloc_count = 0;
2100 symbolS *add_symbolP;
2101 symbolS *sub_symbolP;
2108 segT add_symbol_segment = absolute_section;
2110 /* If the linker is doing the relaxing, we must not do any fixups.
2112 Well, strictly speaking that's not true -- we could do any that are
2113 PC-relative and don't cross regions that could change size. And for the
2114 i960 (the only machine for which we've got a relaxing linker right now),
2115 we might be able to turn callx/callj into bal anyways in cases where we
2116 know the maximum displacement. */
2119 for (; fixP; fixP = fixP->fx_next)
2121 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2122 return seg_reloc_count;
2125 for (; fixP; fixP = fixP->fx_next)
2128 fprintf (stderr, "\nprocessing fixup:\n");
2132 fragP = fixP->fx_frag;
2134 where = fixP->fx_where;
2135 place = fragP->fr_literal + where;
2136 size = fixP->fx_size;
2137 add_symbolP = fixP->fx_addsy;
2138 #ifdef TC_VALIDATE_FIX
2139 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2141 sub_symbolP = fixP->fx_subsy;
2142 add_number = fixP->fx_offset;
2143 pcrel = fixP->fx_pcrel;
2147 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2154 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2155 add_number -= S_GET_VALUE (sub_symbolP);
2157 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2159 /* Should try converting to a constant. */
2164 as_bad_where (fixP->fx_file, fixP->fx_line,
2165 "Negative of non-absolute symbol %s",
2166 S_GET_NAME (sub_symbolP));
2168 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
2169 && (SEG_NORMAL (add_symbol_segment)
2170 || (add_symbol_segment == absolute_section)))
2172 /* Difference of 2 symbols from same segment.
2173 Can't make difference of 2 undefineds: 'value' means
2174 something different for N_UNDF. */
2176 /* Makes no sense to use the difference of 2 arbitrary symbols
2177 as the target of a call instruction. */
2179 as_bad_where (fixP->fx_file, fixP->fx_line,
2180 "callj to difference of 2 symbols");
2181 #endif /* TC_I960 */
2182 add_number += S_GET_VALUE (add_symbolP) -
2183 S_GET_VALUE (sub_symbolP);
2186 pcrel = 0; /* No further pcrel processing. */
2188 /* Let the target machine make the final determination
2189 as to whether or not a relocation will be needed to
2190 handle this fixup. */
2191 if (!TC_FORCE_RELOCATION (fixP))
2194 fixP->fx_addsy = NULL;
2199 /* Different segments in subtraction. */
2200 know (!(S_IS_EXTERNAL (sub_symbolP)
2201 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2203 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2204 add_number -= S_GET_VALUE (sub_symbolP);
2207 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2208 #if 0 /* Do this even if it's already described as pc-relative. For example,
2209 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2210 pc-relative mode. */
2215 /* Make it pc-relative. */
2216 add_number += (md_pcrel_from (fixP)
2217 - S_GET_VALUE (sub_symbolP));
2224 #ifdef BFD_ASSEMBLER
2225 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2226 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2228 /* Leave it alone. */
2234 sprint_value (buf, fragP->fr_address + where);
2235 as_bad_where (fixP->fx_file, fixP->fx_line,
2236 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2237 segment_name (S_GET_SEGMENT (sub_symbolP)),
2238 S_GET_NAME (sub_symbolP), buf);
2245 if (add_symbol_segment == this_segment_type && pcrel && !plt
2246 && TC_RELOC_RTSYM_LOC_FIXUP (fixP->fx_r_type))
2249 * This fixup was made when the symbol's segment was
2250 * SEG_UNKNOWN, but it is now in the local segment.
2251 * So we know how to do the address without relocation.
2254 /* reloc_callj() may replace a 'call' with a 'calls' or a
2255 'bal', in which cases it modifies *fixP as appropriate.
2256 In the case of a 'calls', no further work is required,
2257 and *fixP has been set up to make the rest of the code
2260 #endif /* TC_I960 */
2262 add_number += S_GET_VALUE (add_symbolP);
2263 add_number -= md_pcrel_from (fixP);
2264 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2266 /* Let the target machine make the final determination
2267 as to whether or not a relocation will be needed to
2268 handle this fixup. */
2269 if (!TC_FORCE_RELOCATION (fixP))
2272 fixP->fx_addsy = NULL;
2277 if (add_symbol_segment == absolute_section)
2280 /* See comment about reloc_callj() above. */
2282 #endif /* TC_I960 */
2283 add_number += S_GET_VALUE (add_symbolP);
2285 /* Let the target machine make the final determination
2286 as to whether or not a relocation will be needed to
2287 handle this fixup. */
2288 if (!TC_FORCE_RELOCATION (fixP))
2290 fixP->fx_addsy = NULL;
2294 else if (add_symbol_segment == undefined_section
2295 #ifdef BFD_ASSEMBLER
2296 || bfd_is_com_section (add_symbol_segment)
2301 if ((int) fixP->fx_bit_fixP == 13)
2303 /* This is a COBR instruction. They have only a
2304 * 13-bit displacement and are only to be used
2305 * for local branches: flag as error, don't generate
2308 as_bad_where (fixP->fx_file, fixP->fx_line,
2309 "can't use COBR format with external label");
2310 fixP->fx_addsy = NULL;
2314 #endif /* TC_I960 */
2318 if (S_IS_COMMON (add_symbolP))
2319 add_number += S_GET_VALUE (add_symbolP);
2320 #endif /* TE_I386AIX */
2321 #endif /* OBJ_COFF */
2327 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2328 add_number += S_GET_VALUE (add_symbolP);
2336 add_number -= md_pcrel_from (fixP);
2337 if (add_symbolP == 0)
2339 #ifndef BFD_ASSEMBLER
2340 fixP->fx_addsy = &abs_symbol;
2342 fixP->fx_addsy = section_symbol (absolute_section);
2344 fixP->fx_addsy->sy_used_in_reloc = 1;
2349 if (!fixP->fx_bit_fixP && size > 0)
2352 if (size < sizeof (mask))
2354 /* set all bits to one */
2356 /* Technically, combining these produces an undefined result
2357 if size is sizeof (valueT), though I think these two
2358 half-way operations should both be defined. And the
2359 compiler should be able to combine them if it's valid on
2360 the host architecture. */
2363 if ((add_number & mask) != 0
2364 && (add_number & mask) != mask)
2366 char buf[50], buf2[50];
2367 sprint_value (buf, fragP->fr_address + where);
2368 if (add_number > 1000)
2369 sprint_value (buf2, add_number);
2371 sprintf (buf2, "%ld", (long) add_number);
2372 as_bad_where (fixP->fx_file, fixP->fx_line,
2373 "Value of %s too large for field of %d bytes at %s",
2375 } /* generic error checking */
2377 #ifdef WARN_SIGNED_OVERFLOW_WORD
2378 /* Warn if a .word value is too large when treated as a signed
2379 number. We already know it is not too negative. This is to
2380 catch over-large switches generated by gcc on the 68k. */
2381 if (!flag_signed_overflow_ok
2383 && add_number > 0x7fff)
2384 as_bad_where (fixP->fx_file, fixP->fx_line,
2385 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2387 (unsigned long) (fragP->fr_address + where));
2389 } /* not a bit fix */
2393 #ifdef MD_APPLY_FIX3
2394 md_apply_fix3 (fixP, &add_number, this_segment_type);
2396 #ifdef BFD_ASSEMBLER
2397 md_apply_fix (fixP, &add_number);
2399 md_apply_fix (fixP, add_number);
2403 #ifndef TC_HANDLES_FX_DONE
2404 /* If the tc-* files haven't been converted, assume it's handling
2405 it the old way, where a null fx_addsy means that the fix has
2406 been applied completely, and no further work is needed. */
2407 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2411 #ifdef TC_VALIDATE_FIX
2415 fprintf (stderr, "result:\n");
2418 } /* For each fixS in this segment. */
2420 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2421 return seg_reloc_count;
2424 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2427 number_to_chars_bigendian (buf, val, n)
2432 if (n > sizeof (val)|| n <= 0)
2436 buf[n] = val & 0xff;
2442 number_to_chars_littleendian (buf, val, n)
2447 if (n > sizeof (val) || n <= 0)
2451 *buf++ = val & 0xff;
2457 extern int indent_level;
2458 extern void print_symbol_value_1 ();
2465 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2467 fprintf (stderr, " pcrel");
2468 if (fixp->fx_pcrel_adjust)
2469 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2470 if (fixp->fx_im_disp)
2473 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2475 fprintf (stderr, " im_disp");
2479 fprintf (stderr, " tcbit");
2481 fprintf (stderr, " done");
2482 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2483 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2484 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2485 #ifdef BFD_ASSEMBLER
2486 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2489 #ifdef NEED_FX_R_TYPE
2490 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2495 fprintf (stderr, "\n +<");
2496 print_symbol_value_1 (stderr, fixp->fx_addsy);
2497 fprintf (stderr, ">");
2501 fprintf (stderr, "\n -<");
2502 print_symbol_value_1 (stderr, fixp->fx_subsy);
2503 fprintf (stderr, ">");
2505 fprintf (stderr, "\n");
2508 /* end of write.c */