1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 1994 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;
135 as_where (&fixP->fx_file, &fixP->fx_line);
137 /* Usually, we want relocs sorted numerically, but while
138 comparing to older versions of gas that have relocs
139 reverse sorted, it is convenient to have this compile
140 time option. xoxorich. */
145 fixS **seg_fix_rootP = & (seg_info (now_seg)->fix_root);
146 fixS **seg_fix_tailP = & (seg_info (now_seg)->fix_tail);
149 #ifdef REVERSE_SORT_RELOCS
151 fixP->fx_next = *seg_fix_rootP;
152 *seg_fix_rootP = fixP;
154 #else /* REVERSE_SORT_RELOCS */
156 fixP->fx_next = NULL;
159 (*seg_fix_tailP)->fx_next = fixP;
161 *seg_fix_rootP = fixP;
162 *seg_fix_tailP = fixP;
164 #endif /* REVERSE_SORT_RELOCS */
171 /* Create a fixup relative to a symbol (plus a constant). */
174 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
175 fragS *frag; /* Which frag? */
176 int where; /* Where in that frag? */
177 short int size; /* 1, 2, or 4 usually. */
178 symbolS *add_symbol; /* X_add_symbol. */
179 offsetT offset; /* X_add_number. */
180 int pcrel; /* TRUE if PC-relative relocation. */
182 bfd_reloc_code_real_type r_type; /* Relocation type */
184 int r_type; /* Relocation type */
187 return fix_new_internal (frag, where, size, add_symbol,
188 (symbolS *) NULL, offset, pcrel, r_type);
191 /* Create a fixup for an expression. Currently we only support fixups
192 for difference expressions. That is itself more than most object
193 file formats support anyhow. */
196 fix_new_exp (frag, where, size, exp, pcrel, r_type)
197 fragS *frag; /* Which frag? */
198 int where; /* Where in that frag? */
199 short int size; /* 1, 2, or 4 usually. */
200 expressionS *exp; /* Expression. */
201 int pcrel; /* TRUE if PC-relative relocation. */
203 bfd_reloc_code_real_type r_type; /* Relocation type */
205 int r_type; /* Relocation type */
218 sub = exp->X_add_symbol;
219 off = exp->X_add_number;
223 sub = exp->X_op_symbol;
226 add = exp->X_add_symbol;
229 off = exp->X_add_number;
233 as_bad ("expression too complex for fixup");
236 return fix_new_internal (frag, where, size, add, sub, off,
240 /* Append a string onto another string, bumping the pointer along. */
242 append (charPP, fromP, length)
245 unsigned long length;
247 /* Don't trust memcpy() of 0 chars. */
251 memcpy (*charPP, fromP, length);
255 #ifndef BFD_ASSEMBLER
256 int section_alignment[SEG_MAXIMUM_ORDINAL];
260 * This routine records the largest alignment seen for each segment.
261 * If the beginning of the segment is aligned on the worst-case
262 * boundary, all of the other alignments within it will work. At
263 * least one object format really uses this info.
266 record_alignment (seg, align)
267 /* Segment to which alignment pertains */
269 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
274 if (align > bfd_get_section_alignment (stdoutput, seg))
275 bfd_set_section_alignment (stdoutput, seg, align);
277 if (align > section_alignment[(int) seg])
278 section_alignment[(int) seg] = align;
282 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
285 chain_frchains_together_1 (section, frchp)
287 struct frchain *frchp;
289 fragS dummy, *prev_frag = &dummy;
290 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
292 prev_frag->fr_next = frchp->frch_root;
293 prev_frag = frchp->frch_last;
295 prev_frag->fr_next = 0;
304 chain_frchains_together (abfd, section, xxx)
305 bfd *abfd; /* unused */
307 PTR xxx; /* unused */
309 segment_info_type *info;
311 /* BFD may have introduced its own sections without using
312 subseg_new, so it is possible that seg_info is NULL. */
313 info = seg_info (section);
314 if (info != (segment_info_type *) NULL)
315 info->frchainP->frch_last
316 = chain_frchains_together_1 (section, info->frchainP);
321 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
324 remove_subsegs (head, seg, root, last)
330 *root = head->frch_root;
331 *last = chain_frchains_together_1 (seg, head);
336 #if defined (BFD_ASSEMBLER) || !defined (BFD)
340 cvt_frag_to_fill (sec, fragP)
345 cvt_frag_to_fill (headers, fragP)
346 object_headers *headers;
350 switch (fragP->fr_type)
355 HANDLE_ALIGN (fragP);
357 fragP->fr_type = rs_fill;
358 know (fragP->fr_next != NULL);
359 fragP->fr_offset = (fragP->fr_next->fr_address
361 - fragP->fr_fix) / fragP->fr_var;
367 case rs_machine_dependent:
369 md_convert_frag (stdoutput, sec, fragP);
371 md_convert_frag (headers, fragP);
374 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
377 * After md_convert_frag, we make the frag into a ".space 0".
378 * Md_convert_frag() should set up any fixSs and constants
384 #ifndef WORKING_DOT_WORD
387 struct broken_word *lie;
389 if (fragP->fr_subtype)
391 fragP->fr_fix += md_short_jump_size;
392 for (lie = (struct broken_word *) (fragP->fr_symbol);
393 lie && lie->dispfrag == fragP;
394 lie = lie->next_broken_word)
396 fragP->fr_fix += md_long_jump_size;
404 BAD_CASE (fragP->fr_type);
409 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
413 relax_and_size_seg (abfd, sec, xxx)
420 segment_info_type *seginfo;
422 valueT size, newsize;
424 flags = bfd_get_section_flags (abfd, sec);
426 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
427 if (seginfo && seginfo->frchainP)
429 relax_segment (seginfo->frchainP->frch_root, sec);
430 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
431 cvt_frag_to_fill (sec, fragp);
432 for (fragp = seginfo->frchainP->frch_root;
434 fragp = fragp->fr_next)
435 /* walk to last elt */;
436 size = fragp->fr_address + fragp->fr_fix;
441 if (size > 0 && ! seginfo->bss)
442 flags |= SEC_HAS_CONTENTS;
444 /* @@ This is just an approximation. */
445 if (seginfo && seginfo->fix_root)
449 x = bfd_set_section_flags (abfd, sec, flags);
452 newsize = md_section_align (sec, size);
453 x = bfd_set_section_size (abfd, sec, newsize);
456 /* If the size had to be rounded up, add some padding in the last
458 assert (newsize >= size);
461 fragS *last = seginfo->frchainP->frch_last;
462 fragp = seginfo->frchainP->frch_root;
463 while (fragp->fr_next != last)
464 fragp = fragp->fr_next;
465 last->fr_address = size;
466 fragp->fr_offset += newsize - size;
469 #ifdef tc_frob_section
470 tc_frob_section (sec);
472 #ifdef obj_frob_section
473 obj_frob_section (sec);
479 dump_section_relocs (abfd, sec, stream_)
484 FILE *stream = (FILE *) stream_;
485 segment_info_type *seginfo = seg_info (sec);
486 fixS *fixp = seginfo->fix_root;
491 fprintf (stream, "sec %s relocs:\n", sec->name);
494 symbolS *s = fixp->fx_addsy;
496 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
497 S_GET_NAME (s), s->bsym->section->name,
498 S_GET_VALUE (s), fixp->fx_offset);
500 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
501 fixp = fixp->fx_next;
505 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
508 #ifndef EMIT_SECTION_SYMBOLS
509 #define EMIT_SECTION_SYMBOLS 1
513 adjust_reloc_syms (abfd, sec, xxx)
518 segment_info_type *seginfo = seg_info (sec);
524 dump_section_relocs (abfd, sec, stderr);
526 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
529 else if (fixp->fx_addsy)
531 symbolS *sym = fixp->fx_addsy;
532 asection *symsec = sym->bsym->section;
534 /* If it's one of these sections, assume the symbol is
535 definitely going to be output. The code in
536 md_estimate_size_before_relax in tc-mips.c uses this test
537 as well, so if you change this code you should look at that
539 if (symsec == &bfd_und_section
540 || symsec == &bfd_abs_section
541 || bfd_is_com_section (symsec))
543 fixp->fx_addsy->sy_used_in_reloc = 1;
547 /* Since we're reducing to section symbols, don't attempt to reduce
548 anything that's already using one. */
549 if (sym->bsym->flags & BSF_SECTION_SYM)
551 fixp->fx_addsy->sy_used_in_reloc = 1;
555 /* Is there some other reason we can't adjust this one? (E.g.,
556 call/bal links in i960-bout symbols.) */
557 #ifdef obj_fix_adjustable
558 if (! obj_fix_adjustable (fixp))
560 fixp->fx_addsy->sy_used_in_reloc = 1;
565 /* Is there some other (target cpu dependent) reason we can't adjust
566 this one? (E.g. relocations involving function addresses on
568 #ifdef tc_fix_adjustable
569 if (! tc_fix_adjustable (fixp))
571 fixp->fx_addsy->sy_used_in_reloc = 1;
576 /* If the section symbol isn't going to be output, the relocs
577 at least should still work. If not, figure out what to do
578 when we run into that case. */
579 fixp->fx_offset += S_GET_VALUE (sym);
581 fixp->fx_offset += sym->sy_frag->fr_address;
582 fixp->fx_addsy = section_symbol (symsec);
583 fixp->fx_addsy->sy_used_in_reloc = 1;
585 #ifdef RELOC_REQUIRES_SYMBOL
588 /* There was no symbol required by this relocation. However,
589 BFD doesn't really handle relocations without symbols well.
590 (At least, the COFF support doesn't.) So for now we fake up
591 a local symbol in the absolute section. */
592 static symbolS *abs_sym;
595 abs_sym = section_symbol (absolute_section);
596 abs_sym->sy_used_in_reloc = 1;
598 fixp->fx_addsy = abs_sym;
602 dump_section_relocs (abfd, sec, stderr);
606 write_relocs (abfd, sec, xxx)
611 segment_info_type *seginfo = seg_info (sec);
618 /* If seginfo is NULL, we did not create this section; don't do
623 fixup_segment (seginfo->fix_root, sec);
626 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
629 #ifndef RELOC_EXPANSION_POSSIBLE
630 /* Set up reloc information as well. */
631 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
632 n * sizeof (arelent *));
633 memset ((char*)relocs, 0, n * sizeof (arelent*));
636 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
640 bfd_reloc_status_type s;
647 reloc = tc_gen_reloc (sec, fixp);
653 data = fixp->fx_frag->fr_literal + fixp->fx_where;
654 if (fixp->fx_where + fixp->fx_size
655 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
658 if (reloc->howto->partial_inplace == false
659 && reloc->howto->pcrel_offset == true
660 && reloc->howto->pc_relative == true)
662 /* bfd_perform_relocation screws this up */
663 reloc->addend += reloc->address;
665 /* Pass bogus address so that when bfd_perform_relocation adds
666 `reloc->address' back in, it'll come up with `data', which is where
667 we want it to operate. We can't just do it by fudging reloc->address,
668 since that might be used in the calculations(?). */
669 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
670 sec, stdoutput, &err);
676 as_fatal ("bad return from bfd_perform_relocation");
681 n = n * MAX_RELOC_EXPANSION;
682 /* Set up reloc information as well. */
683 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
684 n * sizeof (arelent *));
687 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
691 bfd_reloc_status_type s;
699 reloc = tc_gen_reloc (sec, fixp);
701 for (j = 0; reloc[j]; j++)
703 relocs[i++] = reloc[j];
706 data = fixp->fx_frag->fr_literal + fixp->fx_where;
707 if (fixp->fx_where + fixp->fx_size
708 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
710 for (j = 0; reloc[j]; j++)
712 s = bfd_perform_relocation (stdoutput, reloc[j],
713 data - reloc[0]->address,
714 sec, stdoutput, &err);
720 as_fatal ("bad return from bfd_perform_relocation");
728 bfd_set_reloc (stdoutput, sec, relocs, n);
730 bfd_set_section_flags (abfd, sec,
731 (bfd_get_section_flags (abfd, sec)
732 & (flagword) ~SEC_RELOC));
739 fprintf (stderr, "relocs for sec %s\n", sec->name);
740 for (i = 0; i < n; i++)
744 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
745 i, r, r->address, s->name, r->addend);
752 write_contents (abfd, sec, xxx)
757 segment_info_type *seginfo = seg_info (sec);
758 unsigned long offset = 0;
761 /* Write out the frags. */
763 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
766 for (f = seginfo->frchainP->frch_root;
771 unsigned long fill_size;
775 assert (f->fr_type == rs_fill);
778 x = bfd_set_section_contents (stdoutput, sec,
779 f->fr_literal, (file_ptr) offset,
780 (bfd_size_type) f->fr_fix);
784 fill_literal = f->fr_literal + f->fr_fix;
785 fill_size = f->fr_var;
786 count = f->fr_offset;
788 if (fill_size && count)
791 x = bfd_set_section_contents (stdoutput, sec,
792 fill_literal, (file_ptr) offset,
793 (bfd_size_type) fill_size);
801 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
803 merge_data_into_text ()
805 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
806 seg_info (text_section)->frchainP->frch_last->fr_next =
807 seg_info (data_section)->frchainP->frch_root;
808 seg_info (text_section)->frchainP->frch_last =
809 seg_info (data_section)->frchainP->frch_last;
810 seg_info (data_section)->frchainP = 0;
814 text_last_frag->fr_next = data_frag_root;
815 text_last_frag = data_last_frag;
816 data_last_frag = NULL;
817 data_frag_root = NULL;
820 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
821 tmp->fx_next = data_fix_root;
822 text_fix_tail = data_fix_tail;
825 text_fix_root = data_fix_root;
826 data_fix_root = NULL;
829 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
831 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
833 relax_and_size_all_segments ()
837 relax_segment (text_frag_root, SEG_TEXT);
838 relax_segment (data_frag_root, SEG_DATA);
839 relax_segment (bss_frag_root, SEG_BSS);
841 * Now the addresses of frags are correct within the segment.
844 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
845 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
846 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
849 * Join the 2 segments into 1 huge segment.
850 * To do this, re-compute every rn_address in the SEG_DATA frags.
851 * Then join the data frags after the text frags.
853 * Determine a_data [length of data segment].
857 register relax_addressT slide;
859 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
861 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
862 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
863 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
865 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
866 /* For b.out: If the data section has a strict alignment
867 requirement, its load address in the .o file will be
868 rounded up from the size of the text section. These
869 two values are *not* the same! Similarly for the bss
871 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
874 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
876 fragP->fr_address += slide;
877 } /* for each data frag */
879 know (text_last_frag != 0);
880 text_last_frag->fr_next = data_frag_root;
884 H_SET_DATA_SIZE (&headers, 0);
888 /* See above comments on b.out data section address. */
891 if (data_last_frag == 0)
892 bss_vma = H_GET_TEXT_SIZE (&headers);
894 bss_vma = data_last_frag->fr_address;
895 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
896 bss_address_frag.fr_address = bss_vma;
898 #else /* ! OBJ_BOUT */
899 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
900 H_GET_DATA_SIZE (&headers));
902 #endif /* ! OBJ_BOUT */
904 /* Slide all the frags */
907 relax_addressT slide = bss_address_frag.fr_address;
909 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
911 fragP->fr_address += slide;
912 } /* for each bss frag */
916 H_SET_BSS_SIZE (&headers,
917 bss_last_frag->fr_address - bss_frag_root->fr_address);
919 H_SET_BSS_SIZE (&headers, 0);
921 #endif /* ! BFD_ASSEMBLER && ! BFD */
923 #if defined (BFD_ASSEMBLER) || !defined (BFD)
928 register struct frchain *frchainP; /* Track along all frchains. */
929 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
930 register fragS *fragP; /* Track along all frags. */
932 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
933 long object_file_size;
936 /* Do we really want to write it? */
939 n_warns = had_warnings ();
940 n_errs = had_errors ();
941 /* The -Z flag indicates that an object file should be generated,
942 regardless of warnings and errors. */
945 if (n_warns || n_errs)
946 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
947 n_errs, n_errs == 1 ? "" : "s",
948 n_warns, n_warns == 1 ? "" : "s");
953 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
954 n_errs, n_errs == 1 ? "" : "s",
955 n_warns, n_warns == 1 ? "" : "s");
961 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
962 * call a routine to check for the definition of the procedure
963 * "_main", and if so -- fix it up so that it can be program
966 VMS_Check_For_Main ();
969 /* After every sub-segment, we fake an ".align ...". This conforms to
970 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
971 frag that requires least thought. ".align" frags like to have a
972 following frag since that makes calculating their intended length
975 @@ Is this really necessary?? */
976 #ifndef SUB_SEGMENT_ALIGN
978 #define SUB_SEGMENT_ALIGN(SEG) (0)
980 #define SUB_SEGMENT_ALIGN(SEG) (2)
983 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
985 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
986 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
987 /* frag_align will have left a new frag.
988 Use this last frag for an empty ".fill".
991 Create a last frag. Do not leave a "being filled in frag". */
992 frag_wane (frag_now);
993 frag_now->fr_fix = 0;
994 know (frag_now->fr_next == NULL);
997 /* From now on, we don't care about sub-segments. Build one frag chain
998 for each segment. Linked thru fr_next. */
1000 #ifdef BFD_ASSEMBLER
1001 /* Remove the sections created by gas for its own purposes. */
1003 asection **seclist, *sec;
1004 seclist = &stdoutput->sections;
1005 while (seclist && *seclist)
1008 while (sec == reg_section || sec == expr_section)
1012 stdoutput->section_count--;
1017 seclist = &(*seclist)->next;
1021 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1023 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1024 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1025 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1028 /* We have two segments. If user gave -R flag, then we must put the
1029 data frags into the text segment. Do this before relaxing so
1030 we know to take advantage of -R and make shorter addresses. */
1031 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1034 merge_data_into_text ();
1038 #ifdef BFD_ASSEMBLER
1039 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1041 relax_and_size_all_segments ();
1042 #endif /* BFD_ASSEMBLER */
1044 #ifndef BFD_ASSEMBLER
1047 * Crawl the symbol chain.
1049 * For each symbol whose value depends on a frag, take the address of
1050 * that frag and subsume it into the value of the symbol.
1051 * After this, there is just one way to lookup a symbol value.
1052 * Values are left in their final state for object file emission.
1053 * We adjust the values of 'L' local symbols, even if we do
1054 * not intend to emit them to the object file, because their values
1055 * are needed for fix-ups.
1057 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1058 * from the symbol chain. (They are still pointed to by the fixes.)
1060 * Count the remaining symbols.
1061 * Assign a symbol number to each symbol.
1062 * Count the number of string-table chars we will emit.
1063 * Put this info into the headers as appropriate.
1066 know (zero_address_frag.fr_address == 0);
1067 string_byte_count = sizeof (string_byte_count);
1069 obj_crawl_symbol_chain (&headers);
1071 if (string_byte_count == sizeof (string_byte_count))
1072 string_byte_count = 0;
1074 H_SET_STRING_SIZE (&headers, string_byte_count);
1077 * Addresses of frags now reflect addresses we use in the object file.
1078 * Symbol values are correct.
1079 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1080 * Also converting any machine-dependent frags using md_convert_frag();
1082 subseg_change (SEG_TEXT, 0);
1084 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1086 cvt_frag_to_fill (&headers, fragP);
1088 /* Some assert macros don't work with # directives mixed in. */
1090 if (!(fragP->fr_next == NULL
1092 || fragP->fr_next == data_frag_root
1094 || ((fragP->fr_next->fr_address - fragP->fr_address)
1095 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1099 #endif /* ! BFD_ASSEMBLER */
1101 #ifndef WORKING_DOT_WORD
1103 struct broken_word *lie;
1104 struct broken_word **prevP;
1106 prevP = &broken_words;
1107 for (lie = broken_words; lie; lie = lie->next_broken_word)
1112 exp.X_op = O_subtract;
1113 exp.X_add_symbol = lie->add;
1114 exp.X_op_symbol = lie->sub;
1115 exp.X_add_number = lie->addnum;
1116 #ifdef BFD_ASSEMBLER
1117 fix_new_exp (lie->frag,
1118 lie->word_goes_here - lie->frag->fr_literal,
1119 2, &exp, 0, BFD_RELOC_NONE);
1121 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1122 fix_new_exp (lie->frag,
1123 lie->word_goes_here - lie->frag->fr_literal,
1124 2, &exp, 0, NO_RELOC);
1127 fix_new_ns32k_exp (lie->frag,
1128 lie->word_goes_here - lie->frag->fr_literal,
1129 2, &exp, 0, 0, 2, 0, 0);
1131 fix_new_exp (lie->frag,
1132 lie->word_goes_here - lie->frag->fr_literal,
1134 #endif /* TC_NS32K */
1135 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1136 #endif /* BFD_ASSEMBLER */
1137 *prevP = lie->next_broken_word;
1140 prevP = &(lie->next_broken_word);
1142 for (lie = broken_words; lie;)
1144 struct broken_word *untruth;
1146 addressT table_addr;
1147 addressT from_addr, to_addr;
1150 fragP = lie->dispfrag;
1152 /* Find out how many broken_words go here. */
1154 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1155 if (untruth->added == 1)
1158 table_ptr = lie->dispfrag->fr_opcode;
1159 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1160 /* Create the jump around the long jumps. This is a short
1161 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1162 from_addr = table_addr;
1163 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1164 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1165 table_ptr += md_short_jump_size;
1166 table_addr += md_short_jump_size;
1168 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1170 if (lie->added == 2)
1172 /* Patch the jump table */
1173 /* This is the offset from ??? to table_ptr+0 */
1174 to_addr = table_addr - S_GET_VALUE (lie->sub);
1175 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1176 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1178 if (untruth->use_jump == lie)
1179 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1182 /* Install the long jump */
1183 /* this is a long jump from table_ptr+0 to the final target */
1184 from_addr = table_addr;
1185 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1186 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1187 table_ptr += md_long_jump_size;
1188 table_addr += md_long_jump_size;
1192 #endif /* not WORKING_DOT_WORD */
1194 #ifndef BFD_ASSEMBLER
1198 * Scan every FixS performing fixups. We had to wait until now to do
1199 * this because md_convert_frag() may have made some fixSs.
1203 subseg_change (SEG_TEXT, 0);
1204 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1205 subseg_change (SEG_DATA, 0);
1206 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1207 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1209 /* FIXME move this stuff into the pre-write-hook */
1210 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1211 H_SET_ENTRY_POINT (&headers, 0);
1213 obj_pre_write_hook (&headers); /* extra coff stuff */
1215 object_file_size = H_GET_FILE_SIZE (&headers);
1216 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1218 output_file_create (out_file_name);
1220 obj_header_append (&next_object_file_charP, &headers);
1222 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1227 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1229 register long count;
1230 register char *fill_literal;
1231 register long fill_size;
1233 know (fragP->fr_type == rs_fill);
1234 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1235 fill_literal = fragP->fr_literal + fragP->fr_fix;
1236 fill_size = fragP->fr_var;
1237 know (fragP->fr_offset >= 0);
1239 for (count = fragP->fr_offset; count; count--)
1241 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1244 } /* for each code frag. */
1246 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1251 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
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)));
1254 /* Make addresses in data relocation directives relative to beginning of
1255 * first data fragment, not end of last text fragment: alignment of the
1256 * start of the data segment may place a gap between the segments.
1258 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1260 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1261 #endif /* TC_I960 */
1263 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)));
1266 * Emit line number entries.
1268 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1269 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)));
1274 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1275 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)));
1281 if (string_byte_count > 0)
1283 obj_emit_strings (&next_object_file_charP);
1284 } /* only if we have a string table */
1287 bfd_seek (stdoutput, 0, 0);
1288 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1291 /* Write the data to the file */
1292 output_file_append (the_object_file, object_file_size, out_file_name);
1294 } /* non vms output */
1297 * Now do the VMS-dependent part of writing the object file
1299 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1300 H_GET_DATA_SIZE (&headers),
1301 H_GET_BSS_SIZE (&headers),
1302 text_frag_root, data_frag_root);
1304 #else /* BFD_ASSEMBLER */
1306 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1308 /* Set up symbol table, and write it out. */
1315 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1317 if (! symp->sy_resolved)
1319 if (symp->sy_value.X_op == O_constant)
1321 /* This is the normal case; skip the call. */
1324 + symp->sy_frag->fr_address));
1325 symp->sy_resolved = 1;
1328 resolve_symbol_value (symp);
1331 /* So far, common symbols have been treated like undefined symbols.
1332 Put them in the common section now. */
1333 if (S_IS_DEFINED (symp) == 0
1334 && S_GET_VALUE (symp) != 0)
1335 S_SET_SEGMENT (symp, &bfd_com_section);
1337 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1338 S_GET_NAME (symp), symp,
1341 segment_name (symp->bsym->section));
1344 #ifdef obj_frob_symbol
1347 obj_frob_symbol (symp, punt);
1349 goto punt_it_if_unused;
1352 #ifdef tc_frob_symbol
1355 tc_frob_symbol (symp, punt);
1357 goto punt_it_if_unused;
1361 if (! EMIT_SECTION_SYMBOLS
1362 && (symp->bsym->flags & BSF_SECTION_SYM))
1365 /* If we don't want to keep this symbol, splice it out of the
1367 if (S_IS_LOCAL (symp))
1369 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1372 if (! symp->sy_used_in_reloc)
1374 symbolS *prev, *next;
1376 prev = symbol_previous (symp);
1377 next = symbol_next (symp);
1379 verify_symbol_chain_2 (symp);
1383 symbol_next (prev) = next;
1386 else if (symp == symbol_rootP)
1387 symbol_rootP = next;
1391 symbol_previous (next) = prev;
1393 symbol_lastP = prev;
1396 verify_symbol_chain_2 (prev);
1398 verify_symbol_chain_2 (next);
1404 /* Make sure we really got a value for the symbol. */
1405 if (! symp->sy_resolved)
1407 as_bad ("can't resolve value for symbol \"%s\"",
1409 symp->sy_resolved = 1;
1412 /* Set the value into the BFD symbol. Up til now the value
1413 has only been kept in the gas symbolS struct. */
1414 symp->bsym->value = S_GET_VALUE (symp);
1423 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1425 asympp = (asymbol **) bfd_alloc (stdoutput,
1426 n * sizeof (asymbol *));
1427 symp = symbol_rootP;
1428 for (i = 0; i < n; i++, symp = symbol_next (symp))
1430 asympp[i] = symp->bsym;
1433 result = bfd_set_symtab (stdoutput, asympp, n);
1434 assert (result == true);
1442 #ifdef obj_frob_file
1443 /* If obj_frob_file changes the symbol value at this point, it is
1444 responsible for moving the changed value into symp->bsym->value
1445 as well. Hopefully all symbol value changing can be done in
1446 {obj,tc}_frob_symbol. */
1450 /* Now that all the sizes are known, and contents correct, we can
1451 start writing the file. */
1452 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1454 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1455 #endif /* BFD_ASSEMBLER */
1462 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1467 * After this, all frags in this segment have addresses that are correct
1468 * within the segment. Since segments live in different file addresses,
1469 * these frag addresses may not be the same as final object-file addresses.
1472 #ifndef md_relax_frag
1474 /* Subroutines of relax_segment. */
1480 for (; f1; f1 = f1->fr_next)
1481 if (f1->fr_next == f2)
1486 #endif /* ! defined (md_relax_frag) */
1488 /* Relax_align. Advance location counter to next address that has 'alignment'
1489 lowest order bits all 0s, return size of adjustment made. */
1490 static relax_addressT
1491 relax_align (address, alignment)
1492 register relax_addressT address; /* Address now. */
1493 register int alignment; /* Alignment (binary). */
1495 relax_addressT mask;
1496 relax_addressT new_address;
1498 mask = ~((~0) << alignment);
1499 new_address = (address + mask) & (~mask);
1501 /* We must provide lots of padding, so the linker can discard it
1502 when needed. The linker will not add extra space, ever. */
1503 new_address += (1 << alignment);
1504 return (new_address - address);
1508 relax_segment (segment_frag_root, segment)
1509 struct frag *segment_frag_root;
1512 register struct frag *fragP;
1513 register relax_addressT address;
1514 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1515 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1517 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1518 subseg_change (segment, 0);
1520 /* For each frag in segment: count and store (a 1st guess of)
1523 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1525 fragP->fr_address = address;
1526 address += fragP->fr_fix;
1528 switch (fragP->fr_type)
1531 address += fragP->fr_offset * fragP->fr_var;
1536 int offset = relax_align (address, (int) fragP->fr_offset);
1537 if (offset % fragP->fr_var != 0)
1539 as_bad ("alignment padding (%d bytes) not a multiple of %d",
1540 offset, fragP->fr_var);
1541 offset -= (offset % fragP->fr_var);
1548 /* Assume .org is nugatory. It will grow with 1st relax. */
1551 case rs_machine_dependent:
1552 address += md_estimate_size_before_relax (fragP, segment);
1555 #ifndef WORKING_DOT_WORD
1556 /* Broken words don't concern us yet */
1557 case rs_broken_word:
1562 BAD_CASE (fragP->fr_type);
1564 } /* switch(fr_type) */
1565 } /* for each frag in the segment */
1569 long stretch; /* May be any size, 0 or negative. */
1570 /* Cumulative number of addresses we have */
1571 /* relaxed this pass. */
1572 /* We may have relaxed more than one address. */
1573 long stretched; /* Have we stretched on this pass? */
1574 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1575 grew, and another shrank. If a branch instruction doesn't fit anymore,
1576 we could be scrod. */
1580 stretch = stretched = 0;
1581 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1584 unsigned long was_address;
1590 was_address = fragP->fr_address;
1591 address = fragP->fr_address += stretch;
1592 symbolP = fragP->fr_symbol;
1593 offset = fragP->fr_offset;
1595 switch (fragP->fr_type)
1597 case rs_fill: /* .fill never relaxes. */
1601 #ifndef WORKING_DOT_WORD
1602 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1603 for it I do not want to write it. I do not want to have
1604 anything to do with it. This is not the proper way to
1605 implement this misfeature. */
1606 case rs_broken_word:
1608 struct broken_word *lie;
1609 struct broken_word *untruth;
1611 /* Yes this is ugly (storing the broken_word pointer
1612 in the symbol slot). Still, this whole chunk of
1613 code is ugly, and I don't feel like doing anything
1614 about it. Think of it as stubbornness in action. */
1616 for (lie = (struct broken_word *) (fragP->fr_symbol);
1617 lie && lie->dispfrag == fragP;
1618 lie = lie->next_broken_word)
1624 offset = (lie->add->sy_frag->fr_address
1625 + S_GET_VALUE (lie->add)
1627 - (lie->sub->sy_frag->fr_address
1628 + S_GET_VALUE (lie->sub)));
1629 if (offset <= -32768 || offset >= 32767)
1634 sprint_value (buf, (addressT) lie->addnum);
1635 as_warn (".word %s-%s+%s didn't fit",
1636 S_GET_NAME (lie->add),
1637 S_GET_NAME (lie->sub),
1641 if (fragP->fr_subtype == 0)
1643 fragP->fr_subtype++;
1644 growth += md_short_jump_size;
1646 for (untruth = lie->next_broken_word;
1647 untruth && untruth->dispfrag == lie->dispfrag;
1648 untruth = untruth->next_broken_word)
1649 if ((untruth->add->sy_frag == lie->add->sy_frag)
1650 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1653 untruth->use_jump = lie;
1655 growth += md_long_jump_size;
1660 } /* case rs_broken_word */
1663 growth = (relax_align ((relax_addressT) (address
1666 - relax_align ((relax_addressT) (was_address
1676 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1677 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1678 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1679 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1680 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1681 know (symbolP->sy_frag);
1682 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1683 || (symbolP->sy_frag == &zero_address_frag));
1685 target += S_GET_VALUE (symbolP)
1686 + symbolP->sy_frag->fr_address;
1687 } /* if we have a symbol */
1689 know (fragP->fr_next);
1690 after = fragP->fr_next->fr_address;
1691 growth = ((target - after) > 0) ? (target - after) : 0;
1692 /* Growth may be negative, but variable part of frag
1693 cannot have fewer than 0 chars. That is, we can't
1696 growth -= stretch; /* This is an absolute growth factor */
1699 case rs_machine_dependent:
1700 #ifdef md_relax_frag
1701 growth = md_relax_frag (fragP, stretch);
1703 /* The default way to relax a frag is to look through
1706 const relax_typeS *this_type;
1707 const relax_typeS *start_type;
1708 relax_substateT next_state;
1709 relax_substateT this_state;
1712 this_state = fragP->fr_subtype;
1713 start_type = this_type = md_relax_table + this_state;
1718 #ifndef DIFF_EXPR_OK
1719 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1720 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1721 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1722 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1723 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1725 know (symbolP->sy_frag);
1727 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1728 || symbolP->sy_frag == &zero_address_frag);
1730 S_GET_VALUE (symbolP)
1731 + symbolP->sy_frag->fr_address;
1733 /* If frag has yet to be reached on this pass,
1734 assume it will move by STRETCH just as we did.
1735 If this is not so, it will be because some frag
1736 between grows, and that will force another pass.
1738 Beware zero-length frags.
1740 There should be a faster way to do this. */
1742 if (symbolP->sy_frag->fr_address >= was_address
1743 && is_dnrange (fragP, symbolP->sy_frag))
1749 aim = target - address - fragP->fr_fix;
1750 /* The displacement is affected by the instruction size
1751 for the 32k architecture. I think we ought to be able
1752 to add fragP->fr_pcrel_adjust in all cases (it should be
1753 zero if not used), but just in case it breaks something
1754 else we'll put this inside #ifdef NS32K ... #endif */
1756 if (fragP->fr_pcrel_adjust)
1759 aim += fragP->fr_pcrel_adjust;
1763 /* Look backwards. */
1764 for (next_state = this_type->rlx_more; next_state;)
1765 if (aim >= this_type->rlx_backward)
1769 /* Grow to next state. */
1770 this_state = next_state;
1771 this_type = md_relax_table + this_state;
1772 next_state = this_type->rlx_more;
1777 #ifdef M68K_AIM_KLUDGE
1778 M68K_AIM_KLUDGE (aim, this_state, this_type);
1780 /* Look forwards. */
1781 for (next_state = this_type->rlx_more; next_state;)
1782 if (aim <= this_type->rlx_forward)
1786 /* Grow to next state. */
1787 this_state = next_state;
1788 this_type = md_relax_table + this_state;
1789 next_state = this_type->rlx_more;
1793 growth = this_type->rlx_length - start_type->rlx_length;
1795 fragP->fr_subtype = this_state;
1801 BAD_CASE (fragP->fr_type);
1809 } /* For each frag in the segment. */
1811 while (stretched); /* Until nothing further to relax. */
1815 * We now have valid fr_address'es for each frag.
1819 * All fr_address's are correct, relative to their own segment.
1820 * We have made all the fixS we will ever make.
1822 } /* relax_segment() */
1824 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1828 Go through all the fixS's in a segment and see which ones can be
1829 handled now. (These consist of fixS where we have since discovered
1830 the value of a symbol, or the address of the frag involved.)
1831 For each one, call md_apply_fix to put the fix into the frag data.
1833 Result is a count of how many relocation structs will be needed to
1834 handle the remaining fixS's that we couldn't completely handle here.
1835 These will be output later by emit_relocations(). */
1838 fixup_segment (fixP, this_segment_type)
1839 register fixS *fixP;
1840 segT this_segment_type; /* N_TYPE bits for segment. */
1842 long seg_reloc_count = 0;
1843 symbolS *add_symbolP;
1844 symbolS *sub_symbolP;
1851 segT add_symbol_segment = absolute_section;
1853 /* If the linker is doing the relaxing, we must not do any fixups.
1855 Well, strictly speaking that's not true -- we could do any that are
1856 PC-relative and don't cross regions that could change size. And for the
1857 i960 (the only machine for which we've got a relaxing linker right now),
1858 we might be able to turn callx/callj into bal anyways in cases where we
1859 know the maximum displacement. */
1862 for (; fixP; fixP = fixP->fx_next)
1864 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1865 return seg_reloc_count;
1868 for (; fixP; fixP = fixP->fx_next)
1870 fragP = fixP->fx_frag;
1872 where = fixP->fx_where;
1873 place = fragP->fr_literal + where;
1874 size = fixP->fx_size;
1875 add_symbolP = fixP->fx_addsy;
1876 #ifdef TC_VALIDATE_FIX
1877 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
1879 sub_symbolP = fixP->fx_subsy;
1880 add_number = fixP->fx_offset;
1881 pcrel = fixP->fx_pcrel;
1884 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1891 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
1892 add_number -= S_GET_VALUE (sub_symbolP);
1894 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
1896 /* Should try converting to a constant. */
1901 as_bad ("Negative of non-absolute symbol %s",
1902 S_GET_NAME (sub_symbolP));
1904 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1905 && (SEG_NORMAL (add_symbol_segment)
1906 || (add_symbol_segment == absolute_section)))
1908 /* Difference of 2 symbols from same segment.
1909 Can't make difference of 2 undefineds: 'value' means
1910 something different for N_UNDF. */
1912 /* Makes no sense to use the difference of 2 arbitrary symbols
1913 as the target of a call instruction. */
1915 as_bad ("callj to difference of 2 symbols");
1916 #endif /* TC_I960 */
1917 add_number += S_GET_VALUE (add_symbolP) -
1918 S_GET_VALUE (sub_symbolP);
1922 /* Let the target machine make the final determination
1923 as to whether or not a relocation will be needed to
1924 handle this fixup. */
1925 if (!TC_FORCE_RELOCATION (fixP))
1927 fixP->fx_addsy = NULL;
1932 /* Different segments in subtraction. */
1933 know (!(S_IS_EXTERNAL (sub_symbolP)
1934 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1936 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1937 add_number -= S_GET_VALUE (sub_symbolP);
1940 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1941 #if 0 /* Do this even if it's already described as pc-relative. For example,
1942 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
1943 pc-relative mode. */
1948 /* Make it pc-relative. */
1949 add_number += (md_pcrel_from (fixP)
1950 - S_GET_VALUE (sub_symbolP));
1957 #ifdef BFD_ASSEMBLER
1958 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
1959 || fixP->fx_r_type == BFD_RELOC_GPREL16)
1961 /* Leave it alone. */
1967 sprint_value (buf, fragP->fr_address + where);
1968 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1969 segment_name (S_GET_SEGMENT (sub_symbolP)),
1970 S_GET_NAME (sub_symbolP), buf);
1977 if (add_symbol_segment == this_segment_type && pcrel)
1980 * This fixup was made when the symbol's segment was
1981 * SEG_UNKNOWN, but it is now in the local segment.
1982 * So we know how to do the address without relocation.
1985 /* reloc_callj() may replace a 'call' with a 'calls' or a
1986 'bal', in which cases it modifies *fixP as appropriate.
1987 In the case of a 'calls', no further work is required,
1988 and *fixP has been set up to make the rest of the code
1991 #endif /* TC_I960 */
1993 add_number += S_GET_VALUE (add_symbolP);
1994 add_number -= md_pcrel_from (fixP);
1995 pcrel = 0; /* Lie. Don't want further pcrel processing. */
1997 /* Let the target machine make the final determination
1998 as to whether or not a relocation will be needed to
1999 handle this fixup. */
2000 if (!TC_FORCE_RELOCATION (fixP))
2003 fixP->fx_addsy = NULL;
2008 if (add_symbol_segment == absolute_section)
2011 /* See comment about reloc_callj() above. */
2013 #endif /* TC_I960 */
2014 add_number += S_GET_VALUE (add_symbolP);
2016 /* Let the target machine make the final determination
2017 as to whether or not a relocation will be needed to
2018 handle this fixup. */
2019 if (!TC_FORCE_RELOCATION (fixP))
2021 fixP->fx_addsy = NULL;
2025 else if (add_symbol_segment == undefined_section
2026 #ifdef BFD_ASSEMBLER
2027 || bfd_is_com_section (add_symbol_segment)
2032 if ((int) fixP->fx_bit_fixP == 13)
2034 /* This is a COBR instruction. They have only a
2035 * 13-bit displacement and are only to be used
2036 * for local branches: flag as error, don't generate
2039 as_bad ("can't use COBR format with external label");
2040 fixP->fx_addsy = NULL;
2044 #endif /* TC_I960 */
2048 if (S_IS_COMMON (add_symbolP))
2049 add_number += S_GET_VALUE (add_symbolP);
2050 #endif /* TE_I386AIX */
2051 #endif /* OBJ_COFF */
2057 add_number += S_GET_VALUE (add_symbolP);
2064 add_number -= md_pcrel_from (fixP);
2065 if (add_symbolP == 0)
2067 fixP->fx_addsy = &abs_symbol;
2072 if (!fixP->fx_bit_fixP && size > 0)
2075 /* set all bits to one */
2077 /* Technically, combining these produces an undefined result
2078 if size is sizeof (valueT), though I think these two
2079 half-way operations should both be defined. And the
2080 compiler should be able to combine them if it's valid on
2081 the host architecture. */
2084 if ((add_number & mask) != 0
2085 && (add_number & mask) != mask)
2087 char buf[50], buf2[50];
2088 sprint_value (buf, fragP->fr_address + where);
2089 if (add_number > 1000)
2090 sprint_value (buf2, add_number);
2092 sprintf (buf2, "%ld", (long) add_number);
2093 as_bad_where (fixP->fx_file, fixP->fx_line,
2094 "Value of %s too large for field of %d bytes at %s",
2096 } /* generic error checking */
2097 #ifdef WARN_SIGNED_OVERFLOW_WORD
2098 /* Warn if a .word value is too large when treated as a signed
2099 number. We already know it is not too negative. This is to
2100 catch over-large switches generated by gcc on the 68k. */
2103 && add_number > 0x7fff)
2104 as_bad_where (fixP->fx_file, fixP->fx_line,
2105 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2107 (unsigned long) (fragP->fr_address + where));
2109 } /* not a bit fix */
2113 #ifdef BFD_ASSEMBLER
2114 md_apply_fix (fixP, &add_number);
2116 md_apply_fix (fixP, add_number);
2119 #ifndef TC_HANDLES_FX_DONE
2120 /* If the tc-* files haven't been converted, assume it's handling
2121 it the old way, where a null fx_addsy means that the fix has
2122 been applied completely, and no further work is needed. */
2123 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2127 #ifdef TC_VALIDATE_FIX
2131 } /* For each fixS in this segment. */
2133 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2134 return seg_reloc_count;
2137 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2140 number_to_chars_bigendian (buf, val, n)
2145 if (n > sizeof (val)|| n <= 0)
2149 buf[n] = val & 0xff;
2155 number_to_chars_littleendian (buf, val, n)
2160 if (n > sizeof (val) || n <= 0)
2164 *buf++ = val & 0xff;
2169 /* end of write.c */