1 /* write.c - emit .o file
2 Copyright (C) 1986, 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This thing should be set up to do byteordering correctly. But... */
25 #include "output-file.h"
27 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
28 instruction so that the disassembler does not choke on it. */
30 #define NOP_OPCODE 0x00
33 #ifndef TC_FORCE_RELOCATION
34 #define TC_FORCE_RELOCATION(FIXP) 0
37 #ifndef WORKING_DOT_WORD
38 extern CONST int md_short_jump_size;
39 extern CONST int md_long_jump_size;
45 struct frag *text_frag_root;
46 struct frag *data_frag_root;
47 struct frag *bss_frag_root;
49 struct frag *text_last_frag; /* Last frag in segment. */
50 struct frag *data_last_frag; /* Last frag in segment. */
51 static struct frag *bss_last_frag; /* Last frag in segment. */
54 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
55 static object_headers headers;
56 static char *the_object_file;
59 long string_byte_count;
60 char *next_object_file_charP; /* Tracks object file bytes. */
63 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
66 #endif /* BFD_ASSEMBLER */
69 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
70 symbolS *add, symbolS *sub,
71 offsetT offset, int pcrel,
72 bfd_reloc_code_real_type r_type));
74 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
75 symbolS *add, symbolS *sub,
76 offsetT offset, int pcrel,
79 #if defined (BFD_ASSEMBLER) || !defined (BFD)
80 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
82 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
87 * Create a fixS in obstack 'notes'.
90 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
92 fragS *frag; /* Which frag? */
93 int where; /* Where in that frag? */
94 int size; /* 1, 2, or 4 usually. */
95 symbolS *add_symbol; /* X_add_symbol. */
96 symbolS *sub_symbol; /* X_op_symbol. */
97 offsetT offset; /* X_add_number. */
98 int pcrel; /* TRUE if PC-relative relocation. */
100 bfd_reloc_code_real_type r_type; /* Relocation type */
102 int r_type; /* Relocation type */
107 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
109 fixP->fx_frag = frag;
110 fixP->fx_where = where;
111 fixP->fx_size = size;
112 fixP->fx_addsy = add_symbol;
113 fixP->fx_subsy = sub_symbol;
114 fixP->fx_offset = offset;
115 fixP->fx_pcrel = pcrel;
116 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
117 fixP->fx_r_type = r_type;
119 fixP->fx_im_disp = 0;
120 fixP->fx_pcrel_adjust = 0;
121 fixP->fx_bit_fixP = 0;
122 fixP->fx_addnumber = 0;
123 fixP->tc_fix_data = NULL;
130 as_where (&fixP->fx_file, &fixP->fx_line);
132 /* Usually, we want relocs sorted numerically, but while
133 comparing to older versions of gas that have relocs
134 reverse sorted, it is convenient to have this compile
135 time option. xoxorich. */
140 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
141 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
144 #ifdef REVERSE_SORT_RELOCS
146 fixP->fx_next = *seg_fix_rootP;
147 *seg_fix_rootP = fixP;
149 #else /* REVERSE_SORT_RELOCS */
151 fixP->fx_next = NULL;
154 (*seg_fix_tailP)->fx_next = fixP;
156 *seg_fix_rootP = fixP;
157 *seg_fix_tailP = fixP;
159 #endif /* REVERSE_SORT_RELOCS */
166 /* Create a fixup relative to a symbol (plus a constant). */
169 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
170 fragS *frag; /* Which frag? */
171 int where; /* Where in that frag? */
172 short int size; /* 1, 2, or 4 usually. */
173 symbolS *add_symbol; /* X_add_symbol. */
174 offsetT offset; /* X_add_number. */
175 int pcrel; /* TRUE if PC-relative relocation. */
177 bfd_reloc_code_real_type r_type; /* Relocation type */
179 int r_type; /* Relocation type */
182 return fix_new_internal (frag, where, size, add_symbol,
183 (symbolS *) NULL, offset, pcrel, r_type);
186 /* Create a fixup for an expression. Currently we only support fixups
187 for difference expressions. That is itself more than most object
188 file formats support anyhow. */
191 fix_new_exp (frag, where, size, exp, pcrel, r_type)
192 fragS *frag; /* Which frag? */
193 int where; /* Where in that frag? */
194 short int size; /* 1, 2, or 4 usually. */
195 expressionS *exp; /* Expression. */
196 int pcrel; /* TRUE if PC-relative relocation. */
198 bfd_reloc_code_real_type r_type; /* Relocation type */
200 int r_type; /* Relocation type */
213 sub = exp->X_add_symbol;
214 off = exp->X_add_number;
218 sub = exp->X_op_symbol;
221 add = exp->X_add_symbol;
224 off = exp->X_add_number;
228 as_bad ("expression too complex for fixup");
231 return fix_new_internal (frag, where, size, add, sub, off,
235 /* Append a string onto another string, bumping the pointer along. */
237 append (charPP, fromP, length)
240 unsigned long length;
242 /* Don't trust memcpy() of 0 chars. */
246 memcpy (*charPP, fromP, length);
250 #ifndef BFD_ASSEMBLER
251 int section_alignment[SEG_MAXIMUM_ORDINAL];
255 * This routine records the largest alignment seen for each segment.
256 * If the beginning of the segment is aligned on the worst-case
257 * boundary, all of the other alignments within it will work. At
258 * least one object format really uses this info.
261 record_alignment (seg, align)
262 /* Segment to which alignment pertains */
264 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
269 if (align > bfd_get_section_alignment (stdoutput, seg))
270 bfd_set_section_alignment (stdoutput, seg, align);
272 if (align > section_alignment[(int) seg])
273 section_alignment[(int) seg] = align;
277 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
280 chain_frchains_together_1 (section, frchp)
282 struct frchain *frchp;
284 fragS dummy, *prev_frag = &dummy;
285 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
287 prev_frag->fr_next = frchp->frch_root;
288 prev_frag = frchp->frch_last;
290 prev_frag->fr_next = 0;
299 chain_frchains_together (abfd, section, xxx)
300 bfd *abfd; /* unused */
302 PTR xxx; /* unused */
304 segment_info_type *info;
306 /* BFD may have introduced its own sections without using
307 subseg_new, so it is possible that seg_info is NULL. */
308 info = seg_info (section);
309 if (info != (segment_info_type *) NULL)
310 info->frchainP->frch_last
311 = chain_frchains_together_1 (section, info->frchainP);
316 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
319 remove_subsegs (head, seg, root, last)
325 *root = head->frch_root;
326 *last = chain_frchains_together_1 (seg, head);
331 #if defined (BFD_ASSEMBLER) || !defined (BFD)
335 cvt_frag_to_fill (sec, fragP)
340 cvt_frag_to_fill (headers, fragP)
341 object_headers *headers;
345 switch (fragP->fr_type)
350 HANDLE_ALIGN (fragP);
352 fragP->fr_type = rs_fill;
353 know (fragP->fr_var == 1);
354 know (fragP->fr_next != NULL);
356 fragP->fr_offset = (fragP->fr_next->fr_address
364 case rs_machine_dependent:
366 md_convert_frag (stdoutput, sec, fragP);
368 md_convert_frag (headers, fragP);
371 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
374 * After md_convert_frag, we make the frag into a ".space 0".
375 * Md_convert_frag() should set up any fixSs and constants
381 #ifndef WORKING_DOT_WORD
384 struct broken_word *lie;
386 if (fragP->fr_subtype)
388 fragP->fr_fix += md_short_jump_size;
389 for (lie = (struct broken_word *) (fragP->fr_symbol);
390 lie && lie->dispfrag == fragP;
391 lie = lie->next_broken_word)
393 fragP->fr_fix += md_long_jump_size;
401 BAD_CASE (fragP->fr_type);
406 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
410 relax_and_size_seg (abfd, sec, xxx)
417 segment_info_type *seginfo;
419 valueT size, newsize;
421 flags = bfd_get_section_flags (abfd, sec);
423 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
424 if (seginfo && seginfo->frchainP)
426 relax_segment (seginfo->frchainP->frch_root, sec);
427 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
428 cvt_frag_to_fill (sec, fragp);
429 for (fragp = seginfo->frchainP->frch_root;
431 fragp = fragp->fr_next)
432 /* walk to last elt */;
433 size = fragp->fr_address + fragp->fr_fix;
438 if (size > 0 && ! seginfo->bss)
439 flags |= SEC_HAS_CONTENTS;
441 /* @@ This is just an approximation. */
442 if (seginfo && seginfo->fix_root)
446 x = bfd_set_section_flags (abfd, sec, flags);
449 newsize = md_section_align (sec, size);
450 x = bfd_set_section_size (abfd, sec, newsize);
453 /* If the size had to be rounded up, add some padding in the last
455 assert (newsize >= size);
458 fragS *last = seginfo->frchainP->frch_last;
459 fragp = seginfo->frchainP->frch_root;
460 while (fragp->fr_next != last)
461 fragp = fragp->fr_next;
462 last->fr_address = size;
463 fragp->fr_offset += newsize - size;
466 #ifdef tc_frob_section
467 tc_frob_section (sec);
469 #ifdef obj_frob_section
470 obj_frob_section (sec);
476 dump_section_relocs (abfd, sec, stream_)
481 FILE *stream = (FILE *) stream_;
482 segment_info_type *seginfo = seg_info (sec);
483 fixS *fixp = seginfo->fix_root;
488 fprintf (stream, "sec %s relocs:\n", sec->name);
491 symbolS *s = fixp->fx_addsy;
493 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
494 S_GET_NAME (s), s->bsym->section->name,
495 S_GET_VALUE (s), fixp->fx_offset);
497 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
498 fixp = fixp->fx_next;
502 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
506 adjust_reloc_syms (abfd, sec, xxx)
511 segment_info_type *seginfo = seg_info (sec);
517 dump_section_relocs (abfd, sec, stderr);
519 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
522 symbolS *sym = fixp->fx_addsy;
523 asection *symsec = sym->bsym->section;
524 segment_info_type *symseginfo = seg_info (symsec);
526 /* If it's one of these sections, assume the symbol is
527 definitely going to be output. The code in
528 md_estimate_size_before_relax in tc-mips.c uses this test
529 as well, so if you change this code you should look at that
531 if (symsec == &bfd_und_section
532 || symsec == &bfd_abs_section
533 || bfd_is_com_section (symsec))
535 fixp->fx_addsy->sy_used_in_reloc = 1;
539 /* Since we're reducing to section symbols, don't attempt to reduce
540 anything that's already using one. */
541 if (sym->bsym == symsec->symbol)
543 fixp->fx_addsy->sy_used_in_reloc = 1;
547 /* Is there some other reason we can't adjust this one? (E.g.,
548 call/bal links in i960-bout symbols.) */
549 #ifdef obj_fix_adjustable
550 if (! obj_fix_adjustable (fixp))
552 fixp->fx_addsy->sy_used_in_reloc = 1;
557 /* Is there some other (target cpu dependent) reason we can't adjust
558 this one? (E.g. relocations involving function addresses on
560 #ifdef tc_fix_adjustable
561 if (! tc_fix_adjustable (fixp))
563 fixp->fx_addsy->sy_used_in_reloc = 1;
568 /* If the section symbol isn't going to be output, the relocs
569 at least should still work. If not, figure out what to do
570 when we run into that case. */
571 fixp->fx_offset += S_GET_VALUE (sym);
573 fixp->fx_offset += sym->sy_frag->fr_address;
575 fixp->fx_addsy = symseginfo->sym;
578 fixp->fx_addsy = symbol_find (symsec->name);
581 fixp->fx_addsy = symbol_make (symsec->name);
582 fixp->fx_addsy->bsym = symsec->symbol;
584 symseginfo->sym = fixp->fx_addsy;
586 fixp->fx_addsy->sy_used_in_reloc = 1;
589 dump_section_relocs (abfd, sec, stderr);
593 write_relocs (abfd, sec, xxx)
598 segment_info_type *seginfo = seg_info (sec);
604 /* If seginfo is NULL, we did not create this section; don't do
609 fixup_segment (seginfo->fix_root, sec);
612 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
615 #ifndef RELOC_EXPANSION_POSSIBLE
616 /* Set up reloc information as well. */
617 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
618 n * sizeof (arelent *));
619 memset ((char*)relocs, 0, n * sizeof (arelent*));
622 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
626 bfd_reloc_status_type s;
628 if (fixp->fx_addsy == 0)
630 /* @@ Need some other flag to indicate which have already
635 reloc = tc_gen_reloc (sec, fixp);
641 data = fixp->fx_frag->fr_literal + fixp->fx_where;
642 if (fixp->fx_where + fixp->fx_size
643 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
646 if (reloc->howto->partial_inplace == false
647 && reloc->howto->pcrel_offset == true
648 && reloc->howto->pc_relative == true)
650 /* bfd_perform_relocation screws this up */
651 reloc->addend += reloc->address;
653 /* Pass bogus address so that when bfd_perform_relocation adds
654 `address' back in, it'll come up with `data', which is where
655 we want it to operate. */
656 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
663 as_fatal ("bad return from bfd_perform_relocation");
668 n = n * MAX_RELOC_EXPANSION;
669 /* Set up reloc information as well. */
670 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
671 n * sizeof (arelent *));
674 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
678 bfd_reloc_status_type s;
681 if (fixp->fx_addsy == 0)
683 /* @@ Need some other flag to indicate which have already
688 reloc = tc_gen_reloc (sec, fixp);
690 for (j = 0; reloc[j]; j++)
692 relocs[i++] = reloc[j];
695 data = fixp->fx_frag->fr_literal + fixp->fx_where;
696 if (fixp->fx_where + fixp->fx_size
697 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
699 for (j = 0; reloc[j]; j++)
701 s = bfd_perform_relocation (stdoutput, reloc[j],
702 data - reloc[0]->address,
709 as_fatal ("bad return from bfd_perform_relocation");
717 bfd_set_reloc (stdoutput, sec, relocs, n);
719 bfd_set_section_flags (abfd, sec,
720 (bfd_get_section_flags (abfd, sec)
721 & (flagword) ~SEC_RELOC));
727 fprintf (stderr, "relocs for sec %s\n", sec->name);
728 for (i = 0; i < n; i++)
732 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
733 i, r, r->address, s->name, r->addend);
740 write_contents (abfd, sec, xxx)
745 segment_info_type *seginfo = seg_info (sec);
746 unsigned long offset = 0;
749 /* Write out the frags. */
751 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
754 for (f = seginfo->frchainP->frch_root;
759 unsigned long fill_size;
763 assert (f->fr_type == rs_fill);
766 x = bfd_set_section_contents (stdoutput, sec,
767 f->fr_literal, (file_ptr) offset,
768 (bfd_size_type) f->fr_fix);
772 fill_literal = f->fr_literal + f->fr_fix;
773 fill_size = f->fr_var;
774 count = f->fr_offset;
776 if (fill_size && count)
779 x = bfd_set_section_contents (stdoutput, sec,
780 fill_literal, (file_ptr) offset,
781 (bfd_size_type) fill_size);
789 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
791 merge_data_into_text ()
793 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
794 seg_info (text_section)->frchainP->frch_last->fr_next =
795 seg_info (data_section)->frchainP->frch_root;
796 seg_info (text_section)->frchainP->frch_last =
797 seg_info (data_section)->frchainP->frch_last;
798 seg_info (data_section)->frchainP = 0;
802 text_last_frag->fr_next = data_frag_root;
803 text_last_frag = data_last_frag;
804 data_last_frag = NULL;
805 data_frag_root = NULL;
808 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
809 tmp->fx_next = data_fix_root;
810 text_fix_tail = data_fix_tail;
813 text_fix_root = data_fix_root;
814 data_fix_root = NULL;
817 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
819 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
821 relax_and_size_all_segments ()
825 relax_segment (text_frag_root, SEG_TEXT);
826 relax_segment (data_frag_root, SEG_DATA);
827 relax_segment (bss_frag_root, SEG_BSS);
829 * Now the addresses of frags are correct within the segment.
832 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
833 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
834 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
837 * Join the 2 segments into 1 huge segment.
838 * To do this, re-compute every rn_address in the SEG_DATA frags.
839 * Then join the data frags after the text frags.
841 * Determine a_data [length of data segment].
845 register relax_addressT slide;
847 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
849 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
850 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
851 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
853 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
854 /* For b.out: If the data section has a strict alignment
855 requirement, its load address in the .o file will be
856 rounded up from the size of the text section. These
857 two values are *not* the same! Similarly for the bss
859 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
862 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
864 fragP->fr_address += slide;
865 } /* for each data frag */
867 know (text_last_frag != 0);
868 text_last_frag->fr_next = data_frag_root;
872 H_SET_DATA_SIZE (&headers, 0);
876 /* See above comments on b.out data section address. */
879 if (data_last_frag == 0)
880 bss_vma = H_GET_TEXT_SIZE (&headers);
882 bss_vma = data_last_frag->fr_address;
883 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
884 bss_address_frag.fr_address = bss_vma;
886 #else /* ! OBJ_BOUT */
887 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
888 H_GET_DATA_SIZE (&headers));
890 #endif /* ! OBJ_BOUT */
892 /* Slide all the frags */
895 relax_addressT slide = bss_address_frag.fr_address;
897 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
899 fragP->fr_address += slide;
900 } /* for each bss frag */
904 H_SET_BSS_SIZE (&headers,
905 bss_last_frag->fr_address - bss_frag_root->fr_address);
907 H_SET_BSS_SIZE (&headers, 0);
909 #endif /* ! BFD_ASSEMBLER && ! BFD */
911 #if defined (BFD_ASSEMBLER) || !defined (BFD)
916 register struct frchain *frchainP; /* Track along all frchains. */
917 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
918 register fragS *fragP; /* Track along all frags. */
920 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
921 long object_file_size;
924 /* Do we really want to write it? */
927 n_warns = had_warnings ();
928 n_errs = had_errors ();
929 /* The -Z flag indicates that an object file should be generated,
930 regardless of warnings and errors. */
933 if (n_warns || n_errs)
934 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
935 n_errs, n_errs == 1 ? "" : "s",
936 n_warns, n_warns == 1 ? "" : "s");
941 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
942 n_errs, n_errs == 1 ? "" : "s",
943 n_warns, n_warns == 1 ? "" : "s");
949 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
950 * call a routine to check for the definition of the procedure
951 * "_main", and if so -- fix it up so that it can be program
954 VMS_Check_For_Main ();
957 /* After every sub-segment, we fake an ".align ...". This conforms to
958 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
959 frag that requires least thought. ".align" frags like to have a
960 following frag since that makes calculating their intended length
963 @@ Is this really necessary?? */
964 #ifndef SUB_SEGMENT_ALIGN
966 #define SUB_SEGMENT_ALIGN(SEG) (0)
968 #define SUB_SEGMENT_ALIGN(SEG) (2)
971 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
973 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
974 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
975 /* frag_align will have left a new frag.
976 Use this last frag for an empty ".fill".
979 Create a last frag. Do not leave a "being filled in frag". */
980 frag_wane (frag_now);
981 frag_now->fr_fix = 0;
982 know (frag_now->fr_next == NULL);
985 /* From now on, we don't care about sub-segments. Build one frag chain
986 for each segment. Linked thru fr_next. */
989 /* Remove the sections created by gas for its own purposes. */
991 asection **seclist, *sec;
992 seclist = &stdoutput->sections;
993 while (seclist && *seclist)
996 while (sec == reg_section || sec == expr_section)
1000 stdoutput->section_count--;
1005 seclist = &(*seclist)->next;
1009 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1011 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1012 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1013 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1016 /* We have two segments. If user gave -R flag, then we must put the
1017 data frags into the text segment. Do this before relaxing so
1018 we know to take advantage of -R and make shorter addresses. */
1019 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1022 merge_data_into_text ();
1026 #ifdef BFD_ASSEMBLER
1027 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1029 relax_and_size_all_segments ();
1030 #endif /* BFD_ASSEMBLER */
1032 #ifndef BFD_ASSEMBLER
1035 * Crawl the symbol chain.
1037 * For each symbol whose value depends on a frag, take the address of
1038 * that frag and subsume it into the value of the symbol.
1039 * After this, there is just one way to lookup a symbol value.
1040 * Values are left in their final state for object file emission.
1041 * We adjust the values of 'L' local symbols, even if we do
1042 * not intend to emit them to the object file, because their values
1043 * are needed for fix-ups.
1045 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1046 * from the symbol chain. (They are still pointed to by the fixes.)
1048 * Count the remaining symbols.
1049 * Assign a symbol number to each symbol.
1050 * Count the number of string-table chars we will emit.
1051 * Put this info into the headers as appropriate.
1054 know (zero_address_frag.fr_address == 0);
1055 string_byte_count = sizeof (string_byte_count);
1057 obj_crawl_symbol_chain (&headers);
1059 if (string_byte_count == sizeof (string_byte_count))
1060 string_byte_count = 0;
1062 H_SET_STRING_SIZE (&headers, string_byte_count);
1065 * Addresses of frags now reflect addresses we use in the object file.
1066 * Symbol values are correct.
1067 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1068 * Also converting any machine-dependent frags using md_convert_frag();
1070 subseg_change (SEG_TEXT, 0);
1072 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1074 cvt_frag_to_fill (&headers, fragP);
1076 /* Some assert macros don't work with # directives mixed in. */
1078 if (!(fragP->fr_next == NULL
1080 || fragP->fr_next == data_frag_root
1082 || ((fragP->fr_next->fr_address - fragP->fr_address)
1083 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1087 #endif /* ! BFD_ASSEMBLER */
1089 #ifndef WORKING_DOT_WORD
1091 struct broken_word *lie;
1092 struct broken_word **prevP;
1094 prevP = &broken_words;
1095 for (lie = broken_words; lie; lie = lie->next_broken_word)
1100 exp.X_op = O_subtract;
1101 exp.X_add_symbol = lie->add;
1102 exp.X_op_symbol = lie->sub;
1103 exp.X_add_number = lie->addnum;
1104 #ifdef BFD_ASSEMBLER
1105 fix_new_exp (lie->frag,
1106 lie->word_goes_here - lie->frag->fr_literal,
1107 2, &exp, 0, BFD_RELOC_NONE);
1109 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1110 fix_new_exp (lie->frag,
1111 lie->word_goes_here - lie->frag->fr_literal,
1112 2, &exp, 0, NO_RELOC);
1115 fix_new_ns32k_exp (lie->frag,
1116 lie->word_goes_here - lie->frag->fr_literal,
1117 2, &exp, 0, 0, 2, 0, 0);
1119 fix_new_exp (lie->frag,
1120 lie->word_goes_here - lie->frag->fr_literal,
1122 #endif /* TC_NS32K */
1123 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1124 #endif /* BFD_ASSEMBLER */
1125 *prevP = lie->next_broken_word;
1128 prevP = &(lie->next_broken_word);
1130 for (lie = broken_words; lie;)
1132 struct broken_word *untruth;
1134 addressT table_addr;
1135 addressT from_addr, to_addr;
1138 fragP = lie->dispfrag;
1140 /* Find out how many broken_words go here. */
1142 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1143 if (untruth->added == 1)
1146 table_ptr = lie->dispfrag->fr_opcode;
1147 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1148 /* Create the jump around the long jumps. This is a short
1149 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1150 from_addr = table_addr;
1151 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1152 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1153 table_ptr += md_short_jump_size;
1154 table_addr += md_short_jump_size;
1156 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1158 if (lie->added == 2)
1160 /* Patch the jump table */
1161 /* This is the offset from ??? to table_ptr+0 */
1162 to_addr = table_addr - S_GET_VALUE (lie->sub);
1163 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1164 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1166 if (untruth->use_jump == lie)
1167 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1170 /* Install the long jump */
1171 /* this is a long jump from table_ptr+0 to the final target */
1172 from_addr = table_addr;
1173 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1174 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1175 table_ptr += md_long_jump_size;
1176 table_addr += md_long_jump_size;
1180 #endif /* not WORKING_DOT_WORD */
1182 #ifndef BFD_ASSEMBLER
1186 * Scan every FixS performing fixups. We had to wait until now to do
1187 * this because md_convert_frag() may have made some fixSs.
1191 subseg_change (SEG_TEXT, 0);
1192 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1193 subseg_change (SEG_DATA, 0);
1194 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1195 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1197 /* FIXME move this stuff into the pre-write-hook */
1198 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1199 H_SET_ENTRY_POINT (&headers, 0);
1201 obj_pre_write_hook (&headers); /* extra coff stuff */
1203 object_file_size = H_GET_FILE_SIZE (&headers);
1204 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1206 output_file_create (out_file_name);
1208 obj_header_append (&next_object_file_charP, &headers);
1210 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1215 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1217 register long count;
1218 register char *fill_literal;
1219 register long fill_size;
1221 know (fragP->fr_type == rs_fill);
1222 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1223 fill_literal = fragP->fr_literal + fragP->fr_fix;
1224 fill_size = fragP->fr_var;
1225 know (fragP->fr_offset >= 0);
1227 for (count = fragP->fr_offset; count; count--)
1229 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1232 } /* for each code frag. */
1234 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1239 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1240 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)));
1242 /* Make addresses in data relocation directives relative to beginning of
1243 * first data fragment, not end of last text fragment: alignment of the
1244 * start of the data segment may place a gap between the segments.
1246 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1248 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1249 #endif /* TC_I960 */
1251 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)));
1254 * Emit line number entries.
1256 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1257 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)));
1262 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1263 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)));
1269 if (string_byte_count > 0)
1271 obj_emit_strings (&next_object_file_charP);
1272 } /* only if we have a string table */
1275 bfd_seek (stdoutput, 0, 0);
1276 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1279 /* Write the data to the file */
1280 output_file_append (the_object_file, object_file_size, out_file_name);
1283 output_file_close (out_file_name);
1284 } /* non vms output */
1287 * Now do the VMS-dependent part of writing the object file
1289 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1290 H_GET_DATA_SIZE (&headers),
1291 H_GET_BSS_SIZE (&headers),
1292 text_frag_root, data_frag_root);
1294 #else /* BFD_ASSEMBLER */
1296 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1298 /* Set up symbol table, and write it out. */
1305 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1307 if (! symp->sy_resolved)
1309 if (symp->sy_value.X_op == O_constant)
1311 /* This is the normal case; skip the call. */
1314 + symp->sy_frag->fr_address));
1315 symp->sy_resolved = 1;
1318 resolve_symbol_value (symp);
1321 /* So far, common symbols have been treated like undefined symbols.
1322 Put them in the common section now. */
1323 if (S_IS_DEFINED (symp) == 0
1324 && S_GET_VALUE (symp) != 0)
1325 S_SET_SEGMENT (symp, &bfd_com_section);
1327 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1328 S_GET_NAME (symp), symp,
1331 segment_name (symp->bsym->section));
1334 #ifdef obj_frob_symbol
1337 obj_frob_symbol (symp, punt);
1342 #ifdef tc_frob_symbol
1345 tc_frob_symbol (symp, punt);
1351 /* If we don't want to keep this symbol, splice it out of the
1353 if (S_IS_LOCAL (symp))
1356 if (! symp->sy_used_in_reloc)
1358 symbolS *prev, *next;
1359 prev = symbol_previous (symp);
1360 next = symbol_next (symp);
1362 verify_symbol_chain_2 (symp);
1366 symbol_next (prev) = next;
1369 else if (symp == symbol_rootP)
1370 symbol_rootP = next;
1374 symbol_previous (next) = prev;
1376 symbol_lastP = prev;
1379 verify_symbol_chain_2 (prev);
1381 verify_symbol_chain_2 (next);
1387 /* Make sure we really got a value for the symbol. */
1388 if (! symp->sy_resolved)
1390 as_bad ("can't resolve value for symbol \"%s\"",
1392 symp->sy_resolved = 1;
1395 /* Set the value into the BFD symbol. Up til now the value
1396 has only been kept in the gas symbolS struct. */
1397 symp->bsym->value = S_GET_VALUE (symp);
1406 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1408 asympp = (asymbol **) bfd_alloc (stdoutput,
1409 n * sizeof (asymbol *));
1410 symp = symbol_rootP;
1411 for (i = 0; i < n; i++, symp = symbol_next (symp))
1413 asympp[i] = symp->bsym;
1416 result = bfd_set_symtab (stdoutput, asympp, n);
1417 assert (result == true);
1422 #ifdef obj_frob_file
1423 /* If obj_frob_file changes the symbol value at this point, it is
1424 responsible for moving the changed value into symp->bsym->value
1425 as well. Hopefully all symbol value changing can be done in
1426 {obj,tc}_frob_symbol. */
1430 /* Now that all the sizes are known, and contents correct, we can
1431 start writing the file. */
1432 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1434 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1436 output_file_close (out_file_name);
1437 #endif /* BFD_ASSEMBLER */
1444 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1449 * After this, all frags in this segment have addresses that are correct
1450 * within the segment. Since segments live in different file addresses,
1451 * these frag addresses may not be the same as final object-file addresses.
1454 #ifndef md_relax_frag
1456 /* Subroutines of relax_segment. */
1462 for (; f1; f1 = f1->fr_next)
1463 if (f1->fr_next == f2)
1468 #endif /* ! defined (md_relax_frag) */
1470 /* Relax_align. Advance location counter to next address that has 'alignment'
1471 lowest order bits all 0s, return size of adjustment made. */
1472 static relax_addressT
1473 relax_align (address, alignment)
1474 register relax_addressT address; /* Address now. */
1475 register int alignment; /* Alignment (binary). */
1477 relax_addressT mask;
1478 relax_addressT new_address;
1480 mask = ~((~0) << alignment);
1481 new_address = (address + mask) & (~mask);
1483 /* We must provide lots of padding, so the linker can discard it
1484 when needed. The linker will not add extra space, ever. */
1485 new_address += (1 << alignment);
1486 return (new_address - address);
1490 relax_segment (segment_frag_root, segment)
1491 struct frag *segment_frag_root;
1494 register struct frag *fragP;
1495 register relax_addressT address;
1496 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1497 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1499 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1500 subseg_change (segment, 0);
1502 /* For each frag in segment: count and store (a 1st guess of)
1505 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1507 fragP->fr_address = address;
1508 address += fragP->fr_fix;
1510 switch (fragP->fr_type)
1513 address += fragP->fr_offset * fragP->fr_var;
1517 address += relax_align (address, (int) fragP->fr_offset);
1521 /* Assume .org is nugatory. It will grow with 1st relax. */
1524 case rs_machine_dependent:
1525 address += md_estimate_size_before_relax (fragP, segment);
1528 #ifndef WORKING_DOT_WORD
1529 /* Broken words don't concern us yet */
1530 case rs_broken_word:
1535 BAD_CASE (fragP->fr_type);
1537 } /* switch(fr_type) */
1538 } /* for each frag in the segment */
1542 long stretch; /* May be any size, 0 or negative. */
1543 /* Cumulative number of addresses we have */
1544 /* relaxed this pass. */
1545 /* We may have relaxed more than one address. */
1546 long stretched; /* Have we stretched on this pass? */
1547 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1548 grew, and another shrank. If a branch instruction doesn't fit anymore,
1549 we could be scrod. */
1553 stretch = stretched = 0;
1554 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1557 unsigned long was_address;
1563 was_address = fragP->fr_address;
1564 address = fragP->fr_address += stretch;
1565 symbolP = fragP->fr_symbol;
1566 offset = fragP->fr_offset;
1568 switch (fragP->fr_type)
1570 case rs_fill: /* .fill never relaxes. */
1574 #ifndef WORKING_DOT_WORD
1575 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1576 for it I do not want to write it. I do not want to have
1577 anything to do with it. This is not the proper way to
1578 implement this misfeature. */
1579 case rs_broken_word:
1581 struct broken_word *lie;
1582 struct broken_word *untruth;
1584 /* Yes this is ugly (storing the broken_word pointer
1585 in the symbol slot). Still, this whole chunk of
1586 code is ugly, and I don't feel like doing anything
1587 about it. Think of it as stubbornness in action. */
1589 for (lie = (struct broken_word *) (fragP->fr_symbol);
1590 lie && lie->dispfrag == fragP;
1591 lie = lie->next_broken_word)
1597 offset = (lie->add->sy_frag->fr_address
1598 + S_GET_VALUE (lie->add)
1600 - (lie->sub->sy_frag->fr_address
1601 + S_GET_VALUE (lie->sub)));
1602 if (offset <= -32768 || offset >= 32767)
1607 sprint_value (buf, (addressT) lie->addnum);
1608 as_warn (".word %s-%s+%s didn't fit",
1609 S_GET_NAME (lie->add),
1610 S_GET_NAME (lie->sub),
1614 if (fragP->fr_subtype == 0)
1616 fragP->fr_subtype++;
1617 growth += md_short_jump_size;
1619 for (untruth = lie->next_broken_word;
1620 untruth && untruth->dispfrag == lie->dispfrag;
1621 untruth = untruth->next_broken_word)
1622 if ((untruth->add->sy_frag == lie->add->sy_frag)
1623 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1626 untruth->use_jump = lie;
1628 growth += md_long_jump_size;
1633 } /* case rs_broken_word */
1636 growth = (relax_align ((relax_addressT) (address
1639 - relax_align ((relax_addressT) (was_address
1649 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1650 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1651 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1652 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1653 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1654 know (symbolP->sy_frag);
1655 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1656 || (symbolP->sy_frag == &zero_address_frag));
1658 target += S_GET_VALUE (symbolP)
1659 + symbolP->sy_frag->fr_address;
1660 } /* if we have a symbol */
1662 know (fragP->fr_next);
1663 after = fragP->fr_next->fr_address;
1664 growth = ((target - after) > 0) ? (target - after) : 0;
1665 /* Growth may be negative, but variable part of frag
1666 cannot have fewer than 0 chars. That is, we can't
1669 growth -= stretch; /* This is an absolute growth factor */
1672 case rs_machine_dependent:
1673 #ifdef md_relax_frag
1674 growth = md_relax_frag (fragP, stretch);
1676 /* The default way to relax a frag is to look through
1679 const relax_typeS *this_type;
1680 const relax_typeS *start_type;
1681 relax_substateT next_state;
1682 relax_substateT this_state;
1685 this_state = fragP->fr_subtype;
1686 start_type = this_type = md_relax_table + this_state;
1691 #ifndef DIFF_EXPR_OK
1692 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1693 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1694 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1695 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1696 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1698 know (symbolP->sy_frag);
1700 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1701 || symbolP->sy_frag == &zero_address_frag);
1703 S_GET_VALUE (symbolP)
1704 + symbolP->sy_frag->fr_address;
1706 /* If frag has yet to be reached on this pass,
1707 assume it will move by STRETCH just as we did.
1708 If this is not so, it will be because some frag
1709 between grows, and that will force another pass.
1711 Beware zero-length frags.
1713 There should be a faster way to do this. */
1715 if (symbolP->sy_frag->fr_address >= was_address
1716 && is_dnrange (fragP, symbolP->sy_frag))
1722 aim = target - address - fragP->fr_fix;
1723 /* The displacement is affected by the instruction size
1724 for the 32k architecture. I think we ought to be able
1725 to add fragP->fr_pcrel_adjust in all cases (it should be
1726 zero if not used), but just in case it breaks something
1727 else we'll put this inside #ifdef NS32K ... #endif */
1729 if (fragP->fr_pcrel_adjust)
1732 aim += fragP->fr_pcrel_adjust;
1736 /* Look backwards. */
1737 for (next_state = this_type->rlx_more; next_state;)
1738 if (aim >= this_type->rlx_backward)
1742 /* Grow to next state. */
1743 this_state = next_state;
1744 this_type = md_relax_table + this_state;
1745 next_state = this_type->rlx_more;
1750 #ifdef M68K_AIM_KLUDGE
1751 M68K_AIM_KLUDGE (aim, this_state, this_type);
1753 /* Look forwards. */
1754 for (next_state = this_type->rlx_more; next_state;)
1755 if (aim <= this_type->rlx_forward)
1759 /* Grow to next state. */
1760 this_state = next_state;
1761 this_type = md_relax_table + this_state;
1762 next_state = this_type->rlx_more;
1766 growth = this_type->rlx_length - start_type->rlx_length;
1768 fragP->fr_subtype = this_state;
1774 BAD_CASE (fragP->fr_type);
1782 } /* For each frag in the segment. */
1784 while (stretched); /* Until nothing further to relax. */
1788 * We now have valid fr_address'es for each frag.
1792 * All fr_address's are correct, relative to their own segment.
1793 * We have made all the fixS we will ever make.
1795 } /* relax_segment() */
1797 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1801 Go through all the fixS's in a segment and see which ones can be
1802 handled now. (These consist of fixS where we have since discovered
1803 the value of a symbol, or the address of the frag involved.)
1804 For each one, call md_apply_fix to put the fix into the frag data.
1806 Result is a count of how many relocation structs will be needed to
1807 handle the remaining fixS's that we couldn't completely handle here.
1808 These will be output later by emit_relocations(). */
1811 fixup_segment (fixP, this_segment_type)
1812 register fixS *fixP;
1813 segT this_segment_type; /* N_TYPE bits for segment. */
1815 register long seg_reloc_count;
1816 register symbolS *add_symbolP;
1817 register symbolS *sub_symbolP;
1820 register char *place;
1821 register long where;
1822 register char pcrel;
1823 register fragS *fragP;
1824 register segT add_symbol_segment = absolute_section;
1826 seg_reloc_count = 0;
1827 /* If the linker is doing the relaxing, we must not do any fixups. */
1828 /* Well, strictly speaking that's not true -- we could do any that
1829 are PC-relative and don't cross regions that could change size.
1830 And for the i960 (the only machine for which we've got a relaxing
1831 linker right now), we might be able to turn callx/callj into bal
1832 in cases where we know the maximum displacement. */
1834 for (; fixP; fixP = fixP->fx_next)
1837 for (; fixP; fixP = fixP->fx_next)
1839 fragP = fixP->fx_frag;
1841 where = fixP->fx_where;
1842 place = fragP->fr_literal + where;
1843 size = fixP->fx_size;
1844 add_symbolP = fixP->fx_addsy;
1846 if (fixP->fx_tcbit && TC_S_IS_CALLNAME (add_symbolP))
1848 /* Relocation should be done via the associated 'bal'
1849 entry point symbol. */
1851 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1853 as_bad ("No 'bal' entry point for leafproc %s",
1854 S_GET_NAME (add_symbolP));
1857 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1860 sub_symbolP = fixP->fx_subsy;
1861 add_number = fixP->fx_offset;
1862 pcrel = fixP->fx_pcrel;
1865 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1872 /* @@ Should try converting to pcrel ref to fixed addr. */
1873 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1874 as_bad ("Negative of non-absolute symbol %s",
1875 S_GET_NAME (sub_symbolP));
1877 add_number -= S_GET_VALUE (sub_symbolP);
1879 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1880 && (SEG_NORMAL (add_symbol_segment)
1881 || (add_symbol_segment == absolute_section)))
1883 /* Difference of 2 symbols from same segment.
1884 Can't make difference of 2 undefineds: 'value' means
1885 something different for N_UNDF. */
1887 /* Makes no sense to use the difference of 2 arbitrary symbols
1888 as the target of a call instruction. */
1891 as_bad ("callj to difference of 2 symbols");
1893 #endif /* TC_I960 */
1894 add_number += S_GET_VALUE (add_symbolP) -
1895 S_GET_VALUE (sub_symbolP);
1899 /* Let the target machine make the final determination
1900 as to whether or not a relocation will be needed to
1901 handle this fixup. */
1902 if (!TC_FORCE_RELOCATION (fixP))
1903 fixP->fx_addsy = NULL;
1907 /* Different segments in subtraction. */
1908 know (!(S_IS_EXTERNAL (sub_symbolP)
1909 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1911 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1913 add_number -= S_GET_VALUE (sub_symbolP);
1916 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1918 /* Do this even if it's already described as
1919 pc-relative. For example, on the m68k, an
1920 operand of "pc@(foo-.-2)" should address "foo"
1921 in a pc-relative mode. */
1926 /* Make it pc-relative. */
1927 add_number += (md_pcrel_from (fixP)
1928 - S_GET_VALUE (sub_symbolP));
1938 sprint_value (buf, fragP->fr_address + where);
1939 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1940 segment_name (S_GET_SEGMENT (sub_symbolP)),
1941 S_GET_NAME (sub_symbolP), buf);
1948 if (add_symbol_segment == this_segment_type && pcrel)
1951 * This fixup was made when the symbol's segment was
1952 * SEG_UNKNOWN, but it is now in the local segment.
1953 * So we know how to do the address without relocation.
1956 /* reloc_callj() may replace a 'call' with a 'calls' or a
1957 'bal', in which cases it modifies *fixP as appropriate.
1958 In the case of a 'calls', no further work is required,
1959 and *fixP has been set up to make the rest of the code
1962 #endif /* TC_I960 */
1964 add_number += S_GET_VALUE (add_symbolP);
1965 add_number -= md_pcrel_from (fixP);
1966 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1968 /* Let the target machine make the final determination
1969 as to whether or not a relocation will be needed to
1970 handle this fixup. */
1971 if (!TC_FORCE_RELOCATION (fixP))
1972 fixP->fx_addsy = NULL;
1976 if (add_symbol_segment == absolute_section)
1979 /* See comment about reloc_callj() above. */
1981 #endif /* TC_I960 */
1982 add_number += S_GET_VALUE (add_symbolP);
1984 /* Let the target machine make the final determination
1985 as to whether or not a relocation will be needed to
1986 handle this fixup. */
1987 if (!TC_FORCE_RELOCATION (fixP))
1988 fixP->fx_addsy = NULL;
1991 else if (add_symbol_segment == undefined_section
1992 #ifdef BFD_ASSEMBLER
1993 || bfd_is_com_section (add_symbol_segment)
1998 if ((int) fixP->fx_bit_fixP == 13)
2000 /* This is a COBR instruction. They have only a
2001 * 13-bit displacement and are only to be used
2002 * for local branches: flag as error, don't generate
2005 as_bad ("can't use COBR format with external label");
2007 /* Let the target machine make the final determination
2008 as to whether or not a relocation will be needed to
2009 handle this fixup. */
2010 if (!TC_FORCE_RELOCATION (fixP))
2011 fixP->fx_addsy = NULL;
2014 #endif /* TC_I960 */
2018 if (S_IS_COMMON (add_symbolP))
2019 add_number += S_GET_VALUE (add_symbolP);
2020 #endif /* TE_I386AIX */
2021 #endif /* OBJ_COFF */
2027 add_number += S_GET_VALUE (add_symbolP);
2034 add_number -= md_pcrel_from (fixP);
2035 if (add_symbolP == 0)
2037 fixP->fx_addsy = &abs_symbol;
2039 } /* if there's an add_symbol */
2042 if (!fixP->fx_bit_fixP && size > 0)
2045 /* set all bits to one */
2047 /* Technically speaking, combining these produces an
2048 undefined result if size is sizeof (valueT), though I
2049 think these two half-way operations should both be
2053 if ((add_number & mask) != 0
2054 && (add_number & mask) != mask)
2056 char buf[50], buf2[50];
2057 sprint_value (buf, fragP->fr_address + where);
2058 if (add_number > 1000)
2059 sprint_value (buf2, add_number);
2061 sprintf (buf2, "%ld", (long) add_number);
2062 as_bad_where (fixP->fx_file, fixP->fx_line,
2063 "Value of %s too large for field of %d bytes at %s",
2065 } /* generic error checking */
2066 #ifdef WARN_SIGNED_OVERFLOW_WORD
2067 /* Warn if a .word value is too large when treated as a signed
2068 number. We already know it is not too negative. This is to
2069 catch over-large switches generated by gcc on the 68k. */
2072 && add_number > 0x7fff)
2073 as_bad_where (fixP->fx_file, fixP->fx_line,
2074 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2076 (unsigned long) (fragP->fr_address + where));
2078 } /* not a bit fix */
2080 #ifdef BFD_ASSEMBLER
2081 md_apply_fix (fixP, &add_number);
2083 md_apply_fix (fixP, add_number);
2085 } /* For each fixS in this segment. */
2087 #if defined (OBJ_COFF) && defined (TC_I960)
2091 /* two relocs per callj under coff. */
2092 for (fixP = topP; fixP; fixP = fixP->fx_next)
2093 if (fixP->fx_tcbit && fixP->fx_addsy != 0)
2096 #endif /* OBJ_COFF && TC_I960 */
2098 return (seg_reloc_count);
2101 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2103 /* end of write.c */