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;
119 fixP->tc_fix_data = NULL;
128 as_where (&fixP->fx_file, &fixP->fx_line);
130 /* Usually, we want relocs sorted numerically, but while
131 comparing to older versions of gas that have relocs
132 reverse sorted, it is convenient to have this compile
133 time option. xoxorich. */
138 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
139 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
142 #ifdef REVERSE_SORT_RELOCS
144 fixP->fx_next = *seg_fix_rootP;
145 *seg_fix_rootP = fixP;
147 #else /* REVERSE_SORT_RELOCS */
149 fixP->fx_next = NULL;
152 (*seg_fix_tailP)->fx_next = fixP;
154 *seg_fix_rootP = fixP;
155 *seg_fix_tailP = fixP;
157 #endif /* REVERSE_SORT_RELOCS */
164 /* Create a fixup relative to a symbol (plus a constant). */
167 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
168 fragS *frag; /* Which frag? */
169 int where; /* Where in that frag? */
170 short int size; /* 1, 2, or 4 usually. */
171 symbolS *add_symbol; /* X_add_symbol. */
172 offsetT offset; /* X_add_number. */
173 int pcrel; /* TRUE if PC-relative relocation. */
175 bfd_reloc_code_real_type r_type; /* Relocation type */
177 int r_type; /* Relocation type */
180 return fix_new_internal (frag, where, size, add_symbol,
181 (symbolS *) NULL, offset, pcrel, r_type);
184 /* Create a fixup for an expression. Currently we only support fixups
185 for difference expressions. That is itself more than most object
186 file formats support anyhow. */
189 fix_new_exp (frag, where, size, exp, pcrel, r_type)
190 fragS *frag; /* Which frag? */
191 int where; /* Where in that frag? */
192 short int size; /* 1, 2, or 4 usually. */
193 expressionS *exp; /* Expression. */
194 int pcrel; /* TRUE if PC-relative relocation. */
196 bfd_reloc_code_real_type r_type; /* Relocation type */
198 int r_type; /* Relocation type */
211 sub = exp->X_add_symbol;
212 off = exp->X_add_number;
216 sub = exp->X_op_symbol;
219 add = exp->X_add_symbol;
222 off = exp->X_add_number;
226 as_bad ("expression too complex for fixup");
229 return fix_new_internal (frag, where, size, add, sub, off,
233 /* Append a string onto another string, bumping the pointer along. */
235 append (charPP, fromP, length)
238 unsigned long length;
240 /* Don't trust memcpy() of 0 chars. */
244 memcpy (*charPP, fromP, length);
248 #ifndef BFD_ASSEMBLER
249 int section_alignment[SEG_MAXIMUM_ORDINAL];
253 * This routine records the largest alignment seen for each segment.
254 * If the beginning of the segment is aligned on the worst-case
255 * boundary, all of the other alignments within it will work. At
256 * least one object format really uses this info.
259 record_alignment (seg, align)
260 /* Segment to which alignment pertains */
262 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
267 if (align > bfd_get_section_alignment (stdoutput, seg))
268 bfd_set_section_alignment (stdoutput, seg, align);
270 if (align > section_alignment[(int) seg])
271 section_alignment[(int) seg] = align;
275 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
278 chain_frchains_together_1 (section, frchp)
280 struct frchain *frchp;
282 fragS dummy, *prev_frag = &dummy;
283 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
285 prev_frag->fr_next = frchp->frch_root;
286 prev_frag = frchp->frch_last;
288 prev_frag->fr_next = 0;
297 chain_frchains_together (abfd, section, xxx)
298 bfd *abfd; /* unused */
300 char *xxx; /* unused */
302 segment_info_type *info;
304 /* BFD may have introduced its own sections without using
305 subseg_new, so it is possible that seg_info is NULL. */
306 info = seg_info (section);
307 if (info != (segment_info_type *) NULL)
308 info->frchainP->frch_last
309 = chain_frchains_together_1 (section, info->frchainP);
314 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
317 remove_subsegs (head, seg, root, last)
323 *root = head->frch_root;
324 *last = chain_frchains_together_1 (seg, head);
329 #if defined (BFD_ASSEMBLER) || !defined (BFD)
333 cvt_frag_to_fill (sec, fragP)
338 cvt_frag_to_fill (headers, fragP)
339 object_headers *headers;
343 switch (fragP->fr_type)
348 HANDLE_ALIGN (fragP);
350 fragP->fr_type = rs_fill;
351 know (fragP->fr_var == 1);
352 know (fragP->fr_next != NULL);
354 fragP->fr_offset = (fragP->fr_next->fr_address
362 case rs_machine_dependent:
364 md_convert_frag (stdoutput, sec, fragP);
366 md_convert_frag (headers, fragP);
369 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
372 * After md_convert_frag, we make the frag into a ".space 0".
373 * Md_convert_frag() should set up any fixSs and constants
379 #ifndef WORKING_DOT_WORD
382 struct broken_word *lie;
384 if (fragP->fr_subtype)
386 fragP->fr_fix += md_short_jump_size;
387 for (lie = (struct broken_word *) (fragP->fr_symbol);
388 lie && lie->dispfrag == fragP;
389 lie = lie->next_broken_word)
391 fragP->fr_fix += md_long_jump_size;
399 BAD_CASE (fragP->fr_type);
404 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
408 relax_and_size_seg (abfd, sec, xxx)
415 segment_info_type *seginfo;
417 valueT size, newsize;
419 flags = bfd_get_section_flags (abfd, sec);
421 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
422 if (seginfo && seginfo->frchainP)
424 relax_segment (seginfo->frchainP->frch_root, sec);
425 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
426 cvt_frag_to_fill (sec, fragp);
427 for (fragp = seginfo->frchainP->frch_root;
429 fragp = fragp->fr_next)
430 /* walk to last elt */;
431 size = fragp->fr_address + fragp->fr_fix;
437 flags |= SEC_HAS_CONTENTS;
438 /* @@ This is just an approximation. */
439 if (seginfo->fix_root)
443 x = bfd_set_section_flags (abfd, sec, flags);
446 newsize = md_section_align (sec, size);
447 x = bfd_set_section_size (abfd, sec, newsize);
450 /* If the size had to be rounded up, add some padding in the last
452 assert (newsize >= size);
455 fragS *last = seginfo->frchainP->frch_last;
456 fragp = seginfo->frchainP->frch_root;
457 while (fragp->fr_next != last)
458 fragp = fragp->fr_next;
459 last->fr_address = size;
460 fragp->fr_offset += newsize - size;
463 #ifdef tc_frob_section
464 tc_frob_section (sec);
466 #ifdef obj_frob_section
467 obj_frob_section (sec);
473 dump_section_relocs (abfd, sec, stream_)
478 FILE *stream = (FILE *) stream_;
479 segment_info_type *seginfo = seg_info (sec);
480 fixS *fixp = seginfo->fix_root;
485 fprintf (stream, "sec %s relocs:\n", sec->name);
488 symbolS *s = fixp->fx_addsy;
490 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
491 S_GET_NAME (s), s->bsym->section->name,
492 S_GET_VALUE (s), fixp->fx_offset);
494 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
495 fixp = fixp->fx_next;
499 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
503 adjust_reloc_syms (abfd, sec, xxx)
508 segment_info_type *seginfo = seg_info (sec);
514 dump_section_relocs (abfd, sec, stderr);
516 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
519 symbolS *sym = fixp->fx_addsy;
520 asection *symsec = sym->bsym->section;
521 segment_info_type *symseginfo = seg_info (symsec);
523 /* If it's one of these sections, assume the symbol is definitely
524 going to be output. */
525 if (symsec == &bfd_und_section
526 || symsec == &bfd_abs_section
527 || bfd_is_com_section (symsec))
529 fixp->fx_addsy->sy_used_in_reloc = 1;
533 /* Since we're reducing to section symbols, don't attempt to reduce
534 anything that's already using one. */
535 if (sym->bsym == symsec->symbol)
537 fixp->fx_addsy->sy_used_in_reloc = 1;
541 /* Is there some other reason we can't adjust this one? (E.g.,
542 call/bal links in i960-bout symbols.) */
543 #ifdef obj_fix_adjustable
544 if (! obj_fix_adjustable (fixp))
546 fixp->fx_addsy->sy_used_in_reloc = 1;
551 /* Is there some other (target cpu dependent) reason we can't adjust
552 this one? (E.g. relocations involving function addresses on
554 #ifdef tc_fix_adjustable
555 if (! tc_fix_adjustable (fixp))
557 fixp->fx_addsy->sy_used_in_reloc = 1;
562 /* If the section symbol isn't going to be output, the relocs
563 at least should still work. If not, figure out what to do
564 when we run into that case. */
565 fixp->fx_offset += S_GET_VALUE (sym);
567 fixp->fx_offset += sym->sy_frag->fr_address;
569 fixp->fx_addsy = symseginfo->sym;
572 fixp->fx_addsy = symbol_find (symsec->name);
575 fixp->fx_addsy = symbol_make (symsec->name);
576 fixp->fx_addsy->bsym = symsec->symbol;
578 symseginfo->sym = fixp->fx_addsy;
580 fixp->fx_addsy->sy_used_in_reloc = 1;
583 dump_section_relocs (abfd, sec, stderr);
587 write_relocs (abfd, sec, xxx)
592 segment_info_type *seginfo = seg_info (sec);
598 /* If seginfo is NULL, we did not create this section; don't do
603 fixup_segment (seginfo->fix_root, sec);
606 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
609 #ifndef RELOC_EXPANSION_POSSIBLE
610 /* Set up reloc information as well. */
611 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
612 n * sizeof (arelent *));
613 memset ((char*)relocs, 0, n * sizeof (arelent*));
616 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
620 bfd_reloc_status_type s;
622 if (fixp->fx_addsy == 0)
624 /* @@ Need some other flag to indicate which have already
629 reloc = tc_gen_reloc (sec, fixp);
635 data = fixp->fx_frag->fr_literal + fixp->fx_where;
636 if (fixp->fx_where + fixp->fx_size
637 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
639 /* Pass bogus address so that when bfd_perform_relocation adds
640 `address' back in, it'll come up with `data', which is where
641 we want it to operate. */
642 if (reloc->howto->partial_inplace == false
643 && reloc->howto->pcrel_offset == true
644 && reloc->howto->pc_relative == true)
646 /* bfd_perform_relocation screws this up */
647 reloc->addend += reloc->address;
649 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
656 as_fatal ("bad return from bfd_perform_relocation");
661 n = n * MAX_RELOC_EXPANSION;
662 /* Set up reloc information as well. */
663 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
664 n * sizeof (arelent *));
667 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
671 bfd_reloc_status_type s;
674 if (fixp->fx_addsy == 0)
676 /* @@ Need some other flag to indicate which have already
681 reloc = tc_gen_reloc (sec, fixp);
683 for (j = 0; reloc[j]; j++)
685 relocs[i++] = reloc[j];
688 data = fixp->fx_frag->fr_literal + fixp->fx_where;
689 if (fixp->fx_where + fixp->fx_size
690 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
692 for (j = 0; reloc[j]; j++)
694 s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
701 as_fatal ("bad return from bfd_perform_relocation");
709 bfd_set_reloc (stdoutput, sec, relocs, n);
711 bfd_set_section_flags (abfd, sec,
712 (bfd_get_section_flags (abfd, sec)
713 & (flagword) ~SEC_RELOC));
719 fprintf (stderr, "relocs for sec %s\n", sec->name);
720 for (i = 0; i < n; i++)
724 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
725 i, r, r->address, s->name, r->addend);
732 write_contents (abfd, sec, xxx)
737 segment_info_type *seginfo = seg_info (sec);
738 unsigned long offset = 0;
741 /* Write out the frags. */
743 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
746 for (f = seginfo->frchainP->frch_root;
751 unsigned long fill_size;
755 assert (f->fr_type == rs_fill);
758 x = bfd_set_section_contents (stdoutput, sec,
759 f->fr_literal, (file_ptr) offset,
760 (bfd_size_type) f->fr_fix);
764 fill_literal = f->fr_literal + f->fr_fix;
765 fill_size = f->fr_var;
766 count = f->fr_offset;
768 if (fill_size && count)
771 x = bfd_set_section_contents (stdoutput, sec,
772 fill_literal, (file_ptr) offset,
773 (bfd_size_type) fill_size);
781 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
783 merge_data_into_text ()
785 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
786 seg_info (text_section)->frchainP->frch_last->fr_next =
787 seg_info (data_section)->frchainP->frch_root;
788 seg_info (text_section)->frchainP->frch_last =
789 seg_info (data_section)->frchainP->frch_last;
790 seg_info (data_section)->frchainP = 0;
794 text_last_frag->fr_next = data_frag_root;
795 text_last_frag = data_last_frag;
796 data_last_frag = NULL;
797 data_frag_root = NULL;
800 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
801 tmp->fx_next = data_fix_root;
802 text_fix_tail = data_fix_tail;
805 text_fix_root = data_fix_root;
806 data_fix_root = NULL;
809 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
811 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
813 relax_and_size_all_segments ()
817 relax_segment (text_frag_root, SEG_TEXT);
818 relax_segment (data_frag_root, SEG_DATA);
819 relax_segment (bss_frag_root, SEG_BSS);
821 * Now the addresses of frags are correct within the segment.
824 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
825 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
826 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
829 * Join the 2 segments into 1 huge segment.
830 * To do this, re-compute every rn_address in the SEG_DATA frags.
831 * Then join the data frags after the text frags.
833 * Determine a_data [length of data segment].
837 register relax_addressT slide;
839 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
841 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
842 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
843 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
845 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
846 /* For b.out: If the data section has a strict alignment
847 requirement, its load address in the .o file will be
848 rounded up from the size of the text section. These
849 two values are *not* the same! Similarly for the bss
851 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
854 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
856 fragP->fr_address += slide;
857 } /* for each data frag */
859 know (text_last_frag != 0);
860 text_last_frag->fr_next = data_frag_root;
864 H_SET_DATA_SIZE (&headers, 0);
868 /* See above comments on b.out data section address. */
871 if (data_last_frag == 0)
872 bss_vma = H_GET_TEXT_SIZE (&headers);
874 bss_vma = data_last_frag->fr_address;
875 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
876 bss_address_frag.fr_address = bss_vma;
878 #else /* ! OBJ_BOUT */
879 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
880 H_GET_DATA_SIZE (&headers));
882 #endif /* ! OBJ_BOUT */
884 /* Slide all the frags */
887 relax_addressT slide = bss_address_frag.fr_address;
889 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
891 fragP->fr_address += slide;
892 } /* for each bss frag */
896 H_SET_BSS_SIZE (&headers,
897 bss_last_frag->fr_address - bss_frag_root->fr_address);
899 H_SET_BSS_SIZE (&headers, 0);
901 #endif /* ! BFD_ASSEMBLER && ! BFD */
903 #if defined (BFD_ASSEMBLER) || !defined (BFD)
908 register struct frchain *frchainP; /* Track along all frchains. */
909 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
910 register fragS *fragP; /* Track along all frags. */
912 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
913 long object_file_size;
916 /* Do we really want to write it? */
919 n_warns = had_warnings ();
920 n_errs = had_errors ();
921 /* The -Z flag indicates that an object file should be generated,
922 regardless of warnings and errors. */
925 if (n_warns || n_errs)
926 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
927 n_errs, n_errs == 1 ? "" : "s",
928 n_warns, n_warns == 1 ? "" : "s");
933 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
934 n_errs, n_errs == 1 ? "" : "s",
935 n_warns, n_warns == 1 ? "" : "s");
941 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
942 * call a routine to check for the definition of the procedure
943 * "_main", and if so -- fix it up so that it can be program
946 VMS_Check_For_Main ();
949 /* After every sub-segment, we fake an ".align ...". This conforms to
950 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
951 frag that requires least thought. ".align" frags like to have a
952 following frag since that makes calculating their intended length
955 @@ Is this really necessary?? */
956 #ifndef SUB_SEGMENT_ALIGN
958 #define SUB_SEGMENT_ALIGN(SEG) (0)
960 #define SUB_SEGMENT_ALIGN(SEG) (2)
963 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
965 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
966 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
967 /* frag_align will have left a new frag.
968 Use this last frag for an empty ".fill".
971 Create a last frag. Do not leave a "being filled in frag". */
972 frag_wane (frag_now);
973 frag_now->fr_fix = 0;
974 know (frag_now->fr_next == NULL);
977 /* From now on, we don't care about sub-segments. Build one frag chain
978 for each segment. Linked thru fr_next. */
981 /* Remove the sections created by gas for its own purposes. */
983 asection **seclist, *sec;
984 seclist = &stdoutput->sections;
985 while (seclist && *seclist)
988 while (sec == reg_section || sec == expr_section)
992 stdoutput->section_count--;
997 seclist = &(*seclist)->next;
1001 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1003 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1004 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1005 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1008 /* We have two segments. If user gave -R flag, then we must put the
1009 data frags into the text segment. Do this before relaxing so
1010 we know to take advantage of -R and make shorter addresses. */
1011 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1014 merge_data_into_text ();
1018 #ifdef BFD_ASSEMBLER
1019 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1021 relax_and_size_all_segments ();
1022 #endif /* BFD_ASSEMBLER */
1024 #ifndef BFD_ASSEMBLER
1027 * Crawl the symbol chain.
1029 * For each symbol whose value depends on a frag, take the address of
1030 * that frag and subsume it into the value of the symbol.
1031 * After this, there is just one way to lookup a symbol value.
1032 * Values are left in their final state for object file emission.
1033 * We adjust the values of 'L' local symbols, even if we do
1034 * not intend to emit them to the object file, because their values
1035 * are needed for fix-ups.
1037 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1038 * from the symbol chain. (They are still pointed to by the fixes.)
1040 * Count the remaining symbols.
1041 * Assign a symbol number to each symbol.
1042 * Count the number of string-table chars we will emit.
1043 * Put this info into the headers as appropriate.
1046 know (zero_address_frag.fr_address == 0);
1047 string_byte_count = sizeof (string_byte_count);
1049 obj_crawl_symbol_chain (&headers);
1051 if (string_byte_count == sizeof (string_byte_count))
1052 string_byte_count = 0;
1054 H_SET_STRING_SIZE (&headers, string_byte_count);
1057 * Addresses of frags now reflect addresses we use in the object file.
1058 * Symbol values are correct.
1059 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1060 * Also converting any machine-dependent frags using md_convert_frag();
1062 subseg_change (SEG_TEXT, 0);
1064 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1066 cvt_frag_to_fill (&headers, fragP);
1068 /* Some assert macros don't work with # directives mixed in. */
1070 if (!(fragP->fr_next == NULL
1072 || fragP->fr_next == data_frag_root
1074 || ((fragP->fr_next->fr_address - fragP->fr_address)
1075 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1079 #endif /* ! BFD_ASSEMBLER */
1081 #ifndef WORKING_DOT_WORD
1083 struct broken_word *lie;
1084 struct broken_word **prevP;
1086 prevP = &broken_words;
1087 for (lie = broken_words; lie; lie = lie->next_broken_word)
1092 exp.X_op = O_subtract;
1093 exp.X_add_symbol = lie->add;
1094 exp.X_op_symbol = lie->sub;
1095 exp.X_add_number = lie->addnum;
1096 #ifdef BFD_ASSEMBLER
1097 fix_new_exp (lie->frag,
1098 lie->word_goes_here - lie->frag->fr_literal,
1099 2, &exp, 0, BFD_RELOC_NONE);
1101 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1102 fix_new_exp (lie->frag,
1103 lie->word_goes_here - lie->frag->fr_literal,
1104 2, &exp, 0, NO_RELOC);
1107 fix_new_ns32k_exp (lie->frag,
1108 lie->word_goes_here - lie->frag->fr_literal,
1109 2, &exp, 0, 0, 2, 0, 0);
1111 fix_new_exp (lie->frag,
1112 lie->word_goes_here - lie->frag->fr_literal,
1114 #endif /* TC_NS32K */
1115 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1116 #endif /* BFD_ASSEMBLER */
1117 *prevP = lie->next_broken_word;
1120 prevP = &(lie->next_broken_word);
1122 for (lie = broken_words; lie;)
1124 struct broken_word *untruth;
1126 addressT table_addr;
1127 addressT from_addr, to_addr;
1130 fragP = lie->dispfrag;
1132 /* Find out how many broken_words go here. */
1134 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1135 if (untruth->added == 1)
1138 table_ptr = lie->dispfrag->fr_opcode;
1139 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1140 /* Create the jump around the long jumps. This is a short
1141 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1142 from_addr = table_addr;
1143 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1144 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1145 table_ptr += md_short_jump_size;
1146 table_addr += md_short_jump_size;
1148 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1150 if (lie->added == 2)
1152 /* Patch the jump table */
1153 /* This is the offset from ??? to table_ptr+0 */
1154 to_addr = table_addr - S_GET_VALUE (lie->sub);
1155 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1156 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1158 if (untruth->use_jump == lie)
1159 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1162 /* Install the long jump */
1163 /* this is a long jump from table_ptr+0 to the final target */
1164 from_addr = table_addr;
1165 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1166 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1167 table_ptr += md_long_jump_size;
1168 table_addr += md_long_jump_size;
1172 #endif /* not WORKING_DOT_WORD */
1174 #ifndef BFD_ASSEMBLER
1178 * Scan every FixS performing fixups. We had to wait until now to do
1179 * this because md_convert_frag() may have made some fixSs.
1183 subseg_change (SEG_TEXT, 0);
1184 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1185 subseg_change (SEG_DATA, 0);
1186 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1187 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1189 /* FIXME move this stuff into the pre-write-hook */
1190 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1191 H_SET_ENTRY_POINT (&headers, 0);
1193 obj_pre_write_hook (&headers); /* extra coff stuff */
1195 object_file_size = H_GET_FILE_SIZE (&headers);
1196 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1198 output_file_create (out_file_name);
1200 obj_header_append (&next_object_file_charP, &headers);
1202 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1207 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1209 register long count;
1210 register char *fill_literal;
1211 register long fill_size;
1213 know (fragP->fr_type == rs_fill);
1214 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1215 fill_literal = fragP->fr_literal + fragP->fr_fix;
1216 fill_size = fragP->fr_var;
1217 know (fragP->fr_offset >= 0);
1219 for (count = fragP->fr_offset; count; count--)
1221 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1224 } /* for each code frag. */
1226 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1231 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1232 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)));
1234 /* Make addresses in data relocation directives relative to beginning of
1235 * first data fragment, not end of last text fragment: alignment of the
1236 * start of the data segment may place a gap between the segments.
1238 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1240 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1241 #endif /* TC_I960 */
1243 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)));
1246 * Emit line number entries.
1248 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1249 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)));
1254 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1255 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)));
1261 if (string_byte_count > 0)
1263 obj_emit_strings (&next_object_file_charP);
1264 } /* only if we have a string table */
1267 bfd_seek (stdoutput, 0, 0);
1268 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1271 /* Write the data to the file */
1272 output_file_append (the_object_file, object_file_size, out_file_name);
1275 output_file_close (out_file_name);
1276 } /* non vms output */
1279 * Now do the VMS-dependent part of writing the object file
1281 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1282 H_GET_DATA_SIZE (&headers),
1283 H_GET_BSS_SIZE (&headers),
1284 text_frag_root, data_frag_root);
1286 #else /* BFD_ASSEMBLER */
1288 #ifdef obj_check_file_symbols
1289 obj_check_file_symbols ();
1292 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1294 /* Set up symbol table, and write it out. */
1301 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1303 if (! symp->sy_resolved)
1305 if (symp->sy_value.X_op == O_constant)
1307 /* This is the normal case; skip the call. */
1310 + symp->sy_frag->fr_address));
1311 symp->sy_resolved = 1;
1314 resolve_symbol_value (symp);
1317 /* So far, common symbols have been treated like undefined symbols.
1318 Put them in the common section now. */
1319 if (S_IS_DEFINED (symp) == 0
1320 && S_GET_VALUE (symp) != 0)
1321 S_SET_SEGMENT (symp, &bfd_com_section);
1323 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1324 S_GET_NAME (symp), symp,
1327 segment_name (symp->bsym->section));
1329 if (! symp->sy_used_in_reloc)
1331 #ifdef obj_frob_symbol
1334 obj_frob_symbol (symp, punt);
1339 #ifdef tc_frob_symbol
1342 tc_frob_symbol (symp, punt);
1349 /* If we don't want to keep this symbol, splice it out of the
1351 if (! symp->sy_used_in_reloc
1352 && S_IS_LOCAL (symp))
1354 symbolS *prev, *next;
1355 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1358 prev = symbol_previous (symp);
1359 next = symbol_next (symp);
1361 verify_symbol_chain_2 (symp);
1365 symbol_next (prev) = next;
1368 else if (symp == symbol_rootP)
1369 symbol_rootP = next;
1373 symbol_previous (next) = prev;
1375 symbol_lastP = prev;
1378 verify_symbol_chain_2 (prev);
1380 verify_symbol_chain_2 (next);
1385 /* Make sure we really got a value for the symbol. */
1386 if (! symp->sy_resolved)
1388 as_bad ("can't resolve value for symbol \"%s\"",
1390 symp->sy_resolved = 1;
1393 /* Set the value into the BFD symbol. Up til now the value
1394 has only been kept in the gas symbolS struct. */
1395 symp->bsym->value = S_GET_VALUE (symp);
1404 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1406 asympp = (asymbol **) bfd_alloc (stdoutput,
1407 n * sizeof (asymbol *));
1408 symp = symbol_rootP;
1409 for (i = 0; i < n; i++, symp = symbol_next (symp))
1411 asympp[i] = symp->bsym;
1414 result = bfd_set_symtab (stdoutput, asympp, n);
1415 assert (result == true);
1420 #ifdef obj_frob_file
1421 /* If obj_frob_file changes the symbol value at this point, it is
1422 responsible for moving the changed value into symp->bsym->value
1423 as well. Hopefully all symbol value changing can be done in
1424 {obj,tc}_frob_symbol. */
1428 /* Now that all the sizes are known, and contents correct, we can
1429 start writing the file. */
1430 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1432 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1434 output_file_close (out_file_name);
1435 #endif /* BFD_ASSEMBLER */
1442 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1447 * After this, all frags in this segment have addresses that are correct
1448 * within the segment. Since segments live in different file addresses,
1449 * these frag addresses may not be the same as final object-file addresses.
1452 /* Subroutines of relax_segment. */
1458 for (; f1; f1 = f1->fr_next)
1459 if (f1->fr_next == f2)
1464 /* Relax_align. Advance location counter to next address that has 'alignment'
1465 lowest order bits all 0s, return size of adjustment made. */
1466 static relax_addressT
1467 relax_align (address, alignment)
1468 register relax_addressT address; /* Address now. */
1469 register int alignment; /* Alignment (binary). */
1471 relax_addressT mask;
1472 relax_addressT new_address;
1474 mask = ~((~0) << alignment);
1475 new_address = (address + mask) & (~mask);
1477 /* We must provide lots of padding, so the linker can discard it
1478 when needed. The linker will not add extra space, ever. */
1479 new_address += (1 << alignment);
1480 return (new_address - address);
1484 relax_segment (segment_frag_root, segment)
1485 struct frag *segment_frag_root;
1488 register struct frag *fragP;
1489 register relax_addressT address;
1490 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1491 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1493 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1494 subseg_change (segment, 0);
1496 /* For each frag in segment: count and store (a 1st guess of)
1499 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1501 fragP->fr_address = address;
1502 address += fragP->fr_fix;
1504 switch (fragP->fr_type)
1507 address += fragP->fr_offset * fragP->fr_var;
1511 address += relax_align (address, (int) fragP->fr_offset);
1515 /* Assume .org is nugatory. It will grow with 1st relax. */
1518 case rs_machine_dependent:
1519 address += md_estimate_size_before_relax (fragP, segment);
1522 #ifndef WORKING_DOT_WORD
1523 /* Broken words don't concern us yet */
1524 case rs_broken_word:
1529 BAD_CASE (fragP->fr_type);
1531 } /* switch(fr_type) */
1532 } /* for each frag in the segment */
1536 long stretch; /* May be any size, 0 or negative. */
1537 /* Cumulative number of addresses we have */
1538 /* relaxed this pass. */
1539 /* We may have relaxed more than one address. */
1540 long stretched; /* Have we stretched on this pass? */
1541 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1542 grew, and another shrank. If a branch instruction doesn't fit anymore,
1543 we could be scrod. */
1547 stretch = stretched = 0;
1548 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1551 unsigned long was_address;
1557 was_address = fragP->fr_address;
1558 address = fragP->fr_address += stretch;
1559 symbolP = fragP->fr_symbol;
1560 offset = fragP->fr_offset;
1562 switch (fragP->fr_type)
1564 case rs_fill: /* .fill never relaxes. */
1568 #ifndef WORKING_DOT_WORD
1569 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1570 for it I do not want to write it. I do not want to have
1571 anything to do with it. This is not the proper way to
1572 implement this misfeature. */
1573 case rs_broken_word:
1575 struct broken_word *lie;
1576 struct broken_word *untruth;
1578 /* Yes this is ugly (storing the broken_word pointer
1579 in the symbol slot). Still, this whole chunk of
1580 code is ugly, and I don't feel like doing anything
1581 about it. Think of it as stubbornness in action. */
1583 for (lie = (struct broken_word *) (fragP->fr_symbol);
1584 lie && lie->dispfrag == fragP;
1585 lie = lie->next_broken_word)
1591 offset = (lie->add->sy_frag->fr_address
1592 + S_GET_VALUE (lie->add)
1594 - (lie->sub->sy_frag->fr_address
1595 + S_GET_VALUE (lie->sub)));
1596 if (offset <= -32768 || offset >= 32767)
1601 sprint_value (buf, (addressT) lie->addnum);
1602 as_warn (".word %s-%s+%s didn't fit",
1603 S_GET_NAME (lie->add),
1604 S_GET_NAME (lie->sub),
1608 if (fragP->fr_subtype == 0)
1610 fragP->fr_subtype++;
1611 growth += md_short_jump_size;
1613 for (untruth = lie->next_broken_word;
1614 untruth && untruth->dispfrag == lie->dispfrag;
1615 untruth = untruth->next_broken_word)
1616 if ((untruth->add->sy_frag == lie->add->sy_frag)
1617 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1620 untruth->use_jump = lie;
1622 growth += md_long_jump_size;
1627 } /* case rs_broken_word */
1630 growth = (relax_align ((relax_addressT) (address
1633 - relax_align ((relax_addressT) (was_address
1643 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1644 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1645 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1646 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1647 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1648 know (symbolP->sy_frag);
1649 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1650 || (symbolP->sy_frag == &zero_address_frag));
1652 target += S_GET_VALUE (symbolP)
1653 + symbolP->sy_frag->fr_address;
1654 } /* if we have a symbol */
1656 know (fragP->fr_next);
1657 after = fragP->fr_next->fr_address;
1658 growth = ((target - after) > 0) ? (target - after) : 0;
1659 /* Growth may be negative, but variable part of frag
1660 cannot have fewer than 0 chars. That is, we can't
1663 growth -= stretch; /* This is an absolute growth factor */
1666 case rs_machine_dependent:
1668 const relax_typeS *this_type;
1669 const relax_typeS *start_type;
1670 relax_substateT next_state;
1671 relax_substateT this_state;
1674 this_state = fragP->fr_subtype;
1675 start_type = this_type = md_relax_table + this_state;
1680 #ifndef DIFF_EXPR_OK
1681 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1682 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1683 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1684 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1685 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1687 know (symbolP->sy_frag);
1689 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1690 || symbolP->sy_frag == &zero_address_frag);
1692 S_GET_VALUE (symbolP)
1693 + symbolP->sy_frag->fr_address;
1695 /* If frag has yet to be reached on this pass,
1696 assume it will move by STRETCH just as we did.
1697 If this is not so, it will be because some frag
1698 between grows, and that will force another pass.
1700 Beware zero-length frags.
1702 There should be a faster way to do this. */
1704 if (symbolP->sy_frag->fr_address >= was_address
1705 && is_dnrange (fragP, symbolP->sy_frag))
1711 aim = target - address - fragP->fr_fix;
1712 /* The displacement is affected by the instruction size
1713 for the 32k architecture. I think we ought to be able
1714 to add fragP->fr_pcrel_adjust in all cases (it should be
1715 zero if not used), but just in case it breaks something
1716 else we'll put this inside #ifdef NS32K ... #endif */
1718 if (fragP->fr_pcrel_adjust)
1721 aim += fragP->fr_pcrel_adjust;
1725 /* Look backwards. */
1726 for (next_state = this_type->rlx_more; next_state;)
1727 if (aim >= this_type->rlx_backward)
1731 /* Grow to next state. */
1732 this_state = next_state;
1733 this_type = md_relax_table + this_state;
1734 next_state = this_type->rlx_more;
1739 #ifdef M68K_AIM_KLUDGE
1740 M68K_AIM_KLUDGE (aim, this_state, this_type);
1742 /* Look forwards. */
1743 for (next_state = this_type->rlx_more; next_state;)
1744 if (aim <= this_type->rlx_forward)
1748 /* Grow to next state. */
1749 this_state = next_state;
1750 this_type = md_relax_table + this_state;
1751 next_state = this_type->rlx_more;
1755 growth = this_type->rlx_length - start_type->rlx_length;
1757 fragP->fr_subtype = this_state;
1762 BAD_CASE (fragP->fr_type);
1770 } /* For each frag in the segment. */
1772 while (stretched); /* Until nothing further to relax. */
1776 * We now have valid fr_address'es for each frag.
1780 * All fr_address's are correct, relative to their own segment.
1781 * We have made all the fixS we will ever make.
1783 } /* relax_segment() */
1785 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1789 Go through all the fixS's in a segment and see which ones can be
1790 handled now. (These consist of fixS where we have since discovered
1791 the value of a symbol, or the address of the frag involved.)
1792 For each one, call md_apply_fix to put the fix into the frag data.
1794 Result is a count of how many relocation structs will be needed to
1795 handle the remaining fixS's that we couldn't completely handle here.
1796 These will be output later by emit_relocations(). */
1799 fixup_segment (fixP, this_segment_type)
1800 register fixS *fixP;
1801 segT this_segment_type; /* N_TYPE bits for segment. */
1803 register long seg_reloc_count;
1804 register symbolS *add_symbolP;
1805 register symbolS *sub_symbolP;
1808 register char *place;
1809 register long where;
1810 register char pcrel;
1811 register fragS *fragP;
1812 register segT add_symbol_segment = absolute_section;
1814 seg_reloc_count = 0;
1815 /* If the linker is doing the relaxing, we must not do any fixups. */
1816 /* Well, strictly speaking that's not true -- we could do any that
1817 are PC-relative and don't cross regions that could change size.
1818 And for the i960 (the only machine for which we've got a relaxing
1819 linker right now), we might be able to turn callx/callj into bal
1820 in cases where we know the maximum displacement. */
1822 for (; fixP; fixP = fixP->fx_next)
1825 for (; fixP; fixP = fixP->fx_next)
1827 fragP = fixP->fx_frag;
1829 where = fixP->fx_where;
1830 place = fragP->fr_literal + where;
1831 size = fixP->fx_size;
1832 add_symbolP = fixP->fx_addsy;
1834 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
1836 /* Relocation should be done via the associated 'bal'
1837 entry point symbol. */
1839 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1841 as_bad ("No 'bal' entry point for leafproc %s",
1842 S_GET_NAME (add_symbolP));
1845 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1848 sub_symbolP = fixP->fx_subsy;
1849 add_number = fixP->fx_offset;
1850 pcrel = fixP->fx_pcrel;
1853 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1860 /* @@ Should try converting to pcrel ref to fixed addr. */
1861 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1862 as_bad ("Negative of non-absolute symbol %s",
1863 S_GET_NAME (sub_symbolP));
1865 add_number -= S_GET_VALUE (sub_symbolP);
1867 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1868 && (SEG_NORMAL (add_symbol_segment)
1869 || (add_symbol_segment == absolute_section)))
1871 /* Difference of 2 symbols from same segment.
1872 Can't make difference of 2 undefineds: 'value' means
1873 something different for N_UNDF. */
1875 /* Makes no sense to use the difference of 2 arbitrary symbols
1876 as the target of a call instruction. */
1879 as_bad ("callj to difference of 2 symbols");
1881 #endif /* TC_I960 */
1882 add_number += S_GET_VALUE (add_symbolP) -
1883 S_GET_VALUE (sub_symbolP);
1886 fixP->fx_addsy = NULL;
1888 #if !defined(SEG_DIFF_ALLOWED) && !defined (GLOBAL_DIFF_ALLOWED)
1891 /* Different segments in subtraction. */
1892 know (!(S_IS_EXTERNAL (sub_symbolP)
1893 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1895 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1897 add_number -= S_GET_VALUE (sub_symbolP);
1900 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1902 /* Do this even if it's already described as
1903 pc-relative. For example, on the m68k, an
1904 operand of "pc@(foo-.-2)" should address "foo"
1905 in a pc-relative mode. */
1910 /* Make it pc-relative. */
1911 add_number += (md_pcrel_from (fixP)
1912 - S_GET_VALUE (sub_symbolP));
1922 sprint_value (buf, fragP->fr_address + where);
1923 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1924 segment_name (S_GET_SEGMENT (sub_symbolP)),
1925 S_GET_NAME (sub_symbolP), buf);
1932 fixP->fx_addnumber = add_number; /* Remember value for emit_reloc */
1940 if (add_symbol_segment == this_segment_type && pcrel)
1943 * This fixup was made when the symbol's segment was
1944 * SEG_UNKNOWN, but it is now in the local segment.
1945 * So we know how to do the address without relocation.
1948 /* reloc_callj() may replace a 'call' with a 'calls' or a
1949 'bal', in which cases it modifies *fixP as appropriate.
1950 In the case of a 'calls', no further work is required,
1951 and *fixP has been set up to make the rest of the code
1954 #endif /* TC_I960 */
1956 add_number += S_GET_VALUE (add_symbolP);
1957 add_number -= md_pcrel_from (fixP);
1958 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1960 fixP->fx_addsy = NULL; /* No relocations please. */
1965 if (add_symbol_segment == absolute_section)
1968 /* See comment about reloc_callj() above. */
1970 #endif /* TC_I960 */
1971 add_number += S_GET_VALUE (add_symbolP);
1972 fixP->fx_addsy = NULL;
1975 else if (add_symbol_segment == undefined_section
1976 #ifdef BFD_ASSEMBLER
1977 || bfd_is_com_section (add_symbol_segment)
1982 if ((int) fixP->fx_bit_fixP == 13)
1984 /* This is a COBR instruction. They have only a
1985 * 13-bit displacement and are only to be used
1986 * for local branches: flag as error, don't generate
1989 as_bad ("can't use COBR format with external label");
1990 fixP->fx_addsy = NULL; /* No relocations please. */
1993 #endif /* TC_I960 */
1997 if (S_IS_COMMON (add_symbolP))
1998 add_number += S_GET_VALUE (add_symbolP);
1999 #endif /* TE_I386AIX */
2000 #endif /* OBJ_COFF */
2006 add_number += S_GET_VALUE (add_symbolP);
2013 add_number -= md_pcrel_from (fixP);
2014 if (add_symbolP == 0)
2016 fixP->fx_addsy = &abs_symbol;
2018 } /* if there's an add_symbol */
2021 if (!fixP->fx_bit_fixP && size > 0)
2024 /* set all bits to one */
2026 /* Technically speaking, combining these produces an
2027 undefined result if size is sizeof (valueT), though I
2028 think these two half-way operations should both be
2032 if ((add_number & mask) != 0
2033 && (add_number & mask) != mask)
2035 char buf[50], buf2[50];
2036 sprint_value (buf, fragP->fr_address + where);
2037 if (add_number > 1000)
2038 sprint_value (buf2, add_number);
2040 sprintf (buf2, "%ld", (long) add_number);
2041 as_bad_where (fixP->fx_file, fixP->fx_line,
2042 "Value of %s too large for field of %d bytes at %s",
2044 } /* generic error checking */
2045 #ifdef WARN_SIGNED_OVERFLOW_WORD
2046 /* Warn if a .word value is too large when treated as a signed
2047 number. We already know it is not too negative. This is to
2048 catch over-large switches generated by gcc on the 68k. */
2051 && add_number > 0x7fff)
2052 as_bad_where (fixP->fx_file, fixP->fx_line,
2053 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2055 (unsigned long) (fragP->fr_address + where));
2057 } /* not a bit fix */
2059 #ifdef BFD_ASSEMBLER
2060 md_apply_fix (fixP, &add_number);
2062 md_apply_fix (fixP, add_number);
2064 } /* For each fixS in this segment. */
2066 #if defined (OBJ_COFF) && defined (TC_I960)
2070 /* two relocs per callj under coff. */
2071 for (fixP = topP; fixP; fixP = fixP->fx_next)
2072 if (fixP->fx_callj && fixP->fx_addsy != 0)
2075 #endif /* OBJ_COFF && TC_I960 */
2077 return (seg_reloc_count);
2080 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2082 /* end of write.c */