1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 94, 1995
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This thing should be set up to do byteordering correctly. But... */
26 #include "output-file.h"
28 /* This looks like a good idea. Let's try turning it on always, for now. */
29 #undef BFD_FAST_SECTION_FILL
30 #define BFD_FAST_SECTION_FILL
32 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
33 instruction so that the disassembler does not choke on it. */
35 #define NOP_OPCODE 0x00
38 #ifndef TC_ADJUST_RELOC_COUNT
39 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
42 #ifndef TC_FORCE_RELOCATION
43 #define TC_FORCE_RELOCATION(FIXP) 0
46 #ifndef WORKING_DOT_WORD
47 extern CONST int md_short_jump_size;
48 extern CONST int md_long_jump_size;
51 int symbol_table_frozen;
52 void print_fixup PARAMS ((fixS *));
55 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
57 /* We generally attach relocs to frag chains. However, after we have
58 chained these all together into a segment, any relocs we add after
59 that must be attached to a segment. This will include relocs added
60 in md_estimate_size_for_relax, for example. */
61 static int frags_chained = 0;
67 struct frag *text_frag_root;
68 struct frag *data_frag_root;
69 struct frag *bss_frag_root;
71 struct frag *text_last_frag; /* Last frag in segment. */
72 struct frag *data_last_frag; /* Last frag in segment. */
73 static struct frag *bss_last_frag; /* Last frag in segment. */
77 static object_headers headers;
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) && !defined (OBJ_VMS))
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;
149 #if defined (TC_I960) || defined (TC_NS32K)
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;
344 fixS fix_dummy, *prev_fix = &fix_dummy;
347 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
349 prev_frag->fr_next = frchp->frch_root;
350 prev_frag = frchp->frch_last;
352 if (frchp->fix_root != (fixS *) NULL)
354 if (seg_info (section)->fix_root == (fixS *) NULL)
355 seg_info (section)->fix_root = frchp->fix_root;
356 prev_fix->fx_next = frchp->fix_root;
357 seg_info (section)->fix_tail = frchp->fix_tail;
358 prev_fix = frchp->fix_tail;
362 prev_frag->fr_next = 0;
371 chain_frchains_together (abfd, section, xxx)
372 bfd *abfd; /* unused */
374 PTR xxx; /* unused */
376 segment_info_type *info;
378 /* BFD may have introduced its own sections without using
379 subseg_new, so it is possible that seg_info is NULL. */
380 info = seg_info (section);
381 if (info != (segment_info_type *) NULL)
382 info->frchainP->frch_last
383 = chain_frchains_together_1 (section, info->frchainP);
385 /* Now that we've chained the frags together, we must add new fixups
386 to the segment, not to the frag chain. */
392 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
395 remove_subsegs (head, seg, root, last)
401 *root = head->frch_root;
402 *last = chain_frchains_together_1 (seg, head);
407 #if defined (BFD_ASSEMBLER) || !defined (BFD)
411 cvt_frag_to_fill (sec, fragP)
416 cvt_frag_to_fill (headersP, fragP)
417 object_headers *headersP;
421 switch (fragP->fr_type)
428 HANDLE_ALIGN (fragP);
430 know (fragP->fr_next != NULL);
431 fragP->fr_offset = (fragP->fr_next->fr_address
433 - fragP->fr_fix) / fragP->fr_var;
434 if (fragP->fr_offset < 0)
436 as_bad ("attempt to .org/.space backwards? (%ld)",
437 (long) fragP->fr_offset);
439 fragP->fr_type = rs_fill;
445 case rs_machine_dependent:
447 md_convert_frag (stdoutput, sec, fragP);
449 md_convert_frag (headersP, fragP);
452 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
455 * After md_convert_frag, we make the frag into a ".space 0".
456 * Md_convert_frag() should set up any fixSs and constants
462 #ifndef WORKING_DOT_WORD
465 struct broken_word *lie;
467 if (fragP->fr_subtype)
469 fragP->fr_fix += md_short_jump_size;
470 for (lie = (struct broken_word *) (fragP->fr_symbol);
471 lie && lie->dispfrag == fragP;
472 lie = lie->next_broken_word)
474 fragP->fr_fix += md_long_jump_size;
482 BAD_CASE (fragP->fr_type);
487 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
491 relax_and_size_seg (abfd, sec, xxx)
498 segment_info_type *seginfo;
500 valueT size, newsize;
502 flags = bfd_get_section_flags (abfd, sec);
504 seginfo = seg_info (sec);
505 if (seginfo && seginfo->frchainP)
507 relax_segment (seginfo->frchainP->frch_root, sec);
508 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
509 cvt_frag_to_fill (sec, fragp);
510 for (fragp = seginfo->frchainP->frch_root;
512 fragp = fragp->fr_next)
513 /* walk to last elt */;
514 size = fragp->fr_address + fragp->fr_fix;
519 if (size > 0 && ! seginfo->bss)
520 flags |= SEC_HAS_CONTENTS;
522 /* @@ This is just an approximation. */
523 if (seginfo && seginfo->fix_root)
527 x = bfd_set_section_flags (abfd, sec, flags);
530 newsize = md_section_align (sec, size);
531 x = bfd_set_section_size (abfd, sec, newsize);
534 /* If the size had to be rounded up, add some padding in the last
536 assert (newsize >= size);
539 fragS *last = seginfo->frchainP->frch_last;
540 fragp = seginfo->frchainP->frch_root;
541 while (fragp->fr_next != last)
542 fragp = fragp->fr_next;
543 last->fr_address = size;
544 fragp->fr_offset += newsize - size;
547 #ifdef tc_frob_section
548 tc_frob_section (sec);
550 #ifdef obj_frob_section
551 obj_frob_section (sec);
557 dump_section_relocs (abfd, sec, stream_)
562 FILE *stream = (FILE *) stream_;
563 segment_info_type *seginfo = seg_info (sec);
564 fixS *fixp = seginfo->fix_root;
569 fprintf (stream, "sec %s relocs:\n", sec->name);
572 symbolS *s = fixp->fx_addsy;
575 fprintf (stream, " %08x: %s(%s", fixp, S_GET_NAME (s),
576 s->bsym->section->name);
577 if (s->bsym->flags & BSF_SECTION_SYM)
579 fprintf (stream, " section sym");
581 fprintf (stream, "+%x", S_GET_VALUE (s));
584 fprintf (stream, "+%x", S_GET_VALUE (s));
585 fprintf (stream, ")+%x\n", fixp->fx_offset);
588 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
589 fixp = fixp->fx_next;
593 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
596 #ifndef EMIT_SECTION_SYMBOLS
597 #define EMIT_SECTION_SYMBOLS 1
601 adjust_reloc_syms (abfd, sec, xxx)
606 segment_info_type *seginfo = seg_info (sec);
612 dump_section_relocs (abfd, sec, stderr);
614 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
617 else if (fixp->fx_addsy)
625 fprintf (stderr, "\n\nadjusting fixup:\n");
629 sym = fixp->fx_addsy;
630 symsec = sym->bsym->section;
632 /* If it's one of these sections, assume the symbol is
633 definitely going to be output. The code in
634 md_estimate_size_before_relax in tc-mips.c uses this test
635 as well, so if you change this code you should look at that
637 if (bfd_is_und_section (symsec)
638 || bfd_is_abs_section (symsec)
639 || bfd_is_com_section (symsec))
641 fixp->fx_addsy->sy_used_in_reloc = 1;
645 /* Since we're reducing to section symbols, don't attempt to reduce
646 anything that's already using one. */
647 if (sym->bsym->flags & BSF_SECTION_SYM)
649 fixp->fx_addsy->sy_used_in_reloc = 1;
653 /* Is there some other reason we can't adjust this one? (E.g.,
654 call/bal links in i960-bout symbols.) */
655 #ifdef obj_fix_adjustable
656 if (! obj_fix_adjustable (fixp))
658 fixp->fx_addsy->sy_used_in_reloc = 1;
663 /* Is there some other (target cpu dependent) reason we can't adjust
664 this one? (E.g. relocations involving function addresses on
666 #ifdef tc_fix_adjustable
667 if (! tc_fix_adjustable (fixp))
669 fixp->fx_addsy->sy_used_in_reloc = 1;
674 /* For PIC support: We may get expressions like
675 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
676 necessarily have had a fixed difference initially. But now
677 it should be a known constant, so we can reduce it. Since
678 we can't easily handle a symbol value that looks like
679 someUndefinedSymbol+const, though, we convert the fixup to
680 access the undefined symbol directly, and discard the
681 intermediate symbol. */
682 if (S_GET_SEGMENT (sym) == expr_section
683 && sym->sy_value.X_op == O_add
684 && (resolve_symbol_value (sym->sy_value.X_add_symbol),
685 S_GET_SEGMENT (sym->sy_value.X_add_symbol) == undefined_section)
686 && (resolve_symbol_value (sym->sy_value.X_op_symbol),
687 S_GET_SEGMENT (sym->sy_value.X_op_symbol) == absolute_section))
689 fixp->fx_offset += S_GET_VALUE (sym->sy_value.X_op_symbol);
690 fixp->fx_offset += sym->sy_value.X_add_number;
691 fixp->fx_addsy = sym->sy_value.X_add_symbol;
695 /* If the section symbol isn't going to be output, the relocs
696 at least should still work. If not, figure out what to do
697 when we run into that case. */
698 fixp->fx_offset += S_GET_VALUE (sym);
699 fixp->fx_addsy = section_symbol (symsec);
700 fixp->fx_addsy->sy_used_in_reloc = 1;
705 #if 1/*def RELOC_REQUIRES_SYMBOL*/
708 /* There was no symbol required by this relocation. However,
709 BFD doesn't really handle relocations without symbols well.
710 (At least, the COFF support doesn't.) So for now we fake up
711 a local symbol in the absolute section. */
713 fixp->fx_addsy = section_symbol (absolute_section);
714 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
718 dump_section_relocs (abfd, sec, stderr);
722 write_relocs (abfd, sec, xxx)
727 segment_info_type *seginfo = seg_info (sec);
734 /* If seginfo is NULL, we did not create this section; don't do
739 fixup_segment (seginfo->fix_root, sec);
742 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
745 #ifndef RELOC_EXPANSION_POSSIBLE
746 /* Set up reloc information as well. */
747 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
748 n * sizeof (arelent *));
749 memset ((char*)relocs, 0, n * sizeof (arelent*));
752 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
755 bfd_reloc_status_type s;
762 reloc = tc_gen_reloc (sec, fixp);
768 if (fixp->fx_where + fixp->fx_size
769 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
772 s = bfd_install_relocation (stdoutput, reloc,
773 fixp->fx_frag->fr_literal,
774 fixp->fx_frag->fr_address,
780 case bfd_reloc_overflow:
781 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
784 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
785 fixp->fx_file, fixp->fx_line);
790 n = n * MAX_RELOC_EXPANSION;
791 /* Set up reloc information as well. */
792 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
793 n * sizeof (arelent *));
796 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
800 bfd_reloc_status_type s;
808 reloc = tc_gen_reloc (sec, fixp);
810 for (j = 0; reloc[j]; j++)
812 relocs[i++] = reloc[j];
815 data = fixp->fx_frag->fr_literal + fixp->fx_where;
816 if (fixp->fx_where + fixp->fx_size
817 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
819 for (j = 0; reloc[j]; j++)
821 s = bfd_install_relocation (stdoutput, reloc[j],
822 fixp->fx_frag->fr_literal,
823 fixp->fx_frag->fr_address,
829 case bfd_reloc_overflow:
830 as_bad_where (fixp->fx_file, fixp->fx_line,
831 "relocation overflow");
834 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
835 fixp->fx_file, fixp->fx_line);
846 sympp = bfd_get_outsymbols (stdoutput);
847 nsyms = bfd_get_symcount (stdoutput);
848 for (i = 0; i < n; i++)
849 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
851 for (j = 0; j < nsyms; j++)
852 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
861 bfd_set_reloc (stdoutput, sec, relocs, n);
863 bfd_set_section_flags (abfd, sec,
864 (bfd_get_section_flags (abfd, sec)
865 & (flagword) ~SEC_RELOC));
872 fprintf (stderr, "relocs for sec %s\n", sec->name);
873 for (i = 0; i < n; i++)
877 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
878 i, r, r->address, s->name, r->addend);
885 write_contents (abfd, sec, xxx)
890 segment_info_type *seginfo = seg_info (sec);
891 unsigned long offset = 0;
894 /* Write out the frags. */
896 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
899 for (f = seginfo->frchainP->frch_root;
904 unsigned long fill_size;
908 assert (f->fr_type == rs_fill);
911 x = bfd_set_section_contents (stdoutput, sec,
912 f->fr_literal, (file_ptr) offset,
913 (bfd_size_type) f->fr_fix);
916 bfd_perror (stdoutput->filename);
917 as_perror ("FATAL: Can't write %s", stdoutput->filename);
922 fill_literal = f->fr_literal + f->fr_fix;
923 fill_size = f->fr_var;
924 count = f->fr_offset;
926 if (fill_size && count)
927 #ifdef BFD_FAST_SECTION_FILL
930 if (fill_size > sizeof(buf)) {
931 /* Do it the old way. Can this ever happen? */
934 x = bfd_set_section_contents (stdoutput, sec,
935 fill_literal, (file_ptr) offset,
936 (bfd_size_type) fill_size);
939 bfd_perror (stdoutput->filename);
940 as_perror ("FATAL: Can't write %s", stdoutput->filename);
947 /* Build a buffer full of fill objects and output it as
948 * often as necessary. This saves on the overhead of potentially
949 * lots of bfd_set_section_contents calls.
954 n_per_buf = sizeof (buf);
955 memset (buf, *fill_literal, n_per_buf);
960 n_per_buf = sizeof(buf)/fill_size;
961 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
962 memcpy(bufp, fill_literal, fill_size);
964 for (; count > 0; count -= n_per_buf)
966 n_per_buf = n_per_buf > count ? count : n_per_buf;
967 x = bfd_set_section_contents (stdoutput, sec,
968 buf, (file_ptr) offset,
969 (bfd_size_type) n_per_buf * fill_size);
971 as_fatal ("Cannot write to output file.");
972 offset += n_per_buf * fill_size;
979 x = bfd_set_section_contents (stdoutput, sec,
980 fill_literal, (file_ptr) offset,
981 (bfd_size_type) fill_size);
983 as_fatal ("Cannot write to output file.");
991 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
993 merge_data_into_text ()
995 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
996 seg_info (text_section)->frchainP->frch_last->fr_next =
997 seg_info (data_section)->frchainP->frch_root;
998 seg_info (text_section)->frchainP->frch_last =
999 seg_info (data_section)->frchainP->frch_last;
1000 seg_info (data_section)->frchainP = 0;
1004 text_last_frag->fr_next = data_frag_root;
1005 text_last_frag = data_last_frag;
1006 data_last_frag = NULL;
1007 data_frag_root = NULL;
1010 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1011 tmp->fx_next = data_fix_root;
1012 text_fix_tail = data_fix_tail;
1015 text_fix_root = data_fix_root;
1016 data_fix_root = NULL;
1019 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1021 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1023 relax_and_size_all_segments ()
1027 relax_segment (text_frag_root, SEG_TEXT);
1028 relax_segment (data_frag_root, SEG_DATA);
1029 relax_segment (bss_frag_root, SEG_BSS);
1031 * Now the addresses of frags are correct within the segment.
1034 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1035 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1036 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1039 * Join the 2 segments into 1 huge segment.
1040 * To do this, re-compute every rn_address in the SEG_DATA frags.
1041 * Then join the data frags after the text frags.
1043 * Determine a_data [length of data segment].
1047 register relax_addressT slide;
1049 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
1051 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1052 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1053 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1055 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1056 /* For b.out: If the data section has a strict alignment
1057 requirement, its load address in the .o file will be
1058 rounded up from the size of the text section. These
1059 two values are *not* the same! Similarly for the bss
1061 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1064 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1066 fragP->fr_address += slide;
1067 } /* for each data frag */
1069 know (text_last_frag != 0);
1070 text_last_frag->fr_next = data_frag_root;
1074 H_SET_DATA_SIZE (&headers, 0);
1078 /* See above comments on b.out data section address. */
1081 if (data_last_frag == 0)
1082 bss_vma = H_GET_TEXT_SIZE (&headers);
1084 bss_vma = data_last_frag->fr_address;
1085 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1086 bss_address_frag.fr_address = bss_vma;
1088 #else /* ! OBJ_BOUT */
1089 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1090 H_GET_DATA_SIZE (&headers));
1092 #endif /* ! OBJ_BOUT */
1094 /* Slide all the frags */
1097 relax_addressT slide = bss_address_frag.fr_address;
1099 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1101 fragP->fr_address += slide;
1102 } /* for each bss frag */
1106 H_SET_BSS_SIZE (&headers,
1107 bss_last_frag->fr_address - bss_frag_root->fr_address);
1109 H_SET_BSS_SIZE (&headers, 0);
1111 #endif /* ! BFD_ASSEMBLER && ! BFD */
1113 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1115 #ifdef BFD_ASSEMBLER
1123 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1125 /* Count symbols. We can't rely on a count made by the loop in
1126 write_object_file, because *_frob_file may add a new symbol or
1129 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1136 asympp = (asymbol **) bfd_alloc (stdoutput,
1137 nsyms * sizeof (asymbol *));
1138 symp = symbol_rootP;
1139 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1141 asympp[i] = symp->bsym;
1147 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1148 assert (result == true);
1149 symbol_table_frozen = 1;
1154 write_object_file ()
1156 struct frchain *frchainP; /* Track along all frchains. */
1157 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1158 fragS *fragP; /* Track along all frags. */
1161 /* Do we really want to write it? */
1163 int n_warns, n_errs;
1164 n_warns = had_warnings ();
1165 n_errs = had_errors ();
1166 /* The -Z flag indicates that an object file should be generated,
1167 regardless of warnings and errors. */
1168 if (flag_always_generate_output)
1170 if (n_warns || n_errs)
1171 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1172 n_errs, n_errs == 1 ? "" : "s",
1173 n_warns, n_warns == 1 ? "" : "s");
1178 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1179 n_errs, n_errs == 1 ? "" : "s",
1180 n_warns, n_warns == 1 ? "" : "s");
1185 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1186 a routine to check for the definition of the procedure "_main",
1187 and if so -- fix it up so that it can be program entry point. */
1188 vms_check_for_main ();
1189 #endif /* OBJ_VMS */
1191 /* After every sub-segment, we fake an ".align ...". This conforms to
1192 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1193 frag that requires least thought. ".align" frags like to have a
1194 following frag since that makes calculating their intended length
1197 @@ Is this really necessary?? */
1198 #ifndef SUB_SEGMENT_ALIGN
1199 #ifdef BFD_ASSEMBLER
1200 #define SUB_SEGMENT_ALIGN(SEG) (0)
1202 #define SUB_SEGMENT_ALIGN(SEG) (2)
1205 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1207 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1208 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1209 /* frag_align will have left a new frag.
1210 Use this last frag for an empty ".fill".
1212 For this segment ...
1213 Create a last frag. Do not leave a "being filled in frag". */
1214 frag_wane (frag_now);
1215 frag_now->fr_fix = 0;
1216 know (frag_now->fr_next == NULL);
1219 /* From now on, we don't care about sub-segments. Build one frag chain
1220 for each segment. Linked thru fr_next. */
1222 #ifdef BFD_ASSEMBLER
1223 /* Remove the sections created by gas for its own purposes. */
1225 asection **seclist, *sec;
1228 seclist = &stdoutput->sections;
1229 while (seclist && *seclist)
1232 while (sec == reg_section || sec == expr_section)
1236 stdoutput->section_count--;
1241 seclist = &(*seclist)->next;
1244 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1247 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1249 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1250 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1251 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1254 /* We have two segments. If user gave -R flag, then we must put the
1255 data frags into the text segment. Do this before relaxing so
1256 we know to take advantage of -R and make shorter addresses. */
1257 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1258 if (flag_readonly_data_in_text)
1260 merge_data_into_text ();
1264 #ifdef BFD_ASSEMBLER
1265 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1267 relax_and_size_all_segments ();
1268 #endif /* BFD_ASSEMBLER */
1270 #ifndef BFD_ASSEMBLER
1273 * Crawl the symbol chain.
1275 * For each symbol whose value depends on a frag, take the address of
1276 * that frag and subsume it into the value of the symbol.
1277 * After this, there is just one way to lookup a symbol value.
1278 * Values are left in their final state for object file emission.
1279 * We adjust the values of 'L' local symbols, even if we do
1280 * not intend to emit them to the object file, because their values
1281 * are needed for fix-ups.
1283 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1284 * from the symbol chain. (They are still pointed to by the fixes.)
1286 * Count the remaining symbols.
1287 * Assign a symbol number to each symbol.
1288 * Count the number of string-table chars we will emit.
1289 * Put this info into the headers as appropriate.
1292 know (zero_address_frag.fr_address == 0);
1293 string_byte_count = sizeof (string_byte_count);
1295 obj_crawl_symbol_chain (&headers);
1297 if (string_byte_count == sizeof (string_byte_count))
1298 string_byte_count = 0;
1300 H_SET_STRING_SIZE (&headers, string_byte_count);
1303 * Addresses of frags now reflect addresses we use in the object file.
1304 * Symbol values are correct.
1305 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1306 * Also converting any machine-dependent frags using md_convert_frag();
1308 subseg_change (SEG_TEXT, 0);
1310 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1312 cvt_frag_to_fill (&headers, fragP);
1314 /* Some assert macros don't work with # directives mixed in. */
1316 if (!(fragP->fr_next == NULL
1318 || fragP->fr_next == data_frag_root
1320 || ((fragP->fr_next->fr_address - fragP->fr_address)
1321 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1325 #endif /* ! BFD_ASSEMBLER */
1327 #ifndef WORKING_DOT_WORD
1329 struct broken_word *lie;
1330 struct broken_word **prevP;
1332 prevP = &broken_words;
1333 for (lie = broken_words; lie; lie = lie->next_broken_word)
1338 exp.X_op = O_subtract;
1339 exp.X_add_symbol = lie->add;
1340 exp.X_op_symbol = lie->sub;
1341 exp.X_add_number = lie->addnum;
1342 #ifdef BFD_ASSEMBLER
1343 #ifdef TC_CONS_FIX_NEW
1344 TC_CONS_FIX_NEW (lie->frag,
1345 lie->word_goes_here - lie->frag->fr_literal,
1348 fix_new_exp (lie->frag,
1349 lie->word_goes_here - lie->frag->fr_literal,
1350 2, &exp, 0, BFD_RELOC_NONE);
1353 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1354 fix_new_exp (lie->frag,
1355 lie->word_goes_here - lie->frag->fr_literal,
1356 2, &exp, 0, NO_RELOC);
1359 fix_new_ns32k_exp (lie->frag,
1360 lie->word_goes_here - lie->frag->fr_literal,
1361 2, &exp, 0, 0, 2, 0, 0);
1363 fix_new_exp (lie->frag,
1364 lie->word_goes_here - lie->frag->fr_literal,
1366 #endif /* TC_NS32K */
1367 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1368 #endif /* BFD_ASSEMBLER */
1369 *prevP = lie->next_broken_word;
1372 prevP = &(lie->next_broken_word);
1374 for (lie = broken_words; lie;)
1376 struct broken_word *untruth;
1378 addressT table_addr;
1379 addressT from_addr, to_addr;
1382 fragP = lie->dispfrag;
1384 /* Find out how many broken_words go here. */
1386 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1387 if (untruth->added == 1)
1390 table_ptr = lie->dispfrag->fr_opcode;
1391 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1392 /* Create the jump around the long jumps. This is a short
1393 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1394 from_addr = table_addr;
1395 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1396 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1397 table_ptr += md_short_jump_size;
1398 table_addr += md_short_jump_size;
1400 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1402 if (lie->added == 2)
1404 /* Patch the jump table */
1405 /* This is the offset from ??? to table_ptr+0 */
1406 to_addr = table_addr - S_GET_VALUE (lie->sub);
1407 #ifdef BFD_ASSEMBLER
1408 to_addr -= lie->sub->sy_frag->fr_address;
1410 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1411 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1413 if (untruth->use_jump == lie)
1414 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1417 /* Install the long jump */
1418 /* this is a long jump from table_ptr+0 to the final target */
1419 from_addr = table_addr;
1420 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1421 #ifdef BFD_ASSEMBLER
1422 to_addr += lie->add->sy_frag->fr_address;
1424 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1425 table_ptr += md_long_jump_size;
1426 table_addr += md_long_jump_size;
1430 #endif /* not WORKING_DOT_WORD */
1432 #ifndef BFD_ASSEMBLER
1435 char *the_object_file;
1436 long object_file_size;
1438 * Scan every FixS performing fixups. We had to wait until now to do
1439 * this because md_convert_frag() may have made some fixSs.
1443 subseg_change (SEG_TEXT, 0);
1444 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1445 subseg_change (SEG_DATA, 0);
1446 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1447 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1449 /* FIXME move this stuff into the pre-write-hook */
1450 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1451 H_SET_ENTRY_POINT (&headers, 0);
1453 obj_pre_write_hook (&headers); /* extra coff stuff */
1455 object_file_size = H_GET_FILE_SIZE (&headers);
1456 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1458 output_file_create (out_file_name);
1460 obj_header_append (&next_object_file_charP, &headers);
1462 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1467 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1469 register long count;
1470 register char *fill_literal;
1471 register long fill_size;
1474 know (fragP->fr_type == rs_fill);
1475 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1476 fill_literal = fragP->fr_literal + fragP->fr_fix;
1477 fill_size = fragP->fr_var;
1478 know (fragP->fr_offset >= 0);
1480 for (count = fragP->fr_offset; count; count--)
1482 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1485 } /* for each code frag. */
1487 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1492 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1493 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)));
1495 /* Make addresses in data relocation directives relative to beginning of
1496 * first data fragment, not end of last text fragment: alignment of the
1497 * start of the data segment may place a gap between the segments.
1499 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1501 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1502 #endif /* TC_I960 */
1504 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)));
1507 * Emit line number entries.
1509 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1510 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)));
1515 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1516 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)));
1522 if (string_byte_count > 0)
1524 obj_emit_strings (&next_object_file_charP);
1525 } /* only if we have a string table */
1528 bfd_seek (stdoutput, 0, 0);
1529 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1532 /* Write the data to the file */
1533 output_file_append (the_object_file, object_file_size, out_file_name);
1534 free (the_object_file);
1536 } /* non vms output */
1539 * Now do the VMS-dependent part of writing the object file
1541 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1542 H_GET_DATA_SIZE (&headers),
1543 H_GET_BSS_SIZE (&headers),
1544 text_frag_root, data_frag_root);
1545 #endif /* OBJ_VMS */
1546 #else /* BFD_ASSEMBLER */
1548 /* Resolve symbol values. This needs to be done before processing
1554 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1555 if (!symp->sy_resolved)
1556 resolve_symbol_value (symp);
1561 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1563 /* Set up symbol table, and write it out. */
1568 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1573 name = S_GET_NAME (symp);
1576 const char *name2 = decode_local_label_name ((char *)S_GET_NAME (symp));
1577 /* They only differ if `name' is a fb or dollar local
1579 if (name2 != name && ! S_IS_DEFINED (symp))
1580 as_bad ("local label %s is not defined", name2);
1583 /* Do it again, because adjust_reloc_syms might introduce
1584 more symbols. They'll probably only be section symbols,
1585 but they'll still need to have the values computed. */
1586 if (! symp->sy_resolved)
1588 if (symp->sy_value.X_op == O_constant)
1590 /* This is the normal case; skip the call. */
1593 + symp->sy_frag->fr_address));
1594 symp->sy_resolved = 1;
1597 resolve_symbol_value (symp);
1600 /* So far, common symbols have been treated like undefined symbols.
1601 Put them in the common section now. */
1602 if (S_IS_DEFINED (symp) == 0
1603 && S_GET_VALUE (symp) != 0)
1604 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1606 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1607 S_GET_NAME (symp), symp,
1610 segment_name (symp->bsym->section));
1613 #ifdef obj_frob_symbol
1614 obj_frob_symbol (symp, punt);
1616 #ifdef tc_frob_symbol
1617 if (! punt || symp->sy_used_in_reloc)
1618 tc_frob_symbol (symp, punt);
1621 /* If we don't want to keep this symbol, splice it out of
1622 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1623 want section symbols. Otherwise, we skip local symbols
1624 and symbols that the frob_symbol macros told us to punt,
1625 but we keep such symbols if they are used in relocs. */
1626 if ((! EMIT_SECTION_SYMBOLS
1627 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1628 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1629 opposites. Sometimes the former checks flags and the
1630 latter examines the name... */
1631 || (!S_IS_EXTERN (symp)
1632 && (S_IS_LOCAL (symp) || punt)
1633 && ! symp->sy_used_in_reloc))
1635 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1636 /* After symbol_remove, symbol_next(symp) still returns
1637 the one that came after it in the chain. So we don't
1638 need to do any extra cleanup work here. */
1643 /* Make sure we really got a value for the symbol. */
1644 if (! symp->sy_resolved)
1646 as_bad ("can't resolve value for symbol \"%s\"",
1648 symp->sy_resolved = 1;
1651 /* Set the value into the BFD symbol. Up til now the value
1652 has only been kept in the gas symbolS struct. */
1653 symp->bsym->value = S_GET_VALUE (symp);
1659 /* Now do any format-specific adjustments to the symbol table, such
1660 as adding file symbols. */
1661 #ifdef obj_adjust_symtab
1662 obj_adjust_symtab ();
1665 /* Now that all the sizes are known, and contents correct, we can
1666 start writing to the file. */
1669 /* If *_frob_file changes the symbol value at this point, it is
1670 responsible for moving the changed value into symp->bsym->value
1671 as well. Hopefully all symbol value changing can be done in
1676 #ifdef obj_frob_file
1680 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1682 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1683 #endif /* BFD_ASSEMBLER */
1690 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1695 * After this, all frags in this segment have addresses that are correct
1696 * within the segment. Since segments live in different file addresses,
1697 * these frag addresses may not be the same as final object-file addresses.
1700 #ifndef md_relax_frag
1702 /* Subroutines of relax_segment. */
1708 for (; f1; f1 = f1->fr_next)
1709 if (f1->fr_next == f2)
1714 #endif /* ! defined (md_relax_frag) */
1716 /* Relax_align. Advance location counter to next address that has 'alignment'
1717 lowest order bits all 0s, return size of adjustment made. */
1718 static relax_addressT
1719 relax_align (address, alignment)
1720 register relax_addressT address; /* Address now. */
1721 register int alignment; /* Alignment (binary). */
1723 relax_addressT mask;
1724 relax_addressT new_address;
1726 mask = ~((~0) << alignment);
1727 new_address = (address + mask) & (~mask);
1729 /* We must provide lots of padding, so the linker can discard it
1730 when needed. The linker will not add extra space, ever. */
1731 new_address += (1 << alignment);
1732 return (new_address - address);
1736 relax_segment (segment_frag_root, segment)
1737 struct frag *segment_frag_root;
1740 register struct frag *fragP;
1741 register relax_addressT address;
1742 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1743 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1745 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1746 subseg_change (segment, 0);
1748 /* For each frag in segment: count and store (a 1st guess of)
1751 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1753 fragP->fr_address = address;
1754 address += fragP->fr_fix;
1756 switch (fragP->fr_type)
1759 address += fragP->fr_offset * fragP->fr_var;
1765 int offset = relax_align (address, (int) fragP->fr_offset);
1766 if (offset % fragP->fr_var != 0)
1768 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1769 offset, (long) fragP->fr_var);
1770 offset -= (offset % fragP->fr_var);
1778 /* Assume .org is nugatory. It will grow with 1st relax. */
1781 case rs_machine_dependent:
1782 address += md_estimate_size_before_relax (fragP, segment);
1785 #ifndef WORKING_DOT_WORD
1786 /* Broken words don't concern us yet */
1787 case rs_broken_word:
1792 BAD_CASE (fragP->fr_type);
1794 } /* switch(fr_type) */
1795 } /* for each frag in the segment */
1799 long stretch; /* May be any size, 0 or negative. */
1800 /* Cumulative number of addresses we have */
1801 /* relaxed this pass. */
1802 /* We may have relaxed more than one address. */
1803 long stretched; /* Have we stretched on this pass? */
1804 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1805 grew, and another shrank. If a branch instruction doesn't fit anymore,
1806 we could be scrod. */
1810 stretch = stretched = 0;
1811 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1814 unsigned long was_address;
1820 was_address = fragP->fr_address;
1821 address = fragP->fr_address += stretch;
1822 symbolP = fragP->fr_symbol;
1823 offset = fragP->fr_offset;
1825 switch (fragP->fr_type)
1827 case rs_fill: /* .fill never relaxes. */
1831 #ifndef WORKING_DOT_WORD
1832 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1833 for it I do not want to write it. I do not want to have
1834 anything to do with it. This is not the proper way to
1835 implement this misfeature. */
1836 case rs_broken_word:
1838 struct broken_word *lie;
1839 struct broken_word *untruth;
1841 /* Yes this is ugly (storing the broken_word pointer
1842 in the symbol slot). Still, this whole chunk of
1843 code is ugly, and I don't feel like doing anything
1844 about it. Think of it as stubbornness in action. */
1846 for (lie = (struct broken_word *) (fragP->fr_symbol);
1847 lie && lie->dispfrag == fragP;
1848 lie = lie->next_broken_word)
1854 offset = (lie->add->sy_frag->fr_address
1855 + S_GET_VALUE (lie->add)
1857 - (lie->sub->sy_frag->fr_address
1858 + S_GET_VALUE (lie->sub)));
1859 if (offset <= -32768 || offset >= 32767)
1861 if (flag_warn_displacement)
1864 sprint_value (buf, (addressT) lie->addnum);
1865 as_warn (".word %s-%s+%s didn't fit",
1866 S_GET_NAME (lie->add),
1867 S_GET_NAME (lie->sub),
1871 if (fragP->fr_subtype == 0)
1873 fragP->fr_subtype++;
1874 growth += md_short_jump_size;
1876 for (untruth = lie->next_broken_word;
1877 untruth && untruth->dispfrag == lie->dispfrag;
1878 untruth = untruth->next_broken_word)
1879 if ((untruth->add->sy_frag == lie->add->sy_frag)
1880 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1883 untruth->use_jump = lie;
1885 growth += md_long_jump_size;
1890 } /* case rs_broken_word */
1894 growth = (relax_align ((relax_addressT) (address
1897 - relax_align ((relax_addressT) (was_address
1907 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1908 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1909 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1910 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1911 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1912 know (symbolP->sy_frag);
1913 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1914 || (symbolP->sy_frag == &zero_address_frag));
1916 target += S_GET_VALUE (symbolP)
1917 + symbolP->sy_frag->fr_address;
1918 } /* if we have a symbol */
1920 know (fragP->fr_next);
1921 after = fragP->fr_next->fr_address;
1922 growth = target - after;
1925 /* Growth may be negative, but variable part of frag
1926 cannot have fewer than 0 chars. That is, we can't
1928 as_bad ("attempt to .org backwards ignored");
1932 growth -= stretch; /* This is an absolute growth factor */
1938 growth = S_GET_VALUE (symbolP);
1939 if (symbolP->sy_frag != &zero_address_frag)
1940 as_bad (".space specifies non-absolute value");
1941 fragP->fr_symbol = 0;
1944 as_warn (".space or .fill with negative value, ignored");
1952 case rs_machine_dependent:
1953 #ifdef md_relax_frag
1954 growth = md_relax_frag (fragP, stretch);
1956 #ifdef TC_GENERIC_RELAX_TABLE
1957 /* The default way to relax a frag is to look through
1960 const relax_typeS *this_type;
1961 const relax_typeS *start_type;
1962 relax_substateT next_state;
1963 relax_substateT this_state;
1965 const relax_typeS *table = TC_GENERIC_RELAX_TABLE;
1967 this_state = fragP->fr_subtype;
1968 start_type = this_type = table + this_state;
1973 #ifndef DIFF_EXPR_OK
1974 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1975 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1976 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1977 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1978 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1980 know (symbolP->sy_frag);
1982 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1983 || symbolP->sy_frag == &zero_address_frag);
1985 S_GET_VALUE (symbolP)
1986 + symbolP->sy_frag->fr_address;
1988 /* If frag has yet to be reached on this pass,
1989 assume it will move by STRETCH just as we did.
1990 If this is not so, it will be because some frag
1991 between grows, and that will force another pass.
1993 Beware zero-length frags.
1995 There should be a faster way to do this. */
1997 if (symbolP->sy_frag->fr_address >= was_address
1998 && is_dnrange (fragP, symbolP->sy_frag))
2004 aim = target - address - fragP->fr_fix;
2005 #ifdef TC_PCREL_ADJUST
2006 /* Currently only the ns32k family needs this */
2007 aim += TC_PCREL_ADJUST(fragP);
2009 /* This machine doesn't want to use pcrel_adjust.
2010 In that case, pcrel_adjust should be zero. */
2011 assert (fragP->fr_pcrel_adjust == 0);
2016 /* Look backwards. */
2017 for (next_state = this_type->rlx_more; next_state;)
2018 if (aim >= this_type->rlx_backward)
2022 /* Grow to next state. */
2023 this_state = next_state;
2024 this_type = table + this_state;
2025 next_state = this_type->rlx_more;
2030 #ifdef M68K_AIM_KLUDGE
2031 M68K_AIM_KLUDGE (aim, this_state, this_type);
2033 /* Look forwards. */
2034 for (next_state = this_type->rlx_more; next_state;)
2035 if (aim <= this_type->rlx_forward)
2039 /* Grow to next state. */
2040 this_state = next_state;
2041 this_type = table + this_state;
2042 next_state = this_type->rlx_more;
2046 growth = this_type->rlx_length - start_type->rlx_length;
2048 fragP->fr_subtype = this_state;
2050 #endif /* TC_GENERIC_RELAX_TABLE */
2055 BAD_CASE (fragP->fr_type);
2063 } /* For each frag in the segment. */
2065 while (stretched); /* Until nothing further to relax. */
2069 * We now have valid fr_address'es for each frag.
2073 * All fr_address's are correct, relative to their own segment.
2074 * We have made all the fixS we will ever make.
2076 } /* relax_segment() */
2078 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2080 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2081 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2086 Go through all the fixS's in a segment and see which ones can be
2087 handled now. (These consist of fixS where we have since discovered
2088 the value of a symbol, or the address of the frag involved.)
2089 For each one, call md_apply_fix to put the fix into the frag data.
2091 Result is a count of how many relocation structs will be needed to
2092 handle the remaining fixS's that we couldn't completely handle here.
2093 These will be output later by emit_relocations(). */
2096 fixup_segment (fixP, this_segment_type)
2097 register fixS *fixP;
2098 segT this_segment_type; /* N_TYPE bits for segment. */
2100 long seg_reloc_count = 0;
2101 symbolS *add_symbolP;
2102 symbolS *sub_symbolP;
2109 segT add_symbol_segment = absolute_section;
2111 /* If the linker is doing the relaxing, we must not do any fixups.
2113 Well, strictly speaking that's not true -- we could do any that are
2114 PC-relative and don't cross regions that could change size. And for the
2115 i960 (the only machine for which we've got a relaxing linker right now),
2116 we might be able to turn callx/callj into bal anyways in cases where we
2117 know the maximum displacement. */
2120 for (; fixP; fixP = fixP->fx_next)
2122 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2123 return seg_reloc_count;
2126 for (; fixP; fixP = fixP->fx_next)
2129 fprintf (stderr, "\nprocessing fixup:\n");
2133 fragP = fixP->fx_frag;
2135 where = fixP->fx_where;
2136 place = fragP->fr_literal + where;
2137 size = fixP->fx_size;
2138 add_symbolP = fixP->fx_addsy;
2139 #ifdef TC_VALIDATE_FIX
2140 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2142 sub_symbolP = fixP->fx_subsy;
2143 add_number = fixP->fx_offset;
2144 pcrel = fixP->fx_pcrel;
2148 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2155 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2156 add_number -= S_GET_VALUE (sub_symbolP);
2158 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2160 /* Should try converting to a constant. */
2165 as_bad_where (fixP->fx_file, fixP->fx_line,
2166 "Negative of non-absolute symbol %s",
2167 S_GET_NAME (sub_symbolP));
2169 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
2170 && (SEG_NORMAL (add_symbol_segment)
2171 || (add_symbol_segment == absolute_section)))
2173 /* Difference of 2 symbols from same segment.
2174 Can't make difference of 2 undefineds: 'value' means
2175 something different for N_UNDF. */
2177 /* Makes no sense to use the difference of 2 arbitrary symbols
2178 as the target of a call instruction. */
2180 as_bad_where (fixP->fx_file, fixP->fx_line,
2181 "callj to difference of 2 symbols");
2182 #endif /* TC_I960 */
2183 add_number += S_GET_VALUE (add_symbolP) -
2184 S_GET_VALUE (sub_symbolP);
2187 pcrel = 0; /* No further pcrel processing. */
2189 /* Let the target machine make the final determination
2190 as to whether or not a relocation will be needed to
2191 handle this fixup. */
2192 if (!TC_FORCE_RELOCATION (fixP))
2195 fixP->fx_addsy = NULL;
2200 /* Different segments in subtraction. */
2201 know (!(S_IS_EXTERNAL (sub_symbolP)
2202 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2204 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2205 add_number -= S_GET_VALUE (sub_symbolP);
2208 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
2209 #if 0 /* Do this even if it's already described as pc-relative. For example,
2210 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2211 pc-relative mode. */
2216 /* Make it pc-relative. */
2217 add_number += (md_pcrel_from (fixP)
2218 - S_GET_VALUE (sub_symbolP));
2225 #ifdef BFD_ASSEMBLER
2226 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2227 || fixP->fx_r_type == BFD_RELOC_GPREL16)
2229 /* Leave it alone. */
2235 sprint_value (buf, fragP->fr_address + where);
2236 as_bad_where (fixP->fx_file, fixP->fx_line,
2237 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2238 segment_name (S_GET_SEGMENT (sub_symbolP)),
2239 S_GET_NAME (sub_symbolP), buf);
2246 if (add_symbol_segment == this_segment_type && pcrel && !plt
2247 && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2250 * This fixup was made when the symbol's segment was
2251 * SEG_UNKNOWN, but it is now in the local segment.
2252 * So we know how to do the address without relocation.
2255 /* reloc_callj() may replace a 'call' with a 'calls' or a
2256 'bal', in which cases it modifies *fixP as appropriate.
2257 In the case of a 'calls', no further work is required,
2258 and *fixP has been set up to make the rest of the code
2261 #endif /* TC_I960 */
2263 add_number += S_GET_VALUE (add_symbolP);
2264 add_number -= md_pcrel_from (fixP);
2265 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2267 /* Let the target machine make the final determination
2268 as to whether or not a relocation will be needed to
2269 handle this fixup. */
2270 if (!TC_FORCE_RELOCATION (fixP))
2273 fixP->fx_addsy = NULL;
2278 if (add_symbol_segment == absolute_section)
2281 /* See comment about reloc_callj() above. */
2283 #endif /* TC_I960 */
2284 add_number += S_GET_VALUE (add_symbolP);
2286 /* Let the target machine make the final determination
2287 as to whether or not a relocation will be needed to
2288 handle this fixup. */
2289 if (!TC_FORCE_RELOCATION (fixP))
2291 fixP->fx_addsy = NULL;
2295 else if (add_symbol_segment == undefined_section
2296 #ifdef BFD_ASSEMBLER
2297 || bfd_is_com_section (add_symbol_segment)
2302 if ((int) fixP->fx_bit_fixP == 13)
2304 /* This is a COBR instruction. They have only a
2305 * 13-bit displacement and are only to be used
2306 * for local branches: flag as error, don't generate
2309 as_bad_where (fixP->fx_file, fixP->fx_line,
2310 "can't use COBR format with external label");
2311 fixP->fx_addsy = NULL;
2315 #endif /* TC_I960 */
2319 if (S_IS_COMMON (add_symbolP))
2320 add_number += S_GET_VALUE (add_symbolP);
2321 #endif /* TE_I386AIX */
2322 #endif /* OBJ_COFF */
2328 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2329 add_number += S_GET_VALUE (add_symbolP);
2337 add_number -= md_pcrel_from (fixP);
2338 if (add_symbolP == 0)
2340 #ifndef BFD_ASSEMBLER
2341 fixP->fx_addsy = &abs_symbol;
2343 fixP->fx_addsy = section_symbol (absolute_section);
2345 fixP->fx_addsy->sy_used_in_reloc = 1;
2350 if (!fixP->fx_bit_fixP && size > 0)
2353 if (size < sizeof (mask))
2355 /* set all bits to one */
2357 /* Technically, combining these produces an undefined result
2358 if size is sizeof (valueT), though I think these two
2359 half-way operations should both be defined. And the
2360 compiler should be able to combine them if it's valid on
2361 the host architecture. */
2364 if ((add_number & mask) != 0
2365 && (add_number & mask) != mask)
2367 char buf[50], buf2[50];
2368 sprint_value (buf, fragP->fr_address + where);
2369 if (add_number > 1000)
2370 sprint_value (buf2, add_number);
2372 sprintf (buf2, "%ld", (long) add_number);
2373 as_bad_where (fixP->fx_file, fixP->fx_line,
2374 "Value of %s too large for field of %d bytes at %s",
2376 } /* generic error checking */
2378 #ifdef WARN_SIGNED_OVERFLOW_WORD
2379 /* Warn if a .word value is too large when treated as a signed
2380 number. We already know it is not too negative. This is to
2381 catch over-large switches generated by gcc on the 68k. */
2382 if (!flag_signed_overflow_ok
2384 && add_number > 0x7fff)
2385 as_bad_where (fixP->fx_file, fixP->fx_line,
2386 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2388 (unsigned long) (fragP->fr_address + where));
2390 } /* not a bit fix */
2394 #ifdef MD_APPLY_FIX3
2395 md_apply_fix3 (fixP, &add_number, this_segment_type);
2397 #ifdef BFD_ASSEMBLER
2398 md_apply_fix (fixP, &add_number);
2400 md_apply_fix (fixP, add_number);
2404 #ifndef TC_HANDLES_FX_DONE
2405 /* If the tc-* files haven't been converted, assume it's handling
2406 it the old way, where a null fx_addsy means that the fix has
2407 been applied completely, and no further work is needed. */
2408 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2412 #ifdef TC_VALIDATE_FIX
2416 fprintf (stderr, "result:\n");
2419 } /* For each fixS in this segment. */
2421 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2422 return seg_reloc_count;
2425 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2428 number_to_chars_bigendian (buf, val, n)
2433 if (n > sizeof (val)|| n <= 0)
2437 buf[n] = val & 0xff;
2443 number_to_chars_littleendian (buf, val, n)
2448 if (n > sizeof (val) || n <= 0)
2452 *buf++ = val & 0xff;
2458 extern int indent_level;
2459 extern void print_symbol_value_1 ();
2466 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2468 fprintf (stderr, " pcrel");
2469 if (fixp->fx_pcrel_adjust)
2470 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2471 if (fixp->fx_im_disp)
2474 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2476 fprintf (stderr, " im_disp");
2480 fprintf (stderr, " tcbit");
2482 fprintf (stderr, " done");
2483 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2484 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2485 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2486 #ifdef BFD_ASSEMBLER
2487 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2490 #ifdef NEED_FX_R_TYPE
2491 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2496 fprintf (stderr, "\n +<");
2497 print_symbol_value_1 (stderr, fixp->fx_addsy);
2498 fprintf (stderr, ">");
2502 fprintf (stderr, "\n -<");
2503 print_symbol_value_1 (stderr, fixp->fx_subsy);
2504 fprintf (stderr, ">");
2506 fprintf (stderr, "\n");
2509 /* end of write.c */