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 static object_headers headers;
51 long string_byte_count;
52 static char *the_object_file;
53 char *next_object_file_charP; /* Tracks object file bytes. */
56 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
59 #endif /* BFD_ASSEMBLER */
62 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
63 symbolS *add, symbolS *sub,
64 offsetT offset, int pcrel,
65 bfd_reloc_code_real_type r_type));
67 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
68 symbolS *add, symbolS *sub,
69 offsetT offset, int pcrel,
72 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
73 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
74 void relax_segment PARAMS ((struct frag * seg_frag_root, segT seg_type));
79 * Create a fixS in obstack 'notes'.
82 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
84 fragS *frag; /* Which frag? */
85 int where; /* Where in that frag? */
86 int size; /* 1, 2, or 4 usually. */
87 symbolS *add_symbol; /* X_add_symbol. */
88 symbolS *sub_symbol; /* X_op_symbol. */
89 offsetT offset; /* X_add_number. */
90 int pcrel; /* TRUE if PC-relative relocation. */
92 bfd_reloc_code_real_type r_type; /* Relocation type */
94 int r_type; /* Relocation type */
99 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
101 fixP->fx_frag = frag;
102 fixP->fx_where = where;
103 fixP->fx_size = size;
104 fixP->fx_addsy = add_symbol;
105 fixP->fx_subsy = sub_symbol;
106 fixP->fx_offset = offset;
107 fixP->fx_pcrel = pcrel;
108 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
109 fixP->fx_r_type = r_type;
111 fixP->fx_im_disp = 0;
112 fixP->fx_pcrel_adjust = 0;
113 fixP->fx_bit_fixP = 0;
114 fixP->fx_addnumber = 0;
123 /* Usually, we want relocs sorted numerically, but while
124 comparing to older versions of gas that have relocs
125 reverse sorted, it is convenient to have this compile
126 time option. xoxorich. */
131 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
132 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
135 #ifdef REVERSE_SORT_RELOCS
137 fixP->fx_next = *seg_fix_rootP;
138 *seg_fix_rootP = fixP;
140 #else /* REVERSE_SORT_RELOCS */
142 fixP->fx_next = NULL;
145 (*seg_fix_tailP)->fx_next = fixP;
147 *seg_fix_rootP = fixP;
148 *seg_fix_tailP = fixP;
150 #endif /* REVERSE_SORT_RELOCS */
157 /* Create a fixup relative to a symbol (plus a constant). */
160 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
161 fragS *frag; /* Which frag? */
162 int where; /* Where in that frag? */
163 short int size; /* 1, 2, or 4 usually. */
164 symbolS *add_symbol; /* X_add_symbol. */
165 offsetT offset; /* X_add_number. */
166 int pcrel; /* TRUE if PC-relative relocation. */
168 bfd_reloc_code_real_type r_type; /* Relocation type */
170 int r_type; /* Relocation type */
173 return fix_new_internal (frag, where, size, add_symbol,
174 (symbolS *) NULL, offset, pcrel, r_type);
177 /* Create a fixup for an expression. Currently we only support fixups
178 for difference expressions. That is itself more than most object
179 file formats support anyhow. */
182 fix_new_exp (frag, where, size, exp, pcrel, r_type)
183 fragS *frag; /* Which frag? */
184 int where; /* Where in that frag? */
185 short int size; /* 1, 2, or 4 usually. */
186 expressionS *exp; /* Expression. */
187 int pcrel; /* TRUE if PC-relative relocation. */
189 bfd_reloc_code_real_type r_type; /* Relocation type */
191 int r_type; /* Relocation type */
204 sub = exp->X_add_symbol;
205 off = exp->X_add_number;
209 sub = exp->X_op_symbol;
212 add = exp->X_add_symbol;
215 off = exp->X_add_number;
219 as_bad ("expression too complex for fixup");
222 return fix_new_internal (frag, where, size, add, sub, off,
226 /* Append a string onto another string, bumping the pointer along. */
228 append (charPP, fromP, length)
231 unsigned long length;
233 /* Don't trust memcpy() of 0 chars. */
237 memcpy (*charPP, fromP, (int) length);
241 #ifndef BFD_ASSEMBLER
242 int section_alignment[SEG_MAXIMUM_ORDINAL];
246 * This routine records the largest alignment seen for each segment.
247 * If the beginning of the segment is aligned on the worst-case
248 * boundary, all of the other alignments within it will work. At
249 * least one object format really uses this info.
252 record_alignment (seg, align)
253 /* Segment to which alignment pertains */
255 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
260 if (align > bfd_get_section_alignment (stdoutput, seg))
261 bfd_set_section_alignment (stdoutput, seg, align);
263 if (align > section_alignment[(int) seg])
264 section_alignment[(int) seg] = align;
268 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
271 chain_frchains_together_1 (section, frchp)
273 struct frchain *frchp;
275 fragS dummy, *prev_frag = &dummy;
276 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
278 prev_frag->fr_next = frchp->frch_root;
279 prev_frag = frchp->frch_last;
281 prev_frag->fr_next = 0;
290 chain_frchains_together (abfd, section, xxx)
291 bfd *abfd; /* unused */
293 char *xxx; /* unused */
295 segment_info_type *info;
297 /* BFD may have introduced its own sections without using
298 subseg_new, so it is possible that seg_info is NULL. */
299 info = seg_info (section);
300 if (info != (segment_info_type *) NULL)
301 chain_frchains_together_1 (section, info->frchainP);
306 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
309 remove_subsegs (head, seg, root, last)
315 *root = head->frch_root;
316 *last = chain_frchains_together_1 (seg, head);
323 cvt_frag_to_fill (sec, fragP)
328 cvt_frag_to_fill (headers, fragP)
329 object_headers *headers;
333 switch (fragP->fr_type)
338 HANDLE_ALIGN (fragP);
340 fragP->fr_type = rs_fill;
341 know (fragP->fr_var == 1);
342 know (fragP->fr_next != NULL);
344 fragP->fr_offset = (fragP->fr_next->fr_address
352 case rs_machine_dependent:
354 md_convert_frag (stdoutput, sec, fragP);
356 md_convert_frag (headers, fragP);
359 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
362 * After md_convert_frag, we make the frag into a ".space 0".
363 * Md_convert_frag() should set up any fixSs and constants
369 #ifndef WORKING_DOT_WORD
372 struct broken_word *lie;
374 if (fragP->fr_subtype)
376 fragP->fr_fix += md_short_jump_size;
377 for (lie = (struct broken_word *) (fragP->fr_symbol);
378 lie && lie->dispfrag == fragP;
379 lie = lie->next_broken_word)
381 fragP->fr_fix += md_long_jump_size;
389 BAD_CASE (fragP->fr_type);
396 relax_and_size_seg (abfd, sec, xxx)
403 segment_info_type *seginfo;
405 valueT size, newsize;
407 flags = bfd_get_section_flags (abfd, sec);
409 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
410 if (seginfo && seginfo->frchainP)
412 relax_segment (seginfo->frchainP->frch_root, sec);
413 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
414 cvt_frag_to_fill (sec, fragp);
415 for (fragp = seginfo->frchainP->frch_root;
417 fragp = fragp->fr_next)
418 /* walk to last elt */;
419 size = fragp->fr_address + fragp->fr_fix;
425 flags |= SEC_HAS_CONTENTS;
426 /* @@ This is just an approximation. */
427 if (seginfo->fix_root)
431 x = bfd_set_section_flags (abfd, sec, flags);
434 size = md_section_align (sec, size);
435 x = bfd_set_section_size (abfd, sec, size);
438 /* If the size had to be rounded up, add some padding in the last
440 newsize = bfd_get_section_size_before_reloc (sec);
441 assert (newsize >= size);
444 fragS *last = seginfo->frchainP->frch_last;
445 fragp = seginfo->frchainP->frch_root;
446 while (fragp->fr_next != last)
447 fragp = fragp->fr_next;
448 last->fr_address = size;
449 fragp->fr_offset += newsize - size;
452 #ifdef tc_frob_section
453 tc_frob_section (sec);
455 #ifdef obj_frob_section
456 obj_frob_section (sec);
462 dump_section_relocs (abfd, sec, stream_)
467 FILE *stream = (FILE *) stream_;
468 segment_info_type *seginfo = seg_info (sec);
469 fixS *fixp = seginfo->fix_root;
474 fprintf (stream, "sec %s relocs:\n", sec->name);
477 symbolS *s = fixp->fx_addsy;
479 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
480 S_GET_NAME (s), s->bsym->section->name,
481 S_GET_VALUE (s), fixp->fx_offset);
483 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
484 fixp = fixp->fx_next;
488 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
492 adjust_reloc_syms (abfd, sec, xxx)
497 segment_info_type *seginfo = seg_info (sec);
503 dump_section_relocs (abfd, sec, stderr);
505 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
508 symbolS *sym = fixp->fx_addsy;
509 asection *symsec = sym->bsym->section;
510 segment_info_type *symseginfo = seg_info (symsec);
512 /* If it's one of these sections, assume the symbol is definitely
513 going to be output. */
514 if (symsec == &bfd_und_section
515 || symsec == &bfd_abs_section
516 || bfd_is_com_section (symsec))
519 /* Since we're reducing to section symbols, don't attempt to reduce
520 anything that's already using one. */
521 if (sym->bsym == symsec->symbol)
524 /* Is there some other reason we can't adjust this one? (E.g.,
525 call/bal links in i960-bout symbols.) */
526 #ifdef obj_fix_adjustable
527 if (! obj_fix_adjustable (fixp))
530 /* If the section symbol isn't going to be output, the relocs
531 at least should still work. If not, figure out what to do
532 when we run into that case. */
533 fixp->fx_offset += S_GET_VALUE (sym);
535 fixp->fx_offset += sym->sy_frag->fr_address;
537 fixp->fx_addsy = symseginfo->sym;
540 fixp->fx_addsy = symbol_find (symsec->name);
543 fixp->fx_addsy = symbol_make (symsec->name);
544 fixp->fx_addsy->bsym = symsec->symbol;
546 symseginfo->sym = fixp->fx_addsy;
550 dump_section_relocs (abfd, sec, stderr);
554 write_relocs (abfd, sec, xxx)
559 segment_info_type *seginfo = seg_info (sec);
564 /* If seginfo is NULL, we did not create this section; don't do
569 fixup_segment (seginfo->fix_root, sec);
572 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
575 #ifndef RELOC_EXPANSION_POSSIBLE
576 /* Set up reloc information as well. */
577 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
578 n * sizeof (arelent *));
579 memset ((char*)relocs, 0, n * sizeof (arelent*));
582 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
585 extern arelent *tc_gen_reloc ();
587 bfd_reloc_status_type s;
589 if (fixp->fx_addsy == 0)
591 /* @@ Need some other flag to indicate which have already
596 reloc = tc_gen_reloc (sec, fixp);
602 data = fixp->fx_frag->fr_literal + fixp->fx_where;
603 /* @@ Assumes max size of reloc is 4. */
604 if (fixp->fx_where + 4
605 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
607 /* Pass bogus address so that when bfd_perform_relocation adds
608 `address' back in, it'll come up with `data', which is where
609 we want it to operate. */
610 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
617 as_fatal ("bad return from bfd_perform_relocation");
622 n = n * MAX_RELOC_EXPANSION;
623 /* Set up reloc information as well. */
624 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
625 n * sizeof (arelent *));
628 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
631 extern arelent **tc_gen_reloc ();
633 bfd_reloc_status_type s;
636 if (fixp->fx_addsy == 0)
638 /* @@ Need some other flag to indicate which have already
643 reloc = tc_gen_reloc (sec, fixp);
645 for (j = 0; reloc[j]; j++)
647 relocs[i++] = reloc[j];
650 data = fixp->fx_frag->fr_literal + fixp->fx_where;
651 if (fixp->fx_where + 4
652 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
654 for (j = 0; reloc[j]; j++)
656 s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
663 as_fatal ("bad return from bfd_perform_relocation");
671 bfd_set_reloc (stdoutput, sec, relocs, n);
673 bfd_set_section_flags (abfd, sec,
674 bfd_get_section_flags (abfd, sec) & ~SEC_RELOC);
680 fprintf (stderr, "relocs for sec %s\n", sec->name);
681 for (i = 0; i < n; i++)
685 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
686 i, r, r->address, s->name, r->addend);
693 write_contents (abfd, sec, xxx)
698 segment_info_type *seginfo = seg_info (sec);
699 unsigned long offset = 0;
702 /* Write out the frags. */
703 if (! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
706 for (frags = seginfo->frchainP->frch_root;
708 frags = frags->fr_next)
711 unsigned long fill_size;
715 assert (frags->fr_type == rs_fill);
718 x = bfd_set_section_contents (stdoutput, sec,
719 frags->fr_literal, offset,
722 offset += frags->fr_fix;
724 fill_literal = frags->fr_literal + frags->fr_fix;
725 fill_size = frags->fr_var;
726 count = frags->fr_offset;
728 if (fill_size && count)
731 x = bfd_set_section_contents (stdoutput, sec,
732 fill_literal, offset,
733 (bfd_size_type) fill_size);
741 #if defined(BFD_ASSEMBLER) || !defined (BFD)
743 merge_data_into_text ()
745 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
746 seg_info (text_section)->frchainP->frch_last->fr_next =
747 seg_info (data_section)->frchainP->frch_root;
748 seg_info (text_section)->frchainP->frch_last =
749 seg_info (data_section)->frchainP->frch_last;
750 seg_info (data_section)->frchainP = 0;
754 text_last_frag->fr_next = data_frag_root;
755 text_last_frag = data_last_frag;
756 data_last_frag = NULL;
757 data_frag_root = NULL;
760 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
761 tmp->fx_next = data_fix_root;
762 text_fix_tail = data_fix_tail;
765 text_fix_root = data_fix_root;
766 data_fix_root = NULL;
769 #endif /* BFD_ASSEMBLER || ! BFD */
771 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
773 relax_and_size_all_segments ()
777 relax_segment (text_frag_root, SEG_TEXT);
778 relax_segment (data_frag_root, SEG_DATA);
779 relax_segment (bss_frag_root, SEG_BSS);
781 * Now the addresses of frags are correct within the segment.
784 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
785 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
786 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
789 * Join the 2 segments into 1 huge segment.
790 * To do this, re-compute every rn_address in the SEG_DATA frags.
791 * Then join the data frags after the text frags.
793 * Determine a_data [length of data segment].
797 register relax_addressT slide;
799 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
801 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
802 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
803 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
805 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
806 /* For b.out: If the data section has a strict alignment
807 requirement, its load address in the .o file will be
808 rounded up from the size of the text section. These
809 two values are *not* the same! Similarly for the bss
811 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
814 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
816 fragP->fr_address += slide;
817 } /* for each data frag */
819 know (text_last_frag != 0);
820 text_last_frag->fr_next = data_frag_root;
824 H_SET_DATA_SIZE (&headers, 0);
828 /* See above comments on b.out data section address. */
831 if (data_last_frag == 0)
832 bss_vma = H_GET_TEXT_SIZE (&headers);
834 bss_vma = data_last_frag->fr_address;
835 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
836 bss_address_frag.fr_address = bss_vma;
838 #else /* ! OBJ_BOUT */
839 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
840 H_GET_DATA_SIZE (&headers));
843 /* Slide all the frags */
846 relax_addressT slide = bss_address_frag.fr_address;
848 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
850 fragP->fr_address += slide;
851 } /* for each bss frag */
854 #endif /* ! OBJ_BOUT */
857 H_SET_BSS_SIZE (&headers,
858 bss_last_frag->fr_address - bss_frag_root->fr_address);
860 H_SET_BSS_SIZE (&headers, 0);
862 #endif /* ! BFD_ASSEMBLER && ! BFD */
864 #if defined (BFD_ASSEMBLER) || !defined (BFD)
869 register struct frchain *frchainP; /* Track along all frchains. */
870 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
871 register fragS *fragP; /* Track along all frags. */
873 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
874 long object_file_size;
877 /* Do we really want to write it? */
880 n_warns = had_warnings ();
881 n_errs = had_errors ();
882 /* The -Z flag indicates that an object file should be generated,
883 regardless of warnings and errors. */
886 if (n_warns || n_errs)
887 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
888 n_errs, n_errs == 1 ? "" : "s",
889 n_warns, n_warns == 1 ? "" : "s");
894 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
895 n_errs, n_errs == 1 ? "" : "s",
896 n_warns, n_warns == 1 ? "" : "s");
902 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
903 * call a routine to check for the definition of the procedure
904 * "_main", and if so -- fix it up so that it can be program
907 VMS_Check_For_Main ();
910 /* After every sub-segment, we fake an ".align ...". This conforms to
911 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
912 frag that requires least thought. ".align" frags like to have a
913 following frag since that makes calculating their intended length
916 @@ Is this really necessary?? */
917 #ifndef SUB_SEGMENT_ALIGN
919 #define SUB_SEGMENT_ALIGN(SEG) (0)
921 #define SUB_SEGMENT_ALIGN(SEG) (2)
924 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
927 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
929 subseg_new (frchainP->frch_seg, frchainP->frch_subseg);
931 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
932 /* frag_align will have left a new frag.
933 Use this last frag for an empty ".fill".
936 Create a last frag. Do not leave a "being filled in frag". */
937 frag_wane (frag_now);
938 frag_now->fr_fix = 0;
939 know (frag_now->fr_next == NULL);
942 /* From now on, we don't care about sub-segments. Build one frag chain
943 for each segment. Linked thru fr_next. */
946 /* Remove the sections created by gas for its own purposes. */
948 asection **seclist, *sec;
949 seclist = &stdoutput->sections;
950 while (seclist && *seclist)
953 while (sec == reg_section || sec == expr_section)
957 stdoutput->section_count--;
962 seclist = &(*seclist)->next;
966 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
968 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
969 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
970 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
973 /* We have two segments. If user gave -R flag, then we must put the
974 data frags into the text segment. Do this before relaxing so
975 we know to take advantage of -R and make shorter addresses. */
976 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
979 merge_data_into_text ();
984 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
986 relax_and_size_all_segments ();
987 #endif /* BFD_ASSEMBLER */
989 #ifndef BFD_ASSEMBLER
992 * Crawl the symbol chain.
994 * For each symbol whose value depends on a frag, take the address of
995 * that frag and subsume it into the value of the symbol.
996 * After this, there is just one way to lookup a symbol value.
997 * Values are left in their final state for object file emission.
998 * We adjust the values of 'L' local symbols, even if we do
999 * not intend to emit them to the object file, because their values
1000 * are needed for fix-ups.
1002 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1003 * from the symbol chain. (They are still pointed to by the fixes.)
1005 * Count the remaining symbols.
1006 * Assign a symbol number to each symbol.
1007 * Count the number of string-table chars we will emit.
1008 * Put this info into the headers as appropriate.
1011 know (zero_address_frag.fr_address == 0);
1012 string_byte_count = sizeof (string_byte_count);
1014 obj_crawl_symbol_chain (&headers);
1016 if (string_byte_count == sizeof (string_byte_count))
1017 string_byte_count = 0;
1019 H_SET_STRING_SIZE (&headers, string_byte_count);
1022 * Addresses of frags now reflect addresses we use in the object file.
1023 * Symbol values are correct.
1024 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1025 * Also converting any machine-dependent frags using md_convert_frag();
1027 subseg_change (SEG_TEXT, 0);
1029 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1031 cvt_frag_to_fill (&headers, fragP);
1033 /* Some assert macros don't work with # directives mixed in. */
1035 if (!(fragP->fr_next == NULL
1037 || fragP->fr_next == data_frag_root
1039 || ((fragP->fr_next->fr_address - fragP->fr_address)
1040 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1044 #endif /* ! BFD_ASSEMBLER */
1046 #ifndef WORKING_DOT_WORD
1048 struct broken_word *lie;
1049 struct broken_word **prevP;
1051 prevP = &broken_words;
1052 for (lie = broken_words; lie; lie = lie->next_broken_word)
1057 exp.X_op = O_subtract;
1058 exp.X_add_symbol = lie->add;
1059 exp.X_op_symbol = lie->sub;
1060 exp.X_add_number = lie->addnum;
1061 #ifdef BFD_ASSEMBLER
1062 fix_new_exp (lie->frag,
1063 lie->word_goes_here - lie->frag->fr_literal,
1064 2, &exp, 0, BFD_RELOC_NONE);
1066 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1067 fix_new_exp (lie->frag,
1068 lie->word_goes_here - lie->frag->fr_literal,
1069 2, &exp, 0, NO_RELOC);
1072 fix_new_ns32k_exp (lie->frag,
1073 lie->word_goes_here - lie->frag->fr_literal,
1074 2, &exp, 0, 0, 2, 0, 0);
1076 fix_new_exp (lie->frag,
1077 lie->word_goes_here - lie->frag->fr_literal,
1079 #endif /* TC_NS32K */
1080 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1081 #endif /* BFD_ASSEMBLER */
1082 *prevP = lie->next_broken_word;
1085 prevP = &(lie->next_broken_word);
1087 for (lie = broken_words; lie;)
1089 struct broken_word *untruth;
1091 addressT table_addr;
1092 addressT from_addr, to_addr;
1095 fragP = lie->dispfrag;
1097 /* Find out how many broken_words go here. */
1099 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1100 if (untruth->added == 1)
1103 table_ptr = lie->dispfrag->fr_opcode;
1104 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1105 /* Create the jump around the long jumps. This is a short
1106 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1107 from_addr = table_addr;
1108 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1109 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1110 table_ptr += md_short_jump_size;
1111 table_addr += md_short_jump_size;
1113 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1115 if (lie->added == 2)
1117 /* Patch the jump table */
1118 /* This is the offset from ??? to table_ptr+0 */
1119 to_addr = table_addr - S_GET_VALUE (lie->sub);
1120 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1121 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1123 if (untruth->use_jump == lie)
1124 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1127 /* Install the long jump */
1128 /* this is a long jump from table_ptr+0 to the final target */
1129 from_addr = table_addr;
1130 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1131 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1132 table_ptr += md_long_jump_size;
1133 table_addr += md_long_jump_size;
1137 #endif /* not WORKING_DOT_WORD */
1139 #ifndef BFD_ASSEMBLER
1143 * Scan every FixS performing fixups. We had to wait until now to do
1144 * this because md_convert_frag() may have made some fixSs.
1148 subseg_change (SEG_TEXT, 0);
1149 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1150 subseg_change (SEG_DATA, 0);
1151 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1152 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1154 /* FIXME move this stuff into the pre-write-hook */
1155 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1156 H_SET_ENTRY_POINT (&headers, 0);
1158 obj_pre_write_hook (&headers); /* extra coff stuff */
1160 object_file_size = H_GET_FILE_SIZE (&headers);
1161 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1163 output_file_create (out_file_name);
1165 obj_header_append (&next_object_file_charP, &headers);
1167 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1172 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1174 register long count;
1175 register char *fill_literal;
1176 register long fill_size;
1178 know (fragP->fr_type == rs_fill);
1179 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1180 fill_literal = fragP->fr_literal + fragP->fr_fix;
1181 fill_size = fragP->fr_var;
1182 know (fragP->fr_offset >= 0);
1184 for (count = fragP->fr_offset; count; count--)
1186 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1189 } /* for each code frag. */
1191 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1196 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1197 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)));
1199 /* Make addresses in data relocation directives relative to beginning of
1200 * first data fragment, not end of last text fragment: alignment of the
1201 * start of the data segment may place a gap between the segments.
1203 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1205 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1206 #endif /* TC_I960 */
1208 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)));
1211 * Emit line number entries.
1213 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1214 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)));
1219 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1220 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)));
1226 if (string_byte_count > 0)
1228 obj_emit_strings (&next_object_file_charP);
1229 } /* only if we have a string table */
1232 bfd_seek (stdoutput, 0, 0);
1233 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1236 /* Write the data to the file */
1237 output_file_append (the_object_file, object_file_size, out_file_name);
1240 output_file_close (out_file_name);
1241 } /* non vms output */
1244 * Now do the VMS-dependent part of writing the object file
1246 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1247 H_GET_DATA_SIZE (&headers),
1248 H_GET_BSS_SIZE (&headers),
1249 text_frag_root, data_frag_root);
1251 #else /* BFD_ASSEMBLER */
1253 #ifdef obj_check_file_symbols
1254 obj_check_file_symbols ();
1257 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1259 /* Set up symbol table, and write it out. */
1265 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1267 if (! symp->sy_resolved)
1269 if (symp->sy_value.X_op == O_constant)
1271 /* This is the normal case; skip the call. */
1274 + symp->sy_frag->fr_address));
1275 symp->sy_resolved = 1;
1278 resolve_symbol_value (symp);
1281 /* So far, common symbols have been treated like undefined symbols.
1282 Put them in the common section now. */
1283 if (S_IS_DEFINED (symp) == 0
1284 && S_GET_VALUE (symp) != 0)
1285 S_SET_SEGMENT (symp, &bfd_com_section);
1287 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1288 S_GET_NAME (symp), symp,
1291 segment_name (symp->bsym->section));
1294 #ifdef obj_frob_symbol
1297 obj_frob_symbol (symp, punt);
1302 #ifdef tc_frob_symbol
1305 tc_frob_symbol (symp, punt);
1311 /* If we don't want to keep this symbol, splice it out of the
1313 if (S_IS_LOCAL (symp))
1315 symbolS *prev, *next;
1316 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1319 prev = symbol_previous (symp);
1320 next = symbol_next (symp);
1322 verify_symbol_chain_2 (symp);
1326 symbol_next (prev) = next;
1329 else if (symp == symbol_rootP)
1330 symbol_rootP = next;
1334 symbol_previous (next) = prev;
1336 symbol_lastP = prev;
1339 verify_symbol_chain_2 (prev);
1341 verify_symbol_chain_2 (next);
1346 /* Set the value into the BFD symbol. Up til now the value
1347 has only been kept in the gas symbolS struct. */
1348 symp->bsym->value = S_GET_VALUE (symp);
1357 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1359 asympp = (asymbol **) bfd_alloc (stdoutput,
1360 n * sizeof (asymbol *));
1361 symp = symbol_rootP;
1362 for (i = 0; i < n; i++, symp = symbol_next (symp))
1364 asympp[i] = symp->bsym;
1367 result = bfd_set_symtab (stdoutput, asympp, n);
1368 assert (result == true);
1373 #ifdef obj_frob_file
1374 /* If obj_frob_file changes the symbol value at this point, it is
1375 responsible for moving the changed value into symp->bsym->value
1376 as well. Hopefully all symbol value changing can be done in
1377 {obj,tc}_frob_symbol. */
1381 /* Now that all the sizes are known, and contents correct, we can
1382 start writing the file. */
1383 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1385 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1387 output_file_close (out_file_name);
1388 #endif /* BFD_ASSEMBLER */
1395 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1400 * After this, all frags in this segment have addresses that are correct
1401 * within the segment. Since segments live in different file addresses,
1402 * these frag addresses may not be the same as final object-file addresses.
1405 /* Subroutines of relax_segment. */
1411 for (; f1; f1 = f1->fr_next)
1412 if (f1->fr_next == f2)
1417 /* Relax_align. Advance location counter to next address that has 'alignment'
1418 lowest order bits all 0s, return size of adjustment made. */
1419 static relax_addressT
1420 relax_align (address, alignment)
1421 register relax_addressT address; /* Address now. */
1422 register int alignment; /* Alignment (binary). */
1424 relax_addressT mask;
1425 relax_addressT new_address;
1427 mask = ~((~0) << alignment);
1428 new_address = (address + mask) & (~mask);
1430 /* We must provide lots of padding, so the linker can discard it
1431 when needed. The linker will not add extra space, ever. */
1432 new_address += (1 << alignment);
1433 return (new_address - address);
1437 relax_segment (segment_frag_root, segment)
1438 struct frag *segment_frag_root;
1441 register struct frag *fragP;
1442 register relax_addressT address;
1443 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1444 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1446 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1447 subseg_change (segment, 0);
1449 /* For each frag in segment: count and store (a 1st guess of)
1452 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1454 fragP->fr_address = address;
1455 address += fragP->fr_fix;
1457 switch (fragP->fr_type)
1460 address += fragP->fr_offset * fragP->fr_var;
1464 address += relax_align (address, (int) fragP->fr_offset);
1468 /* Assume .org is nugatory. It will grow with 1st relax. */
1471 case rs_machine_dependent:
1472 address += md_estimate_size_before_relax (fragP, segment);
1475 #ifndef WORKING_DOT_WORD
1476 /* Broken words don't concern us yet */
1477 case rs_broken_word:
1482 BAD_CASE (fragP->fr_type);
1484 } /* switch(fr_type) */
1485 } /* for each frag in the segment */
1489 long stretch; /* May be any size, 0 or negative. */
1490 /* Cumulative number of addresses we have */
1491 /* relaxed this pass. */
1492 /* We may have relaxed more than one address. */
1493 long stretched; /* Have we stretched on this pass? */
1494 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1495 grew, and another shrank. If a branch instruction doesn't fit anymore,
1496 we could be scrod. */
1500 stretch = stretched = 0;
1501 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1504 unsigned long was_address;
1511 was_address = fragP->fr_address;
1512 address = fragP->fr_address += stretch;
1513 symbolP = fragP->fr_symbol;
1514 offset = fragP->fr_offset;
1516 switch (fragP->fr_type)
1518 case rs_fill: /* .fill never relaxes. */
1522 #ifndef WORKING_DOT_WORD
1523 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1524 for it I do not want to write it. I do not want to have
1525 anything to do with it. This is not the proper way to
1526 implement this misfeature. */
1527 case rs_broken_word:
1529 struct broken_word *lie;
1530 struct broken_word *untruth;
1532 /* Yes this is ugly (storing the broken_word pointer
1533 in the symbol slot). Still, this whole chunk of
1534 code is ugly, and I don't feel like doing anything
1535 about it. Think of it as stubbornness in action. */
1537 for (lie = (struct broken_word *) (fragP->fr_symbol);
1538 lie && lie->dispfrag == fragP;
1539 lie = lie->next_broken_word)
1545 offset = (lie->add->sy_frag->fr_address
1546 + S_GET_VALUE (lie->add)
1548 - (lie->sub->sy_frag->fr_address
1549 + S_GET_VALUE (lie->sub)));
1550 if (offset <= -32768 || offset >= 32767)
1555 sprint_value (buf, lie->addnum);
1556 as_warn (".word %s-%s+%s didn't fit",
1557 S_GET_NAME (lie->add),
1558 S_GET_NAME (lie->sub),
1562 if (fragP->fr_subtype == 0)
1564 fragP->fr_subtype++;
1565 growth += md_short_jump_size;
1567 for (untruth = lie->next_broken_word;
1568 untruth && untruth->dispfrag == lie->dispfrag;
1569 untruth = untruth->next_broken_word)
1570 if ((untruth->add->sy_frag == lie->add->sy_frag)
1571 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1574 untruth->use_jump = lie;
1576 growth += md_long_jump_size;
1581 } /* case rs_broken_word */
1584 growth = (relax_align ((relax_addressT) (address
1587 - relax_align ((relax_addressT) (was_address
1597 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1598 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1599 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1600 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1601 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1602 know (symbolP->sy_frag);
1603 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1604 || (symbolP->sy_frag == &zero_address_frag));
1606 target += S_GET_VALUE (symbolP)
1607 + symbolP->sy_frag->fr_address;
1608 } /* if we have a symbol */
1610 know (fragP->fr_next);
1611 after = fragP->fr_next->fr_address;
1612 growth = ((target - after) > 0) ? (target - after) : 0;
1613 /* Growth may be negative, but variable part of frag
1614 cannot have fewer than 0 chars. That is, we can't
1617 growth -= stretch; /* This is an absolute growth factor */
1620 case rs_machine_dependent:
1622 const relax_typeS *this_type;
1623 const relax_typeS *start_type;
1624 relax_substateT next_state;
1625 relax_substateT this_state;
1627 this_state = fragP->fr_subtype;
1628 start_type = this_type = md_relax_table + this_state;
1633 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1634 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1635 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1636 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1637 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1639 know (symbolP->sy_frag);
1640 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1641 || symbolP->sy_frag == &zero_address_frag);
1643 S_GET_VALUE (symbolP)
1644 + symbolP->sy_frag->fr_address;
1646 /* If frag has yet to be reached on this pass,
1647 assume it will move by STRETCH just as we did.
1648 If this is not so, it will be because some frag
1649 between grows, and that will force another pass.
1651 Beware zero-length frags.
1653 There should be a faster way to do this. */
1655 if (symbolP->sy_frag->fr_address >= was_address
1656 && is_dnrange (fragP, symbolP->sy_frag))
1662 aim = target - address - fragP->fr_fix;
1663 /* The displacement is affected by the instruction size
1664 for the 32k architecture. I think we ought to be able
1665 to add fragP->fr_pcrel_adjust in all cases (it should be
1666 zero if not used), but just in case it breaks something
1667 else we'll put this inside #ifdef NS32K ... #endif */
1669 if (fragP->fr_pcrel_adjust)
1672 aim += fragP->fr_pcrel_adjust;
1676 /* Look backwards. */
1677 for (next_state = this_type->rlx_more; next_state;)
1678 if (aim >= this_type->rlx_backward)
1682 /* Grow to next state. */
1683 this_state = next_state;
1684 this_type = md_relax_table + this_state;
1685 next_state = this_type->rlx_more;
1690 #ifdef M68K_AIM_KLUDGE
1691 M68K_AIM_KLUDGE (aim, this_state, this_type);
1693 /* Look forwards. */
1694 for (next_state = this_type->rlx_more; next_state;)
1695 if (aim <= this_type->rlx_forward)
1699 /* Grow to next state. */
1700 this_state = next_state;
1701 this_type = md_relax_table + this_state;
1702 next_state = this_type->rlx_more;
1706 growth = this_type->rlx_length - start_type->rlx_length;
1708 fragP->fr_subtype = this_state;
1713 BAD_CASE (fragP->fr_type);
1721 } /* For each frag in the segment. */
1723 while (stretched); /* Until nothing further to relax. */
1727 * We now have valid fr_address'es for each frag.
1731 * All fr_address's are correct, relative to their own segment.
1732 * We have made all the fixS we will ever make.
1734 } /* relax_segment() */
1738 Go through all the fixS's in a segment and see which ones can be
1739 handled now. (These consist of fixS where we have since discovered
1740 the value of a symbol, or the address of the frag involved.)
1741 For each one, call md_apply_fix to put the fix into the frag data.
1743 Result is a count of how many relocation structs will be needed to
1744 handle the remaining fixS's that we couldn't completely handle here.
1745 These will be output later by emit_relocations(). */
1748 fixup_segment (fixP, this_segment_type)
1749 register fixS *fixP;
1750 segT this_segment_type; /* N_TYPE bits for segment. */
1752 register long seg_reloc_count;
1753 register symbolS *add_symbolP;
1754 register symbolS *sub_symbolP;
1757 register char *place;
1758 register long where;
1759 register char pcrel;
1760 register fragS *fragP;
1761 register segT add_symbol_segment = absolute_section;
1763 seg_reloc_count = 0;
1764 /* If the linker is doing the relaxing, we must not do any fixups. */
1765 /* Well, strictly speaking that's not true -- we could do any that
1766 are PC-relative and don't cross regions that could change size.
1767 And for the i960 (the only machine for which we've got a relaxing
1768 linker right now), we might be able to turn callx/callj into bal
1769 in cases where we know the maximum displacement. */
1771 for (; fixP; fixP = fixP->fx_next)
1774 for (; fixP; fixP = fixP->fx_next)
1776 fragP = fixP->fx_frag;
1778 where = fixP->fx_where;
1779 place = fragP->fr_literal + where;
1780 size = fixP->fx_size;
1781 add_symbolP = fixP->fx_addsy;
1783 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
1785 /* Relocation should be done via the associated 'bal'
1786 entry point symbol. */
1788 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1790 as_bad ("No 'bal' entry point for leafproc %s",
1791 S_GET_NAME (add_symbolP));
1794 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1797 sub_symbolP = fixP->fx_subsy;
1798 add_number = fixP->fx_offset;
1799 pcrel = fixP->fx_pcrel;
1802 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1809 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1810 as_bad ("Negative of non-absolute symbol %s",
1811 S_GET_NAME (sub_symbolP));
1813 add_number -= S_GET_VALUE (sub_symbolP);
1815 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1816 && (SEG_NORMAL (add_symbol_segment)
1817 || (add_symbol_segment == absolute_section)))
1819 /* Difference of 2 symbols from same segment.
1820 Can't make difference of 2 undefineds: 'value' means
1821 something different for N_UNDF. */
1823 /* Makes no sense to use the difference of 2 arbitrary symbols
1824 as the target of a call instruction. */
1827 as_bad ("callj to difference of 2 symbols");
1829 #endif /* TC_I960 */
1830 add_number += S_GET_VALUE (add_symbolP) -
1831 S_GET_VALUE (sub_symbolP);
1834 fixP->fx_addsy = NULL;
1838 /* Different segments in subtraction. */
1839 know (!(S_IS_EXTERNAL (sub_symbolP)
1840 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1842 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1844 add_number -= S_GET_VALUE (sub_symbolP);
1849 sprint_value (buf, fragP->fr_address + where);
1850 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1851 segment_name (S_GET_SEGMENT (sub_symbolP)),
1852 S_GET_NAME (sub_symbolP), buf);
1859 if (add_symbol_segment == this_segment_type && pcrel)
1862 * This fixup was made when the symbol's segment was
1863 * SEG_UNKNOWN, but it is now in the local segment.
1864 * So we know how to do the address without relocation.
1867 /* reloc_callj() may replace a 'call' with a 'calls' or a
1868 'bal', in which cases it modifies *fixP as appropriate.
1869 In the case of a 'calls', no further work is required,
1870 and *fixP has been set up to make the rest of the code
1873 #endif /* TC_I960 */
1875 add_number += S_GET_VALUE (add_symbolP);
1876 add_number -= md_pcrel_from (fixP);
1877 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1878 fixP->fx_addsy = NULL; /* No relocations please. */
1882 if (add_symbol_segment == absolute_section)
1885 /* See comment about reloc_callj() above. */
1887 #endif /* TC_I960 */
1888 add_number += S_GET_VALUE (add_symbolP);
1889 fixP->fx_addsy = NULL;
1892 else if (add_symbol_segment == undefined_section
1893 #ifdef BFD_ASSEMBLER
1894 || bfd_is_com_section (add_symbol_segment)
1899 if ((int) fixP->fx_bit_fixP == 13)
1901 /* This is a COBR instruction. They have only a
1902 * 13-bit displacement and are only to be used
1903 * for local branches: flag as error, don't generate
1906 as_bad ("can't use COBR format with external label");
1907 fixP->fx_addsy = NULL; /* No relocations please. */
1910 #endif /* TC_I960 */
1914 if (S_IS_COMMON (add_symbolP))
1915 add_number += S_GET_VALUE (add_symbolP);
1916 #endif /* TE_I386AIX */
1917 #endif /* OBJ_COFF */
1923 add_number += S_GET_VALUE (add_symbolP);
1925 } /* if not in local seg */
1926 } /* if there was a + symbol */
1930 add_number -= md_pcrel_from (fixP);
1931 if (add_symbolP == 0)
1933 fixP->fx_addsy = &abs_symbol;
1935 } /* if there's an add_symbol */
1938 if (!fixP->fx_bit_fixP)
1941 /* set all bits to one */
1943 /* Technically speaking, combining these produces an
1944 undefined result if size is sizeof (valueT), though I
1945 think these two half-way operations should both be
1949 if ((add_number & mask) != 0
1950 && (add_number & mask) != mask)
1953 sprint_value (buf, fragP->fr_address + where);
1954 as_bad ("Value of %ld too large for field of %d bytes at %s",
1955 (long) add_number, size, buf);
1956 } /* generic error checking */
1957 #ifdef WARN_SIGNED_OVERFLOW_WORD
1958 /* Warn if a .word value is too large when treated as a signed
1959 number. We already know it is not too negative. This is to
1960 catch over-large switches generated by gcc on the 68k. */
1963 && add_number > 0x7fff)
1964 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
1965 add_number, fragP->fr_address + where);
1967 } /* not a bit fix */
1969 #ifdef BFD_ASSEMBLER
1970 md_apply_fix (fixP, &add_number);
1972 md_apply_fix (fixP, add_number);
1974 } /* For each fixS in this segment. */
1976 #if defined (OBJ_COFF) && defined (TC_I960)
1980 /* two relocs per callj under coff. */
1981 for (fixP = topP; fixP; fixP = fixP->fx_next)
1982 if (fixP->fx_callj && fixP->fx_addsy != 0)
1985 #endif /* OBJ_COFF && TC_I960 */
1987 return (seg_reloc_count);
1990 /* end of write.c */