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 fixS *fix_new_internal PARAMS ((fragS *, int where, short int size,
62 symbolS *add, symbolS *sub,
63 offsetT offset, int pcrel,
65 bfd_reloc_code_real_type r_type
70 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
71 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
72 void relax_segment PARAMS ((struct frag * seg_frag_root, segT seg_type));
77 * Create a fixS in obstack 'notes'.
80 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
82 fragS *frag; /* Which frag? */
83 int where; /* Where in that frag? */
84 short int size; /* 1, 2, or 4 usually. */
85 symbolS *add_symbol; /* X_add_symbol. */
86 symbolS *sub_symbol; /* X_op_symbol. */
87 offsetT offset; /* X_add_number. */
88 int pcrel; /* TRUE if PC-relative relocation. */
90 bfd_reloc_code_real_type r_type; /* Relocation type */
92 int r_type; /* Relocation type */
97 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
100 fixP->fx_where = where;
101 fixP->fx_size = size;
102 fixP->fx_addsy = add_symbol;
103 fixP->fx_subsy = sub_symbol;
104 fixP->fx_offset = offset;
105 fixP->fx_pcrel = pcrel;
106 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
107 fixP->fx_r_type = r_type;
109 fixP->fx_im_disp = 0;
110 fixP->fx_pcrel_adjust = 0;
111 fixP->fx_bit_fixP = 0;
112 fixP->fx_addnumber = 0;
121 /* Usually, we want relocs sorted numerically, but while
122 comparing to older versions of gas that have relocs
123 reverse sorted, it is convenient to have this compile
124 time option. xoxorich. */
129 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
130 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
133 #ifdef REVERSE_SORT_RELOCS
135 fixP->fx_next = *seg_fix_rootP;
136 *seg_fix_rootP = fixP;
138 #else /* REVERSE_SORT_RELOCS */
140 fixP->fx_next = NULL;
143 (*seg_fix_tailP)->fx_next = fixP;
145 *seg_fix_rootP = fixP;
146 *seg_fix_tailP = fixP;
148 #endif /* REVERSE_SORT_RELOCS */
155 /* Create a fixup relative to a symbol (plus a constant). */
158 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
159 fragS *frag; /* Which frag? */
160 int where; /* Where in that frag? */
161 short int size; /* 1, 2, or 4 usually. */
162 symbolS *add_symbol; /* X_add_symbol. */
163 offsetT offset; /* X_add_number. */
164 int pcrel; /* TRUE if PC-relative relocation. */
166 bfd_reloc_code_real_type r_type; /* Relocation type */
168 int r_type; /* Relocation type */
171 return fix_new_internal (frag, where, size, add_symbol,
172 (symbolS *) NULL, offset, pcrel, r_type);
175 /* Create a fixup for an expression. Currently we only support fixups
176 for difference expressions. That is itself more than most object
177 file formats support anyhow. */
180 fix_new_exp (frag, where, size, exp, pcrel, r_type)
181 fragS *frag; /* Which frag? */
182 int where; /* Where in that frag? */
183 short int size; /* 1, 2, or 4 usually. */
184 expressionS *exp; /* Expression. */
185 int pcrel; /* TRUE if PC-relative relocation. */
187 bfd_reloc_code_real_type r_type; /* Relocation type */
189 int r_type; /* Relocation type */
202 sub = exp->X_op_symbol;
205 add = exp->X_add_symbol;
208 off = exp->X_add_number;
212 as_bad ("expression too complex for fixup");
215 return fix_new_internal (frag, where, size, add, sub, off,
219 /* Append a string onto another string, bumping the pointer along. */
221 append (charPP, fromP, length)
224 unsigned long length;
226 /* Don't trust memcpy() of 0 chars. */
230 memcpy (*charPP, fromP, (int) length);
234 #ifndef BFD_ASSEMBLER
235 int section_alignment[SEG_MAXIMUM_ORDINAL];
239 * This routine records the largest alignment seen for each segment.
240 * If the beginning of the segment is aligned on the worst-case
241 * boundary, all of the other alignments within it will work. At
242 * least one object format really uses this info.
245 record_alignment (seg, align)
246 /* Segment to which alignment pertains */
248 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
253 if (align > bfd_get_section_alignment (stdoutput, seg))
254 bfd_set_section_alignment (stdoutput, seg, align);
256 if (align > section_alignment[(int) seg])
257 section_alignment[(int) seg] = align;
261 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
264 chain_frchains_together_1 (section, frchp)
266 struct frchain *frchp;
268 fragS dummy, *prev_frag = &dummy;
269 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
271 prev_frag->fr_next = frchp->frch_root;
272 prev_frag = frchp->frch_last;
274 prev_frag->fr_next = 0;
283 chain_frchains_together (abfd, section, xxx)
284 bfd *abfd; /* unused */
286 char *xxx; /* unused */
288 segment_info_type *info;
290 /* BFD may have introduced its own sections without using
291 subseg_new, so it is possible that seg_info is NULL. */
292 info = seg_info (section);
293 if (info != (segment_info_type *) NULL)
294 chain_frchains_together_1 (section, info->frchainP);
299 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
302 remove_subsegs (head, seg, root, last)
308 *root = head->frch_root;
309 *last = chain_frchains_together_1 (seg, head);
315 cvt_frag_to_fill (x, fragP)
326 object_headers *headers = x;
329 switch (fragP->fr_type)
334 HANDLE_ALIGN (fragP);
336 fragP->fr_type = rs_fill;
337 know (fragP->fr_var == 1);
338 know (fragP->fr_next != NULL);
340 fragP->fr_offset = (fragP->fr_next->fr_address
348 case rs_machine_dependent:
350 md_convert_frag (stdoutput, sec, fragP);
352 md_convert_frag (headers, fragP);
355 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
358 * After md_convert_frag, we make the frag into a ".space 0".
359 * Md_convert_frag() should set up any fixSs and constants
365 #ifndef WORKING_DOT_WORD
368 struct broken_word *lie;
370 if (fragP->fr_subtype)
372 fragP->fr_fix += md_short_jump_size;
373 for (lie = (struct broken_word *) (fragP->fr_symbol);
374 lie && lie->dispfrag == fragP;
375 lie = lie->next_broken_word)
377 fragP->fr_fix += md_long_jump_size;
385 BAD_CASE (fragP->fr_type);
392 relax_and_size_seg (abfd, sec, xxx)
399 flags = bfd_get_section_flags (abfd, sec);
401 if (/*flags & SEC_ALLOC*/ 1)
404 segment_info_type *seginfo;
406 valueT size, newsize;
408 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
409 if (seginfo && seginfo->frchainP)
411 relax_segment (seginfo->frchainP->frch_root, sec);
412 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
413 cvt_frag_to_fill (sec, fragp);
414 for (fragp = seginfo->frchainP->frch_root;
416 fragp = fragp->fr_next)
417 /* walk to last elt */;
418 size = fragp->fr_address + fragp->fr_fix;
424 flags |= SEC_HAS_CONTENTS;
425 /* @@ This is just an approximation. */
426 if (seginfo->fix_root)
430 x = bfd_set_section_flags (abfd, sec, flags);
433 size = md_section_align (sec, size);
434 x = bfd_set_section_size (abfd, sec, size);
437 /* If the size had to be rounded up, add some padding in the last
439 newsize = bfd_get_section_size_before_reloc (sec);
440 assert (newsize >= size);
443 fragS *last = seginfo->frchainP->frch_last;
444 fragp = seginfo->frchainP->frch_root;
445 while (fragp->fr_next != last)
446 fragp = fragp->fr_next;
447 last->fr_address = size;
448 fragp->fr_offset += newsize - size;
451 #ifdef tc_frob_section
452 tc_frob_section (sec);
454 #ifdef obj_frob_section
455 obj_frob_section (sec);
461 dump_section_relocs (abfd, sec, stream_)
466 FILE *stream = (FILE *) stream_;
467 segment_info_type *seginfo = seg_info (sec);
468 fixS *fixp = seginfo->fix_root;
473 fprintf (stream, "sec %s relocs:\n", sec->name);
476 symbolS *s = fixp->fx_addsy;
478 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
479 S_GET_NAME (s), s->bsym->section->name,
480 S_GET_VALUE (s), fixp->fx_offset);
482 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
483 fixp = fixp->fx_next;
487 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
491 adjust_reloc_syms (abfd, sec, xxx)
496 segment_info_type *seginfo = seg_info (sec);
502 dump_section_relocs (abfd, sec, stderr);
504 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
507 symbolS *sym = fixp->fx_addsy;
508 asection *symsec = sym->bsym->section;
509 segment_info_type *symseginfo = seg_info (symsec);
511 /* If it's one of these sections, assume the symbol is definitely
512 going to be output. */
513 if (symsec == &bfd_und_section
514 || symsec == &bfd_abs_section
515 || bfd_is_com_section (symsec))
518 /* Since we're reducing to section symbols, don't attempt to reduce
519 anything that's already using one. */
520 if (sym->bsym == symsec->symbol)
523 /* Is there some other reason we can't adjust this one? (E.g.,
524 call/bal links in i960-bout symbols.) */
525 #ifdef obj_fix_adjustable
526 if (! obj_fix_adjustable (fixp))
529 /* If the section symbol isn't going to be output, the relocs
530 at least should still work. If not, figure out what to do
531 when we run into that case. */
532 fixp->fx_offset += S_GET_VALUE (sym);
534 fixp->fx_offset += sym->sy_frag->fr_address;
536 fixp->fx_addsy = symseginfo->sym;
539 fixp->fx_addsy = symbol_find (symsec->name);
542 fixp->fx_addsy = symbol_make (symsec->name);
543 fixp->fx_addsy->bsym = symsec->symbol;
545 symseginfo->sym = fixp->fx_addsy;
549 dump_section_relocs (abfd, sec, stderr);
553 write_relocs (abfd, sec, xxx)
558 segment_info_type *seginfo = seg_info (sec);
559 unsigned long offset = 0;
565 /* If seginfo is NULL, we did not create this section; don't do
570 fixup_segment (seginfo->fix_root, sec);
573 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
576 #ifndef RELOC_EXPANSION_POSSIBLE
577 /* Set up reloc information as well. */
578 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
579 n * sizeof (arelent *));
580 memset ((char*)relocs, 0, n * sizeof (arelent*));
583 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
586 extern arelent *tc_gen_reloc ();
588 bfd_reloc_status_type s;
590 if (fixp->fx_addsy == 0)
592 /* @@ Need some other flag to indicate which have already
597 reloc = tc_gen_reloc (sec, fixp);
603 data = fixp->fx_frag->fr_literal + fixp->fx_where;
604 /* @@ Assumes max size of reloc is 4. */
605 if (fixp->fx_where + 4
606 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
608 /* Pass bogus address so that when bfd_perform_relocation adds
609 `address' back in, it'll come up with `data', which is where
610 we want it to operate. */
611 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
618 as_fatal ("bad return from bfd_perform_relocation");
623 n = n * MAX_RELOC_EXPANSION;
624 /* Set up reloc information as well. */
625 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
626 n * sizeof (arelent *));
629 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
632 extern arelent *tc_gen_reloc ();
634 bfd_reloc_status_type s;
637 if (fixp->fx_addsy == 0)
639 /* @@ Need some other flag to indicate which have already
644 reloc = tc_gen_reloc (sec, fixp);
646 for (j = 0; reloc[j]; j++)
648 relocs[i++] = reloc[j];
651 data = fixp->fx_frag->fr_literal + fixp->fx_where;
652 if (fixp->fx_where + 4
653 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
655 for (j = 0; reloc[j]; j++)
657 s = bfd_perform_relocation (stdoutput, reloc[j], data - reloc[j]->address,
664 as_fatal ("bad return from bfd_perform_relocation");
672 bfd_set_reloc (stdoutput, sec, relocs, n);
674 bfd_set_section_flags (abfd, sec,
675 bfd_get_section_flags (abfd, sec) & ~SEC_RELOC);
681 fprintf (stderr, "relocs for sec %s\n", sec->name);
682 for (i = 0; i < n; i++)
686 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
687 i, r, r->address, s->name, r->addend);
694 write_contents (abfd, sec, xxx)
699 segment_info_type *seginfo = seg_info (sec);
700 unsigned long offset = 0;
706 /* Write out the frags. */
707 if (! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
710 #if 0 /* Who cares? Let the first call, below, do it. */
711 /* Force calculations (size, vma) to get done. */
712 bfd_set_section_contents (stdoutput, sec, "", 0, (addressT) 0);
715 for (frags = seginfo->frchainP->frch_root;
717 frags = frags->fr_next)
720 unsigned long fill_size;
724 assert (frags->fr_type == rs_fill);
727 x = bfd_set_section_contents (stdoutput, sec,
728 frags->fr_literal, offset,
731 offset += frags->fr_fix;
733 fill_literal = frags->fr_literal + frags->fr_fix;
734 fill_size = frags->fr_var;
735 count = frags->fr_offset;
737 if (fill_size && count)
740 x = bfd_set_section_contents (stdoutput, sec,
741 fill_literal, offset,
742 (bfd_size_type) fill_size);
750 #if defined (BFD_ASSEMBLER) || !defined (BFD)
755 register struct frchain *frchainP; /* Track along all frchains. */
756 register fragS *fragP; /* Track along all frags. */
758 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
759 long object_file_size;
762 /* Do we really want to write it? */
765 n_warns = had_warnings ();
766 n_errs = had_errors ();
767 /* The -Z flag indicates that an object file should be generated,
768 regardless of warnings and errors. */
771 if (n_warns || n_errs)
772 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
773 n_errs, n_errs == 1 ? "" : "s",
774 n_warns, n_warns == 1 ? "" : "s");
779 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
780 n_errs, n_errs == 1 ? "" : "s",
781 n_warns, n_warns == 1 ? "" : "s");
787 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
788 * call a routine to check for the definition of the procedure
789 * "_main", and if so -- fix it up so that it can be program
792 VMS_Check_For_Main ();
795 /* After every sub-segment, we fake an ".align ...". This conforms to
796 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
797 frag that requires least thought. ".align" frags like to have a
798 following frag since that makes calculating their intended length
801 @@ Is this really necessary?? */
802 #ifndef SUB_SEGMENT_ALIGN
804 #define SUB_SEGMENT_ALIGN(SEG) (0)
806 #define SUB_SEGMENT_ALIGN(SEG) (2)
809 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
812 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
814 subseg_new (frchainP->frch_seg, frchainP->frch_subseg);
816 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
817 /* frag_align will have left a new frag.
818 Use this last frag for an empty ".fill".
821 Create a last frag. Do not leave a "being filled in frag". */
822 frag_wane (frag_now);
823 frag_now->fr_fix = 0;
824 know (frag_now->fr_next == NULL);
825 /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
826 /* Above shows we haven't left a half-completed object on obstack. */
829 /* From now on, we don't care about sub-segments. Build one frag chain
830 for each segment. Linked thru fr_next. */
833 /* Remove the sections created by gas for its own purposes. */
835 asection **seclist, *sec;
836 seclist = &stdoutput->sections;
837 while (seclist && *seclist)
840 while (sec == reg_section || sec == expr_section)
844 stdoutput->section_count--;
849 seclist = &(*seclist)->next;
853 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
855 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
856 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
857 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
860 /* We have two segments. If user gave -R flag, then we must put the
861 data frags into the text segment. Do this before relaxing so
862 we know to take advantage of -R and make shorter addresses. */
863 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
867 seg_info (text_section)->frchainP->frch_last->fr_next =
868 seg_info (data_section)->frchainP->frch_root;
869 seg_info (text_section)->frchainP->frch_last =
870 seg_info (data_section)->frchainP->frch_last;
871 seg_info (data_section)->frchainP = 0;
875 text_last_frag->fr_next = data_frag_root;
876 text_last_frag = data_last_frag;
877 data_last_frag = NULL;
878 data_frag_root = NULL;
881 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
882 tmp->fx_next = data_fix_root;
883 text_fix_tail = data_fix_tail;
886 text_fix_root = data_fix_root;
887 data_fix_root = NULL;
894 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
896 relax_segment (text_frag_root, SEG_TEXT);
897 relax_segment (data_frag_root, SEG_DATA);
898 relax_segment (bss_frag_root, SEG_BSS);
900 * Now the addresses of frags are correct within the segment.
903 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
904 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
905 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
908 * Join the 2 segments into 1 huge segment.
909 * To do this, re-compute every rn_address in the SEG_DATA frags.
910 * Then join the data frags after the text frags.
912 * Determine a_data [length of data segment].
916 register relax_addressT slide;
918 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
920 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
921 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
922 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
924 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
925 /* For b.out: If the data section has a strict alignment
926 requirement, its load address in the .o file will be
927 rounded up from the size of the text section. These
928 two values are *not* the same! Similarly for the bss
930 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
933 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
935 fragP->fr_address += slide;
936 } /* for each data frag */
938 know (text_last_frag != 0);
939 text_last_frag->fr_next = data_frag_root;
943 H_SET_DATA_SIZE (&headers, 0);
947 /* See above comments on b.out data section address. */
950 if (data_last_frag == 0)
951 bss_vma = H_GET_TEXT_SIZE (&headers);
953 bss_vma = data_last_frag->fr_address;
954 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
955 bss_address_frag.fr_address = bss_vma;
957 #else /* ! OBJ_BOUT */
958 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
959 H_GET_DATA_SIZE (&headers));
962 /* Slide all the frags */
965 relax_addressT slide = bss_address_frag.fr_address;
967 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
969 fragP->fr_address += slide;
970 } /* for each bss frag */
973 #endif /* ! OBJ_BOUT */
976 H_SET_BSS_SIZE (&headers,
977 bss_last_frag->fr_address - bss_frag_root->fr_address);
979 H_SET_BSS_SIZE (&headers, 0);
980 #endif /* BFD_ASSEMBLER */
982 #ifndef BFD_ASSEMBLER
985 * Crawl the symbol chain.
987 * For each symbol whose value depends on a frag, take the address of
988 * that frag and subsume it into the value of the symbol.
989 * After this, there is just one way to lookup a symbol value.
990 * Values are left in their final state for object file emission.
991 * We adjust the values of 'L' local symbols, even if we do
992 * not intend to emit them to the object file, because their values
993 * are needed for fix-ups.
995 * Unless we saw a -L flag, remove all symbols that begin with 'L'
996 * from the symbol chain. (They are still pointed to by the fixes.)
998 * Count the remaining symbols.
999 * Assign a symbol number to each symbol.
1000 * Count the number of string-table chars we will emit.
1001 * Put this info into the headers as appropriate.
1004 know (zero_address_frag.fr_address == 0);
1005 string_byte_count = sizeof (string_byte_count);
1007 obj_crawl_symbol_chain (&headers);
1009 if (string_byte_count == sizeof (string_byte_count))
1010 string_byte_count = 0;
1012 H_SET_STRING_SIZE (&headers, string_byte_count);
1015 * Addresses of frags now reflect addresses we use in the object file.
1016 * Symbol values are correct.
1017 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1018 * Also converting any machine-dependent frags using md_convert_frag();
1020 subseg_change (SEG_TEXT, 0);
1022 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1024 cvt_frag_to_fill (&headers, fragP);
1026 /* Some assert macros don't work with # directives mixed in. */
1028 if (!(fragP->fr_next == NULL
1030 || fragP->fr_next == data_frag_root
1032 || ((fragP->fr_next->fr_address - fragP->fr_address)
1033 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1037 #endif /* ! BFD_ASSEMBLER */
1039 #ifndef WORKING_DOT_WORD
1041 struct broken_word *lie;
1042 struct broken_word **prevP;
1044 prevP = &broken_words;
1045 for (lie = broken_words; lie; lie = lie->next_broken_word)
1050 exp.X_op = O_subtract;
1051 exp.X_add_symbol = lie->add;
1052 exp.X_op_symbol = lie->sub;
1053 exp.X_add_number = lie->addnum;
1054 #ifdef BFD_ASSEMBLER
1055 fix_new_exp (lie->frag,
1056 lie->word_goes_here - lie->frag->fr_literal,
1057 2, &exp, 0, BFD_RELOC_NONE);
1059 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1060 fix_new_exp (lie->frag,
1061 lie->word_goes_here - lie->frag->fr_literal,
1062 2, &exp, 0, NO_RELOC);
1065 fix_new_ns32k_exp (lie->frag,
1066 lie->word_goes_here - lie->frag->fr_literal,
1067 2, &exp, 0, 0, 2, 0, 0);
1069 fix_new_exp (lie->frag,
1070 lie->word_goes_here - lie->frag->fr_literal,
1072 #endif /* TC_NS32K */
1073 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1074 #endif /* BFD_ASSEMBLER */
1075 *prevP = lie->next_broken_word;
1078 prevP = &(lie->next_broken_word);
1080 for (lie = broken_words; lie;)
1082 struct broken_word *untruth;
1084 addressT table_addr;
1085 addressT from_addr, to_addr;
1088 fragP = lie->dispfrag;
1090 /* Find out how many broken_words go here. */
1092 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1093 if (untruth->added == 1)
1096 table_ptr = lie->dispfrag->fr_opcode;
1097 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1098 /* Create the jump around the long jumps. This is a short
1099 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1100 from_addr = table_addr;
1101 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1102 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1103 table_ptr += md_short_jump_size;
1104 table_addr += md_short_jump_size;
1106 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1108 if (lie->added == 2)
1110 /* Patch the jump table */
1111 /* This is the offset from ??? to table_ptr+0 */
1112 to_addr = table_addr - S_GET_VALUE (lie->sub);
1113 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1114 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1116 if (untruth->use_jump == lie)
1117 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1120 /* Install the long jump */
1121 /* this is a long jump from table_ptr+0 to the final target */
1122 from_addr = table_addr;
1123 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1124 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1125 table_ptr += md_long_jump_size;
1126 table_addr += md_long_jump_size;
1130 #endif /* not WORKING_DOT_WORD */
1132 #ifndef BFD_ASSEMBLER
1136 * Scan every FixS performing fixups. We had to wait until now to do
1137 * this because md_convert_frag() may have made some fixSs.
1141 subseg_change (SEG_TEXT, 0);
1142 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1143 subseg_change (SEG_DATA, 0);
1144 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1145 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1147 /* FIXME move this stuff into the pre-write-hook */
1148 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1149 H_SET_ENTRY_POINT (&headers, 0);
1151 obj_pre_write_hook (&headers); /* extra coff stuff */
1153 object_file_size = H_GET_FILE_SIZE (&headers);
1154 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1156 output_file_create (out_file_name);
1158 obj_header_append (&next_object_file_charP, &headers);
1160 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1165 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1167 register long count;
1168 register char *fill_literal;
1169 register long fill_size;
1171 know (fragP->fr_type == rs_fill);
1172 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1173 fill_literal = fragP->fr_literal + fragP->fr_fix;
1174 fill_size = fragP->fr_var;
1175 know (fragP->fr_offset >= 0);
1177 for (count = fragP->fr_offset; count; count--)
1179 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1182 } /* for each code frag. */
1184 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1189 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1190 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)));
1192 /* Make addresses in data relocation directives relative to beginning of
1193 * first data fragment, not end of last text fragment: alignment of the
1194 * start of the data segment may place a gap between the segments.
1196 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1198 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1199 #endif /* TC_I960 */
1201 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)));
1204 * Emit line number entries.
1206 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1207 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)));
1212 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1213 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)));
1219 if (string_byte_count > 0)
1221 obj_emit_strings (&next_object_file_charP);
1222 } /* only if we have a string table */
1225 bfd_seek (stdoutput, 0, 0);
1226 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1229 /* Write the data to the file */
1230 output_file_append (the_object_file, object_file_size, out_file_name);
1233 output_file_close (out_file_name);
1234 } /* non vms output */
1237 * Now do the VMS-dependent part of writing the object file
1239 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1240 H_GET_DATA_SIZE (&headers),
1241 H_GET_BSS_SIZE (&headers),
1242 text_frag_root, data_frag_root);
1244 #else /* BFD_ASSEMBLER */
1246 #ifdef obj_check_file_symbols
1247 obj_check_file_symbols ();
1250 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1252 /* Set up symbol table, and write it out. */
1258 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1262 if (! symp->sy_resolved)
1264 if (symp->sy_value.X_op == O_constant)
1266 /* This is the normal case; skip the call. */
1269 + symp->sy_frag->fr_address));
1270 symp->sy_resolved = 1;
1273 resolve_symbol_value (symp);
1276 /* So far, common symbols have been treated like undefined symbols.
1277 Put them in the common section now. */
1278 if (S_IS_DEFINED (symp) == 0
1279 && S_GET_VALUE (symp) != 0)
1280 S_SET_SEGMENT (symp, &bfd_com_section);
1282 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1283 S_GET_NAME (symp), symp,
1286 segment_name (symp->bsym->section));
1290 #ifdef obj_frob_symbol
1291 obj_frob_symbol (symp, punt);
1295 #ifdef tc_frob_symbol
1296 tc_frob_symbol (symp, punt);
1301 /* If we don't want to keep this symbol, splice it out of the
1303 if (S_IS_LOCAL (symp))
1305 symbolS *prev, *next;
1307 prev = symbol_previous (symp);
1308 next = symbol_next (symp);
1310 verify_symbol_chain_2 (symp);
1314 symbol_next (prev) = next;
1317 else if (symp == symbol_rootP)
1318 symbol_rootP = next;
1322 symbol_previous (next) = prev;
1324 symbol_lastP = prev;
1327 verify_symbol_chain_2 (prev);
1329 verify_symbol_chain_2 (next);
1334 /* Set the value into the BFD symbol. Up til now the value
1335 has only been kept in the gas symbolS struct. */
1336 symp->bsym->value = S_GET_VALUE (symp);
1345 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1347 asympp = (asymbol **) bfd_alloc (stdoutput,
1348 n * sizeof (asymbol *));
1349 symp = symbol_rootP;
1350 for (i = 0; i < n; i++, symp = symbol_next (symp))
1352 asympp[i] = symp->bsym;
1355 result = bfd_set_symtab (stdoutput, asympp, n);
1356 assert (result == true);
1361 #ifdef obj_frob_file
1362 /* If obj_frob_file changes the symbol value at this point, it is
1363 responsible for moving the changed value into symp->bsym->value
1364 as well. Hopefully all symbol value changing can be done in
1365 {obj,tc}_frob_symbol. */
1369 /* Now that all the sizes are known, and contents correct, we can
1370 start writing the file. */
1371 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1373 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1375 output_file_close (out_file_name);
1376 #endif /* BFD_ASSEMBLER */
1383 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1388 * After this, all frags in this segment have addresses that are correct
1389 * within the segment. Since segments live in different file addresses,
1390 * these frag addresses may not be the same as final object-file addresses.
1393 /* Subroutines of relax_segment. */
1399 for (; f1; f1 = f1->fr_next)
1400 if (f1->fr_next == f2)
1405 /* Relax_align. Advance location counter to next address that has 'alignment'
1406 lowest order bits all 0s, return size of adjustment made. */
1407 static relax_addressT
1408 relax_align (address, alignment)
1409 register relax_addressT address; /* Address now. */
1410 register int alignment; /* Alignment (binary). */
1412 relax_addressT mask;
1413 relax_addressT new_address;
1415 mask = ~((~0) << alignment);
1416 new_address = (address + mask) & (~mask);
1418 /* We must provide lots of padding, so the linker can discard it
1419 when needed. The linker will not add extra space, ever. */
1420 new_address += (1 << alignment);
1421 return (new_address - address);
1425 relax_segment (segment_frag_root, segment)
1426 struct frag *segment_frag_root;
1429 register struct frag *fragP;
1430 register relax_addressT address;
1431 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1432 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1434 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1435 subseg_change (segment, 0);
1437 /* For each frag in segment: count and store (a 1st guess of)
1440 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1442 fragP->fr_address = address;
1443 address += fragP->fr_fix;
1445 switch (fragP->fr_type)
1448 address += fragP->fr_offset * fragP->fr_var;
1452 address += relax_align (address, (int) fragP->fr_offset);
1456 /* Assume .org is nugatory. It will grow with 1st relax. */
1459 case rs_machine_dependent:
1460 address += md_estimate_size_before_relax (fragP, segment);
1463 #ifndef WORKING_DOT_WORD
1464 /* Broken words don't concern us yet */
1465 case rs_broken_word:
1470 BAD_CASE (fragP->fr_type);
1472 } /* switch(fr_type) */
1473 } /* for each frag in the segment */
1477 long stretch; /* May be any size, 0 or negative. */
1478 /* Cumulative number of addresses we have */
1479 /* relaxed this pass. */
1480 /* We may have relaxed more than one address. */
1481 long stretched; /* Have we stretched on this pass? */
1482 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1483 grew, and another shrank. If a branch instruction doesn't fit anymore,
1484 we could be scrod. */
1488 stretch = stretched = 0;
1489 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1492 unsigned long was_address;
1499 was_address = fragP->fr_address;
1500 address = fragP->fr_address += stretch;
1501 symbolP = fragP->fr_symbol;
1502 offset = fragP->fr_offset;
1504 switch (fragP->fr_type)
1506 case rs_fill: /* .fill never relaxes. */
1510 #ifndef WORKING_DOT_WORD
1511 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1512 for it I do not want to write it. I do not want to have
1513 anything to do with it. This is not the proper way to
1514 implement this misfeature. */
1515 case rs_broken_word:
1517 struct broken_word *lie;
1518 struct broken_word *untruth;
1520 /* Yes this is ugly (storing the broken_word pointer
1521 in the symbol slot). Still, this whole chunk of
1522 code is ugly, and I don't feel like doing anything
1523 about it. Think of it as stubbornness in action. */
1525 for (lie = (struct broken_word *) (fragP->fr_symbol);
1526 lie && lie->dispfrag == fragP;
1527 lie = lie->next_broken_word)
1533 offset = (lie->add->sy_frag->fr_address
1534 + S_GET_VALUE (lie->add)
1536 - (lie->sub->sy_frag->fr_address
1537 + S_GET_VALUE (lie->sub)));
1538 if (offset <= -32768 || offset >= 32767)
1543 sprint_value (buf, lie->addnum);
1544 as_warn (".word %s-%s+%s didn't fit",
1545 S_GET_NAME (lie->add),
1546 S_GET_NAME (lie->sub),
1550 if (fragP->fr_subtype == 0)
1552 fragP->fr_subtype++;
1553 growth += md_short_jump_size;
1555 for (untruth = lie->next_broken_word;
1556 untruth && untruth->dispfrag == lie->dispfrag;
1557 untruth = untruth->next_broken_word)
1558 if ((untruth->add->sy_frag == lie->add->sy_frag)
1559 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1562 untruth->use_jump = lie;
1564 growth += md_long_jump_size;
1569 } /* case rs_broken_word */
1572 growth = (relax_align ((relax_addressT) (address
1575 - relax_align ((relax_addressT) (was_address
1585 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1586 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1587 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1588 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1589 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1590 know (symbolP->sy_frag);
1591 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1592 || (symbolP->sy_frag == &zero_address_frag));
1594 target += S_GET_VALUE (symbolP)
1595 + symbolP->sy_frag->fr_address;
1596 } /* if we have a symbol */
1598 know (fragP->fr_next);
1599 after = fragP->fr_next->fr_address;
1600 growth = ((target - after) > 0) ? (target - after) : 0;
1601 /* Growth may be negative, but variable part of frag
1602 cannot have fewer than 0 chars. That is, we can't
1605 growth -= stretch; /* This is an absolute growth factor */
1608 case rs_machine_dependent:
1610 const relax_typeS *this_type;
1611 const relax_typeS *start_type;
1612 relax_substateT next_state;
1613 relax_substateT this_state;
1615 this_state = fragP->fr_subtype;
1616 start_type = this_type = md_relax_table + this_state;
1621 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1622 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1623 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1624 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1625 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1627 know (symbolP->sy_frag);
1628 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1629 || symbolP->sy_frag == &zero_address_frag);
1631 S_GET_VALUE (symbolP)
1632 + symbolP->sy_frag->fr_address;
1634 /* If frag has yet to be reached on this pass,
1635 assume it will move by STRETCH just as we did.
1636 If this is not so, it will be because some frag
1637 between grows, and that will force another pass.
1639 Beware zero-length frags.
1641 There should be a faster way to do this. */
1643 if (symbolP->sy_frag->fr_address >= was_address
1644 && is_dnrange (fragP, symbolP->sy_frag))
1650 aim = target - address - fragP->fr_fix;
1651 /* The displacement is affected by the instruction size
1652 for the 32k architecture. I think we ought to be able
1653 to add fragP->fr_pcrel_adjust in all cases (it should be
1654 zero if not used), but just in case it breaks something
1655 else we'll put this inside #ifdef NS32K ... #endif */
1657 if (fragP->fr_pcrel_adjust)
1660 aim += fragP->fr_pcrel_adjust;
1664 /* Look backwards. */
1665 for (next_state = this_type->rlx_more; next_state;)
1666 if (aim >= this_type->rlx_backward)
1670 /* Grow to next state. */
1671 this_state = next_state;
1672 this_type = md_relax_table + this_state;
1673 next_state = this_type->rlx_more;
1678 #ifdef M68K_AIM_KLUDGE
1679 M68K_AIM_KLUDGE (aim, this_state, this_type);
1681 /* Look forwards. */
1682 for (next_state = this_type->rlx_more; next_state;)
1683 if (aim <= this_type->rlx_forward)
1687 /* Grow to next state. */
1688 this_state = next_state;
1689 this_type = md_relax_table + this_state;
1690 next_state = this_type->rlx_more;
1694 growth = this_type->rlx_length - start_type->rlx_length;
1696 fragP->fr_subtype = this_state;
1701 BAD_CASE (fragP->fr_type);
1709 } /* For each frag in the segment. */
1711 while (stretched); /* Until nothing further to relax. */
1715 * We now have valid fr_address'es for each frag.
1719 * All fr_address's are correct, relative to their own segment.
1720 * We have made all the fixS we will ever make.
1722 } /* relax_segment() */
1726 Go through all the fixS's in a segment and see which ones can be
1727 handled now. (These consist of fixS where we have since discovered
1728 the value of a symbol, or the address of the frag involved.)
1729 For each one, call md_apply_fix to put the fix into the frag data.
1731 Result is a count of how many relocation structs will be needed to
1732 handle the remaining fixS's that we couldn't completely handle here.
1733 These will be output later by emit_relocations(). */
1736 fixup_segment (fixP, this_segment_type)
1737 register fixS *fixP;
1738 segT this_segment_type; /* N_TYPE bits for segment. */
1740 register long seg_reloc_count;
1741 register symbolS *add_symbolP;
1742 register symbolS *sub_symbolP;
1745 register char *place;
1746 register long where;
1747 register char pcrel;
1748 register fragS *fragP;
1749 register segT add_symbol_segment = absolute_section;
1751 seg_reloc_count = 0;
1752 /* If the linker is doing the relaxing, we must not do any fixups */
1754 for (; fixP; fixP = fixP->fx_next)
1757 for (; fixP; fixP = fixP->fx_next)
1759 fragP = fixP->fx_frag;
1761 where = fixP->fx_where;
1762 place = fragP->fr_literal + where;
1763 size = fixP->fx_size;
1764 add_symbolP = fixP->fx_addsy;
1766 if (fixP->fx_callj && TC_S_IS_CALLNAME (add_symbolP))
1768 /* Relocation should be done via the associated 'bal'
1769 entry point symbol. */
1771 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1773 as_bad ("No 'bal' entry point for leafproc %s",
1774 S_GET_NAME (add_symbolP));
1777 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1780 sub_symbolP = fixP->fx_subsy;
1781 add_number = fixP->fx_offset;
1782 pcrel = fixP->fx_pcrel;
1785 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1792 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1793 as_bad ("Negative of non-absolute symbol %s",
1794 S_GET_NAME (sub_symbolP));
1796 add_number -= S_GET_VALUE (sub_symbolP);
1798 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1799 && (SEG_NORMAL (add_symbol_segment)
1800 || (add_symbol_segment == absolute_section)))
1802 /* Difference of 2 symbols from same segment.
1803 Can't make difference of 2 undefineds: 'value' means
1804 something different for N_UNDF. */
1806 /* Makes no sense to use the difference of 2 arbitrary symbols
1807 as the target of a call instruction. */
1810 as_bad ("callj to difference of 2 symbols");
1812 #endif /* TC_I960 */
1813 add_number += S_GET_VALUE (add_symbolP) -
1814 S_GET_VALUE (sub_symbolP);
1817 fixP->fx_addsy = NULL;
1821 /* Different segments in subtraction. */
1822 know (!(S_IS_EXTERNAL (sub_symbolP)
1823 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1825 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1827 add_number -= S_GET_VALUE (sub_symbolP);
1832 sprint_value (buf, fragP->fr_address + where);
1833 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1834 segment_name (S_GET_SEGMENT (sub_symbolP)),
1835 S_GET_NAME (sub_symbolP), buf);
1842 if (add_symbol_segment == this_segment_type && pcrel)
1845 * This fixup was made when the symbol's segment was
1846 * SEG_UNKNOWN, but it is now in the local segment.
1847 * So we know how to do the address without relocation.
1850 /* reloc_callj() may replace a 'call' with a 'calls' or a
1851 'bal', in which cases it modifies *fixP as appropriate.
1852 In the case of a 'calls', no further work is required,
1853 and *fixP has been set up to make the rest of the code
1856 #endif /* TC_I960 */
1858 add_number += S_GET_VALUE (add_symbolP);
1859 add_number -= md_pcrel_from (fixP);
1860 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1861 fixP->fx_addsy = NULL; /* No relocations please. */
1865 if (add_symbol_segment == absolute_section)
1868 /* See comment about reloc_callj() above. */
1870 #endif /* TC_I960 */
1871 add_number += S_GET_VALUE (add_symbolP);
1872 fixP->fx_addsy = NULL;
1875 else if (add_symbol_segment == undefined_section
1876 #ifdef BFD_ASSEMBLER
1877 || add_symbol_segment == &bfd_com_section
1882 if ((int) fixP->fx_bit_fixP == 13)
1884 /* This is a COBR instruction. They have only a
1885 * 13-bit displacement and are only to be used
1886 * for local branches: flag as error, don't generate
1889 as_bad ("can't use COBR format with external label");
1890 fixP->fx_addsy = NULL; /* No relocations please. */
1893 #endif /* TC_I960 */
1897 if (S_IS_COMMON (add_symbolP))
1898 add_number += S_GET_VALUE (add_symbolP);
1899 #endif /* TE_I386AIX */
1900 #endif /* OBJ_COFF */
1906 add_number += S_GET_VALUE (add_symbolP);
1908 } /* if not in local seg */
1909 } /* if there was a + symbol */
1913 add_number -= md_pcrel_from (fixP);
1914 if (add_symbolP == 0)
1916 fixP->fx_addsy = &abs_symbol;
1918 } /* if there's an add_symbol */
1921 if (!fixP->fx_bit_fixP)
1924 && (add_number & ~0xFF)
1925 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
1927 && (add_number & ~0xFFFF)
1928 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)))
1930 && (add_number & ~(valueT)0xFFFFFFFF)
1931 && ((add_number & ~(valueT)0xFFFFFFFF) != (-1 & ~(valueT)0xFFFFFFFF)))
1935 sprint_value (buf, fragP->fr_address + where);
1936 as_bad ("Value of %d too large for field of %d bytes at %s",
1937 add_number, size, buf);
1938 } /* generic error checking */
1939 #ifdef WARN_SIGNED_OVERFLOW_WORD
1940 /* Warn if a .word value is too large when treated as a signed
1941 number. We already know it is not too negative. This is to
1942 catch over-large switches generated by gcc on the 68k. */
1945 && add_number > 0x7fff)
1946 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
1947 add_number, fragP->fr_address + where);
1949 } /* not a bit fix */
1951 #ifdef BFD_ASSEMBLER
1952 md_apply_fix (fixP, &add_number);
1954 md_apply_fix (fixP, add_number);
1956 } /* For each fixS in this segment. */
1963 /* two relocs per callj under coff. */
1964 for (fixP = topP; fixP; fixP = fixP->fx_next)
1966 if (fixP->fx_callj && fixP->fx_addsy != 0)
1969 } /* if callj and not already fixed. */
1970 } /* for each fix */
1972 #endif /* TC_I960 */
1974 #endif /* OBJ_COFF */
1975 return (seg_reloc_count);
1978 /* end of write.c */