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 WORKING_DOT_WORD
34 extern CONST int md_short_jump_size;
35 extern CONST int md_long_jump_size;
41 struct frag *text_frag_root;
42 struct frag *data_frag_root;
43 struct frag *bss_frag_root;
45 struct frag *text_last_frag; /* Last frag in segment. */
46 struct frag *data_last_frag; /* Last frag in segment. */
47 static struct frag *bss_last_frag; /* Last frag in segment. */
50 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
51 static object_headers headers;
52 static char *the_object_file;
55 long string_byte_count;
56 char *next_object_file_charP; /* Tracks object file bytes. */
59 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
62 #endif /* BFD_ASSEMBLER */
65 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
66 symbolS *add, symbolS *sub,
67 offsetT offset, int pcrel,
68 bfd_reloc_code_real_type r_type));
70 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
71 symbolS *add, symbolS *sub,
72 offsetT offset, int pcrel,
75 #if defined (BFD_ASSEMBLER) || !defined (BFD)
76 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
78 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
83 * Create a fixS in obstack 'notes'.
86 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
88 fragS *frag; /* Which frag? */
89 int where; /* Where in that frag? */
90 int size; /* 1, 2, or 4 usually. */
91 symbolS *add_symbol; /* X_add_symbol. */
92 symbolS *sub_symbol; /* X_op_symbol. */
93 offsetT offset; /* X_add_number. */
94 int pcrel; /* TRUE if PC-relative relocation. */
96 bfd_reloc_code_real_type r_type; /* Relocation type */
98 int r_type; /* Relocation type */
103 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
105 fixP->fx_frag = frag;
106 fixP->fx_where = where;
107 fixP->fx_size = size;
108 fixP->fx_addsy = add_symbol;
109 fixP->fx_subsy = sub_symbol;
110 fixP->fx_offset = offset;
111 fixP->fx_pcrel = pcrel;
112 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
113 fixP->fx_r_type = r_type;
115 fixP->fx_im_disp = 0;
116 fixP->fx_pcrel_adjust = 0;
117 fixP->fx_bit_fixP = 0;
118 fixP->fx_addnumber = 0;
127 as_where (&fixP->fx_file, &fixP->fx_line);
129 /* Usually, we want relocs sorted numerically, but while
130 comparing to older versions of gas that have relocs
131 reverse sorted, it is convenient to have this compile
132 time option. xoxorich. */
137 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
138 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
141 #ifdef REVERSE_SORT_RELOCS
143 fixP->fx_next = *seg_fix_rootP;
144 *seg_fix_rootP = fixP;
146 #else /* REVERSE_SORT_RELOCS */
148 fixP->fx_next = NULL;
151 (*seg_fix_tailP)->fx_next = fixP;
153 *seg_fix_rootP = fixP;
154 *seg_fix_tailP = fixP;
156 #endif /* REVERSE_SORT_RELOCS */
163 /* Create a fixup relative to a symbol (plus a constant). */
166 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
167 fragS *frag; /* Which frag? */
168 int where; /* Where in that frag? */
169 short int size; /* 1, 2, or 4 usually. */
170 symbolS *add_symbol; /* X_add_symbol. */
171 offsetT offset; /* X_add_number. */
172 int pcrel; /* TRUE if PC-relative relocation. */
174 bfd_reloc_code_real_type r_type; /* Relocation type */
176 int r_type; /* Relocation type */
179 return fix_new_internal (frag, where, size, add_symbol,
180 (symbolS *) NULL, offset, pcrel, r_type);
183 /* Create a fixup for an expression. Currently we only support fixups
184 for difference expressions. That is itself more than most object
185 file formats support anyhow. */
188 fix_new_exp (frag, where, size, exp, pcrel, r_type)
189 fragS *frag; /* Which frag? */
190 int where; /* Where in that frag? */
191 short int size; /* 1, 2, or 4 usually. */
192 expressionS *exp; /* Expression. */
193 int pcrel; /* TRUE if PC-relative relocation. */
195 bfd_reloc_code_real_type r_type; /* Relocation type */
197 int r_type; /* Relocation type */
210 sub = exp->X_add_symbol;
211 off = exp->X_add_number;
215 sub = exp->X_op_symbol;
218 add = exp->X_add_symbol;
221 off = exp->X_add_number;
225 as_bad ("expression too complex for fixup");
228 return fix_new_internal (frag, where, size, add, sub, off,
232 /* Append a string onto another string, bumping the pointer along. */
234 append (charPP, fromP, length)
237 unsigned long length;
239 /* Don't trust memcpy() of 0 chars. */
243 memcpy (*charPP, fromP, length);
247 #ifndef BFD_ASSEMBLER
248 int section_alignment[SEG_MAXIMUM_ORDINAL];
252 * This routine records the largest alignment seen for each segment.
253 * If the beginning of the segment is aligned on the worst-case
254 * boundary, all of the other alignments within it will work. At
255 * least one object format really uses this info.
258 record_alignment (seg, align)
259 /* Segment to which alignment pertains */
261 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
266 if (align > bfd_get_section_alignment (stdoutput, seg))
267 bfd_set_section_alignment (stdoutput, seg, align);
269 if (align > section_alignment[(int) seg])
270 section_alignment[(int) seg] = align;
274 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
277 chain_frchains_together_1 (section, frchp)
279 struct frchain *frchp;
281 fragS dummy, *prev_frag = &dummy;
282 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
284 prev_frag->fr_next = frchp->frch_root;
285 prev_frag = frchp->frch_last;
287 prev_frag->fr_next = 0;
296 chain_frchains_together (abfd, section, xxx)
297 bfd *abfd; /* unused */
299 char *xxx; /* unused */
301 segment_info_type *info;
303 /* BFD may have introduced its own sections without using
304 subseg_new, so it is possible that seg_info is NULL. */
305 info = seg_info (section);
306 if (info != (segment_info_type *) NULL)
307 chain_frchains_together_1 (section, info->frchainP);
312 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
315 remove_subsegs (head, seg, root, last)
321 *root = head->frch_root;
322 *last = chain_frchains_together_1 (seg, head);
327 #if defined (BFD_ASSEMBLER) || !defined (BFD)
331 cvt_frag_to_fill (sec, fragP)
336 cvt_frag_to_fill (headers, fragP)
337 object_headers *headers;
341 switch (fragP->fr_type)
346 HANDLE_ALIGN (fragP);
348 fragP->fr_type = rs_fill;
349 know (fragP->fr_var == 1);
350 know (fragP->fr_next != NULL);
352 fragP->fr_offset = (fragP->fr_next->fr_address
360 case rs_machine_dependent:
362 md_convert_frag (stdoutput, sec, fragP);
364 md_convert_frag (headers, fragP);
367 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
370 * After md_convert_frag, we make the frag into a ".space 0".
371 * Md_convert_frag() should set up any fixSs and constants
377 #ifndef WORKING_DOT_WORD
380 struct broken_word *lie;
382 if (fragP->fr_subtype)
384 fragP->fr_fix += md_short_jump_size;
385 for (lie = (struct broken_word *) (fragP->fr_symbol);
386 lie && lie->dispfrag == fragP;
387 lie = lie->next_broken_word)
389 fragP->fr_fix += md_long_jump_size;
397 BAD_CASE (fragP->fr_type);
402 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
406 relax_and_size_seg (abfd, sec, xxx)
413 segment_info_type *seginfo;
415 valueT size, newsize;
417 flags = bfd_get_section_flags (abfd, sec);
419 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
420 if (seginfo && seginfo->frchainP)
422 relax_segment (seginfo->frchainP->frch_root, sec);
423 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
424 cvt_frag_to_fill (sec, fragp);
425 for (fragp = seginfo->frchainP->frch_root;
427 fragp = fragp->fr_next)
428 /* walk to last elt */;
429 size = fragp->fr_address + fragp->fr_fix;
435 flags |= SEC_HAS_CONTENTS;
436 /* @@ This is just an approximation. */
437 if (seginfo->fix_root)
441 x = bfd_set_section_flags (abfd, sec, flags);
444 size = md_section_align (sec, size);
445 x = bfd_set_section_size (abfd, sec, size);
448 /* If the size had to be rounded up, add some padding in the last
450 newsize = bfd_get_section_size_before_reloc (sec);
451 assert (newsize >= size);
454 fragS *last = seginfo->frchainP->frch_last;
455 fragp = seginfo->frchainP->frch_root;
456 while (fragp->fr_next != last)
457 fragp = fragp->fr_next;
458 last->fr_address = size;
459 fragp->fr_offset += newsize - size;
462 #ifdef tc_frob_section
463 tc_frob_section (sec);
465 #ifdef obj_frob_section
466 obj_frob_section (sec);
472 dump_section_relocs (abfd, sec, stream_)
477 FILE *stream = (FILE *) stream_;
478 segment_info_type *seginfo = seg_info (sec);
479 fixS *fixp = seginfo->fix_root;
484 fprintf (stream, "sec %s relocs:\n", sec->name);
487 symbolS *s = fixp->fx_addsy;
489 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
490 S_GET_NAME (s), s->bsym->section->name,
491 S_GET_VALUE (s), fixp->fx_offset);
493 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
494 fixp = fixp->fx_next;
498 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
502 adjust_reloc_syms (abfd, sec, xxx)
507 segment_info_type *seginfo = seg_info (sec);
513 dump_section_relocs (abfd, sec, stderr);
515 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
518 symbolS *sym = fixp->fx_addsy;
519 asection *symsec = sym->bsym->section;
520 segment_info_type *symseginfo = seg_info (symsec);
522 /* If it's one of these sections, assume the symbol is definitely
523 going to be output. */
524 if (symsec == &bfd_und_section
525 || symsec == &bfd_abs_section
526 || bfd_is_com_section (symsec))
528 fixp->fx_addsy->sy_used_in_reloc = 1;
532 /* Since we're reducing to section symbols, don't attempt to reduce
533 anything that's already using one. */
534 if (sym->bsym == symsec->symbol)
536 fixp->fx_addsy->sy_used_in_reloc = 1;
540 /* Is there some other reason we can't adjust this one? (E.g.,
541 call/bal links in i960-bout symbols.) */
542 #ifdef obj_fix_adjustable
543 if (! obj_fix_adjustable (fixp))
545 fixp->fx_addsy->sy_used_in_reloc = 1;
550 /* Is there some other (target cpu dependent) reason we can't adjust
551 this one? (E.g. relocations involving function addresses on
553 #ifdef tc_fix_adjustable
554 if (! tc_fix_adjustable (fixp))
558 /* If the section symbol isn't going to be output, the relocs
559 at least should still work. If not, figure out what to do
560 when we run into that case. */
561 fixp->fx_offset += S_GET_VALUE (sym);
563 fixp->fx_offset += sym->sy_frag->fr_address;
565 fixp->fx_addsy = symseginfo->sym;
568 fixp->fx_addsy = symbol_find (symsec->name);
571 fixp->fx_addsy = symbol_make (symsec->name);
572 fixp->fx_addsy->bsym = symsec->symbol;
574 symseginfo->sym = fixp->fx_addsy;
576 fixp->fx_addsy->sy_used_in_reloc = 1;
579 dump_section_relocs (abfd, sec, stderr);
583 write_relocs (abfd, sec, xxx)
588 segment_info_type *seginfo = seg_info (sec);
594 /* If seginfo is NULL, we did not create this section; don't do
599 fixup_segment (seginfo->fix_root, sec);
602 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
605 #ifndef RELOC_EXPANSION_POSSIBLE
606 /* Set up reloc information as well. */
607 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
608 n * sizeof (arelent *));
609 memset ((char*)relocs, 0, n * sizeof (arelent*));
612 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
616 bfd_reloc_status_type s;
618 if (fixp->fx_addsy == 0)
620 /* @@ Need some other flag to indicate which have already
625 reloc = tc_gen_reloc (sec, fixp);
631 data = fixp->fx_frag->fr_literal + fixp->fx_where;
632 /* @@ Assumes max size of reloc is 4. */
633 if (fixp->fx_where + 4
634 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
636 /* Pass bogus address so that when bfd_perform_relocation adds
637 `address' back in, it'll come up with `data', which is where
638 we want it to operate. */
639 if (reloc->howto->partial_inplace == false
640 && reloc->howto->pcrel_offset == true
641 && reloc->howto->pc_relative == true)
643 /* bfd_perform_relocation screws this up */
644 reloc->addend += reloc->address;
646 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
653 as_fatal ("bad return from bfd_perform_relocation");
658 n = n * MAX_RELOC_EXPANSION;
659 /* Set up reloc information as well. */
660 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
661 n * sizeof (arelent *));
664 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
668 bfd_reloc_status_type s;
671 if (fixp->fx_addsy == 0)
673 /* @@ Need some other flag to indicate which have already
678 reloc = tc_gen_reloc (sec, fixp);
680 for (j = 0; reloc[j]; j++)
682 relocs[i++] = reloc[j];
685 data = fixp->fx_frag->fr_literal + fixp->fx_where;
686 if (fixp->fx_where + 4
687 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
689 for (j = 0; reloc[j]; j++)
691 s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
698 as_fatal ("bad return from bfd_perform_relocation");
706 bfd_set_reloc (stdoutput, sec, relocs, n);
708 bfd_set_section_flags (abfd, sec,
709 (bfd_get_section_flags (abfd, sec)
710 & (flagword) ~SEC_RELOC));
716 fprintf (stderr, "relocs for sec %s\n", sec->name);
717 for (i = 0; i < n; i++)
721 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
722 i, r, r->address, s->name, r->addend);
729 write_contents (abfd, sec, xxx)
734 segment_info_type *seginfo = seg_info (sec);
735 unsigned long offset = 0;
738 /* Write out the frags. */
740 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
743 for (f = seginfo->frchainP->frch_root;
748 unsigned long fill_size;
752 assert (f->fr_type == rs_fill);
755 x = bfd_set_section_contents (stdoutput, sec,
756 f->fr_literal, (file_ptr) offset,
757 (bfd_size_type) f->fr_fix);
761 fill_literal = f->fr_literal + f->fr_fix;
762 fill_size = f->fr_var;
763 count = f->fr_offset;
765 if (fill_size && count)
768 x = bfd_set_section_contents (stdoutput, sec,
769 fill_literal, (file_ptr) offset,
770 (bfd_size_type) fill_size);
778 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
780 merge_data_into_text ()
782 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
783 seg_info (text_section)->frchainP->frch_last->fr_next =
784 seg_info (data_section)->frchainP->frch_root;
785 seg_info (text_section)->frchainP->frch_last =
786 seg_info (data_section)->frchainP->frch_last;
787 seg_info (data_section)->frchainP = 0;
791 text_last_frag->fr_next = data_frag_root;
792 text_last_frag = data_last_frag;
793 data_last_frag = NULL;
794 data_frag_root = NULL;
797 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
798 tmp->fx_next = data_fix_root;
799 text_fix_tail = data_fix_tail;
802 text_fix_root = data_fix_root;
803 data_fix_root = NULL;
806 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
808 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
810 relax_and_size_all_segments ()
814 relax_segment (text_frag_root, SEG_TEXT);
815 relax_segment (data_frag_root, SEG_DATA);
816 relax_segment (bss_frag_root, SEG_BSS);
818 * Now the addresses of frags are correct within the segment.
821 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
822 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
823 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
826 * Join the 2 segments into 1 huge segment.
827 * To do this, re-compute every rn_address in the SEG_DATA frags.
828 * Then join the data frags after the text frags.
830 * Determine a_data [length of data segment].
834 register relax_addressT slide;
836 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
838 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
839 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
840 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
842 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
843 /* For b.out: If the data section has a strict alignment
844 requirement, its load address in the .o file will be
845 rounded up from the size of the text section. These
846 two values are *not* the same! Similarly for the bss
848 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
851 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
853 fragP->fr_address += slide;
854 } /* for each data frag */
856 know (text_last_frag != 0);
857 text_last_frag->fr_next = data_frag_root;
861 H_SET_DATA_SIZE (&headers, 0);
865 /* See above comments on b.out data section address. */
868 if (data_last_frag == 0)
869 bss_vma = H_GET_TEXT_SIZE (&headers);
871 bss_vma = data_last_frag->fr_address;
872 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
873 bss_address_frag.fr_address = bss_vma;
875 #else /* ! OBJ_BOUT */
876 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
877 H_GET_DATA_SIZE (&headers));
879 #endif /* ! OBJ_BOUT */
881 /* Slide all the frags */
884 relax_addressT slide = bss_address_frag.fr_address;
886 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
888 fragP->fr_address += slide;
889 } /* for each bss frag */
893 H_SET_BSS_SIZE (&headers,
894 bss_last_frag->fr_address - bss_frag_root->fr_address);
896 H_SET_BSS_SIZE (&headers, 0);
898 #endif /* ! BFD_ASSEMBLER && ! BFD */
900 #if defined (BFD_ASSEMBLER) || !defined (BFD)
905 register struct frchain *frchainP; /* Track along all frchains. */
906 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
907 register fragS *fragP; /* Track along all frags. */
909 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
910 long object_file_size;
913 /* Do we really want to write it? */
916 n_warns = had_warnings ();
917 n_errs = had_errors ();
918 /* The -Z flag indicates that an object file should be generated,
919 regardless of warnings and errors. */
922 if (n_warns || n_errs)
923 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
924 n_errs, n_errs == 1 ? "" : "s",
925 n_warns, n_warns == 1 ? "" : "s");
930 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
931 n_errs, n_errs == 1 ? "" : "s",
932 n_warns, n_warns == 1 ? "" : "s");
938 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
939 * call a routine to check for the definition of the procedure
940 * "_main", and if so -- fix it up so that it can be program
943 VMS_Check_For_Main ();
946 /* After every sub-segment, we fake an ".align ...". This conforms to
947 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
948 frag that requires least thought. ".align" frags like to have a
949 following frag since that makes calculating their intended length
952 @@ Is this really necessary?? */
953 #ifndef SUB_SEGMENT_ALIGN
955 #define SUB_SEGMENT_ALIGN(SEG) (0)
957 #define SUB_SEGMENT_ALIGN(SEG) (2)
960 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
962 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
963 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
964 /* frag_align will have left a new frag.
965 Use this last frag for an empty ".fill".
968 Create a last frag. Do not leave a "being filled in frag". */
969 frag_wane (frag_now);
970 frag_now->fr_fix = 0;
971 know (frag_now->fr_next == NULL);
974 /* From now on, we don't care about sub-segments. Build one frag chain
975 for each segment. Linked thru fr_next. */
978 /* Remove the sections created by gas for its own purposes. */
980 asection **seclist, *sec;
981 seclist = &stdoutput->sections;
982 while (seclist && *seclist)
985 while (sec == reg_section || sec == expr_section)
989 stdoutput->section_count--;
994 seclist = &(*seclist)->next;
998 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1000 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1001 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1002 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1005 /* We have two segments. If user gave -R flag, then we must put the
1006 data frags into the text segment. Do this before relaxing so
1007 we know to take advantage of -R and make shorter addresses. */
1008 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1011 merge_data_into_text ();
1015 #ifdef BFD_ASSEMBLER
1016 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1018 relax_and_size_all_segments ();
1019 #endif /* BFD_ASSEMBLER */
1021 #ifndef BFD_ASSEMBLER
1024 * Crawl the symbol chain.
1026 * For each symbol whose value depends on a frag, take the address of
1027 * that frag and subsume it into the value of the symbol.
1028 * After this, there is just one way to lookup a symbol value.
1029 * Values are left in their final state for object file emission.
1030 * We adjust the values of 'L' local symbols, even if we do
1031 * not intend to emit them to the object file, because their values
1032 * are needed for fix-ups.
1034 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1035 * from the symbol chain. (They are still pointed to by the fixes.)
1037 * Count the remaining symbols.
1038 * Assign a symbol number to each symbol.
1039 * Count the number of string-table chars we will emit.
1040 * Put this info into the headers as appropriate.
1043 know (zero_address_frag.fr_address == 0);
1044 string_byte_count = sizeof (string_byte_count);
1046 obj_crawl_symbol_chain (&headers);
1048 if (string_byte_count == sizeof (string_byte_count))
1049 string_byte_count = 0;
1051 H_SET_STRING_SIZE (&headers, string_byte_count);
1054 * Addresses of frags now reflect addresses we use in the object file.
1055 * Symbol values are correct.
1056 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1057 * Also converting any machine-dependent frags using md_convert_frag();
1059 subseg_change (SEG_TEXT, 0);
1061 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1063 cvt_frag_to_fill (&headers, fragP);
1065 /* Some assert macros don't work with # directives mixed in. */
1067 if (!(fragP->fr_next == NULL
1069 || fragP->fr_next == data_frag_root
1071 || ((fragP->fr_next->fr_address - fragP->fr_address)
1072 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1076 #endif /* ! BFD_ASSEMBLER */
1078 #ifndef WORKING_DOT_WORD
1080 struct broken_word *lie;
1081 struct broken_word **prevP;
1083 prevP = &broken_words;
1084 for (lie = broken_words; lie; lie = lie->next_broken_word)
1089 exp.X_op = O_subtract;
1090 exp.X_add_symbol = lie->add;
1091 exp.X_op_symbol = lie->sub;
1092 exp.X_add_number = lie->addnum;
1093 #ifdef BFD_ASSEMBLER
1094 fix_new_exp (lie->frag,
1095 lie->word_goes_here - lie->frag->fr_literal,
1096 2, &exp, 0, BFD_RELOC_NONE);
1098 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1099 fix_new_exp (lie->frag,
1100 lie->word_goes_here - lie->frag->fr_literal,
1101 2, &exp, 0, NO_RELOC);
1104 fix_new_ns32k_exp (lie->frag,
1105 lie->word_goes_here - lie->frag->fr_literal,
1106 2, &exp, 0, 0, 2, 0, 0);
1108 fix_new_exp (lie->frag,
1109 lie->word_goes_here - lie->frag->fr_literal,
1111 #endif /* TC_NS32K */
1112 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1113 #endif /* BFD_ASSEMBLER */
1114 *prevP = lie->next_broken_word;
1117 prevP = &(lie->next_broken_word);
1119 for (lie = broken_words; lie;)
1121 struct broken_word *untruth;
1123 addressT table_addr;
1124 addressT from_addr, to_addr;
1127 fragP = lie->dispfrag;
1129 /* Find out how many broken_words go here. */
1131 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1132 if (untruth->added == 1)
1135 table_ptr = lie->dispfrag->fr_opcode;
1136 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1137 /* Create the jump around the long jumps. This is a short
1138 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1139 from_addr = table_addr;
1140 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1141 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1142 table_ptr += md_short_jump_size;
1143 table_addr += md_short_jump_size;
1145 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1147 if (lie->added == 2)
1149 /* Patch the jump table */
1150 /* This is the offset from ??? to table_ptr+0 */
1151 to_addr = table_addr - S_GET_VALUE (lie->sub);
1152 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1153 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1155 if (untruth->use_jump == lie)
1156 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1159 /* Install the long jump */
1160 /* this is a long jump from table_ptr+0 to the final target */
1161 from_addr = table_addr;
1162 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1163 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1164 table_ptr += md_long_jump_size;
1165 table_addr += md_long_jump_size;
1169 #endif /* not WORKING_DOT_WORD */
1171 #ifndef BFD_ASSEMBLER
1175 * Scan every FixS performing fixups. We had to wait until now to do
1176 * this because md_convert_frag() may have made some fixSs.
1180 subseg_change (SEG_TEXT, 0);
1181 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1182 subseg_change (SEG_DATA, 0);
1183 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1184 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1186 /* FIXME move this stuff into the pre-write-hook */
1187 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1188 H_SET_ENTRY_POINT (&headers, 0);
1190 obj_pre_write_hook (&headers); /* extra coff stuff */
1192 object_file_size = H_GET_FILE_SIZE (&headers);
1193 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1195 output_file_create (out_file_name);
1197 obj_header_append (&next_object_file_charP, &headers);
1199 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1204 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1206 register long count;
1207 register char *fill_literal;
1208 register long fill_size;
1210 know (fragP->fr_type == rs_fill);
1211 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1212 fill_literal = fragP->fr_literal + fragP->fr_fix;
1213 fill_size = fragP->fr_var;
1214 know (fragP->fr_offset >= 0);
1216 for (count = fragP->fr_offset; count; count--)
1218 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1221 } /* for each code frag. */
1223 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1228 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1229 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)));
1231 /* Make addresses in data relocation directives relative to beginning of
1232 * first data fragment, not end of last text fragment: alignment of the
1233 * start of the data segment may place a gap between the segments.
1235 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1237 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1238 #endif /* TC_I960 */
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) + H_GET_DATA_RELOCATION_SIZE (&headers)));
1243 * Emit line number entries.
1245 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1246 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)));
1251 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1252 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)));
1258 if (string_byte_count > 0)
1260 obj_emit_strings (&next_object_file_charP);
1261 } /* only if we have a string table */
1264 bfd_seek (stdoutput, 0, 0);
1265 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1268 /* Write the data to the file */
1269 output_file_append (the_object_file, object_file_size, out_file_name);
1272 output_file_close (out_file_name);
1273 } /* non vms output */
1276 * Now do the VMS-dependent part of writing the object file
1278 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1279 H_GET_DATA_SIZE (&headers),
1280 H_GET_BSS_SIZE (&headers),
1281 text_frag_root, data_frag_root);
1283 #else /* BFD_ASSEMBLER */
1285 #ifdef obj_check_file_symbols
1286 obj_check_file_symbols ();
1289 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1291 /* Set up symbol table, and write it out. */
1298 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1300 if (! symp->sy_resolved)
1302 if (symp->sy_value.X_op == O_constant)
1304 /* This is the normal case; skip the call. */
1307 + symp->sy_frag->fr_address));
1308 symp->sy_resolved = 1;
1311 resolve_symbol_value (symp);
1314 /* So far, common symbols have been treated like undefined symbols.
1315 Put them in the common section now. */
1316 if (S_IS_DEFINED (symp) == 0
1317 && S_GET_VALUE (symp) != 0)
1318 S_SET_SEGMENT (symp, &bfd_com_section);
1320 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1321 S_GET_NAME (symp), symp,
1324 segment_name (symp->bsym->section));
1326 if (! symp->sy_used_in_reloc)
1328 #ifdef obj_frob_symbol
1331 obj_frob_symbol (symp, punt);
1336 #ifdef tc_frob_symbol
1339 tc_frob_symbol (symp, punt);
1346 /* If we don't want to keep this symbol, splice it out of the
1348 if (! symp->sy_used_in_reloc
1349 && S_IS_LOCAL (symp))
1351 symbolS *prev, *next;
1352 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1355 prev = symbol_previous (symp);
1356 next = symbol_next (symp);
1358 verify_symbol_chain_2 (symp);
1362 symbol_next (prev) = next;
1365 else if (symp == symbol_rootP)
1366 symbol_rootP = next;
1370 symbol_previous (next) = prev;
1372 symbol_lastP = prev;
1375 verify_symbol_chain_2 (prev);
1377 verify_symbol_chain_2 (next);
1382 /* Make sure we really got a value for the symbol. */
1383 if (! symp->sy_resolved)
1385 as_bad ("can't resolve value for symbol \"%s\"",
1387 symp->sy_resolved = 1;
1390 /* Set the value into the BFD symbol. Up til now the value
1391 has only been kept in the gas symbolS struct. */
1392 symp->bsym->value = S_GET_VALUE (symp);
1401 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1403 asympp = (asymbol **) bfd_alloc (stdoutput,
1404 n * sizeof (asymbol *));
1405 symp = symbol_rootP;
1406 for (i = 0; i < n; i++, symp = symbol_next (symp))
1408 asympp[i] = symp->bsym;
1411 result = bfd_set_symtab (stdoutput, asympp, n);
1412 assert (result == true);
1417 #ifdef obj_frob_file
1418 /* If obj_frob_file changes the symbol value at this point, it is
1419 responsible for moving the changed value into symp->bsym->value
1420 as well. Hopefully all symbol value changing can be done in
1421 {obj,tc}_frob_symbol. */
1425 /* Now that all the sizes are known, and contents correct, we can
1426 start writing the file. */
1427 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1429 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1431 output_file_close (out_file_name);
1432 #endif /* BFD_ASSEMBLER */
1439 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1444 * After this, all frags in this segment have addresses that are correct
1445 * within the segment. Since segments live in different file addresses,
1446 * these frag addresses may not be the same as final object-file addresses.
1449 /* Subroutines of relax_segment. */
1455 for (; f1; f1 = f1->fr_next)
1456 if (f1->fr_next == f2)
1461 /* Relax_align. Advance location counter to next address that has 'alignment'
1462 lowest order bits all 0s, return size of adjustment made. */
1463 static relax_addressT
1464 relax_align (address, alignment)
1465 register relax_addressT address; /* Address now. */
1466 register int alignment; /* Alignment (binary). */
1468 relax_addressT mask;
1469 relax_addressT new_address;
1471 mask = ~((~0) << alignment);
1472 new_address = (address + mask) & (~mask);
1474 /* We must provide lots of padding, so the linker can discard it
1475 when needed. The linker will not add extra space, ever. */
1476 new_address += (1 << alignment);
1477 return (new_address - address);
1481 relax_segment (segment_frag_root, segment)
1482 struct frag *segment_frag_root;
1485 register struct frag *fragP;
1486 register relax_addressT address;
1487 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1488 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1490 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1491 subseg_change (segment, 0);
1493 /* For each frag in segment: count and store (a 1st guess of)
1496 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1498 fragP->fr_address = address;
1499 address += fragP->fr_fix;
1501 switch (fragP->fr_type)
1504 address += fragP->fr_offset * fragP->fr_var;
1508 address += relax_align (address, (int) fragP->fr_offset);
1512 /* Assume .org is nugatory. It will grow with 1st relax. */
1515 case rs_machine_dependent:
1516 address += md_estimate_size_before_relax (fragP, segment);
1519 #ifndef WORKING_DOT_WORD
1520 /* Broken words don't concern us yet */
1521 case rs_broken_word:
1526 BAD_CASE (fragP->fr_type);
1528 } /* switch(fr_type) */
1529 } /* for each frag in the segment */
1533 long stretch; /* May be any size, 0 or negative. */
1534 /* Cumulative number of addresses we have */
1535 /* relaxed this pass. */
1536 /* We may have relaxed more than one address. */
1537 long stretched; /* Have we stretched on this pass? */
1538 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1539 grew, and another shrank. If a branch instruction doesn't fit anymore,
1540 we could be scrod. */
1544 stretch = stretched = 0;
1545 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1548 unsigned long was_address;
1554 was_address = fragP->fr_address;
1555 address = fragP->fr_address += stretch;
1556 symbolP = fragP->fr_symbol;
1557 offset = fragP->fr_offset;
1559 switch (fragP->fr_type)
1561 case rs_fill: /* .fill never relaxes. */
1565 #ifndef WORKING_DOT_WORD
1566 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1567 for it I do not want to write it. I do not want to have
1568 anything to do with it. This is not the proper way to
1569 implement this misfeature. */
1570 case rs_broken_word:
1572 struct broken_word *lie;
1573 struct broken_word *untruth;
1575 /* Yes this is ugly (storing the broken_word pointer
1576 in the symbol slot). Still, this whole chunk of
1577 code is ugly, and I don't feel like doing anything
1578 about it. Think of it as stubbornness in action. */
1580 for (lie = (struct broken_word *) (fragP->fr_symbol);
1581 lie && lie->dispfrag == fragP;
1582 lie = lie->next_broken_word)
1588 offset = (lie->add->sy_frag->fr_address
1589 + S_GET_VALUE (lie->add)
1591 - (lie->sub->sy_frag->fr_address
1592 + S_GET_VALUE (lie->sub)));
1593 if (offset <= -32768 || offset >= 32767)
1598 sprint_value (buf, (addressT) lie->addnum);
1599 as_warn (".word %s-%s+%s didn't fit",
1600 S_GET_NAME (lie->add),
1601 S_GET_NAME (lie->sub),
1605 if (fragP->fr_subtype == 0)
1607 fragP->fr_subtype++;
1608 growth += md_short_jump_size;
1610 for (untruth = lie->next_broken_word;
1611 untruth && untruth->dispfrag == lie->dispfrag;
1612 untruth = untruth->next_broken_word)
1613 if ((untruth->add->sy_frag == lie->add->sy_frag)
1614 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1617 untruth->use_jump = lie;
1619 growth += md_long_jump_size;
1624 } /* case rs_broken_word */
1627 growth = (relax_align ((relax_addressT) (address
1630 - relax_align ((relax_addressT) (was_address
1640 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1641 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1642 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1643 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1644 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1645 know (symbolP->sy_frag);
1646 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1647 || (symbolP->sy_frag == &zero_address_frag));
1649 target += S_GET_VALUE (symbolP)
1650 + symbolP->sy_frag->fr_address;
1651 } /* if we have a symbol */
1653 know (fragP->fr_next);
1654 after = fragP->fr_next->fr_address;
1655 growth = ((target - after) > 0) ? (target - after) : 0;
1656 /* Growth may be negative, but variable part of frag
1657 cannot have fewer than 0 chars. That is, we can't
1660 growth -= stretch; /* This is an absolute growth factor */
1663 case rs_machine_dependent:
1665 const relax_typeS *this_type;
1666 const relax_typeS *start_type;
1667 relax_substateT next_state;
1668 relax_substateT this_state;
1671 this_state = fragP->fr_subtype;
1672 start_type = this_type = md_relax_table + this_state;
1677 #ifndef DIFF_EXPR_OK
1678 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1679 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1680 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1681 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1682 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1684 know (symbolP->sy_frag);
1686 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1687 || symbolP->sy_frag == &zero_address_frag);
1689 S_GET_VALUE (symbolP)
1690 + symbolP->sy_frag->fr_address;
1692 /* If frag has yet to be reached on this pass,
1693 assume it will move by STRETCH just as we did.
1694 If this is not so, it will be because some frag
1695 between grows, and that will force another pass.
1697 Beware zero-length frags.
1699 There should be a faster way to do this. */
1701 if (symbolP->sy_frag->fr_address >= was_address
1702 && is_dnrange (fragP, symbolP->sy_frag))
1708 aim = target - address - fragP->fr_fix;
1709 /* The displacement is affected by the instruction size
1710 for the 32k architecture. I think we ought to be able
1711 to add fragP->fr_pcrel_adjust in all cases (it should be
1712 zero if not used), but just in case it breaks something
1713 else we'll put this inside #ifdef NS32K ... #endif */
1715 if (fragP->fr_pcrel_adjust)
1718 aim += fragP->fr_pcrel_adjust;
1722 /* Look backwards. */
1723 for (next_state = this_type->rlx_more; next_state;)
1724 if (aim >= this_type->rlx_backward)
1728 /* Grow to next state. */
1729 this_state = next_state;
1730 this_type = md_relax_table + this_state;
1731 next_state = this_type->rlx_more;
1736 #ifdef M68K_AIM_KLUDGE
1737 M68K_AIM_KLUDGE (aim, this_state, this_type);
1739 /* Look forwards. */
1740 for (next_state = this_type->rlx_more; next_state;)
1741 if (aim <= this_type->rlx_forward)
1745 /* Grow to next state. */
1746 this_state = next_state;
1747 this_type = md_relax_table + this_state;
1748 next_state = this_type->rlx_more;
1752 growth = this_type->rlx_length - start_type->rlx_length;
1754 fragP->fr_subtype = this_state;
1759 BAD_CASE (fragP->fr_type);
1767 } /* For each frag in the segment. */
1769 while (stretched); /* Until nothing further to relax. */
1773 * We now have valid fr_address'es for each frag.
1777 * All fr_address's are correct, relative to their own segment.
1778 * We have made all the fixS we will ever make.
1780 } /* relax_segment() */
1782 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1786 Go through all the fixS's in a segment and see which ones can be
1787 handled now. (These consist of fixS where we have since discovered
1788 the value of a symbol, or the address of the frag involved.)
1789 For each one, call md_apply_fix to put the fix into the frag data.
1791 Result is a count of how many relocation structs will be needed to
1792 handle the remaining fixS's that we couldn't completely handle here.
1793 These will be output later by emit_relocations(). */
1796 fixup_segment (fixP, this_segment_type)
1797 register fixS *fixP;
1798 segT this_segment_type; /* N_TYPE bits for segment. */
1800 register long seg_reloc_count;
1801 register symbolS *add_symbolP;
1802 register symbolS *sub_symbolP;
1805 register char *place;
1806 register long where;
1807 register char pcrel;
1808 register fragS *fragP;
1809 register segT add_symbol_segment = absolute_section;
1811 seg_reloc_count = 0;
1812 /* If the linker is doing the relaxing, we must not do any fixups. */
1813 /* Well, strictly speaking that's not true -- we could do any that
1814 are PC-relative and don't cross regions that could change size.
1815 And for the i960 (the only machine for which we've got a relaxing
1816 linker right now), we might be able to turn callx/callj into bal
1817 in cases where we know the maximum displacement. */
1819 for (; fixP; fixP = fixP->fx_next)
1822 for (; fixP; fixP = fixP->fx_next)
1824 fragP = fixP->fx_frag;
1826 where = fixP->fx_where;
1827 place = fragP->fr_literal + where;
1828 size = fixP->fx_size;
1829 add_symbolP = fixP->fx_addsy;
1831 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
1833 /* Relocation should be done via the associated 'bal'
1834 entry point symbol. */
1836 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1838 as_bad ("No 'bal' entry point for leafproc %s",
1839 S_GET_NAME (add_symbolP));
1842 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1845 sub_symbolP = fixP->fx_subsy;
1846 add_number = fixP->fx_offset;
1847 pcrel = fixP->fx_pcrel;
1850 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1857 /* @@ Should try converting to pcrel ref to fixed addr. */
1858 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1859 as_bad ("Negative of non-absolute symbol %s",
1860 S_GET_NAME (sub_symbolP));
1862 add_number -= S_GET_VALUE (sub_symbolP);
1864 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1865 && (SEG_NORMAL (add_symbol_segment)
1866 || (add_symbol_segment == absolute_section)))
1868 /* Difference of 2 symbols from same segment.
1869 Can't make difference of 2 undefineds: 'value' means
1870 something different for N_UNDF. */
1872 /* Makes no sense to use the difference of 2 arbitrary symbols
1873 as the target of a call instruction. */
1876 as_bad ("callj to difference of 2 symbols");
1878 #endif /* TC_I960 */
1879 add_number += S_GET_VALUE (add_symbolP) -
1880 S_GET_VALUE (sub_symbolP);
1883 fixP->fx_addsy = NULL;
1885 #if !defined(SEG_DIFF_ALLOWED) && !defined (GLOBAL_DIFF_ALLOWED)
1888 /* Different segments in subtraction. */
1889 know (!(S_IS_EXTERNAL (sub_symbolP)
1890 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1892 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1894 add_number -= S_GET_VALUE (sub_symbolP);
1898 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
1900 /* Make it pc-relative. */
1901 add_number += (md_pcrel_from (fixP)
1902 - S_GET_VALUE (sub_symbolP));
1912 sprint_value (buf, fragP->fr_address + where);
1913 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1914 segment_name (S_GET_SEGMENT (sub_symbolP)),
1915 S_GET_NAME (sub_symbolP), buf);
1921 fixP->fx_addnumber = add_number; /* Remember value for emit_reloc */
1930 if (add_symbol_segment == this_segment_type && pcrel)
1933 * This fixup was made when the symbol's segment was
1934 * SEG_UNKNOWN, but it is now in the local segment.
1935 * So we know how to do the address without relocation.
1938 /* reloc_callj() may replace a 'call' with a 'calls' or a
1939 'bal', in which cases it modifies *fixP as appropriate.
1940 In the case of a 'calls', no further work is required,
1941 and *fixP has been set up to make the rest of the code
1944 #endif /* TC_I960 */
1946 add_number += S_GET_VALUE (add_symbolP);
1947 add_number -= md_pcrel_from (fixP);
1948 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1950 fixP->fx_addsy = NULL; /* No relocations please. */
1955 if (add_symbol_segment == absolute_section)
1958 /* See comment about reloc_callj() above. */
1960 #endif /* TC_I960 */
1961 add_number += S_GET_VALUE (add_symbolP);
1962 fixP->fx_addsy = NULL;
1965 else if (add_symbol_segment == undefined_section
1966 #ifdef BFD_ASSEMBLER
1967 || bfd_is_com_section (add_symbol_segment)
1972 if ((int) fixP->fx_bit_fixP == 13)
1974 /* This is a COBR instruction. They have only a
1975 * 13-bit displacement and are only to be used
1976 * for local branches: flag as error, don't generate
1979 as_bad ("can't use COBR format with external label");
1980 fixP->fx_addsy = NULL; /* No relocations please. */
1983 #endif /* TC_I960 */
1987 if (S_IS_COMMON (add_symbolP))
1988 add_number += S_GET_VALUE (add_symbolP);
1989 #endif /* TE_I386AIX */
1990 #endif /* OBJ_COFF */
1996 add_number += S_GET_VALUE (add_symbolP);
2003 add_number -= md_pcrel_from (fixP);
2004 if (add_symbolP == 0)
2006 fixP->fx_addsy = &abs_symbol;
2008 } /* if there's an add_symbol */
2011 if (!fixP->fx_bit_fixP)
2014 /* set all bits to one */
2016 /* Technically speaking, combining these produces an
2017 undefined result if size is sizeof (valueT), though I
2018 think these two half-way operations should both be
2022 if ((add_number & mask) != 0
2023 && (add_number & mask) != mask)
2025 char buf[50], buf2[50];
2026 sprint_value (buf, fragP->fr_address + where);
2027 if (add_number > 1000)
2028 sprint_value (buf2, add_number);
2030 sprintf (buf2, "%ld", (long) add_number);
2031 as_bad_where (fixP->fx_file, fixP->fx_line,
2032 "Value of %s too large for field of %d bytes at %s",
2034 } /* generic error checking */
2035 #ifdef WARN_SIGNED_OVERFLOW_WORD
2036 /* Warn if a .word value is too large when treated as a signed
2037 number. We already know it is not too negative. This is to
2038 catch over-large switches generated by gcc on the 68k. */
2041 && add_number > 0x7fff)
2042 as_bad_where (fixP->fx_file, fixP->fx_line,
2043 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2045 (unsigned long) (fragP->fr_address + where));
2047 } /* not a bit fix */
2049 #ifdef BFD_ASSEMBLER
2050 md_apply_fix (fixP, &add_number);
2052 md_apply_fix (fixP, add_number);
2054 } /* For each fixS in this segment. */
2056 #if defined (OBJ_COFF) && defined (TC_I960)
2060 /* two relocs per callj under coff. */
2061 for (fixP = topP; fixP; fixP = fixP->fx_next)
2062 if (fixP->fx_callj && fixP->fx_addsy != 0)
2065 #endif /* OBJ_COFF && TC_I960 */
2067 return (seg_reloc_count);
2070 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2072 /* end of write.c */