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 */
61 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
62 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
63 void relax_segment PARAMS ((struct frag * seg_frag_root, segT seg_type));
68 * Create a fixS in obstack 'notes'.
71 fix_new (frag, where, size, add_symbol, sub_symbol, offset, pcrel, r_type)
72 fragS *frag; /* Which frag? */
73 int where; /* Where in that frag? */
74 short int size; /* 1, 2, or 4 usually. */
75 symbolS *add_symbol; /* X_add_symbol. */
76 symbolS *sub_symbol; /* X_subtract_symbol. */
77 offsetT offset; /* X_add_number. */
78 int pcrel; /* TRUE if PC-relative relocation. */
80 bfd_reloc_code_real_type r_type; /* Relocation type */
82 int r_type; /* Relocation type */
87 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
90 fixP->fx_where = where;
92 fixP->fx_addsy = add_symbol;
93 fixP->fx_subsy = sub_symbol;
94 fixP->fx_offset = offset;
95 fixP->fx_pcrel = pcrel;
96 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
97 fixP->fx_r_type = r_type;
100 fixP->fx_pcrel_adjust = 0;
101 fixP->fx_bit_fixP = 0;
102 fixP->fx_addnumber = 0;
111 /* Usually, we want relocs sorted numerically, but while
112 comparing to older versions of gas that have relocs
113 reverse sorted, it is convenient to have this compile
114 time option. xoxorich. */
119 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
120 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
123 #ifdef REVERSE_SORT_RELOCS
125 fixP->fx_next = *seg_fix_rootP;
126 *seg_fix_rootP = fixP;
128 #else /* REVERSE_SORT_RELOCS */
130 fixP->fx_next = NULL;
133 (*seg_fix_tailP)->fx_next = fixP;
135 *seg_fix_rootP = fixP;
136 *seg_fix_tailP = fixP;
138 #endif /* REVERSE_SORT_RELOCS */
145 /* Append a string onto another string, bumping the pointer along. */
147 append (charPP, fromP, length)
150 unsigned long length;
152 /* Don't trust memcpy() of 0 chars. */
156 memcpy (*charPP, fromP, (int) length);
160 #ifndef BFD_ASSEMBLER
161 int section_alignment[SEG_MAXIMUM_ORDINAL];
165 * This routine records the largest alignment seen for each segment.
166 * If the beginning of the segment is aligned on the worst-case
167 * boundary, all of the other alignments within it will work. At
168 * least one object format really uses this info.
171 record_alignment (seg, align)
172 /* Segment to which alignment pertains */
174 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
179 if (align > bfd_get_section_alignment (stdoutput, seg))
180 bfd_set_section_alignment (stdoutput, seg, align);
182 if (align > section_alignment[(int) seg])
183 section_alignment[(int) seg] = align;
187 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
190 chain_frchains_together_1 (section, frchp)
192 struct frchain *frchp;
194 fragS dummy, *prev_frag = &dummy;
195 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
197 prev_frag->fr_next = frchp->frch_root;
198 prev_frag = frchp->frch_last;
200 prev_frag->fr_next = 0;
209 chain_frchains_together (abfd, section, xxx)
210 bfd *abfd; /* unused */
212 char *xxx; /* unused */
214 segment_info_type *info;
216 /* BFD may have introduced its own sections without using
217 subseg_new, so it is possible that seg_info is NULL. */
218 info = seg_info (section);
219 if (info != (segment_info_type *) NULL)
220 chain_frchains_together_1 (section, info->frchainP);
225 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
228 remove_subsegs (head, seg, root, last)
234 *root = head->frch_root;
235 *last = chain_frchains_together_1 (seg, head);
241 cvt_frag_to_fill (x, fragP)
252 object_headers *headers = x;
255 switch (fragP->fr_type)
260 HANDLE_ALIGN (fragP);
262 fragP->fr_type = rs_fill;
263 know (fragP->fr_var == 1);
264 know (fragP->fr_next != NULL);
266 fragP->fr_offset = (fragP->fr_next->fr_address
274 case rs_machine_dependent:
276 md_convert_frag (stdoutput, sec, fragP);
278 md_convert_frag (headers, fragP);
281 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
284 * After md_convert_frag, we make the frag into a ".space 0".
285 * Md_convert_frag() should set up any fixSs and constants
291 #ifndef WORKING_DOT_WORD
294 struct broken_word *lie;
296 if (fragP->fr_subtype)
298 fragP->fr_fix += md_short_jump_size;
299 for (lie = (struct broken_word *) (fragP->fr_symbol);
300 lie && lie->dispfrag == fragP;
301 lie = lie->next_broken_word)
303 fragP->fr_fix += md_long_jump_size;
311 BAD_CASE (fragP->fr_type);
318 relax_and_size_seg (abfd, sec, xxx)
325 flags = bfd_get_section_flags (abfd, sec);
327 if (/*flags & SEC_ALLOC*/ 1)
330 segment_info_type *seginfo;
332 valueT size, newsize;
334 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
335 if (seginfo && seginfo->frchainP)
337 relax_segment (seginfo->frchainP->frch_root, sec);
338 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
339 cvt_frag_to_fill (sec, fragp);
340 for (fragp = seginfo->frchainP->frch_root;
342 fragp = fragp->fr_next)
343 /* walk to last elt */;
344 size = fragp->fr_address + fragp->fr_fix;
350 flags |= SEC_HAS_CONTENTS;
351 /* @@ This is just an approximation. */
352 if (seginfo->fix_root)
356 x = bfd_set_section_flags (abfd, sec, flags);
359 size = md_section_align (sec, size);
360 x = bfd_set_section_size (abfd, sec, size);
363 /* If the size had to be rounded up, add some padding in the last
365 newsize = bfd_get_section_size_before_reloc (sec);
366 assert (newsize >= size);
369 fragS *last = seginfo->frchainP->frch_last;
370 fragp = seginfo->frchainP->frch_root;
371 while (fragp->fr_next != last)
372 fragp = fragp->fr_next;
373 last->fr_address = size;
374 fragp->fr_offset += newsize - size;
377 #ifdef tc_frob_section
378 tc_frob_section (sec);
380 #ifdef obj_frob_section
381 obj_frob_section (sec);
387 dump_section_relocs (abfd, sec, stream_)
392 FILE *stream = (FILE *) stream_;
393 segment_info_type *seginfo = seg_info (sec);
394 fixS *fixp = seginfo->fix_root;
399 fprintf (stream, "sec %s relocs:\n", sec->name);
402 symbolS *s = fixp->fx_addsy;
404 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
405 S_GET_NAME (s), s->bsym->section->name,
406 S_GET_VALUE (s), fixp->fx_offset);
408 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
409 fixp = fixp->fx_next;
413 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
417 adjust_reloc_syms (abfd, sec, xxx)
422 segment_info_type *seginfo = seg_info (sec);
428 dump_section_relocs (abfd, sec, stderr);
430 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
433 symbolS *sym = fixp->fx_addsy;
434 asection *symsec = sym->bsym->section;
435 segment_info_type *symseginfo = seg_info (symsec);
437 /* If it's one of these sections, assume the symbol is definitely
438 going to be output. */
439 if (symsec == &bfd_und_section
440 || symsec == &bfd_abs_section
441 || bfd_is_com_section (symsec))
444 /* Since we're reducing to section symbols, don't attempt to reduce
445 anything that's already using one. */
446 if (sym->bsym == symsec->symbol)
449 /* Is there some other reason we can't adjust this one? (E.g.,
450 call/bal links in i960-bout symbols.) */
451 #ifdef obj_fix_adjustable
452 if (! obj_fix_adjustable (fixp))
455 /* If the section symbol isn't going to be output, the relocs
456 at least should still work. If not, figure out what to do
457 when we run into that case. */
458 fixp->fx_offset += S_GET_VALUE (sym);
460 fixp->fx_offset += sym->sy_frag->fr_address;
462 fixp->fx_addsy = symseginfo->sym;
465 fixp->fx_addsy = symbol_find (symsec->name);
468 fixp->fx_addsy = symbol_make (symsec->name);
469 fixp->fx_addsy->bsym = symsec->symbol;
471 symseginfo->sym = fixp->fx_addsy;
475 dump_section_relocs (abfd, sec, stderr);
479 write_relocs (abfd, sec, xxx)
484 segment_info_type *seginfo = seg_info (sec);
485 unsigned long offset = 0;
491 /* If seginfo is NULL, we did not create this section; don't do
496 fixup_segment (seginfo->fix_root, sec);
499 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
502 #ifndef RELOC_EXPANSION_POSSIBLE
503 /* Set up reloc information as well. */
504 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
505 n * sizeof (arelent *));
506 memset ((char*)relocs, 0, n * sizeof (arelent*));
509 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
512 extern arelent *tc_gen_reloc ();
514 bfd_reloc_status_type s;
516 if (fixp->fx_addsy == 0)
518 /* @@ Need some other flag to indicate which have already
523 reloc = tc_gen_reloc (sec, fixp);
529 data = fixp->fx_frag->fr_literal + fixp->fx_where;
530 /* @@ Assumes max size of reloc is 4. */
531 if (fixp->fx_where + 4
532 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
534 /* Pass bogus address so that when bfd_perform_relocation adds
535 `address' back in, it'll come up with `data', which is where
536 we want it to operate. */
537 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
544 as_fatal ("bad return from bfd_perform_relocation");
549 n = n * MAX_RELOC_EXPANSION;
550 /* Set up reloc information as well. */
551 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
552 n * sizeof (arelent *));
555 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
558 extern arelent *tc_gen_reloc ();
560 bfd_reloc_status_type s;
563 if (fixp->fx_addsy == 0)
565 /* @@ Need some other flag to indicate which have already
570 reloc = tc_gen_reloc (sec, fixp);
572 for (j = 0; reloc[j]; j++)
574 relocs[i++] = reloc[j];
577 data = fixp->fx_frag->fr_literal + fixp->fx_where;
578 if (fixp->fx_where + 4
579 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
581 for (j = 0; reloc[j]; j++)
583 s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
590 as_fatal ("bad return from bfd_perform_relocation");
598 bfd_set_reloc (stdoutput, sec, relocs, n);
600 bfd_set_section_flags (abfd, sec,
601 bfd_get_section_flags (abfd, sec) & ~SEC_RELOC);
607 fprintf (stderr, "relocs for sec %s\n", sec->name);
608 for (i = 0; i < n; i++)
612 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
613 i, r, r->address, s->name, r->addend);
620 write_contents (abfd, sec, xxx)
625 segment_info_type *seginfo = seg_info (sec);
626 unsigned long offset = 0;
632 /* Write out the frags. */
633 if (! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
636 #if 0 /* Who cares? Let the first call, below, do it. */
637 /* Force calculations (size, vma) to get done. */
638 bfd_set_section_contents (stdoutput, sec, "", 0, (addressT) 0);
641 for (frags = seginfo->frchainP->frch_root;
643 frags = frags->fr_next)
646 unsigned long fill_size;
650 assert (frags->fr_type == rs_fill);
653 x = bfd_set_section_contents (stdoutput, sec,
654 frags->fr_literal, offset,
657 offset += frags->fr_fix;
659 fill_literal = frags->fr_literal + frags->fr_fix;
660 fill_size = frags->fr_var;
661 count = frags->fr_offset;
663 if (fill_size && count)
666 x = bfd_set_section_contents (stdoutput, sec,
667 fill_literal, offset,
668 (bfd_size_type) fill_size);
676 #if defined (BFD_ASSEMBLER) || !defined (BFD)
681 register struct frchain *frchainP; /* Track along all frchains. */
682 register fragS *fragP; /* Track along all frags. */
684 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
685 long object_file_size;
688 /* Do we really want to write it? */
691 n_warns = had_warnings ();
692 n_errs = had_errors ();
693 /* The -Z flag indicates that an object file should be generated,
694 regardless of warnings and errors. */
697 if (n_warns || n_errs)
698 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
699 n_errs, n_errs == 1 ? "" : "s",
700 n_warns, n_warns == 1 ? "" : "s");
705 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
706 n_errs, n_errs == 1 ? "" : "s",
707 n_warns, n_warns == 1 ? "" : "s");
713 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
714 * call a routine to check for the definition of the procedure
715 * "_main", and if so -- fix it up so that it can be program
718 VMS_Check_For_Main ();
721 /* After every sub-segment, we fake an ".align ...". This conforms to
722 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
723 frag that requires least thought. ".align" frags like to have a
724 following frag since that makes calculating their intended length
727 @@ Is this really necessary?? */
728 #ifndef SUB_SEGMENT_ALIGN
730 #define SUB_SEGMENT_ALIGN(SEG) (0)
732 #define SUB_SEGMENT_ALIGN(SEG) (2)
735 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
738 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
740 subseg_new (frchainP->frch_seg, frchainP->frch_subseg);
742 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
743 /* frag_align will have left a new frag.
744 Use this last frag for an empty ".fill".
747 Create a last frag. Do not leave a "being filled in frag". */
748 frag_wane (frag_now);
749 frag_now->fr_fix = 0;
750 know (frag_now->fr_next == NULL);
751 /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
752 /* Above shows we haven't left a half-completed object on obstack. */
755 /* From now on, we don't care about sub-segments. Build one frag chain
756 for each segment. Linked thru fr_next. */
759 /* Remove the sections created by gas for its own purposes. */
761 asection **seclist, *sec;
762 seclist = &stdoutput->sections;
763 while (seclist && *seclist)
766 while (sec == big_section
767 || sec == reg_section
768 || sec == pass1_section
769 || sec == diff_section
770 || sec == absent_section)
774 stdoutput->section_count--;
779 seclist = &(*seclist)->next;
783 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
785 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
786 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
787 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
790 /* We have two segments. If user gave -R flag, then we must put the
791 data frags into the text segment. Do this before relaxing so
792 we know to take advantage of -R and make shorter addresses. */
793 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
797 seg_info (text_section)->frchainP->frch_last->fr_next =
798 seg_info (data_section)->frchainP->frch_root;
799 seg_info (text_section)->frchainP->frch_last =
800 seg_info (data_section)->frchainP->frch_last;
801 seg_info (data_section)->frchainP = 0;
805 text_last_frag->fr_next = data_frag_root;
806 text_last_frag = data_last_frag;
807 data_last_frag = NULL;
808 data_frag_root = NULL;
811 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
812 tmp->fx_next = data_fix_root;
813 text_fix_tail = data_fix_tail;
816 text_fix_root = data_fix_root;
817 data_fix_root = NULL;
824 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
826 relax_segment (text_frag_root, SEG_TEXT);
827 relax_segment (data_frag_root, SEG_DATA);
828 relax_segment (bss_frag_root, SEG_BSS);
830 * Now the addresses of frags are correct within the segment.
833 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
834 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
835 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
838 * Join the 2 segments into 1 huge segment.
839 * To do this, re-compute every rn_address in the SEG_DATA frags.
840 * Then join the data frags after the text frags.
842 * Determine a_data [length of data segment].
846 register relax_addressT slide;
848 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
850 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
851 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
852 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
854 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
855 /* For b.out: If the data section has a strict alignment
856 requirement, its load address in the .o file will be
857 rounded up from the size of the text section. These
858 two values are *not* the same! Similarly for the bss
860 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
863 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
865 fragP->fr_address += slide;
866 } /* for each data frag */
868 know (text_last_frag != 0);
869 text_last_frag->fr_next = data_frag_root;
873 H_SET_DATA_SIZE (&headers, 0);
877 /* See above comments on b.out data section address. */
880 if (data_last_frag == 0)
881 bss_vma = H_GET_TEXT_SIZE (&headers);
883 bss_vma = data_last_frag->fr_address;
884 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
885 bss_address_frag.fr_address = bss_vma;
887 #else /* ! OBJ_BOUT */
888 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
889 H_GET_DATA_SIZE (&headers));
892 /* Slide all the frags */
895 relax_addressT slide = bss_address_frag.fr_address;
897 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
899 fragP->fr_address += slide;
900 } /* for each bss frag */
903 #endif /* ! OBJ_BOUT */
906 H_SET_BSS_SIZE (&headers,
907 bss_last_frag->fr_address - bss_frag_root->fr_address);
909 H_SET_BSS_SIZE (&headers, 0);
910 #endif /* BFD_ASSEMBLER */
912 #ifndef BFD_ASSEMBLER
915 * Crawl the symbol chain.
917 * For each symbol whose value depends on a frag, take the address of
918 * that frag and subsume it into the value of the symbol.
919 * After this, there is just one way to lookup a symbol value.
920 * Values are left in their final state for object file emission.
921 * We adjust the values of 'L' local symbols, even if we do
922 * not intend to emit them to the object file, because their values
923 * are needed for fix-ups.
925 * Unless we saw a -L flag, remove all symbols that begin with 'L'
926 * from the symbol chain. (They are still pointed to by the fixes.)
928 * Count the remaining symbols.
929 * Assign a symbol number to each symbol.
930 * Count the number of string-table chars we will emit.
931 * Put this info into the headers as appropriate.
934 know (zero_address_frag.fr_address == 0);
935 string_byte_count = sizeof (string_byte_count);
937 obj_crawl_symbol_chain (&headers);
939 if (string_byte_count == sizeof (string_byte_count))
940 string_byte_count = 0;
942 H_SET_STRING_SIZE (&headers, string_byte_count);
945 * Addresses of frags now reflect addresses we use in the object file.
946 * Symbol values are correct.
947 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
948 * Also converting any machine-dependent frags using md_convert_frag();
950 subseg_change (SEG_TEXT, 0);
952 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
954 cvt_frag_to_fill (&headers, fragP);
956 /* Some assert macros don't work with # directives mixed in. */
958 if (!(fragP->fr_next == NULL
960 || fragP->fr_next == data_frag_root
962 || ((fragP->fr_next->fr_address - fragP->fr_address)
963 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
967 #endif /* ! BFD_ASSEMBLER */
969 #ifndef WORKING_DOT_WORD
971 struct broken_word *lie;
972 struct broken_word **prevP;
974 prevP = &broken_words;
975 for (lie = broken_words; lie; lie = lie->next_broken_word)
979 fix_new (lie->frag, lie->word_goes_here - lie->frag->fr_literal,
980 2, lie->add, lie->sub, lie->addnum, 0,
983 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
984 fix_new (lie->frag, lie->word_goes_here - lie->frag->fr_literal,
986 lie->sub, lie->addnum,
990 fix_new_ns32k (lie->frag,
991 lie->word_goes_here - lie->frag->fr_literal,
998 fix_new (lie->frag, lie->word_goes_here - lie->frag->fr_literal,
1000 lie->sub, lie->addnum,
1002 #endif /* TC_NS32K */
1003 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1004 #endif /* BFD_ASSEMBLER */
1005 *prevP = lie->next_broken_word;
1008 prevP = &(lie->next_broken_word);
1010 for (lie = broken_words; lie;)
1012 struct broken_word *untruth;
1014 addressT table_addr;
1015 addressT from_addr, to_addr;
1018 fragP = lie->dispfrag;
1020 /* Find out how many broken_words go here. */
1022 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1023 if (untruth->added == 1)
1026 table_ptr = lie->dispfrag->fr_opcode;
1027 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1028 /* Create the jump around the long jumps. This is a short
1029 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1030 from_addr = table_addr;
1031 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1032 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1033 table_ptr += md_short_jump_size;
1034 table_addr += md_short_jump_size;
1036 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1038 if (lie->added == 2)
1040 /* Patch the jump table */
1041 /* This is the offset from ??? to table_ptr+0 */
1042 to_addr = table_addr - S_GET_VALUE (lie->sub);
1043 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1044 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1046 if (untruth->use_jump == lie)
1047 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1050 /* Install the long jump */
1051 /* this is a long jump from table_ptr+0 to the final target */
1052 from_addr = table_addr;
1053 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1054 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1055 table_ptr += md_long_jump_size;
1056 table_addr += md_long_jump_size;
1060 #endif /* not WORKING_DOT_WORD */
1062 #ifndef BFD_ASSEMBLER
1066 * Scan every FixS performing fixups. We had to wait until now to do
1067 * this because md_convert_frag() may have made some fixSs.
1071 subseg_change (SEG_TEXT, 0);
1072 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1073 subseg_change (SEG_DATA, 0);
1074 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1075 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1077 /* FIXME move this stuff into the pre-write-hook */
1078 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1079 H_SET_ENTRY_POINT (&headers, 0);
1081 obj_pre_write_hook (&headers); /* extra coff stuff */
1083 object_file_size = H_GET_FILE_SIZE (&headers);
1084 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1086 output_file_create (out_file_name);
1088 obj_header_append (&next_object_file_charP, &headers);
1090 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1095 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1097 register long count;
1098 register char *fill_literal;
1099 register long fill_size;
1101 know (fragP->fr_type == rs_fill);
1102 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1103 fill_literal = fragP->fr_literal + fragP->fr_fix;
1104 fill_size = fragP->fr_var;
1105 know (fragP->fr_offset >= 0);
1107 for (count = fragP->fr_offset; count; count--)
1109 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1112 } /* for each code frag. */
1114 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1119 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1120 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)));
1122 /* Make addresses in data relocation directives relative to beginning of
1123 * first data fragment, not end of last text fragment: alignment of the
1124 * start of the data segment may place a gap between the segments.
1126 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1128 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1129 #endif /* TC_I960 */
1131 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)));
1134 * Emit line number entries.
1136 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1137 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)));
1142 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1143 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)));
1149 if (string_byte_count > 0)
1151 obj_emit_strings (&next_object_file_charP);
1152 } /* only if we have a string table */
1155 bfd_seek (stdoutput, 0, 0);
1156 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1159 /* Write the data to the file */
1160 output_file_append (the_object_file, object_file_size, out_file_name);
1163 output_file_close (out_file_name);
1164 } /* non vms output */
1167 * Now do the VMS-dependent part of writing the object file
1169 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1170 H_GET_DATA_SIZE (&headers),
1171 H_GET_BSS_SIZE (&headers),
1172 text_frag_root, data_frag_root);
1174 #else /* BFD_ASSEMBLER */
1176 #ifdef obj_check_file_symbols
1177 obj_check_file_symbols ();
1180 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1182 /* Set up symbol table, and write it out. */
1188 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1192 if (! symp->sy_resolved)
1194 if (symp->sy_value.X_seg == absolute_section)
1196 /* This is the normal case; skip the call. */
1199 + symp->sy_frag->fr_address));
1200 symp->sy_resolved = 1;
1203 resolve_symbol_value (symp);
1206 /* So far, common symbols have been treated like undefined symbols.
1207 Put them in the common section now. */
1208 if (S_IS_DEFINED (symp) == 0
1209 && S_GET_VALUE (symp) != 0)
1210 S_SET_SEGMENT (symp, &bfd_com_section);
1212 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1213 S_GET_NAME (symp), symp,
1216 segment_name (symp->bsym->section));
1220 #ifdef obj_frob_symbol
1221 obj_frob_symbol (symp, punt);
1225 #ifdef tc_frob_symbol
1226 tc_frob_symbol (symp, punt);
1231 /* If we don't want to keep this symbol, splice it out of the
1233 if (S_IS_LOCAL (symp))
1235 symbolS *prev, *next;
1237 prev = symbol_previous (symp);
1238 next = symbol_next (symp);
1240 verify_symbol_chain_2 (symp);
1244 symbol_next (prev) = next;
1247 else if (symp == symbol_rootP)
1248 symbol_rootP = next;
1252 symbol_previous (next) = prev;
1254 symbol_lastP = prev;
1257 verify_symbol_chain_2 (prev);
1259 verify_symbol_chain_2 (next);
1264 /* Set the value into the BFD symbol. Up til now the value
1265 has only been kept in the gas symbolS struct. */
1266 symp->bsym->value = S_GET_VALUE (symp);
1275 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1277 asympp = (asymbol **) bfd_alloc (stdoutput,
1278 n * sizeof (asymbol *));
1279 symp = symbol_rootP;
1280 for (i = 0; i < n; i++, symp = symbol_next (symp))
1282 asympp[i] = symp->bsym;
1285 result = bfd_set_symtab (stdoutput, asympp, n);
1286 assert (result == true);
1291 #ifdef obj_frob_file
1292 /* If obj_frob_file changes the symbol value at this point, it is
1293 responsible for moving the changed value into symp->bsym->value
1294 as well. Hopefully all symbol value changing can be done in
1295 {obj,tc}_frob_symbol. */
1299 /* Now that all the sizes are known, and contents correct, we can
1300 start writing the file. */
1301 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1303 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1305 output_file_close (out_file_name);
1306 #endif /* BFD_ASSEMBLER */
1313 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1318 * After this, all frags in this segment have addresses that are correct
1319 * within the segment. Since segments live in different file addresses,
1320 * these frag addresses may not be the same as final object-file addresses.
1323 /* Subroutines of relax_segment. */
1329 for (; f1; f1 = f1->fr_next)
1330 if (f1->fr_next == f2)
1335 /* Relax_align. Advance location counter to next address that has 'alignment'
1336 lowest order bits all 0s, return size of adjustment made. */
1337 static relax_addressT
1338 relax_align (address, alignment)
1339 register relax_addressT address; /* Address now. */
1340 register int alignment; /* Alignment (binary). */
1342 relax_addressT mask;
1343 relax_addressT new_address;
1345 mask = ~((~0) << alignment);
1346 new_address = (address + mask) & (~mask);
1348 /* We must provide lots of padding, so the linker can discard it
1349 when needed. The linker will not add extra space, ever. */
1350 new_address += (1 << alignment);
1351 return (new_address - address);
1355 relax_segment (segment_frag_root, segment)
1356 struct frag *segment_frag_root;
1359 register struct frag *fragP;
1360 register relax_addressT address;
1361 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1362 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1364 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1365 subseg_change (segment, 0);
1367 /* For each frag in segment: count and store (a 1st guess of)
1370 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1372 fragP->fr_address = address;
1373 address += fragP->fr_fix;
1375 switch (fragP->fr_type)
1378 address += fragP->fr_offset * fragP->fr_var;
1382 address += relax_align (address, (int) fragP->fr_offset);
1386 /* Assume .org is nugatory. It will grow with 1st relax. */
1389 case rs_machine_dependent:
1390 address += md_estimate_size_before_relax (fragP, segment);
1393 #ifndef WORKING_DOT_WORD
1394 /* Broken words don't concern us yet */
1395 case rs_broken_word:
1400 BAD_CASE (fragP->fr_type);
1402 } /* switch(fr_type) */
1403 } /* for each frag in the segment */
1407 long stretch; /* May be any size, 0 or negative. */
1408 /* Cumulative number of addresses we have */
1409 /* relaxed this pass. */
1410 /* We may have relaxed more than one address. */
1411 long stretched; /* Have we stretched on this pass? */
1412 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1413 grew, and another shrank. If a branch instruction doesn't fit anymore,
1414 we could be scrod. */
1418 stretch = stretched = 0;
1419 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1422 unsigned long was_address;
1429 was_address = fragP->fr_address;
1430 address = fragP->fr_address += stretch;
1431 symbolP = fragP->fr_symbol;
1432 offset = fragP->fr_offset;
1434 switch (fragP->fr_type)
1436 case rs_fill: /* .fill never relaxes. */
1440 #ifndef WORKING_DOT_WORD
1441 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1442 for it I do not want to write it. I do not want to have
1443 anything to do with it. This is not the proper way to
1444 implement this misfeature. */
1445 case rs_broken_word:
1447 struct broken_word *lie;
1448 struct broken_word *untruth;
1450 /* Yes this is ugly (storing the broken_word pointer
1451 in the symbol slot). Still, this whole chunk of
1452 code is ugly, and I don't feel like doing anything
1453 about it. Think of it as stubbornness in action. */
1455 for (lie = (struct broken_word *) (fragP->fr_symbol);
1456 lie && lie->dispfrag == fragP;
1457 lie = lie->next_broken_word)
1463 offset = (lie->add->sy_frag->fr_address
1464 + S_GET_VALUE (lie->add)
1466 - (lie->sub->sy_frag->fr_address
1467 + S_GET_VALUE (lie->sub)));
1468 if (offset <= -32768 || offset >= 32767)
1473 sprint_value (buf, lie->addnum);
1474 as_warn (".word %s-%s+%s didn't fit",
1475 S_GET_NAME (lie->add),
1476 S_GET_NAME (lie->sub),
1480 if (fragP->fr_subtype == 0)
1482 fragP->fr_subtype++;
1483 growth += md_short_jump_size;
1485 for (untruth = lie->next_broken_word;
1486 untruth && untruth->dispfrag == lie->dispfrag;
1487 untruth = untruth->next_broken_word)
1488 if ((untruth->add->sy_frag == lie->add->sy_frag)
1489 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1492 untruth->use_jump = lie;
1494 growth += md_long_jump_size;
1499 } /* case rs_broken_word */
1502 growth = (relax_align ((relax_addressT) (address
1505 - relax_align ((relax_addressT) (was_address
1515 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1516 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1517 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1518 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1519 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1520 know (symbolP->sy_frag);
1521 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1522 || (symbolP->sy_frag == &zero_address_frag));
1524 target += S_GET_VALUE (symbolP)
1525 + symbolP->sy_frag->fr_address;
1526 } /* if we have a symbol */
1528 know (fragP->fr_next);
1529 after = fragP->fr_next->fr_address;
1530 growth = ((target - after) > 0) ? (target - after) : 0;
1531 /* Growth may be negative, but variable part of frag
1532 cannot have fewer than 0 chars. That is, we can't
1535 growth -= stretch; /* This is an absolute growth factor */
1538 case rs_machine_dependent:
1540 const relax_typeS *this_type;
1541 const relax_typeS *start_type;
1542 relax_substateT next_state;
1543 relax_substateT this_state;
1545 this_state = fragP->fr_subtype;
1546 start_type = this_type = md_relax_table + this_state;
1551 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1552 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1553 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1554 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1555 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1557 know (symbolP->sy_frag);
1558 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1559 || symbolP->sy_frag == &zero_address_frag);
1561 S_GET_VALUE (symbolP)
1562 + symbolP->sy_frag->fr_address;
1564 /* If frag has yet to be reached on this pass,
1565 assume it will move by STRETCH just as we did.
1566 If this is not so, it will be because some frag
1567 between grows, and that will force another pass.
1569 Beware zero-length frags.
1571 There should be a faster way to do this. */
1573 if (symbolP->sy_frag->fr_address >= was_address
1574 && is_dnrange (fragP, symbolP->sy_frag))
1580 aim = target - address - fragP->fr_fix;
1581 /* The displacement is affected by the instruction size
1582 for the 32k architecture. I think we ought to be able
1583 to add fragP->fr_pcrel_adjust in all cases (it should be
1584 zero if not used), but just in case it breaks something
1585 else we'll put this inside #ifdef NS32K ... #endif */
1587 if (fragP->fr_pcrel_adjust)
1590 aim += fragP->fr_pcrel_adjust;
1594 /* Look backwards. */
1595 for (next_state = this_type->rlx_more; next_state;)
1596 if (aim >= this_type->rlx_backward)
1600 /* Grow to next state. */
1601 this_state = next_state;
1602 this_type = md_relax_table + this_state;
1603 next_state = this_type->rlx_more;
1608 #ifdef M68K_AIM_KLUDGE
1609 M68K_AIM_KLUDGE (aim, this_state, this_type);
1611 /* Look forwards. */
1612 for (next_state = this_type->rlx_more; next_state;)
1613 if (aim <= this_type->rlx_forward)
1617 /* Grow to next state. */
1618 this_state = next_state;
1619 this_type = md_relax_table + this_state;
1620 next_state = this_type->rlx_more;
1624 growth = this_type->rlx_length - start_type->rlx_length;
1626 fragP->fr_subtype = this_state;
1631 BAD_CASE (fragP->fr_type);
1639 } /* For each frag in the segment. */
1641 while (stretched); /* Until nothing further to relax. */
1645 * We now have valid fr_address'es for each frag.
1649 * All fr_address's are correct, relative to their own segment.
1650 * We have made all the fixS we will ever make.
1652 } /* relax_segment() */
1656 Go through all the fixS's in a segment and see which ones can be
1657 handled now. (These consist of fixS where we have since discovered
1658 the value of a symbol, or the address of the frag involved.)
1659 For each one, call md_apply_fix to put the fix into the frag data.
1661 Result is a count of how many relocation structs will be needed to
1662 handle the remaining fixS's that we couldn't completely handle here.
1663 These will be output later by emit_relocations(). */
1666 fixup_segment (fixP, this_segment_type)
1667 register fixS *fixP;
1668 segT this_segment_type; /* N_TYPE bits for segment. */
1670 register long seg_reloc_count;
1671 register symbolS *add_symbolP;
1672 register symbolS *sub_symbolP;
1675 register char *place;
1676 register long where;
1677 register char pcrel;
1678 register fragS *fragP;
1679 register segT add_symbol_segment = absolute_section;
1681 seg_reloc_count = 0;
1682 /* If the linker is doing the relaxing, we must not do any fixups */
1684 for (; fixP; fixP = fixP->fx_next)
1687 for (; fixP; fixP = fixP->fx_next)
1689 fragP = fixP->fx_frag;
1691 where = fixP->fx_where;
1692 place = fragP->fr_literal + where;
1693 size = fixP->fx_size;
1694 add_symbolP = fixP->fx_addsy;
1696 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
1698 /* Relocation should be done via the associated 'bal'
1699 entry point symbol. */
1701 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1703 as_bad ("No 'bal' entry point for leafproc %s",
1704 S_GET_NAME (add_symbolP));
1707 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1710 sub_symbolP = fixP->fx_subsy;
1711 add_number = fixP->fx_offset;
1712 pcrel = fixP->fx_pcrel;
1715 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1722 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1723 as_bad ("Negative of non-absolute symbol %s",
1724 S_GET_NAME (sub_symbolP));
1726 add_number -= S_GET_VALUE (sub_symbolP);
1728 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1729 && (SEG_NORMAL (add_symbol_segment)
1730 || (add_symbol_segment == absolute_section)))
1732 /* Difference of 2 symbols from same segment.
1733 Can't make difference of 2 undefineds: 'value' means
1734 something different for N_UNDF. */
1736 /* Makes no sense to use the difference of 2 arbitrary symbols
1737 as the target of a call instruction. */
1740 as_bad ("callj to difference of 2 symbols");
1742 #endif /* TC_I960 */
1743 add_number += S_GET_VALUE (add_symbolP) -
1744 S_GET_VALUE (sub_symbolP);
1747 fixP->fx_addsy = NULL;
1751 /* Different segments in subtraction. */
1752 know (!(S_IS_EXTERNAL (sub_symbolP)
1753 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1755 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1757 add_number -= S_GET_VALUE (sub_symbolP);
1762 sprint_value (buf, fragP->fr_address + where);
1763 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1764 segment_name (S_GET_SEGMENT (sub_symbolP)),
1765 S_GET_NAME (sub_symbolP), buf);
1772 if (add_symbol_segment == this_segment_type && pcrel)
1775 * This fixup was made when the symbol's segment was
1776 * SEG_UNKNOWN, but it is now in the local segment.
1777 * So we know how to do the address without relocation.
1780 /* reloc_callj() may replace a 'call' with a 'calls' or a
1781 'bal', in which cases it modifies *fixP as appropriate.
1782 In the case of a 'calls', no further work is required,
1783 and *fixP has been set up to make the rest of the code
1786 #endif /* TC_I960 */
1788 add_number += S_GET_VALUE (add_symbolP);
1789 add_number -= md_pcrel_from (fixP);
1790 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1791 fixP->fx_addsy = NULL; /* No relocations please. */
1795 if (add_symbol_segment == absolute_section)
1798 /* See comment about reloc_callj() above. */
1800 #endif /* TC_I960 */
1801 add_number += S_GET_VALUE (add_symbolP);
1802 fixP->fx_addsy = NULL;
1805 else if (add_symbol_segment == undefined_section
1806 #ifdef BFD_ASSEMBLER
1807 || add_symbol_segment == &bfd_com_section
1812 if ((int) fixP->fx_bit_fixP == 13)
1814 /* This is a COBR instruction. They have only a
1815 * 13-bit displacement and are only to be used
1816 * for local branches: flag as error, don't generate
1819 as_bad ("can't use COBR format with external label");
1820 fixP->fx_addsy = NULL; /* No relocations please. */
1823 #endif /* TC_I960 */
1827 if (S_IS_COMMON (add_symbolP))
1828 add_number += S_GET_VALUE (add_symbolP);
1829 #endif /* TE_I386AIX */
1830 #endif /* OBJ_COFF */
1836 add_number += S_GET_VALUE (add_symbolP);
1838 } /* if not in local seg */
1839 } /* if there was a + symbol */
1843 add_number -= md_pcrel_from (fixP);
1844 if (add_symbolP == 0)
1846 fixP->fx_addsy = &abs_symbol;
1848 } /* if there's an add_symbol */
1851 if (!fixP->fx_bit_fixP)
1854 && (add_number & ~0xFF)
1855 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
1857 && (add_number & ~0xFFFF)
1858 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)))
1860 && (add_number & ~(valueT)0xFFFFFFFF)
1861 && ((add_number & ~(valueT)0xFFFFFFFF) != (-1 & ~(valueT)0xFFFFFFFF)))
1865 sprint_value (buf, fragP->fr_address + where);
1866 as_bad ("Value of %d too large for field of %d bytes at %s",
1867 add_number, size, buf);
1868 } /* generic error checking */
1869 #ifdef WARN_SIGNED_OVERFLOW_WORD
1870 /* Warn if a .word value is too large when treated as a signed
1871 number. We already know it is not too negative. This is to
1872 catch over-large switches generated by gcc on the 68k. */
1875 && add_number > 0x7fff)
1876 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
1877 add_number, fragP->fr_address + where);
1879 } /* not a bit fix */
1881 #ifdef BFD_ASSEMBLER
1882 md_apply_fix (fixP, &add_number);
1884 md_apply_fix (fixP, add_number);
1886 } /* For each fixS in this segment. */
1893 /* two relocs per callj under coff. */
1894 for (fixP = topP; fixP; fixP = fixP->fx_next)
1896 if (fixP->fx_callj && fixP->fx_addsy != 0)
1899 } /* if callj and not already fixed. */
1900 } /* for each fix */
1902 #endif /* TC_I960 */
1904 #endif /* OBJ_COFF */
1905 return (seg_reloc_count);
1908 /* end of write.c */