1 /* write.c - emit .o file
2 Copyright (C) 1986, 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This thing should be set up to do byteordering correctly. But... */
25 #include "output-file.h"
27 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
28 instruction so that the disassembler does not choke on it. */
30 #define NOP_OPCODE 0x00
33 #ifndef WORKING_DOT_WORD
34 extern CONST int md_short_jump_size;
35 extern CONST int md_long_jump_size;
41 struct frag *text_frag_root;
42 struct frag *data_frag_root;
43 struct frag *bss_frag_root;
45 struct frag *text_last_frag; /* Last frag in segment. */
46 struct frag *data_last_frag; /* Last frag in segment. */
47 static struct frag *bss_last_frag; /* Last frag in segment. */
50 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
51 static object_headers headers;
52 static char *the_object_file;
55 long string_byte_count;
56 char *next_object_file_charP; /* Tracks object file bytes. */
59 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
62 #endif /* BFD_ASSEMBLER */
65 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
66 symbolS *add, symbolS *sub,
67 offsetT offset, int pcrel,
68 bfd_reloc_code_real_type r_type));
70 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
71 symbolS *add, symbolS *sub,
72 offsetT offset, int pcrel,
75 #if defined (BFD_ASSEMBLER) || !defined (BFD)
76 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
78 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
83 * Create a fixS in obstack 'notes'.
86 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
88 fragS *frag; /* Which frag? */
89 int where; /* Where in that frag? */
90 int size; /* 1, 2, or 4 usually. */
91 symbolS *add_symbol; /* X_add_symbol. */
92 symbolS *sub_symbol; /* X_op_symbol. */
93 offsetT offset; /* X_add_number. */
94 int pcrel; /* TRUE if PC-relative relocation. */
96 bfd_reloc_code_real_type r_type; /* Relocation type */
98 int r_type; /* Relocation type */
103 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
105 fixP->fx_frag = frag;
106 fixP->fx_where = where;
107 fixP->fx_size = size;
108 fixP->fx_addsy = add_symbol;
109 fixP->fx_subsy = sub_symbol;
110 fixP->fx_offset = offset;
111 fixP->fx_pcrel = pcrel;
112 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
113 fixP->fx_r_type = r_type;
115 fixP->fx_im_disp = 0;
116 fixP->fx_pcrel_adjust = 0;
117 fixP->fx_bit_fixP = 0;
118 fixP->fx_addnumber = 0;
119 fixP->tc_fix_data = NULL;
126 as_where (&fixP->fx_file, &fixP->fx_line);
128 /* Usually, we want relocs sorted numerically, but while
129 comparing to older versions of gas that have relocs
130 reverse sorted, it is convenient to have this compile
131 time option. xoxorich. */
136 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
137 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
140 #ifdef REVERSE_SORT_RELOCS
142 fixP->fx_next = *seg_fix_rootP;
143 *seg_fix_rootP = fixP;
145 #else /* REVERSE_SORT_RELOCS */
147 fixP->fx_next = NULL;
150 (*seg_fix_tailP)->fx_next = fixP;
152 *seg_fix_rootP = fixP;
153 *seg_fix_tailP = fixP;
155 #endif /* REVERSE_SORT_RELOCS */
162 /* Create a fixup relative to a symbol (plus a constant). */
165 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
166 fragS *frag; /* Which frag? */
167 int where; /* Where in that frag? */
168 short int size; /* 1, 2, or 4 usually. */
169 symbolS *add_symbol; /* X_add_symbol. */
170 offsetT offset; /* X_add_number. */
171 int pcrel; /* TRUE if PC-relative relocation. */
173 bfd_reloc_code_real_type r_type; /* Relocation type */
175 int r_type; /* Relocation type */
178 return fix_new_internal (frag, where, size, add_symbol,
179 (symbolS *) NULL, offset, pcrel, r_type);
182 /* Create a fixup for an expression. Currently we only support fixups
183 for difference expressions. That is itself more than most object
184 file formats support anyhow. */
187 fix_new_exp (frag, where, size, exp, pcrel, r_type)
188 fragS *frag; /* Which frag? */
189 int where; /* Where in that frag? */
190 short int size; /* 1, 2, or 4 usually. */
191 expressionS *exp; /* Expression. */
192 int pcrel; /* TRUE if PC-relative relocation. */
194 bfd_reloc_code_real_type r_type; /* Relocation type */
196 int r_type; /* Relocation type */
209 sub = exp->X_add_symbol;
210 off = exp->X_add_number;
214 sub = exp->X_op_symbol;
217 add = exp->X_add_symbol;
220 off = exp->X_add_number;
224 as_bad ("expression too complex for fixup");
227 return fix_new_internal (frag, where, size, add, sub, off,
231 /* Append a string onto another string, bumping the pointer along. */
233 append (charPP, fromP, length)
236 unsigned long length;
238 /* Don't trust memcpy() of 0 chars. */
242 memcpy (*charPP, fromP, length);
246 #ifndef BFD_ASSEMBLER
247 int section_alignment[SEG_MAXIMUM_ORDINAL];
251 * This routine records the largest alignment seen for each segment.
252 * If the beginning of the segment is aligned on the worst-case
253 * boundary, all of the other alignments within it will work. At
254 * least one object format really uses this info.
257 record_alignment (seg, align)
258 /* Segment to which alignment pertains */
260 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
265 if (align > bfd_get_section_alignment (stdoutput, seg))
266 bfd_set_section_alignment (stdoutput, seg, align);
268 if (align > section_alignment[(int) seg])
269 section_alignment[(int) seg] = align;
273 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
276 chain_frchains_together_1 (section, frchp)
278 struct frchain *frchp;
280 fragS dummy, *prev_frag = &dummy;
281 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
283 prev_frag->fr_next = frchp->frch_root;
284 prev_frag = frchp->frch_last;
286 prev_frag->fr_next = 0;
295 chain_frchains_together (abfd, section, xxx)
296 bfd *abfd; /* unused */
298 PTR xxx; /* unused */
300 segment_info_type *info;
302 /* BFD may have introduced its own sections without using
303 subseg_new, so it is possible that seg_info is NULL. */
304 info = seg_info (section);
305 if (info != (segment_info_type *) NULL)
306 info->frchainP->frch_last
307 = chain_frchains_together_1 (section, info->frchainP);
312 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
315 remove_subsegs (head, seg, root, last)
321 *root = head->frch_root;
322 *last = chain_frchains_together_1 (seg, head);
327 #if defined (BFD_ASSEMBLER) || !defined (BFD)
331 cvt_frag_to_fill (sec, fragP)
336 cvt_frag_to_fill (headers, fragP)
337 object_headers *headers;
341 switch (fragP->fr_type)
346 HANDLE_ALIGN (fragP);
348 fragP->fr_type = rs_fill;
349 know (fragP->fr_var == 1);
350 know (fragP->fr_next != NULL);
352 fragP->fr_offset = (fragP->fr_next->fr_address
360 case rs_machine_dependent:
362 md_convert_frag (stdoutput, sec, fragP);
364 md_convert_frag (headers, fragP);
367 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
370 * After md_convert_frag, we make the frag into a ".space 0".
371 * Md_convert_frag() should set up any fixSs and constants
377 #ifndef WORKING_DOT_WORD
380 struct broken_word *lie;
382 if (fragP->fr_subtype)
384 fragP->fr_fix += md_short_jump_size;
385 for (lie = (struct broken_word *) (fragP->fr_symbol);
386 lie && lie->dispfrag == fragP;
387 lie = lie->next_broken_word)
389 fragP->fr_fix += md_long_jump_size;
397 BAD_CASE (fragP->fr_type);
402 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
406 relax_and_size_seg (abfd, sec, xxx)
413 segment_info_type *seginfo;
415 valueT size, newsize;
417 flags = bfd_get_section_flags (abfd, sec);
419 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
420 if (seginfo && seginfo->frchainP)
422 relax_segment (seginfo->frchainP->frch_root, sec);
423 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
424 cvt_frag_to_fill (sec, fragp);
425 for (fragp = seginfo->frchainP->frch_root;
427 fragp = fragp->fr_next)
428 /* walk to last elt */;
429 size = fragp->fr_address + fragp->fr_fix;
434 if (size > 0 && ! seginfo->bss)
435 flags |= SEC_HAS_CONTENTS;
437 /* @@ This is just an approximation. */
438 if (seginfo->fix_root)
442 x = bfd_set_section_flags (abfd, sec, flags);
445 newsize = md_section_align (sec, size);
446 x = bfd_set_section_size (abfd, sec, newsize);
449 /* If the size had to be rounded up, add some padding in the last
451 assert (newsize >= size);
454 fragS *last = seginfo->frchainP->frch_last;
455 fragp = seginfo->frchainP->frch_root;
456 while (fragp->fr_next != last)
457 fragp = fragp->fr_next;
458 last->fr_address = size;
459 fragp->fr_offset += newsize - size;
462 #ifdef tc_frob_section
463 tc_frob_section (sec);
465 #ifdef obj_frob_section
466 obj_frob_section (sec);
472 dump_section_relocs (abfd, sec, stream_)
477 FILE *stream = (FILE *) stream_;
478 segment_info_type *seginfo = seg_info (sec);
479 fixS *fixp = seginfo->fix_root;
484 fprintf (stream, "sec %s relocs:\n", sec->name);
487 symbolS *s = fixp->fx_addsy;
489 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
490 S_GET_NAME (s), s->bsym->section->name,
491 S_GET_VALUE (s), fixp->fx_offset);
493 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
494 fixp = fixp->fx_next;
498 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
502 adjust_reloc_syms (abfd, sec, xxx)
507 segment_info_type *seginfo = seg_info (sec);
513 dump_section_relocs (abfd, sec, stderr);
515 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
518 symbolS *sym = fixp->fx_addsy;
519 asection *symsec = sym->bsym->section;
520 segment_info_type *symseginfo = seg_info (symsec);
522 /* If it's one of these sections, assume the symbol is
523 definitely going to be output. The code in
524 md_estimate_size_before_relax in tc-mips.c uses this test
525 as well, so if you change this code you should look at that
527 if (symsec == &bfd_und_section
528 || symsec == &bfd_abs_section
529 || bfd_is_com_section (symsec))
531 fixp->fx_addsy->sy_used_in_reloc = 1;
535 /* Since we're reducing to section symbols, don't attempt to reduce
536 anything that's already using one. */
537 if (sym->bsym == symsec->symbol)
539 fixp->fx_addsy->sy_used_in_reloc = 1;
543 /* Is there some other reason we can't adjust this one? (E.g.,
544 call/bal links in i960-bout symbols.) */
545 #ifdef obj_fix_adjustable
546 if (! obj_fix_adjustable (fixp))
548 fixp->fx_addsy->sy_used_in_reloc = 1;
553 /* Is there some other (target cpu dependent) reason we can't adjust
554 this one? (E.g. relocations involving function addresses on
556 #ifdef tc_fix_adjustable
557 if (! tc_fix_adjustable (fixp))
559 fixp->fx_addsy->sy_used_in_reloc = 1;
564 /* If the section symbol isn't going to be output, the relocs
565 at least should still work. If not, figure out what to do
566 when we run into that case. */
567 fixp->fx_offset += S_GET_VALUE (sym);
569 fixp->fx_offset += sym->sy_frag->fr_address;
571 fixp->fx_addsy = symseginfo->sym;
574 fixp->fx_addsy = symbol_find (symsec->name);
577 fixp->fx_addsy = symbol_make (symsec->name);
578 fixp->fx_addsy->bsym = symsec->symbol;
580 symseginfo->sym = fixp->fx_addsy;
582 fixp->fx_addsy->sy_used_in_reloc = 1;
585 dump_section_relocs (abfd, sec, stderr);
589 write_relocs (abfd, sec, xxx)
594 segment_info_type *seginfo = seg_info (sec);
600 /* If seginfo is NULL, we did not create this section; don't do
605 fixup_segment (seginfo->fix_root, sec);
608 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
611 #ifndef RELOC_EXPANSION_POSSIBLE
612 /* Set up reloc information as well. */
613 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
614 n * sizeof (arelent *));
615 memset ((char*)relocs, 0, n * sizeof (arelent*));
618 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
622 bfd_reloc_status_type s;
624 if (fixp->fx_addsy == 0)
626 /* @@ Need some other flag to indicate which have already
631 reloc = tc_gen_reloc (sec, fixp);
637 data = fixp->fx_frag->fr_literal + fixp->fx_where;
638 if (fixp->fx_where + fixp->fx_size
639 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
641 /* Pass bogus address so that when bfd_perform_relocation adds
642 `address' back in, it'll come up with `data', which is where
643 we want it to operate. */
644 if (reloc->howto->partial_inplace == false
645 && reloc->howto->pcrel_offset == true
646 && reloc->howto->pc_relative == true)
648 /* bfd_perform_relocation screws this up */
649 reloc->addend += reloc->address;
651 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
658 as_fatal ("bad return from bfd_perform_relocation");
663 n = n * MAX_RELOC_EXPANSION;
664 /* Set up reloc information as well. */
665 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
666 n * sizeof (arelent *));
669 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
673 bfd_reloc_status_type s;
676 if (fixp->fx_addsy == 0)
678 /* @@ Need some other flag to indicate which have already
683 reloc = tc_gen_reloc (sec, fixp);
685 for (j = 0; reloc[j]; j++)
687 relocs[i++] = reloc[j];
690 data = fixp->fx_frag->fr_literal + fixp->fx_where;
691 if (fixp->fx_where + fixp->fx_size
692 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
694 for (j = 0; reloc[j]; j++)
696 s = bfd_perform_relocation (stdoutput, reloc[j],
697 data - reloc[0]->address,
704 as_fatal ("bad return from bfd_perform_relocation");
712 bfd_set_reloc (stdoutput, sec, relocs, n);
714 bfd_set_section_flags (abfd, sec,
715 (bfd_get_section_flags (abfd, sec)
716 & (flagword) ~SEC_RELOC));
722 fprintf (stderr, "relocs for sec %s\n", sec->name);
723 for (i = 0; i < n; i++)
727 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
728 i, r, r->address, s->name, r->addend);
735 write_contents (abfd, sec, xxx)
740 segment_info_type *seginfo = seg_info (sec);
741 unsigned long offset = 0;
744 /* Write out the frags. */
746 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
749 for (f = seginfo->frchainP->frch_root;
754 unsigned long fill_size;
758 assert (f->fr_type == rs_fill);
761 x = bfd_set_section_contents (stdoutput, sec,
762 f->fr_literal, (file_ptr) offset,
763 (bfd_size_type) f->fr_fix);
767 fill_literal = f->fr_literal + f->fr_fix;
768 fill_size = f->fr_var;
769 count = f->fr_offset;
771 if (fill_size && count)
774 x = bfd_set_section_contents (stdoutput, sec,
775 fill_literal, (file_ptr) offset,
776 (bfd_size_type) fill_size);
784 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
786 merge_data_into_text ()
788 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
789 seg_info (text_section)->frchainP->frch_last->fr_next =
790 seg_info (data_section)->frchainP->frch_root;
791 seg_info (text_section)->frchainP->frch_last =
792 seg_info (data_section)->frchainP->frch_last;
793 seg_info (data_section)->frchainP = 0;
797 text_last_frag->fr_next = data_frag_root;
798 text_last_frag = data_last_frag;
799 data_last_frag = NULL;
800 data_frag_root = NULL;
803 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
804 tmp->fx_next = data_fix_root;
805 text_fix_tail = data_fix_tail;
808 text_fix_root = data_fix_root;
809 data_fix_root = NULL;
812 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
814 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
816 relax_and_size_all_segments ()
820 relax_segment (text_frag_root, SEG_TEXT);
821 relax_segment (data_frag_root, SEG_DATA);
822 relax_segment (bss_frag_root, SEG_BSS);
824 * Now the addresses of frags are correct within the segment.
827 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
828 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
829 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
832 * Join the 2 segments into 1 huge segment.
833 * To do this, re-compute every rn_address in the SEG_DATA frags.
834 * Then join the data frags after the text frags.
836 * Determine a_data [length of data segment].
840 register relax_addressT slide;
842 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
844 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
845 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
846 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
848 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
849 /* For b.out: If the data section has a strict alignment
850 requirement, its load address in the .o file will be
851 rounded up from the size of the text section. These
852 two values are *not* the same! Similarly for the bss
854 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
857 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
859 fragP->fr_address += slide;
860 } /* for each data frag */
862 know (text_last_frag != 0);
863 text_last_frag->fr_next = data_frag_root;
867 H_SET_DATA_SIZE (&headers, 0);
871 /* See above comments on b.out data section address. */
874 if (data_last_frag == 0)
875 bss_vma = H_GET_TEXT_SIZE (&headers);
877 bss_vma = data_last_frag->fr_address;
878 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
879 bss_address_frag.fr_address = bss_vma;
881 #else /* ! OBJ_BOUT */
882 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
883 H_GET_DATA_SIZE (&headers));
885 #endif /* ! OBJ_BOUT */
887 /* Slide all the frags */
890 relax_addressT slide = bss_address_frag.fr_address;
892 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
894 fragP->fr_address += slide;
895 } /* for each bss frag */
899 H_SET_BSS_SIZE (&headers,
900 bss_last_frag->fr_address - bss_frag_root->fr_address);
902 H_SET_BSS_SIZE (&headers, 0);
904 #endif /* ! BFD_ASSEMBLER && ! BFD */
906 #if defined (BFD_ASSEMBLER) || !defined (BFD)
911 register struct frchain *frchainP; /* Track along all frchains. */
912 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
913 register fragS *fragP; /* Track along all frags. */
915 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
916 long object_file_size;
919 /* Do we really want to write it? */
922 n_warns = had_warnings ();
923 n_errs = had_errors ();
924 /* The -Z flag indicates that an object file should be generated,
925 regardless of warnings and errors. */
928 if (n_warns || n_errs)
929 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
930 n_errs, n_errs == 1 ? "" : "s",
931 n_warns, n_warns == 1 ? "" : "s");
936 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
937 n_errs, n_errs == 1 ? "" : "s",
938 n_warns, n_warns == 1 ? "" : "s");
944 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
945 * call a routine to check for the definition of the procedure
946 * "_main", and if so -- fix it up so that it can be program
949 VMS_Check_For_Main ();
952 /* After every sub-segment, we fake an ".align ...". This conforms to
953 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
954 frag that requires least thought. ".align" frags like to have a
955 following frag since that makes calculating their intended length
958 @@ Is this really necessary?? */
959 #ifndef SUB_SEGMENT_ALIGN
961 #define SUB_SEGMENT_ALIGN(SEG) (0)
963 #define SUB_SEGMENT_ALIGN(SEG) (2)
966 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
968 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
969 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
970 /* frag_align will have left a new frag.
971 Use this last frag for an empty ".fill".
974 Create a last frag. Do not leave a "being filled in frag". */
975 frag_wane (frag_now);
976 frag_now->fr_fix = 0;
977 know (frag_now->fr_next == NULL);
980 /* From now on, we don't care about sub-segments. Build one frag chain
981 for each segment. Linked thru fr_next. */
984 /* Remove the sections created by gas for its own purposes. */
986 asection **seclist, *sec;
987 seclist = &stdoutput->sections;
988 while (seclist && *seclist)
991 while (sec == reg_section || sec == expr_section)
995 stdoutput->section_count--;
1000 seclist = &(*seclist)->next;
1004 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1006 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1007 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1008 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1011 /* We have two segments. If user gave -R flag, then we must put the
1012 data frags into the text segment. Do this before relaxing so
1013 we know to take advantage of -R and make shorter addresses. */
1014 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1017 merge_data_into_text ();
1021 #ifdef BFD_ASSEMBLER
1022 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1024 relax_and_size_all_segments ();
1025 #endif /* BFD_ASSEMBLER */
1027 #ifndef BFD_ASSEMBLER
1030 * Crawl the symbol chain.
1032 * For each symbol whose value depends on a frag, take the address of
1033 * that frag and subsume it into the value of the symbol.
1034 * After this, there is just one way to lookup a symbol value.
1035 * Values are left in their final state for object file emission.
1036 * We adjust the values of 'L' local symbols, even if we do
1037 * not intend to emit them to the object file, because their values
1038 * are needed for fix-ups.
1040 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1041 * from the symbol chain. (They are still pointed to by the fixes.)
1043 * Count the remaining symbols.
1044 * Assign a symbol number to each symbol.
1045 * Count the number of string-table chars we will emit.
1046 * Put this info into the headers as appropriate.
1049 know (zero_address_frag.fr_address == 0);
1050 string_byte_count = sizeof (string_byte_count);
1052 obj_crawl_symbol_chain (&headers);
1054 if (string_byte_count == sizeof (string_byte_count))
1055 string_byte_count = 0;
1057 H_SET_STRING_SIZE (&headers, string_byte_count);
1060 * Addresses of frags now reflect addresses we use in the object file.
1061 * Symbol values are correct.
1062 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1063 * Also converting any machine-dependent frags using md_convert_frag();
1065 subseg_change (SEG_TEXT, 0);
1067 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1069 cvt_frag_to_fill (&headers, fragP);
1071 /* Some assert macros don't work with # directives mixed in. */
1073 if (!(fragP->fr_next == NULL
1075 || fragP->fr_next == data_frag_root
1077 || ((fragP->fr_next->fr_address - fragP->fr_address)
1078 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1082 #endif /* ! BFD_ASSEMBLER */
1084 #ifndef WORKING_DOT_WORD
1086 struct broken_word *lie;
1087 struct broken_word **prevP;
1089 prevP = &broken_words;
1090 for (lie = broken_words; lie; lie = lie->next_broken_word)
1095 exp.X_op = O_subtract;
1096 exp.X_add_symbol = lie->add;
1097 exp.X_op_symbol = lie->sub;
1098 exp.X_add_number = lie->addnum;
1099 #ifdef BFD_ASSEMBLER
1100 fix_new_exp (lie->frag,
1101 lie->word_goes_here - lie->frag->fr_literal,
1102 2, &exp, 0, BFD_RELOC_NONE);
1104 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1105 fix_new_exp (lie->frag,
1106 lie->word_goes_here - lie->frag->fr_literal,
1107 2, &exp, 0, NO_RELOC);
1110 fix_new_ns32k_exp (lie->frag,
1111 lie->word_goes_here - lie->frag->fr_literal,
1112 2, &exp, 0, 0, 2, 0, 0);
1114 fix_new_exp (lie->frag,
1115 lie->word_goes_here - lie->frag->fr_literal,
1117 #endif /* TC_NS32K */
1118 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1119 #endif /* BFD_ASSEMBLER */
1120 *prevP = lie->next_broken_word;
1123 prevP = &(lie->next_broken_word);
1125 for (lie = broken_words; lie;)
1127 struct broken_word *untruth;
1129 addressT table_addr;
1130 addressT from_addr, to_addr;
1133 fragP = lie->dispfrag;
1135 /* Find out how many broken_words go here. */
1137 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1138 if (untruth->added == 1)
1141 table_ptr = lie->dispfrag->fr_opcode;
1142 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1143 /* Create the jump around the long jumps. This is a short
1144 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1145 from_addr = table_addr;
1146 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1147 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1148 table_ptr += md_short_jump_size;
1149 table_addr += md_short_jump_size;
1151 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1153 if (lie->added == 2)
1155 /* Patch the jump table */
1156 /* This is the offset from ??? to table_ptr+0 */
1157 to_addr = table_addr - S_GET_VALUE (lie->sub);
1158 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1159 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1161 if (untruth->use_jump == lie)
1162 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1165 /* Install the long jump */
1166 /* this is a long jump from table_ptr+0 to the final target */
1167 from_addr = table_addr;
1168 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1169 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1170 table_ptr += md_long_jump_size;
1171 table_addr += md_long_jump_size;
1175 #endif /* not WORKING_DOT_WORD */
1177 #ifndef BFD_ASSEMBLER
1181 * Scan every FixS performing fixups. We had to wait until now to do
1182 * this because md_convert_frag() may have made some fixSs.
1186 subseg_change (SEG_TEXT, 0);
1187 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1188 subseg_change (SEG_DATA, 0);
1189 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1190 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1192 /* FIXME move this stuff into the pre-write-hook */
1193 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1194 H_SET_ENTRY_POINT (&headers, 0);
1196 obj_pre_write_hook (&headers); /* extra coff stuff */
1198 object_file_size = H_GET_FILE_SIZE (&headers);
1199 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1201 output_file_create (out_file_name);
1203 obj_header_append (&next_object_file_charP, &headers);
1205 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1210 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1212 register long count;
1213 register char *fill_literal;
1214 register long fill_size;
1216 know (fragP->fr_type == rs_fill);
1217 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1218 fill_literal = fragP->fr_literal + fragP->fr_fix;
1219 fill_size = fragP->fr_var;
1220 know (fragP->fr_offset >= 0);
1222 for (count = fragP->fr_offset; count; count--)
1224 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1227 } /* for each code frag. */
1229 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1234 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1235 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)));
1237 /* Make addresses in data relocation directives relative to beginning of
1238 * first data fragment, not end of last text fragment: alignment of the
1239 * start of the data segment may place a gap between the segments.
1241 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1243 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1244 #endif /* TC_I960 */
1246 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers)));
1249 * Emit line number entries.
1251 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1252 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers) + H_GET_TEXT_RELOCATION_SIZE (&headers) + H_GET_DATA_RELOCATION_SIZE (&headers) + H_GET_LINENO_SIZE (&headers)));
1257 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1258 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)));
1264 if (string_byte_count > 0)
1266 obj_emit_strings (&next_object_file_charP);
1267 } /* only if we have a string table */
1270 bfd_seek (stdoutput, 0, 0);
1271 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1274 /* Write the data to the file */
1275 output_file_append (the_object_file, object_file_size, out_file_name);
1278 output_file_close (out_file_name);
1279 } /* non vms output */
1282 * Now do the VMS-dependent part of writing the object file
1284 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1285 H_GET_DATA_SIZE (&headers),
1286 H_GET_BSS_SIZE (&headers),
1287 text_frag_root, data_frag_root);
1289 #else /* BFD_ASSEMBLER */
1291 #ifdef obj_check_file_symbols
1292 obj_check_file_symbols ();
1295 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1297 /* Set up symbol table, and write it out. */
1304 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1306 if (! symp->sy_resolved)
1308 if (symp->sy_value.X_op == O_constant)
1310 /* This is the normal case; skip the call. */
1313 + symp->sy_frag->fr_address));
1314 symp->sy_resolved = 1;
1317 resolve_symbol_value (symp);
1320 /* So far, common symbols have been treated like undefined symbols.
1321 Put them in the common section now. */
1322 if (S_IS_DEFINED (symp) == 0
1323 && S_GET_VALUE (symp) != 0)
1324 S_SET_SEGMENT (symp, &bfd_com_section);
1326 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1327 S_GET_NAME (symp), symp,
1330 segment_name (symp->bsym->section));
1332 if (! symp->sy_used_in_reloc)
1334 #ifdef obj_frob_symbol
1337 obj_frob_symbol (symp, punt);
1342 #ifdef tc_frob_symbol
1345 tc_frob_symbol (symp, punt);
1352 /* If we don't want to keep this symbol, splice it out of the
1354 if (! symp->sy_used_in_reloc
1355 && S_IS_LOCAL (symp))
1357 symbolS *prev, *next;
1358 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1361 prev = symbol_previous (symp);
1362 next = symbol_next (symp);
1364 verify_symbol_chain_2 (symp);
1368 symbol_next (prev) = next;
1371 else if (symp == symbol_rootP)
1372 symbol_rootP = next;
1376 symbol_previous (next) = prev;
1378 symbol_lastP = prev;
1381 verify_symbol_chain_2 (prev);
1383 verify_symbol_chain_2 (next);
1388 /* Make sure we really got a value for the symbol. */
1389 if (! symp->sy_resolved)
1391 as_bad ("can't resolve value for symbol \"%s\"",
1393 symp->sy_resolved = 1;
1396 /* Set the value into the BFD symbol. Up til now the value
1397 has only been kept in the gas symbolS struct. */
1398 symp->bsym->value = S_GET_VALUE (symp);
1407 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1409 asympp = (asymbol **) bfd_alloc (stdoutput,
1410 n * sizeof (asymbol *));
1411 symp = symbol_rootP;
1412 for (i = 0; i < n; i++, symp = symbol_next (symp))
1414 asympp[i] = symp->bsym;
1417 result = bfd_set_symtab (stdoutput, asympp, n);
1418 assert (result == true);
1423 #ifdef obj_frob_file
1424 /* If obj_frob_file changes the symbol value at this point, it is
1425 responsible for moving the changed value into symp->bsym->value
1426 as well. Hopefully all symbol value changing can be done in
1427 {obj,tc}_frob_symbol. */
1431 /* Now that all the sizes are known, and contents correct, we can
1432 start writing the file. */
1433 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1435 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1437 output_file_close (out_file_name);
1438 #endif /* BFD_ASSEMBLER */
1445 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1450 * After this, all frags in this segment have addresses that are correct
1451 * within the segment. Since segments live in different file addresses,
1452 * these frag addresses may not be the same as final object-file addresses.
1455 #ifndef md_relax_frag
1457 /* Subroutines of relax_segment. */
1463 for (; f1; f1 = f1->fr_next)
1464 if (f1->fr_next == f2)
1469 #endif /* ! defined (md_relax_frag) */
1471 /* Relax_align. Advance location counter to next address that has 'alignment'
1472 lowest order bits all 0s, return size of adjustment made. */
1473 static relax_addressT
1474 relax_align (address, alignment)
1475 register relax_addressT address; /* Address now. */
1476 register int alignment; /* Alignment (binary). */
1478 relax_addressT mask;
1479 relax_addressT new_address;
1481 mask = ~((~0) << alignment);
1482 new_address = (address + mask) & (~mask);
1484 /* We must provide lots of padding, so the linker can discard it
1485 when needed. The linker will not add extra space, ever. */
1486 new_address += (1 << alignment);
1487 return (new_address - address);
1491 relax_segment (segment_frag_root, segment)
1492 struct frag *segment_frag_root;
1495 register struct frag *fragP;
1496 register relax_addressT address;
1497 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1498 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1500 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1501 subseg_change (segment, 0);
1503 /* For each frag in segment: count and store (a 1st guess of)
1506 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1508 fragP->fr_address = address;
1509 address += fragP->fr_fix;
1511 switch (fragP->fr_type)
1514 address += fragP->fr_offset * fragP->fr_var;
1518 address += relax_align (address, (int) fragP->fr_offset);
1522 /* Assume .org is nugatory. It will grow with 1st relax. */
1525 case rs_machine_dependent:
1526 address += md_estimate_size_before_relax (fragP, segment);
1529 #ifndef WORKING_DOT_WORD
1530 /* Broken words don't concern us yet */
1531 case rs_broken_word:
1536 BAD_CASE (fragP->fr_type);
1538 } /* switch(fr_type) */
1539 } /* for each frag in the segment */
1543 long stretch; /* May be any size, 0 or negative. */
1544 /* Cumulative number of addresses we have */
1545 /* relaxed this pass. */
1546 /* We may have relaxed more than one address. */
1547 long stretched; /* Have we stretched on this pass? */
1548 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1549 grew, and another shrank. If a branch instruction doesn't fit anymore,
1550 we could be scrod. */
1554 stretch = stretched = 0;
1555 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1558 unsigned long was_address;
1564 was_address = fragP->fr_address;
1565 address = fragP->fr_address += stretch;
1566 symbolP = fragP->fr_symbol;
1567 offset = fragP->fr_offset;
1569 switch (fragP->fr_type)
1571 case rs_fill: /* .fill never relaxes. */
1575 #ifndef WORKING_DOT_WORD
1576 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1577 for it I do not want to write it. I do not want to have
1578 anything to do with it. This is not the proper way to
1579 implement this misfeature. */
1580 case rs_broken_word:
1582 struct broken_word *lie;
1583 struct broken_word *untruth;
1585 /* Yes this is ugly (storing the broken_word pointer
1586 in the symbol slot). Still, this whole chunk of
1587 code is ugly, and I don't feel like doing anything
1588 about it. Think of it as stubbornness in action. */
1590 for (lie = (struct broken_word *) (fragP->fr_symbol);
1591 lie && lie->dispfrag == fragP;
1592 lie = lie->next_broken_word)
1598 offset = (lie->add->sy_frag->fr_address
1599 + S_GET_VALUE (lie->add)
1601 - (lie->sub->sy_frag->fr_address
1602 + S_GET_VALUE (lie->sub)));
1603 if (offset <= -32768 || offset >= 32767)
1608 sprint_value (buf, (addressT) lie->addnum);
1609 as_warn (".word %s-%s+%s didn't fit",
1610 S_GET_NAME (lie->add),
1611 S_GET_NAME (lie->sub),
1615 if (fragP->fr_subtype == 0)
1617 fragP->fr_subtype++;
1618 growth += md_short_jump_size;
1620 for (untruth = lie->next_broken_word;
1621 untruth && untruth->dispfrag == lie->dispfrag;
1622 untruth = untruth->next_broken_word)
1623 if ((untruth->add->sy_frag == lie->add->sy_frag)
1624 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1627 untruth->use_jump = lie;
1629 growth += md_long_jump_size;
1634 } /* case rs_broken_word */
1637 growth = (relax_align ((relax_addressT) (address
1640 - relax_align ((relax_addressT) (was_address
1650 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1651 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1652 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1653 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1654 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1655 know (symbolP->sy_frag);
1656 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1657 || (symbolP->sy_frag == &zero_address_frag));
1659 target += S_GET_VALUE (symbolP)
1660 + symbolP->sy_frag->fr_address;
1661 } /* if we have a symbol */
1663 know (fragP->fr_next);
1664 after = fragP->fr_next->fr_address;
1665 growth = ((target - after) > 0) ? (target - after) : 0;
1666 /* Growth may be negative, but variable part of frag
1667 cannot have fewer than 0 chars. That is, we can't
1670 growth -= stretch; /* This is an absolute growth factor */
1673 case rs_machine_dependent:
1674 #ifdef md_relax_frag
1675 growth = md_relax_frag (fragP, stretch);
1677 /* The default way to relax a frag is to look through
1680 const relax_typeS *this_type;
1681 const relax_typeS *start_type;
1682 relax_substateT next_state;
1683 relax_substateT this_state;
1686 this_state = fragP->fr_subtype;
1687 start_type = this_type = md_relax_table + this_state;
1692 #ifndef DIFF_EXPR_OK
1693 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1694 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1695 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1696 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1697 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1699 know (symbolP->sy_frag);
1701 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1702 || symbolP->sy_frag == &zero_address_frag);
1704 S_GET_VALUE (symbolP)
1705 + symbolP->sy_frag->fr_address;
1707 /* If frag has yet to be reached on this pass,
1708 assume it will move by STRETCH just as we did.
1709 If this is not so, it will be because some frag
1710 between grows, and that will force another pass.
1712 Beware zero-length frags.
1714 There should be a faster way to do this. */
1716 if (symbolP->sy_frag->fr_address >= was_address
1717 && is_dnrange (fragP, symbolP->sy_frag))
1723 aim = target - address - fragP->fr_fix;
1724 /* The displacement is affected by the instruction size
1725 for the 32k architecture. I think we ought to be able
1726 to add fragP->fr_pcrel_adjust in all cases (it should be
1727 zero if not used), but just in case it breaks something
1728 else we'll put this inside #ifdef NS32K ... #endif */
1730 if (fragP->fr_pcrel_adjust)
1733 aim += fragP->fr_pcrel_adjust;
1737 /* Look backwards. */
1738 for (next_state = this_type->rlx_more; next_state;)
1739 if (aim >= this_type->rlx_backward)
1743 /* Grow to next state. */
1744 this_state = next_state;
1745 this_type = md_relax_table + this_state;
1746 next_state = this_type->rlx_more;
1751 #ifdef M68K_AIM_KLUDGE
1752 M68K_AIM_KLUDGE (aim, this_state, this_type);
1754 /* Look forwards. */
1755 for (next_state = this_type->rlx_more; next_state;)
1756 if (aim <= this_type->rlx_forward)
1760 /* Grow to next state. */
1761 this_state = next_state;
1762 this_type = md_relax_table + this_state;
1763 next_state = this_type->rlx_more;
1767 growth = this_type->rlx_length - start_type->rlx_length;
1769 fragP->fr_subtype = this_state;
1775 BAD_CASE (fragP->fr_type);
1783 } /* For each frag in the segment. */
1785 while (stretched); /* Until nothing further to relax. */
1789 * We now have valid fr_address'es for each frag.
1793 * All fr_address's are correct, relative to their own segment.
1794 * We have made all the fixS we will ever make.
1796 } /* relax_segment() */
1798 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1802 Go through all the fixS's in a segment and see which ones can be
1803 handled now. (These consist of fixS where we have since discovered
1804 the value of a symbol, or the address of the frag involved.)
1805 For each one, call md_apply_fix to put the fix into the frag data.
1807 Result is a count of how many relocation structs will be needed to
1808 handle the remaining fixS's that we couldn't completely handle here.
1809 These will be output later by emit_relocations(). */
1812 fixup_segment (fixP, this_segment_type)
1813 register fixS *fixP;
1814 segT this_segment_type; /* N_TYPE bits for segment. */
1816 register long seg_reloc_count;
1817 register symbolS *add_symbolP;
1818 register symbolS *sub_symbolP;
1821 register char *place;
1822 register long where;
1823 register char pcrel;
1824 register fragS *fragP;
1825 register segT add_symbol_segment = absolute_section;
1827 seg_reloc_count = 0;
1828 /* If the linker is doing the relaxing, we must not do any fixups. */
1829 /* Well, strictly speaking that's not true -- we could do any that
1830 are PC-relative and don't cross regions that could change size.
1831 And for the i960 (the only machine for which we've got a relaxing
1832 linker right now), we might be able to turn callx/callj into bal
1833 in cases where we know the maximum displacement. */
1835 for (; fixP; fixP = fixP->fx_next)
1838 for (; fixP; fixP = fixP->fx_next)
1840 fragP = fixP->fx_frag;
1842 where = fixP->fx_where;
1843 place = fragP->fr_literal + where;
1844 size = fixP->fx_size;
1845 add_symbolP = fixP->fx_addsy;
1847 if (fixP->fx_tcbit && TC_S_IS_CALLNAME (add_symbolP))
1849 /* Relocation should be done via the associated 'bal'
1850 entry point symbol. */
1852 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP)))
1854 as_bad ("No 'bal' entry point for leafproc %s",
1855 S_GET_NAME (add_symbolP));
1858 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
1861 sub_symbolP = fixP->fx_subsy;
1862 add_number = fixP->fx_offset;
1863 pcrel = fixP->fx_pcrel;
1866 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1873 /* @@ Should try converting to pcrel ref to fixed addr. */
1874 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
1875 as_bad ("Negative of non-absolute symbol %s",
1876 S_GET_NAME (sub_symbolP));
1878 add_number -= S_GET_VALUE (sub_symbolP);
1880 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1881 && (SEG_NORMAL (add_symbol_segment)
1882 || (add_symbol_segment == absolute_section)))
1884 /* Difference of 2 symbols from same segment.
1885 Can't make difference of 2 undefineds: 'value' means
1886 something different for N_UNDF. */
1888 /* Makes no sense to use the difference of 2 arbitrary symbols
1889 as the target of a call instruction. */
1892 as_bad ("callj to difference of 2 symbols");
1894 #endif /* TC_I960 */
1895 add_number += S_GET_VALUE (add_symbolP) -
1896 S_GET_VALUE (sub_symbolP);
1899 fixP->fx_addsy = NULL;
1903 /* Different segments in subtraction. */
1904 know (!(S_IS_EXTERNAL (sub_symbolP)
1905 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1907 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1909 add_number -= S_GET_VALUE (sub_symbolP);
1912 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1914 /* Do this even if it's already described as
1915 pc-relative. For example, on the m68k, an
1916 operand of "pc@(foo-.-2)" should address "foo"
1917 in a pc-relative mode. */
1922 /* Make it pc-relative. */
1923 add_number += (md_pcrel_from (fixP)
1924 - S_GET_VALUE (sub_symbolP));
1934 sprint_value (buf, fragP->fr_address + where);
1935 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1936 segment_name (S_GET_SEGMENT (sub_symbolP)),
1937 S_GET_NAME (sub_symbolP), buf);
1944 if (add_symbol_segment == this_segment_type && pcrel)
1947 * This fixup was made when the symbol's segment was
1948 * SEG_UNKNOWN, but it is now in the local segment.
1949 * So we know how to do the address without relocation.
1952 /* reloc_callj() may replace a 'call' with a 'calls' or a
1953 'bal', in which cases it modifies *fixP as appropriate.
1954 In the case of a 'calls', no further work is required,
1955 and *fixP has been set up to make the rest of the code
1958 #endif /* TC_I960 */
1960 add_number += S_GET_VALUE (add_symbolP);
1961 add_number -= md_pcrel_from (fixP);
1962 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1964 fixP->fx_addsy = NULL; /* No relocations please. */
1969 if (add_symbol_segment == absolute_section)
1972 /* See comment about reloc_callj() above. */
1974 #endif /* TC_I960 */
1975 add_number += S_GET_VALUE (add_symbolP);
1976 fixP->fx_addsy = NULL;
1979 else if (add_symbol_segment == undefined_section
1980 #ifdef BFD_ASSEMBLER
1981 || bfd_is_com_section (add_symbol_segment)
1986 if ((int) fixP->fx_bit_fixP == 13)
1988 /* This is a COBR instruction. They have only a
1989 * 13-bit displacement and are only to be used
1990 * for local branches: flag as error, don't generate
1993 as_bad ("can't use COBR format with external label");
1994 fixP->fx_addsy = NULL; /* No relocations please. */
1997 #endif /* TC_I960 */
2001 if (S_IS_COMMON (add_symbolP))
2002 add_number += S_GET_VALUE (add_symbolP);
2003 #endif /* TE_I386AIX */
2004 #endif /* OBJ_COFF */
2010 add_number += S_GET_VALUE (add_symbolP);
2017 add_number -= md_pcrel_from (fixP);
2018 if (add_symbolP == 0)
2020 fixP->fx_addsy = &abs_symbol;
2022 } /* if there's an add_symbol */
2025 if (!fixP->fx_bit_fixP && size > 0)
2028 /* set all bits to one */
2030 /* Technically speaking, combining these produces an
2031 undefined result if size is sizeof (valueT), though I
2032 think these two half-way operations should both be
2036 if ((add_number & mask) != 0
2037 && (add_number & mask) != mask)
2039 char buf[50], buf2[50];
2040 sprint_value (buf, fragP->fr_address + where);
2041 if (add_number > 1000)
2042 sprint_value (buf2, add_number);
2044 sprintf (buf2, "%ld", (long) add_number);
2045 as_bad_where (fixP->fx_file, fixP->fx_line,
2046 "Value of %s too large for field of %d bytes at %s",
2048 } /* generic error checking */
2049 #ifdef WARN_SIGNED_OVERFLOW_WORD
2050 /* Warn if a .word value is too large when treated as a signed
2051 number. We already know it is not too negative. This is to
2052 catch over-large switches generated by gcc on the 68k. */
2055 && add_number > 0x7fff)
2056 as_bad_where (fixP->fx_file, fixP->fx_line,
2057 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2059 (unsigned long) (fragP->fr_address + where));
2061 } /* not a bit fix */
2063 #ifdef BFD_ASSEMBLER
2064 md_apply_fix (fixP, &add_number);
2066 md_apply_fix (fixP, add_number);
2068 } /* For each fixS in this segment. */
2070 #if defined (OBJ_COFF) && defined (TC_I960)
2074 /* two relocs per callj under coff. */
2075 for (fixP = topP; fixP; fixP = fixP->fx_next)
2076 if (fixP->fx_tcbit && fixP->fx_addsy != 0)
2079 #endif /* OBJ_COFF && TC_I960 */
2081 return (seg_reloc_count);
2084 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2086 /* end of write.c */