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 TC_ADJUST_RELOC_COUNT
34 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
37 #ifndef TC_FORCE_RELOCATION
38 #define TC_FORCE_RELOCATION(FIXP) 0
41 #ifndef WORKING_DOT_WORD
42 extern CONST int md_short_jump_size;
43 extern CONST int md_long_jump_size;
49 struct frag *text_frag_root;
50 struct frag *data_frag_root;
51 struct frag *bss_frag_root;
53 struct frag *text_last_frag; /* Last frag in segment. */
54 struct frag *data_last_frag; /* Last frag in segment. */
55 static struct frag *bss_last_frag; /* Last frag in segment. */
58 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
59 static object_headers headers;
60 static char *the_object_file;
63 long string_byte_count;
64 char *next_object_file_charP; /* Tracks object file bytes. */
67 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
70 #endif /* BFD_ASSEMBLER */
73 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
74 symbolS *add, symbolS *sub,
75 offsetT offset, int pcrel,
76 bfd_reloc_code_real_type r_type));
78 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
79 symbolS *add, symbolS *sub,
80 offsetT offset, int pcrel,
83 #if defined (BFD_ASSEMBLER) || !defined (BFD)
84 static long fixup_segment PARAMS ((fixS * fixP, segT this_segment_type));
86 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
91 * Create a fixS in obstack 'notes'.
94 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
96 fragS *frag; /* Which frag? */
97 int where; /* Where in that frag? */
98 int size; /* 1, 2, or 4 usually. */
99 symbolS *add_symbol; /* X_add_symbol. */
100 symbolS *sub_symbol; /* X_op_symbol. */
101 offsetT offset; /* X_add_number. */
102 int pcrel; /* TRUE if PC-relative relocation. */
104 bfd_reloc_code_real_type r_type; /* Relocation type */
106 int r_type; /* Relocation type */
111 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
113 fixP->fx_frag = frag;
114 fixP->fx_where = where;
115 fixP->fx_size = size;
116 fixP->fx_addsy = add_symbol;
117 fixP->fx_subsy = sub_symbol;
118 fixP->fx_offset = offset;
119 fixP->fx_pcrel = pcrel;
120 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
121 fixP->fx_r_type = r_type;
123 fixP->fx_im_disp = 0;
124 fixP->fx_pcrel_adjust = 0;
125 fixP->fx_bit_fixP = 0;
126 fixP->fx_addnumber = 0;
127 fixP->tc_fix_data = NULL;
134 as_where (&fixP->fx_file, &fixP->fx_line);
136 /* Usually, we want relocs sorted numerically, but while
137 comparing to older versions of gas that have relocs
138 reverse sorted, it is convenient to have this compile
139 time option. xoxorich. */
144 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
145 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
148 #ifdef REVERSE_SORT_RELOCS
150 fixP->fx_next = *seg_fix_rootP;
151 *seg_fix_rootP = fixP;
153 #else /* REVERSE_SORT_RELOCS */
155 fixP->fx_next = NULL;
158 (*seg_fix_tailP)->fx_next = fixP;
160 *seg_fix_rootP = fixP;
161 *seg_fix_tailP = fixP;
163 #endif /* REVERSE_SORT_RELOCS */
170 /* Create a fixup relative to a symbol (plus a constant). */
173 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
174 fragS *frag; /* Which frag? */
175 int where; /* Where in that frag? */
176 short int size; /* 1, 2, or 4 usually. */
177 symbolS *add_symbol; /* X_add_symbol. */
178 offsetT offset; /* X_add_number. */
179 int pcrel; /* TRUE if PC-relative relocation. */
181 bfd_reloc_code_real_type r_type; /* Relocation type */
183 int r_type; /* Relocation type */
186 return fix_new_internal (frag, where, size, add_symbol,
187 (symbolS *) NULL, offset, pcrel, r_type);
190 /* Create a fixup for an expression. Currently we only support fixups
191 for difference expressions. That is itself more than most object
192 file formats support anyhow. */
195 fix_new_exp (frag, where, size, exp, pcrel, r_type)
196 fragS *frag; /* Which frag? */
197 int where; /* Where in that frag? */
198 short int size; /* 1, 2, or 4 usually. */
199 expressionS *exp; /* Expression. */
200 int pcrel; /* TRUE if PC-relative relocation. */
202 bfd_reloc_code_real_type r_type; /* Relocation type */
204 int r_type; /* Relocation type */
217 sub = exp->X_add_symbol;
218 off = exp->X_add_number;
222 sub = exp->X_op_symbol;
225 add = exp->X_add_symbol;
228 off = exp->X_add_number;
232 as_bad ("expression too complex for fixup");
235 return fix_new_internal (frag, where, size, add, sub, off,
239 /* Append a string onto another string, bumping the pointer along. */
241 append (charPP, fromP, length)
244 unsigned long length;
246 /* Don't trust memcpy() of 0 chars. */
250 memcpy (*charPP, fromP, length);
254 #ifndef BFD_ASSEMBLER
255 int section_alignment[SEG_MAXIMUM_ORDINAL];
259 * This routine records the largest alignment seen for each segment.
260 * If the beginning of the segment is aligned on the worst-case
261 * boundary, all of the other alignments within it will work. At
262 * least one object format really uses this info.
265 record_alignment (seg, align)
266 /* Segment to which alignment pertains */
268 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
273 if (align > bfd_get_section_alignment (stdoutput, seg))
274 bfd_set_section_alignment (stdoutput, seg, align);
276 if (align > section_alignment[(int) seg])
277 section_alignment[(int) seg] = align;
281 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
284 chain_frchains_together_1 (section, frchp)
286 struct frchain *frchp;
288 fragS dummy, *prev_frag = &dummy;
289 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
291 prev_frag->fr_next = frchp->frch_root;
292 prev_frag = frchp->frch_last;
294 prev_frag->fr_next = 0;
303 chain_frchains_together (abfd, section, xxx)
304 bfd *abfd; /* unused */
306 PTR xxx; /* unused */
308 segment_info_type *info;
310 /* BFD may have introduced its own sections without using
311 subseg_new, so it is possible that seg_info is NULL. */
312 info = seg_info (section);
313 if (info != (segment_info_type *) NULL)
314 info->frchainP->frch_last
315 = chain_frchains_together_1 (section, info->frchainP);
320 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
323 remove_subsegs (head, seg, root, last)
329 *root = head->frch_root;
330 *last = chain_frchains_together_1 (seg, head);
335 #if defined (BFD_ASSEMBLER) || !defined (BFD)
339 cvt_frag_to_fill (sec, fragP)
344 cvt_frag_to_fill (headers, fragP)
345 object_headers *headers;
349 switch (fragP->fr_type)
354 HANDLE_ALIGN (fragP);
356 fragP->fr_type = rs_fill;
357 know (fragP->fr_var == 1);
358 know (fragP->fr_next != NULL);
360 fragP->fr_offset = (fragP->fr_next->fr_address
368 case rs_machine_dependent:
370 md_convert_frag (stdoutput, sec, fragP);
372 md_convert_frag (headers, fragP);
375 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
378 * After md_convert_frag, we make the frag into a ".space 0".
379 * Md_convert_frag() should set up any fixSs and constants
385 #ifndef WORKING_DOT_WORD
388 struct broken_word *lie;
390 if (fragP->fr_subtype)
392 fragP->fr_fix += md_short_jump_size;
393 for (lie = (struct broken_word *) (fragP->fr_symbol);
394 lie && lie->dispfrag == fragP;
395 lie = lie->next_broken_word)
397 fragP->fr_fix += md_long_jump_size;
405 BAD_CASE (fragP->fr_type);
410 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
414 relax_and_size_seg (abfd, sec, xxx)
421 segment_info_type *seginfo;
423 valueT size, newsize;
425 flags = bfd_get_section_flags (abfd, sec);
427 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
428 if (seginfo && seginfo->frchainP)
430 relax_segment (seginfo->frchainP->frch_root, sec);
431 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
432 cvt_frag_to_fill (sec, fragp);
433 for (fragp = seginfo->frchainP->frch_root;
435 fragp = fragp->fr_next)
436 /* walk to last elt */;
437 size = fragp->fr_address + fragp->fr_fix;
442 if (size > 0 && ! seginfo->bss)
443 flags |= SEC_HAS_CONTENTS;
445 /* @@ This is just an approximation. */
446 if (seginfo && seginfo->fix_root)
450 x = bfd_set_section_flags (abfd, sec, flags);
453 newsize = md_section_align (sec, size);
454 x = bfd_set_section_size (abfd, sec, newsize);
457 /* If the size had to be rounded up, add some padding in the last
459 assert (newsize >= size);
462 fragS *last = seginfo->frchainP->frch_last;
463 fragp = seginfo->frchainP->frch_root;
464 while (fragp->fr_next != last)
465 fragp = fragp->fr_next;
466 last->fr_address = size;
467 fragp->fr_offset += newsize - size;
470 #ifdef tc_frob_section
471 tc_frob_section (sec);
473 #ifdef obj_frob_section
474 obj_frob_section (sec);
480 dump_section_relocs (abfd, sec, stream_)
485 FILE *stream = (FILE *) stream_;
486 segment_info_type *seginfo = seg_info (sec);
487 fixS *fixp = seginfo->fix_root;
492 fprintf (stream, "sec %s relocs:\n", sec->name);
495 symbolS *s = fixp->fx_addsy;
497 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
498 S_GET_NAME (s), s->bsym->section->name,
499 S_GET_VALUE (s), fixp->fx_offset);
501 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
502 fixp = fixp->fx_next;
506 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
510 adjust_reloc_syms (abfd, sec, xxx)
515 segment_info_type *seginfo = seg_info (sec);
521 dump_section_relocs (abfd, sec, stderr);
523 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
526 symbolS *sym = fixp->fx_addsy;
527 asection *symsec = sym->bsym->section;
528 segment_info_type *symseginfo = seg_info (symsec);
530 /* If it's one of these sections, assume the symbol is
531 definitely going to be output. The code in
532 md_estimate_size_before_relax in tc-mips.c uses this test
533 as well, so if you change this code you should look at that
535 if (symsec == &bfd_und_section
536 || symsec == &bfd_abs_section
537 || bfd_is_com_section (symsec))
539 fixp->fx_addsy->sy_used_in_reloc = 1;
543 /* Since we're reducing to section symbols, don't attempt to reduce
544 anything that's already using one. */
545 if (sym->bsym == symsec->symbol)
547 fixp->fx_addsy->sy_used_in_reloc = 1;
551 /* Is there some other reason we can't adjust this one? (E.g.,
552 call/bal links in i960-bout symbols.) */
553 #ifdef obj_fix_adjustable
554 if (! obj_fix_adjustable (fixp))
556 fixp->fx_addsy->sy_used_in_reloc = 1;
561 /* Is there some other (target cpu dependent) reason we can't adjust
562 this one? (E.g. relocations involving function addresses on
564 #ifdef tc_fix_adjustable
565 if (! tc_fix_adjustable (fixp))
567 fixp->fx_addsy->sy_used_in_reloc = 1;
572 /* If the section symbol isn't going to be output, the relocs
573 at least should still work. If not, figure out what to do
574 when we run into that case. */
575 fixp->fx_offset += S_GET_VALUE (sym);
577 fixp->fx_offset += sym->sy_frag->fr_address;
579 fixp->fx_addsy = symseginfo->sym;
582 fixp->fx_addsy = symbol_find (symsec->name);
585 fixp->fx_addsy = symbol_make (symsec->name);
586 fixp->fx_addsy->bsym = symsec->symbol;
588 symseginfo->sym = fixp->fx_addsy;
590 fixp->fx_addsy->sy_used_in_reloc = 1;
593 dump_section_relocs (abfd, sec, stderr);
597 write_relocs (abfd, sec, xxx)
602 segment_info_type *seginfo = seg_info (sec);
608 /* If seginfo is NULL, we did not create this section; don't do
613 fixup_segment (seginfo->fix_root, sec);
616 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
619 #ifndef RELOC_EXPANSION_POSSIBLE
620 /* Set up reloc information as well. */
621 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
622 n * sizeof (arelent *));
623 memset ((char*)relocs, 0, n * sizeof (arelent*));
626 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
630 bfd_reloc_status_type s;
632 if (fixp->fx_addsy == 0)
634 /* @@ Need some other flag to indicate which have already
639 reloc = tc_gen_reloc (sec, fixp);
645 data = fixp->fx_frag->fr_literal + fixp->fx_where;
646 if (fixp->fx_where + fixp->fx_size
647 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
650 if (reloc->howto->partial_inplace == false
651 && reloc->howto->pcrel_offset == true
652 && reloc->howto->pc_relative == true)
654 /* bfd_perform_relocation screws this up */
655 reloc->addend += reloc->address;
657 /* Pass bogus address so that when bfd_perform_relocation adds
658 `reloc->address' back in, it'll come up with `data', which is where
659 we want it to operate. We can't just do it by fudging reloc->address,
660 since that might be used in the calculations(?). */
661 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
668 as_fatal ("bad return from bfd_perform_relocation");
673 n = n * MAX_RELOC_EXPANSION;
674 /* Set up reloc information as well. */
675 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
676 n * sizeof (arelent *));
679 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
683 bfd_reloc_status_type s;
686 if (fixp->fx_addsy == 0)
688 /* @@ Need some other flag to indicate which have already
693 reloc = tc_gen_reloc (sec, fixp);
695 for (j = 0; reloc[j]; j++)
697 relocs[i++] = reloc[j];
700 data = fixp->fx_frag->fr_literal + fixp->fx_where;
701 if (fixp->fx_where + fixp->fx_size
702 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
704 for (j = 0; reloc[j]; j++)
706 s = bfd_perform_relocation (stdoutput, reloc[j],
707 data - reloc[0]->address,
714 as_fatal ("bad return from bfd_perform_relocation");
722 bfd_set_reloc (stdoutput, sec, relocs, n);
724 bfd_set_section_flags (abfd, sec,
725 (bfd_get_section_flags (abfd, sec)
726 & (flagword) ~SEC_RELOC));
732 fprintf (stderr, "relocs for sec %s\n", sec->name);
733 for (i = 0; i < n; i++)
737 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
738 i, r, r->address, s->name, r->addend);
745 write_contents (abfd, sec, xxx)
750 segment_info_type *seginfo = seg_info (sec);
751 unsigned long offset = 0;
754 /* Write out the frags. */
756 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
759 for (f = seginfo->frchainP->frch_root;
764 unsigned long fill_size;
768 assert (f->fr_type == rs_fill);
771 x = bfd_set_section_contents (stdoutput, sec,
772 f->fr_literal, (file_ptr) offset,
773 (bfd_size_type) f->fr_fix);
777 fill_literal = f->fr_literal + f->fr_fix;
778 fill_size = f->fr_var;
779 count = f->fr_offset;
781 if (fill_size && count)
784 x = bfd_set_section_contents (stdoutput, sec,
785 fill_literal, (file_ptr) offset,
786 (bfd_size_type) fill_size);
794 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
796 merge_data_into_text ()
798 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
799 seg_info (text_section)->frchainP->frch_last->fr_next =
800 seg_info (data_section)->frchainP->frch_root;
801 seg_info (text_section)->frchainP->frch_last =
802 seg_info (data_section)->frchainP->frch_last;
803 seg_info (data_section)->frchainP = 0;
807 text_last_frag->fr_next = data_frag_root;
808 text_last_frag = data_last_frag;
809 data_last_frag = NULL;
810 data_frag_root = NULL;
813 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
814 tmp->fx_next = data_fix_root;
815 text_fix_tail = data_fix_tail;
818 text_fix_root = data_fix_root;
819 data_fix_root = NULL;
822 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
824 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
826 relax_and_size_all_segments ()
830 relax_segment (text_frag_root, SEG_TEXT);
831 relax_segment (data_frag_root, SEG_DATA);
832 relax_segment (bss_frag_root, SEG_BSS);
834 * Now the addresses of frags are correct within the segment.
837 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
838 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
839 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
842 * Join the 2 segments into 1 huge segment.
843 * To do this, re-compute every rn_address in the SEG_DATA frags.
844 * Then join the data frags after the text frags.
846 * Determine a_data [length of data segment].
850 register relax_addressT slide;
852 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
854 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
855 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
856 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
858 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
859 /* For b.out: If the data section has a strict alignment
860 requirement, its load address in the .o file will be
861 rounded up from the size of the text section. These
862 two values are *not* the same! Similarly for the bss
864 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
867 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
869 fragP->fr_address += slide;
870 } /* for each data frag */
872 know (text_last_frag != 0);
873 text_last_frag->fr_next = data_frag_root;
877 H_SET_DATA_SIZE (&headers, 0);
881 /* See above comments on b.out data section address. */
884 if (data_last_frag == 0)
885 bss_vma = H_GET_TEXT_SIZE (&headers);
887 bss_vma = data_last_frag->fr_address;
888 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
889 bss_address_frag.fr_address = bss_vma;
891 #else /* ! OBJ_BOUT */
892 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
893 H_GET_DATA_SIZE (&headers));
895 #endif /* ! OBJ_BOUT */
897 /* Slide all the frags */
900 relax_addressT slide = bss_address_frag.fr_address;
902 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
904 fragP->fr_address += slide;
905 } /* for each bss frag */
909 H_SET_BSS_SIZE (&headers,
910 bss_last_frag->fr_address - bss_frag_root->fr_address);
912 H_SET_BSS_SIZE (&headers, 0);
914 #endif /* ! BFD_ASSEMBLER && ! BFD */
916 #if defined (BFD_ASSEMBLER) || !defined (BFD)
921 register struct frchain *frchainP; /* Track along all frchains. */
922 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
923 register fragS *fragP; /* Track along all frags. */
925 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
926 long object_file_size;
929 /* Do we really want to write it? */
932 n_warns = had_warnings ();
933 n_errs = had_errors ();
934 /* The -Z flag indicates that an object file should be generated,
935 regardless of warnings and errors. */
938 if (n_warns || n_errs)
939 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
940 n_errs, n_errs == 1 ? "" : "s",
941 n_warns, n_warns == 1 ? "" : "s");
946 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
947 n_errs, n_errs == 1 ? "" : "s",
948 n_warns, n_warns == 1 ? "" : "s");
954 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
955 * call a routine to check for the definition of the procedure
956 * "_main", and if so -- fix it up so that it can be program
959 VMS_Check_For_Main ();
962 /* After every sub-segment, we fake an ".align ...". This conforms to
963 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
964 frag that requires least thought. ".align" frags like to have a
965 following frag since that makes calculating their intended length
968 @@ Is this really necessary?? */
969 #ifndef SUB_SEGMENT_ALIGN
971 #define SUB_SEGMENT_ALIGN(SEG) (0)
973 #define SUB_SEGMENT_ALIGN(SEG) (2)
976 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
978 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
979 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
980 /* frag_align will have left a new frag.
981 Use this last frag for an empty ".fill".
984 Create a last frag. Do not leave a "being filled in frag". */
985 frag_wane (frag_now);
986 frag_now->fr_fix = 0;
987 know (frag_now->fr_next == NULL);
990 /* From now on, we don't care about sub-segments. Build one frag chain
991 for each segment. Linked thru fr_next. */
994 /* Remove the sections created by gas for its own purposes. */
996 asection **seclist, *sec;
997 seclist = &stdoutput->sections;
998 while (seclist && *seclist)
1001 while (sec == reg_section || sec == expr_section)
1005 stdoutput->section_count--;
1010 seclist = &(*seclist)->next;
1014 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1016 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1017 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1018 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1021 /* We have two segments. If user gave -R flag, then we must put the
1022 data frags into the text segment. Do this before relaxing so
1023 we know to take advantage of -R and make shorter addresses. */
1024 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1027 merge_data_into_text ();
1031 #ifdef BFD_ASSEMBLER
1032 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1034 relax_and_size_all_segments ();
1035 #endif /* BFD_ASSEMBLER */
1037 #ifndef BFD_ASSEMBLER
1040 * Crawl the symbol chain.
1042 * For each symbol whose value depends on a frag, take the address of
1043 * that frag and subsume it into the value of the symbol.
1044 * After this, there is just one way to lookup a symbol value.
1045 * Values are left in their final state for object file emission.
1046 * We adjust the values of 'L' local symbols, even if we do
1047 * not intend to emit them to the object file, because their values
1048 * are needed for fix-ups.
1050 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1051 * from the symbol chain. (They are still pointed to by the fixes.)
1053 * Count the remaining symbols.
1054 * Assign a symbol number to each symbol.
1055 * Count the number of string-table chars we will emit.
1056 * Put this info into the headers as appropriate.
1059 know (zero_address_frag.fr_address == 0);
1060 string_byte_count = sizeof (string_byte_count);
1062 obj_crawl_symbol_chain (&headers);
1064 if (string_byte_count == sizeof (string_byte_count))
1065 string_byte_count = 0;
1067 H_SET_STRING_SIZE (&headers, string_byte_count);
1070 * Addresses of frags now reflect addresses we use in the object file.
1071 * Symbol values are correct.
1072 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1073 * Also converting any machine-dependent frags using md_convert_frag();
1075 subseg_change (SEG_TEXT, 0);
1077 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1079 cvt_frag_to_fill (&headers, fragP);
1081 /* Some assert macros don't work with # directives mixed in. */
1083 if (!(fragP->fr_next == NULL
1085 || fragP->fr_next == data_frag_root
1087 || ((fragP->fr_next->fr_address - fragP->fr_address)
1088 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1092 #endif /* ! BFD_ASSEMBLER */
1094 #ifndef WORKING_DOT_WORD
1096 struct broken_word *lie;
1097 struct broken_word **prevP;
1099 prevP = &broken_words;
1100 for (lie = broken_words; lie; lie = lie->next_broken_word)
1105 exp.X_op = O_subtract;
1106 exp.X_add_symbol = lie->add;
1107 exp.X_op_symbol = lie->sub;
1108 exp.X_add_number = lie->addnum;
1109 #ifdef BFD_ASSEMBLER
1110 fix_new_exp (lie->frag,
1111 lie->word_goes_here - lie->frag->fr_literal,
1112 2, &exp, 0, BFD_RELOC_NONE);
1114 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1115 fix_new_exp (lie->frag,
1116 lie->word_goes_here - lie->frag->fr_literal,
1117 2, &exp, 0, NO_RELOC);
1120 fix_new_ns32k_exp (lie->frag,
1121 lie->word_goes_here - lie->frag->fr_literal,
1122 2, &exp, 0, 0, 2, 0, 0);
1124 fix_new_exp (lie->frag,
1125 lie->word_goes_here - lie->frag->fr_literal,
1127 #endif /* TC_NS32K */
1128 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1129 #endif /* BFD_ASSEMBLER */
1130 *prevP = lie->next_broken_word;
1133 prevP = &(lie->next_broken_word);
1135 for (lie = broken_words; lie;)
1137 struct broken_word *untruth;
1139 addressT table_addr;
1140 addressT from_addr, to_addr;
1143 fragP = lie->dispfrag;
1145 /* Find out how many broken_words go here. */
1147 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1148 if (untruth->added == 1)
1151 table_ptr = lie->dispfrag->fr_opcode;
1152 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1153 /* Create the jump around the long jumps. This is a short
1154 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1155 from_addr = table_addr;
1156 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1157 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1158 table_ptr += md_short_jump_size;
1159 table_addr += md_short_jump_size;
1161 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1163 if (lie->added == 2)
1165 /* Patch the jump table */
1166 /* This is the offset from ??? to table_ptr+0 */
1167 to_addr = table_addr - S_GET_VALUE (lie->sub);
1168 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1169 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1171 if (untruth->use_jump == lie)
1172 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1175 /* Install the long jump */
1176 /* this is a long jump from table_ptr+0 to the final target */
1177 from_addr = table_addr;
1178 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1179 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1180 table_ptr += md_long_jump_size;
1181 table_addr += md_long_jump_size;
1185 #endif /* not WORKING_DOT_WORD */
1187 #ifndef BFD_ASSEMBLER
1191 * Scan every FixS performing fixups. We had to wait until now to do
1192 * this because md_convert_frag() may have made some fixSs.
1196 subseg_change (SEG_TEXT, 0);
1197 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1198 subseg_change (SEG_DATA, 0);
1199 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1200 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1202 /* FIXME move this stuff into the pre-write-hook */
1203 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1204 H_SET_ENTRY_POINT (&headers, 0);
1206 obj_pre_write_hook (&headers); /* extra coff stuff */
1208 object_file_size = H_GET_FILE_SIZE (&headers);
1209 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1211 output_file_create (out_file_name);
1213 obj_header_append (&next_object_file_charP, &headers);
1215 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1220 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1222 register long count;
1223 register char *fill_literal;
1224 register long fill_size;
1226 know (fragP->fr_type == rs_fill);
1227 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1228 fill_literal = fragP->fr_literal + fragP->fr_fix;
1229 fill_size = fragP->fr_var;
1230 know (fragP->fr_offset >= 0);
1232 for (count = fragP->fr_offset; count; count--)
1234 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1237 } /* for each code frag. */
1239 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1244 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1245 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)));
1247 /* Make addresses in data relocation directives relative to beginning of
1248 * first data fragment, not end of last text fragment: alignment of the
1249 * start of the data segment may place a gap between the segments.
1251 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1253 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1254 #endif /* TC_I960 */
1256 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)));
1259 * Emit line number entries.
1261 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1262 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)));
1267 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1268 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)));
1274 if (string_byte_count > 0)
1276 obj_emit_strings (&next_object_file_charP);
1277 } /* only if we have a string table */
1280 bfd_seek (stdoutput, 0, 0);
1281 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1284 /* Write the data to the file */
1285 output_file_append (the_object_file, object_file_size, out_file_name);
1288 output_file_close (out_file_name);
1289 } /* non vms output */
1292 * Now do the VMS-dependent part of writing the object file
1294 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1295 H_GET_DATA_SIZE (&headers),
1296 H_GET_BSS_SIZE (&headers),
1297 text_frag_root, data_frag_root);
1299 #else /* BFD_ASSEMBLER */
1301 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1303 /* Set up symbol table, and write it out. */
1310 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1312 if (! symp->sy_resolved)
1314 if (symp->sy_value.X_op == O_constant)
1316 /* This is the normal case; skip the call. */
1319 + symp->sy_frag->fr_address));
1320 symp->sy_resolved = 1;
1323 resolve_symbol_value (symp);
1326 /* So far, common symbols have been treated like undefined symbols.
1327 Put them in the common section now. */
1328 if (S_IS_DEFINED (symp) == 0
1329 && S_GET_VALUE (symp) != 0)
1330 S_SET_SEGMENT (symp, &bfd_com_section);
1332 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1333 S_GET_NAME (symp), symp,
1336 segment_name (symp->bsym->section));
1339 #ifdef obj_frob_symbol
1342 obj_frob_symbol (symp, punt);
1347 #ifdef tc_frob_symbol
1350 tc_frob_symbol (symp, punt);
1356 /* If we don't want to keep this symbol, splice it out of the
1358 if (S_IS_LOCAL (symp))
1361 if (! symp->sy_used_in_reloc)
1363 symbolS *prev, *next;
1364 prev = symbol_previous (symp);
1365 next = symbol_next (symp);
1367 verify_symbol_chain_2 (symp);
1371 symbol_next (prev) = next;
1374 else if (symp == symbol_rootP)
1375 symbol_rootP = next;
1379 symbol_previous (next) = prev;
1381 symbol_lastP = prev;
1384 verify_symbol_chain_2 (prev);
1386 verify_symbol_chain_2 (next);
1392 /* Make sure we really got a value for the symbol. */
1393 if (! symp->sy_resolved)
1395 as_bad ("can't resolve value for symbol \"%s\"",
1397 symp->sy_resolved = 1;
1400 /* Set the value into the BFD symbol. Up til now the value
1401 has only been kept in the gas symbolS struct. */
1402 symp->bsym->value = S_GET_VALUE (symp);
1411 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1413 asympp = (asymbol **) bfd_alloc (stdoutput,
1414 n * sizeof (asymbol *));
1415 symp = symbol_rootP;
1416 for (i = 0; i < n; i++, symp = symbol_next (symp))
1418 asympp[i] = symp->bsym;
1421 result = bfd_set_symtab (stdoutput, asympp, n);
1422 assert (result == true);
1427 #ifdef obj_frob_file
1428 /* If obj_frob_file changes the symbol value at this point, it is
1429 responsible for moving the changed value into symp->bsym->value
1430 as well. Hopefully all symbol value changing can be done in
1431 {obj,tc}_frob_symbol. */
1435 /* Now that all the sizes are known, and contents correct, we can
1436 start writing the file. */
1437 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1439 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1441 output_file_close (out_file_name);
1442 #endif /* BFD_ASSEMBLER */
1449 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1454 * After this, all frags in this segment have addresses that are correct
1455 * within the segment. Since segments live in different file addresses,
1456 * these frag addresses may not be the same as final object-file addresses.
1459 #ifndef md_relax_frag
1461 /* Subroutines of relax_segment. */
1467 for (; f1; f1 = f1->fr_next)
1468 if (f1->fr_next == f2)
1473 #endif /* ! defined (md_relax_frag) */
1475 /* Relax_align. Advance location counter to next address that has 'alignment'
1476 lowest order bits all 0s, return size of adjustment made. */
1477 static relax_addressT
1478 relax_align (address, alignment)
1479 register relax_addressT address; /* Address now. */
1480 register int alignment; /* Alignment (binary). */
1482 relax_addressT mask;
1483 relax_addressT new_address;
1485 mask = ~((~0) << alignment);
1486 new_address = (address + mask) & (~mask);
1488 /* We must provide lots of padding, so the linker can discard it
1489 when needed. The linker will not add extra space, ever. */
1490 new_address += (1 << alignment);
1491 return (new_address - address);
1495 relax_segment (segment_frag_root, segment)
1496 struct frag *segment_frag_root;
1499 register struct frag *fragP;
1500 register relax_addressT address;
1501 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1502 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1504 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1505 subseg_change (segment, 0);
1507 /* For each frag in segment: count and store (a 1st guess of)
1510 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1512 fragP->fr_address = address;
1513 address += fragP->fr_fix;
1515 switch (fragP->fr_type)
1518 address += fragP->fr_offset * fragP->fr_var;
1522 address += relax_align (address, (int) fragP->fr_offset);
1526 /* Assume .org is nugatory. It will grow with 1st relax. */
1529 case rs_machine_dependent:
1530 address += md_estimate_size_before_relax (fragP, segment);
1533 #ifndef WORKING_DOT_WORD
1534 /* Broken words don't concern us yet */
1535 case rs_broken_word:
1540 BAD_CASE (fragP->fr_type);
1542 } /* switch(fr_type) */
1543 } /* for each frag in the segment */
1547 long stretch; /* May be any size, 0 or negative. */
1548 /* Cumulative number of addresses we have */
1549 /* relaxed this pass. */
1550 /* We may have relaxed more than one address. */
1551 long stretched; /* Have we stretched on this pass? */
1552 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1553 grew, and another shrank. If a branch instruction doesn't fit anymore,
1554 we could be scrod. */
1558 stretch = stretched = 0;
1559 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1562 unsigned long was_address;
1568 was_address = fragP->fr_address;
1569 address = fragP->fr_address += stretch;
1570 symbolP = fragP->fr_symbol;
1571 offset = fragP->fr_offset;
1573 switch (fragP->fr_type)
1575 case rs_fill: /* .fill never relaxes. */
1579 #ifndef WORKING_DOT_WORD
1580 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1581 for it I do not want to write it. I do not want to have
1582 anything to do with it. This is not the proper way to
1583 implement this misfeature. */
1584 case rs_broken_word:
1586 struct broken_word *lie;
1587 struct broken_word *untruth;
1589 /* Yes this is ugly (storing the broken_word pointer
1590 in the symbol slot). Still, this whole chunk of
1591 code is ugly, and I don't feel like doing anything
1592 about it. Think of it as stubbornness in action. */
1594 for (lie = (struct broken_word *) (fragP->fr_symbol);
1595 lie && lie->dispfrag == fragP;
1596 lie = lie->next_broken_word)
1602 offset = (lie->add->sy_frag->fr_address
1603 + S_GET_VALUE (lie->add)
1605 - (lie->sub->sy_frag->fr_address
1606 + S_GET_VALUE (lie->sub)));
1607 if (offset <= -32768 || offset >= 32767)
1612 sprint_value (buf, (addressT) lie->addnum);
1613 as_warn (".word %s-%s+%s didn't fit",
1614 S_GET_NAME (lie->add),
1615 S_GET_NAME (lie->sub),
1619 if (fragP->fr_subtype == 0)
1621 fragP->fr_subtype++;
1622 growth += md_short_jump_size;
1624 for (untruth = lie->next_broken_word;
1625 untruth && untruth->dispfrag == lie->dispfrag;
1626 untruth = untruth->next_broken_word)
1627 if ((untruth->add->sy_frag == lie->add->sy_frag)
1628 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1631 untruth->use_jump = lie;
1633 growth += md_long_jump_size;
1638 } /* case rs_broken_word */
1641 growth = (relax_align ((relax_addressT) (address
1644 - relax_align ((relax_addressT) (was_address
1654 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1655 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1656 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1657 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1658 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1659 know (symbolP->sy_frag);
1660 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1661 || (symbolP->sy_frag == &zero_address_frag));
1663 target += S_GET_VALUE (symbolP)
1664 + symbolP->sy_frag->fr_address;
1665 } /* if we have a symbol */
1667 know (fragP->fr_next);
1668 after = fragP->fr_next->fr_address;
1669 growth = ((target - after) > 0) ? (target - after) : 0;
1670 /* Growth may be negative, but variable part of frag
1671 cannot have fewer than 0 chars. That is, we can't
1674 growth -= stretch; /* This is an absolute growth factor */
1677 case rs_machine_dependent:
1678 #ifdef md_relax_frag
1679 growth = md_relax_frag (fragP, stretch);
1681 /* The default way to relax a frag is to look through
1684 const relax_typeS *this_type;
1685 const relax_typeS *start_type;
1686 relax_substateT next_state;
1687 relax_substateT this_state;
1690 this_state = fragP->fr_subtype;
1691 start_type = this_type = md_relax_table + this_state;
1696 #ifndef DIFF_EXPR_OK
1697 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1698 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1699 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1700 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1701 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1703 know (symbolP->sy_frag);
1705 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1706 || symbolP->sy_frag == &zero_address_frag);
1708 S_GET_VALUE (symbolP)
1709 + symbolP->sy_frag->fr_address;
1711 /* If frag has yet to be reached on this pass,
1712 assume it will move by STRETCH just as we did.
1713 If this is not so, it will be because some frag
1714 between grows, and that will force another pass.
1716 Beware zero-length frags.
1718 There should be a faster way to do this. */
1720 if (symbolP->sy_frag->fr_address >= was_address
1721 && is_dnrange (fragP, symbolP->sy_frag))
1727 aim = target - address - fragP->fr_fix;
1728 /* The displacement is affected by the instruction size
1729 for the 32k architecture. I think we ought to be able
1730 to add fragP->fr_pcrel_adjust in all cases (it should be
1731 zero if not used), but just in case it breaks something
1732 else we'll put this inside #ifdef NS32K ... #endif */
1734 if (fragP->fr_pcrel_adjust)
1737 aim += fragP->fr_pcrel_adjust;
1741 /* Look backwards. */
1742 for (next_state = this_type->rlx_more; next_state;)
1743 if (aim >= this_type->rlx_backward)
1747 /* Grow to next state. */
1748 this_state = next_state;
1749 this_type = md_relax_table + this_state;
1750 next_state = this_type->rlx_more;
1755 #ifdef M68K_AIM_KLUDGE
1756 M68K_AIM_KLUDGE (aim, this_state, this_type);
1758 /* Look forwards. */
1759 for (next_state = this_type->rlx_more; next_state;)
1760 if (aim <= this_type->rlx_forward)
1764 /* Grow to next state. */
1765 this_state = next_state;
1766 this_type = md_relax_table + this_state;
1767 next_state = this_type->rlx_more;
1771 growth = this_type->rlx_length - start_type->rlx_length;
1773 fragP->fr_subtype = this_state;
1779 BAD_CASE (fragP->fr_type);
1787 } /* For each frag in the segment. */
1789 while (stretched); /* Until nothing further to relax. */
1793 * We now have valid fr_address'es for each frag.
1797 * All fr_address's are correct, relative to their own segment.
1798 * We have made all the fixS we will ever make.
1800 } /* relax_segment() */
1802 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1806 Go through all the fixS's in a segment and see which ones can be
1807 handled now. (These consist of fixS where we have since discovered
1808 the value of a symbol, or the address of the frag involved.)
1809 For each one, call md_apply_fix to put the fix into the frag data.
1811 Result is a count of how many relocation structs will be needed to
1812 handle the remaining fixS's that we couldn't completely handle here.
1813 These will be output later by emit_relocations(). */
1816 fixup_segment (fixP, this_segment_type)
1817 register fixS *fixP;
1818 segT this_segment_type; /* N_TYPE bits for segment. */
1820 long seg_reloc_count = 0;
1821 symbolS *add_symbolP;
1822 symbolS *sub_symbolP;
1829 segT add_symbol_segment = absolute_section;
1831 /* If the linker is doing the relaxing, we must not do any fixups.
1833 Well, strictly speaking that's not true -- we could do any that are
1834 PC-relative and don't cross regions that could change size. And for the
1835 i960 (the only machine for which we've got a relaxing linker right now),
1836 we might be able to turn callx/callj into bal anyways in cases where we
1837 know the maximum displacement. */
1840 for (; fixP; fixP = fixP->fx_next)
1842 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1843 return seg_reloc_count;
1846 for (; fixP; fixP = fixP->fx_next)
1848 fragP = fixP->fx_frag;
1850 where = fixP->fx_where;
1851 place = fragP->fr_literal + where;
1852 size = fixP->fx_size;
1853 add_symbolP = fixP->fx_addsy;
1854 #ifdef TC_VALIDATE_FIX
1855 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
1857 sub_symbolP = fixP->fx_subsy;
1858 add_number = fixP->fx_offset;
1859 pcrel = fixP->fx_pcrel;
1862 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1869 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
1870 add_number -= S_GET_VALUE (sub_symbolP);
1872 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
1874 /* Should try converting to a constant. */
1879 as_bad ("Negative of non-absolute symbol %s",
1880 S_GET_NAME (sub_symbolP));
1882 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1883 && (SEG_NORMAL (add_symbol_segment)
1884 || (add_symbol_segment == absolute_section)))
1886 /* Difference of 2 symbols from same segment.
1887 Can't make difference of 2 undefineds: 'value' means
1888 something different for N_UNDF. */
1890 /* Makes no sense to use the difference of 2 arbitrary symbols
1891 as the target of a call instruction. */
1893 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);
1900 /* Let the target machine make the final determination
1901 as to whether or not a relocation will be needed to
1902 handle this fixup. */
1903 if (!TC_FORCE_RELOCATION (fixP))
1904 fixP->fx_addsy = NULL;
1908 /* Different segments in subtraction. */
1909 know (!(S_IS_EXTERNAL (sub_symbolP)
1910 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1912 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1913 add_number -= S_GET_VALUE (sub_symbolP);
1916 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1917 #if 0 /* Do this even if it's already described as pc-relative. For example,
1918 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
1919 pc-relative mode. */
1924 /* Make it pc-relative. */
1925 add_number += (md_pcrel_from (fixP)
1926 - S_GET_VALUE (sub_symbolP));
1936 sprint_value (buf, fragP->fr_address + where);
1937 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1938 segment_name (S_GET_SEGMENT (sub_symbolP)),
1939 S_GET_NAME (sub_symbolP), buf);
1946 if (add_symbol_segment == this_segment_type && pcrel)
1949 * This fixup was made when the symbol's segment was
1950 * SEG_UNKNOWN, but it is now in the local segment.
1951 * So we know how to do the address without relocation.
1954 /* reloc_callj() may replace a 'call' with a 'calls' or a
1955 'bal', in which cases it modifies *fixP as appropriate.
1956 In the case of a 'calls', no further work is required,
1957 and *fixP has been set up to make the rest of the code
1960 #endif /* TC_I960 */
1962 add_number += S_GET_VALUE (add_symbolP);
1963 add_number -= md_pcrel_from (fixP);
1964 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1966 /* Let the target machine make the final determination
1967 as to whether or not a relocation will be needed to
1968 handle this fixup. */
1969 if (!TC_FORCE_RELOCATION (fixP))
1970 fixP->fx_addsy = NULL;
1974 if (add_symbol_segment == absolute_section)
1977 /* See comment about reloc_callj() above. */
1979 #endif /* TC_I960 */
1980 add_number += S_GET_VALUE (add_symbolP);
1982 /* Let the target machine make the final determination
1983 as to whether or not a relocation will be needed to
1984 handle this fixup. */
1985 if (!TC_FORCE_RELOCATION (fixP))
1986 fixP->fx_addsy = NULL;
1989 else if (add_symbol_segment == undefined_section
1990 #ifdef BFD_ASSEMBLER
1991 || bfd_is_com_section (add_symbol_segment)
1996 if ((int) fixP->fx_bit_fixP == 13)
1998 /* This is a COBR instruction. They have only a
1999 * 13-bit displacement and are only to be used
2000 * for local branches: flag as error, don't generate
2003 as_bad ("can't use COBR format with external label");
2005 /* Let the target machine make the final determination
2006 as to whether or not a relocation will be needed to
2007 handle this fixup. */
2008 if (!TC_FORCE_RELOCATION (fixP))
2009 fixP->fx_addsy = NULL;
2012 #endif /* TC_I960 */
2016 if (S_IS_COMMON (add_symbolP))
2017 add_number += S_GET_VALUE (add_symbolP);
2018 #endif /* TE_I386AIX */
2019 #endif /* OBJ_COFF */
2025 add_number += S_GET_VALUE (add_symbolP);
2032 add_number -= md_pcrel_from (fixP);
2033 if (add_symbolP == 0)
2035 fixP->fx_addsy = &abs_symbol;
2037 } /* if there's an add_symbol */
2040 if (!fixP->fx_bit_fixP && size > 0)
2043 /* set all bits to one */
2045 /* Technically speaking, combining these produces an
2046 undefined result if size is sizeof (valueT), though I
2047 think these two half-way operations should both be
2051 if ((add_number & mask) != 0
2052 && (add_number & mask) != mask)
2054 char buf[50], buf2[50];
2055 sprint_value (buf, fragP->fr_address + where);
2056 if (add_number > 1000)
2057 sprint_value (buf2, add_number);
2059 sprintf (buf2, "%ld", (long) add_number);
2060 as_bad_where (fixP->fx_file, fixP->fx_line,
2061 "Value of %s too large for field of %d bytes at %s",
2063 } /* generic error checking */
2064 #ifdef WARN_SIGNED_OVERFLOW_WORD
2065 /* Warn if a .word value is too large when treated as a signed
2066 number. We already know it is not too negative. This is to
2067 catch over-large switches generated by gcc on the 68k. */
2070 && add_number > 0x7fff)
2071 as_bad_where (fixP->fx_file, fixP->fx_line,
2072 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2074 (unsigned long) (fragP->fr_address + where));
2076 } /* not a bit fix */
2078 #ifdef BFD_ASSEMBLER
2079 md_apply_fix (fixP, &add_number);
2081 md_apply_fix (fixP, add_number);
2085 } /* For each fixS in this segment. */
2087 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2088 return seg_reloc_count;
2091 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2094 number_to_chars_bigendian (buf, val, n)
2099 if (n > sizeof (val)|| n <= 0)
2103 buf[n] = val & 0xff;
2109 number_to_chars_littleendian (buf, val, n)
2114 if (n > sizeof (val) || n <= 0)
2118 *buf++ = val & 0xff;
2123 /* end of write.c */