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 = &frchain_now->fix_root;
146 fixS **seg_fix_tailP = &frchain_now->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 fixS fix_dummy, *prev_fix = &fix_dummy;
292 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
294 prev_frag->fr_next = frchp->frch_root;
295 prev_frag = frchp->frch_last;
297 if (frchp->fix_root != (fixS *) NULL)
299 if (seg_info (section)->fix_root == (fixS *) NULL)
300 seg_info (section)->fix_root = frchp->fix_root;
301 prev_fix->fx_next = frchp->fix_root;
302 prev_fix = frchp->fix_tail;
306 prev_frag->fr_next = 0;
315 chain_frchains_together (abfd, section, xxx)
316 bfd *abfd; /* unused */
318 PTR xxx; /* unused */
320 segment_info_type *info;
322 /* BFD may have introduced its own sections without using
323 subseg_new, so it is possible that seg_info is NULL. */
324 info = seg_info (section);
325 if (info != (segment_info_type *) NULL)
326 info->frchainP->frch_last
327 = chain_frchains_together_1 (section, info->frchainP);
332 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
335 remove_subsegs (head, seg, root, last)
341 *root = head->frch_root;
342 *last = chain_frchains_together_1 (seg, head);
347 #if defined (BFD_ASSEMBLER) || !defined (BFD)
351 cvt_frag_to_fill (sec, fragP)
356 cvt_frag_to_fill (headers, fragP)
357 object_headers *headers;
361 switch (fragP->fr_type)
366 HANDLE_ALIGN (fragP);
368 fragP->fr_type = rs_fill;
369 know (fragP->fr_next != NULL);
370 fragP->fr_offset = (fragP->fr_next->fr_address
372 - fragP->fr_fix) / fragP->fr_var;
378 case rs_machine_dependent:
380 md_convert_frag (stdoutput, sec, fragP);
382 md_convert_frag (headers, fragP);
385 assert (fragP->fr_next == NULL || (fragP->fr_next->fr_address - fragP->fr_address == fragP->fr_fix));
388 * After md_convert_frag, we make the frag into a ".space 0".
389 * Md_convert_frag() should set up any fixSs and constants
395 #ifndef WORKING_DOT_WORD
398 struct broken_word *lie;
400 if (fragP->fr_subtype)
402 fragP->fr_fix += md_short_jump_size;
403 for (lie = (struct broken_word *) (fragP->fr_symbol);
404 lie && lie->dispfrag == fragP;
405 lie = lie->next_broken_word)
407 fragP->fr_fix += md_long_jump_size;
415 BAD_CASE (fragP->fr_type);
420 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
424 relax_and_size_seg (abfd, sec, xxx)
431 segment_info_type *seginfo;
433 valueT size, newsize;
435 flags = bfd_get_section_flags (abfd, sec);
437 seginfo = (segment_info_type *) bfd_get_section_userdata (abfd, sec);
438 if (seginfo && seginfo->frchainP)
440 relax_segment (seginfo->frchainP->frch_root, sec);
441 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
442 cvt_frag_to_fill (sec, fragp);
443 for (fragp = seginfo->frchainP->frch_root;
445 fragp = fragp->fr_next)
446 /* walk to last elt */;
447 size = fragp->fr_address + fragp->fr_fix;
452 if (size > 0 && ! seginfo->bss)
453 flags |= SEC_HAS_CONTENTS;
455 /* @@ This is just an approximation. */
456 if (seginfo && seginfo->fix_root)
460 x = bfd_set_section_flags (abfd, sec, flags);
463 newsize = md_section_align (sec, size);
464 x = bfd_set_section_size (abfd, sec, newsize);
467 /* If the size had to be rounded up, add some padding in the last
469 assert (newsize >= size);
472 fragS *last = seginfo->frchainP->frch_last;
473 fragp = seginfo->frchainP->frch_root;
474 while (fragp->fr_next != last)
475 fragp = fragp->fr_next;
476 last->fr_address = size;
477 fragp->fr_offset += newsize - size;
480 #ifdef tc_frob_section
481 tc_frob_section (sec);
483 #ifdef obj_frob_section
484 obj_frob_section (sec);
490 dump_section_relocs (abfd, sec, stream_)
495 FILE *stream = (FILE *) stream_;
496 segment_info_type *seginfo = seg_info (sec);
497 fixS *fixp = seginfo->fix_root;
502 fprintf (stream, "sec %s relocs:\n", sec->name);
505 symbolS *s = fixp->fx_addsy;
507 fprintf (stream, " %08x: %s(%s+%x)+%x\n", fixp,
508 S_GET_NAME (s), s->bsym->section->name,
509 S_GET_VALUE (s), fixp->fx_offset);
511 fprintf (stream, " %08x: type %d no sym\n", fixp, fixp->fx_r_type);
512 fixp = fixp->fx_next;
516 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
519 #ifndef EMIT_SECTION_SYMBOLS
520 #define EMIT_SECTION_SYMBOLS 1
524 adjust_reloc_syms (abfd, sec, xxx)
529 segment_info_type *seginfo = seg_info (sec);
535 dump_section_relocs (abfd, sec, stderr);
537 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
540 else if (fixp->fx_addsy)
542 symbolS *sym = fixp->fx_addsy;
543 asection *symsec = sym->bsym->section;
545 /* If it's one of these sections, assume the symbol is
546 definitely going to be output. The code in
547 md_estimate_size_before_relax in tc-mips.c uses this test
548 as well, so if you change this code you should look at that
550 if (symsec == &bfd_und_section
551 || symsec == &bfd_abs_section
552 || bfd_is_com_section (symsec))
554 fixp->fx_addsy->sy_used_in_reloc = 1;
558 /* Since we're reducing to section symbols, don't attempt to reduce
559 anything that's already using one. */
560 if (sym->bsym->flags & BSF_SECTION_SYM)
562 fixp->fx_addsy->sy_used_in_reloc = 1;
566 /* Is there some other reason we can't adjust this one? (E.g.,
567 call/bal links in i960-bout symbols.) */
568 #ifdef obj_fix_adjustable
569 if (! obj_fix_adjustable (fixp))
571 fixp->fx_addsy->sy_used_in_reloc = 1;
576 /* Is there some other (target cpu dependent) reason we can't adjust
577 this one? (E.g. relocations involving function addresses on
579 #ifdef tc_fix_adjustable
580 if (! tc_fix_adjustable (fixp))
582 fixp->fx_addsy->sy_used_in_reloc = 1;
587 /* If the section symbol isn't going to be output, the relocs
588 at least should still work. If not, figure out what to do
589 when we run into that case. */
590 fixp->fx_offset += S_GET_VALUE (sym);
592 fixp->fx_offset += sym->sy_frag->fr_address;
593 fixp->fx_addsy = section_symbol (symsec);
594 fixp->fx_addsy->sy_used_in_reloc = 1;
596 #ifdef RELOC_REQUIRES_SYMBOL
599 /* There was no symbol required by this relocation. However,
600 BFD doesn't really handle relocations without symbols well.
601 (At least, the COFF support doesn't.) So for now we fake up
602 a local symbol in the absolute section. */
603 static symbolS *abs_sym;
606 abs_sym = section_symbol (absolute_section);
607 abs_sym->sy_used_in_reloc = 1;
609 fixp->fx_addsy = abs_sym;
613 dump_section_relocs (abfd, sec, stderr);
617 write_relocs (abfd, sec, xxx)
622 segment_info_type *seginfo = seg_info (sec);
629 /* If seginfo is NULL, we did not create this section; don't do
634 fixup_segment (seginfo->fix_root, sec);
637 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
640 #ifndef RELOC_EXPANSION_POSSIBLE
641 /* Set up reloc information as well. */
642 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
643 n * sizeof (arelent *));
644 memset ((char*)relocs, 0, n * sizeof (arelent*));
647 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
651 bfd_reloc_status_type s;
658 reloc = tc_gen_reloc (sec, fixp);
664 data = fixp->fx_frag->fr_literal + fixp->fx_where;
665 if (fixp->fx_where + fixp->fx_size
666 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
669 if (reloc->howto->partial_inplace == false
670 && reloc->howto->pcrel_offset == true
671 && reloc->howto->pc_relative == true)
673 /* bfd_perform_relocation screws this up */
674 reloc->addend += reloc->address;
676 /* Pass bogus address so that when bfd_perform_relocation adds
677 `reloc->address' back in, it'll come up with `data', which is where
678 we want it to operate. We can't just do it by fudging reloc->address,
679 since that might be used in the calculations(?). */
680 s = bfd_perform_relocation (stdoutput, reloc, data - reloc->address,
681 sec, stdoutput, &err);
686 case bfd_reloc_overflow:
687 as_bad_where (fixp->fx_file, fixp->fx_line, "relocation overflow");
690 as_fatal ("bad return from bfd_perform_relocation");
695 n = n * MAX_RELOC_EXPANSION;
696 /* Set up reloc information as well. */
697 relocs = (arelent **) bfd_alloc_by_size_t (stdoutput,
698 n * sizeof (arelent *));
701 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
705 bfd_reloc_status_type s;
713 reloc = tc_gen_reloc (sec, fixp);
715 for (j = 0; reloc[j]; j++)
717 relocs[i++] = reloc[j];
720 data = fixp->fx_frag->fr_literal + fixp->fx_where;
721 if (fixp->fx_where + fixp->fx_size
722 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
724 for (j = 0; reloc[j]; j++)
726 s = bfd_perform_relocation (stdoutput, reloc[j],
727 data - reloc[0]->address,
728 sec, stdoutput, &err);
734 as_fatal ("bad return from bfd_perform_relocation");
742 bfd_set_reloc (stdoutput, sec, relocs, n);
744 bfd_set_section_flags (abfd, sec,
745 (bfd_get_section_flags (abfd, sec)
746 & (flagword) ~SEC_RELOC));
753 fprintf (stderr, "relocs for sec %s\n", sec->name);
754 for (i = 0; i < n; i++)
758 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
759 i, r, r->address, s->name, r->addend);
766 write_contents (abfd, sec, xxx)
771 segment_info_type *seginfo = seg_info (sec);
772 unsigned long offset = 0;
775 /* Write out the frags. */
777 || ! (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
780 for (f = seginfo->frchainP->frch_root;
785 unsigned long fill_size;
789 assert (f->fr_type == rs_fill);
792 x = bfd_set_section_contents (stdoutput, sec,
793 f->fr_literal, (file_ptr) offset,
794 (bfd_size_type) f->fr_fix);
798 fill_literal = f->fr_literal + f->fr_fix;
799 fill_size = f->fr_var;
800 count = f->fr_offset;
802 if (fill_size && count)
805 x = bfd_set_section_contents (stdoutput, sec,
806 fill_literal, (file_ptr) offset,
807 (bfd_size_type) fill_size);
815 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
817 merge_data_into_text ()
819 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
820 seg_info (text_section)->frchainP->frch_last->fr_next =
821 seg_info (data_section)->frchainP->frch_root;
822 seg_info (text_section)->frchainP->frch_last =
823 seg_info (data_section)->frchainP->frch_last;
824 seg_info (data_section)->frchainP = 0;
828 text_last_frag->fr_next = data_frag_root;
829 text_last_frag = data_last_frag;
830 data_last_frag = NULL;
831 data_frag_root = NULL;
834 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
835 tmp->fx_next = data_fix_root;
836 text_fix_tail = data_fix_tail;
839 text_fix_root = data_fix_root;
840 data_fix_root = NULL;
843 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
845 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
847 relax_and_size_all_segments ()
851 relax_segment (text_frag_root, SEG_TEXT);
852 relax_segment (data_frag_root, SEG_DATA);
853 relax_segment (bss_frag_root, SEG_BSS);
855 * Now the addresses of frags are correct within the segment.
858 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
859 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
860 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
863 * Join the 2 segments into 1 huge segment.
864 * To do this, re-compute every rn_address in the SEG_DATA frags.
865 * Then join the data frags after the text frags.
867 * Determine a_data [length of data segment].
871 register relax_addressT slide;
873 know ((text_last_frag->fr_type == rs_fill) && (text_last_frag->fr_offset == 0));
875 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
876 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
877 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
879 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
880 /* For b.out: If the data section has a strict alignment
881 requirement, its load address in the .o file will be
882 rounded up from the size of the text section. These
883 two values are *not* the same! Similarly for the bss
885 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
888 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
890 fragP->fr_address += slide;
891 } /* for each data frag */
893 know (text_last_frag != 0);
894 text_last_frag->fr_next = data_frag_root;
898 H_SET_DATA_SIZE (&headers, 0);
902 /* See above comments on b.out data section address. */
905 if (data_last_frag == 0)
906 bss_vma = H_GET_TEXT_SIZE (&headers);
908 bss_vma = data_last_frag->fr_address;
909 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
910 bss_address_frag.fr_address = bss_vma;
912 #else /* ! OBJ_BOUT */
913 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
914 H_GET_DATA_SIZE (&headers));
916 #endif /* ! OBJ_BOUT */
918 /* Slide all the frags */
921 relax_addressT slide = bss_address_frag.fr_address;
923 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
925 fragP->fr_address += slide;
926 } /* for each bss frag */
930 H_SET_BSS_SIZE (&headers,
931 bss_last_frag->fr_address - bss_frag_root->fr_address);
933 H_SET_BSS_SIZE (&headers, 0);
935 #endif /* ! BFD_ASSEMBLER && ! BFD */
937 #if defined (BFD_ASSEMBLER) || !defined (BFD)
942 register struct frchain *frchainP; /* Track along all frchains. */
943 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
944 register fragS *fragP; /* Track along all frags. */
946 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
947 long object_file_size;
950 /* Do we really want to write it? */
953 n_warns = had_warnings ();
954 n_errs = had_errors ();
955 /* The -Z flag indicates that an object file should be generated,
956 regardless of warnings and errors. */
959 if (n_warns || n_errs)
960 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
961 n_errs, n_errs == 1 ? "" : "s",
962 n_warns, n_warns == 1 ? "" : "s");
967 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
968 n_errs, n_errs == 1 ? "" : "s",
969 n_warns, n_warns == 1 ? "" : "s");
975 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
976 * call a routine to check for the definition of the procedure
977 * "_main", and if so -- fix it up so that it can be program
980 VMS_Check_For_Main ();
983 /* After every sub-segment, we fake an ".align ...". This conforms to
984 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
985 frag that requires least thought. ".align" frags like to have a
986 following frag since that makes calculating their intended length
989 @@ Is this really necessary?? */
990 #ifndef SUB_SEGMENT_ALIGN
992 #define SUB_SEGMENT_ALIGN(SEG) (0)
994 #define SUB_SEGMENT_ALIGN(SEG) (2)
997 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
999 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1000 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
1001 /* frag_align will have left a new frag.
1002 Use this last frag for an empty ".fill".
1004 For this segment ...
1005 Create a last frag. Do not leave a "being filled in frag". */
1006 frag_wane (frag_now);
1007 frag_now->fr_fix = 0;
1008 know (frag_now->fr_next == NULL);
1011 /* From now on, we don't care about sub-segments. Build one frag chain
1012 for each segment. Linked thru fr_next. */
1014 #ifdef BFD_ASSEMBLER
1015 /* Remove the sections created by gas for its own purposes. */
1017 asection **seclist, *sec;
1018 seclist = &stdoutput->sections;
1019 while (seclist && *seclist)
1022 while (sec == reg_section || sec == expr_section)
1026 stdoutput->section_count--;
1031 seclist = &(*seclist)->next;
1035 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1037 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1038 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1039 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1042 /* We have two segments. If user gave -R flag, then we must put the
1043 data frags into the text segment. Do this before relaxing so
1044 we know to take advantage of -R and make shorter addresses. */
1045 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1048 merge_data_into_text ();
1052 #ifdef BFD_ASSEMBLER
1053 bfd_map_over_sections (stdoutput, relax_and_size_seg, (char *) 0);
1055 relax_and_size_all_segments ();
1056 #endif /* BFD_ASSEMBLER */
1058 #ifndef BFD_ASSEMBLER
1061 * Crawl the symbol chain.
1063 * For each symbol whose value depends on a frag, take the address of
1064 * that frag and subsume it into the value of the symbol.
1065 * After this, there is just one way to lookup a symbol value.
1066 * Values are left in their final state for object file emission.
1067 * We adjust the values of 'L' local symbols, even if we do
1068 * not intend to emit them to the object file, because their values
1069 * are needed for fix-ups.
1071 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1072 * from the symbol chain. (They are still pointed to by the fixes.)
1074 * Count the remaining symbols.
1075 * Assign a symbol number to each symbol.
1076 * Count the number of string-table chars we will emit.
1077 * Put this info into the headers as appropriate.
1080 know (zero_address_frag.fr_address == 0);
1081 string_byte_count = sizeof (string_byte_count);
1083 obj_crawl_symbol_chain (&headers);
1085 if (string_byte_count == sizeof (string_byte_count))
1086 string_byte_count = 0;
1088 H_SET_STRING_SIZE (&headers, string_byte_count);
1091 * Addresses of frags now reflect addresses we use in the object file.
1092 * Symbol values are correct.
1093 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1094 * Also converting any machine-dependent frags using md_convert_frag();
1096 subseg_change (SEG_TEXT, 0);
1098 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1100 cvt_frag_to_fill (&headers, fragP);
1102 /* Some assert macros don't work with # directives mixed in. */
1104 if (!(fragP->fr_next == NULL
1106 || fragP->fr_next == data_frag_root
1108 || ((fragP->fr_next->fr_address - fragP->fr_address)
1109 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1113 #endif /* ! BFD_ASSEMBLER */
1115 #ifndef WORKING_DOT_WORD
1117 struct broken_word *lie;
1118 struct broken_word **prevP;
1120 prevP = &broken_words;
1121 for (lie = broken_words; lie; lie = lie->next_broken_word)
1126 exp.X_op = O_subtract;
1127 exp.X_add_symbol = lie->add;
1128 exp.X_op_symbol = lie->sub;
1129 exp.X_add_number = lie->addnum;
1130 #ifdef BFD_ASSEMBLER
1131 fix_new_exp (lie->frag,
1132 lie->word_goes_here - lie->frag->fr_literal,
1133 2, &exp, 0, BFD_RELOC_NONE);
1135 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1136 fix_new_exp (lie->frag,
1137 lie->word_goes_here - lie->frag->fr_literal,
1138 2, &exp, 0, NO_RELOC);
1141 fix_new_ns32k_exp (lie->frag,
1142 lie->word_goes_here - lie->frag->fr_literal,
1143 2, &exp, 0, 0, 2, 0, 0);
1145 fix_new_exp (lie->frag,
1146 lie->word_goes_here - lie->frag->fr_literal,
1148 #endif /* TC_NS32K */
1149 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1150 #endif /* BFD_ASSEMBLER */
1151 *prevP = lie->next_broken_word;
1154 prevP = &(lie->next_broken_word);
1156 for (lie = broken_words; lie;)
1158 struct broken_word *untruth;
1160 addressT table_addr;
1161 addressT from_addr, to_addr;
1164 fragP = lie->dispfrag;
1166 /* Find out how many broken_words go here. */
1168 for (untruth = lie; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1169 if (untruth->added == 1)
1172 table_ptr = lie->dispfrag->fr_opcode;
1173 table_addr = lie->dispfrag->fr_address + (table_ptr - lie->dispfrag->fr_literal);
1174 /* Create the jump around the long jumps. This is a short
1175 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1176 from_addr = table_addr;
1177 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1178 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1179 table_ptr += md_short_jump_size;
1180 table_addr += md_short_jump_size;
1182 for (m = 0; lie && lie->dispfrag == fragP; m++, lie = lie->next_broken_word)
1184 if (lie->added == 2)
1186 /* Patch the jump table */
1187 /* This is the offset from ??? to table_ptr+0 */
1188 to_addr = table_addr - S_GET_VALUE (lie->sub);
1189 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1190 for (untruth = lie->next_broken_word; untruth && untruth->dispfrag == fragP; untruth = untruth->next_broken_word)
1192 if (untruth->use_jump == lie)
1193 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1196 /* Install the long jump */
1197 /* this is a long jump from table_ptr+0 to the final target */
1198 from_addr = table_addr;
1199 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1200 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
1201 table_ptr += md_long_jump_size;
1202 table_addr += md_long_jump_size;
1206 #endif /* not WORKING_DOT_WORD */
1208 #ifndef BFD_ASSEMBLER
1212 * Scan every FixS performing fixups. We had to wait until now to do
1213 * this because md_convert_frag() may have made some fixSs.
1217 subseg_change (SEG_TEXT, 0);
1218 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1219 subseg_change (SEG_DATA, 0);
1220 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1221 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1223 /* FIXME move this stuff into the pre-write-hook */
1224 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1225 H_SET_ENTRY_POINT (&headers, 0);
1227 obj_pre_write_hook (&headers); /* extra coff stuff */
1229 object_file_size = H_GET_FILE_SIZE (&headers);
1230 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1232 output_file_create (out_file_name);
1234 obj_header_append (&next_object_file_charP, &headers);
1236 know ((next_object_file_charP - the_object_file) == H_GET_HEADER_SIZE (&headers));
1241 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1243 register long count;
1244 register char *fill_literal;
1245 register long fill_size;
1247 know (fragP->fr_type == rs_fill);
1248 append (&next_object_file_charP, fragP->fr_literal, (unsigned long) fragP->fr_fix);
1249 fill_literal = fragP->fr_literal + fragP->fr_fix;
1250 fill_size = fragP->fr_var;
1251 know (fragP->fr_offset >= 0);
1253 for (count = fragP->fr_offset; count; count--)
1255 append (&next_object_file_charP, fill_literal, (unsigned long) fill_size);
1258 } /* for each code frag. */
1260 know ((next_object_file_charP - the_object_file) == (H_GET_HEADER_SIZE (&headers) + H_GET_TEXT_SIZE (&headers) + H_GET_DATA_SIZE (&headers)));
1265 obj_emit_relocations (&next_object_file_charP, text_fix_root, (relax_addressT) 0);
1266 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)));
1268 /* Make addresses in data relocation directives relative to beginning of
1269 * first data fragment, not end of last text fragment: alignment of the
1270 * start of the data segment may place a gap between the segments.
1272 obj_emit_relocations (&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
1274 obj_emit_relocations (&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
1275 #endif /* TC_I960 */
1277 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)));
1280 * Emit line number entries.
1282 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1283 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)));
1288 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1289 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)));
1295 if (string_byte_count > 0)
1297 obj_emit_strings (&next_object_file_charP);
1298 } /* only if we have a string table */
1301 bfd_seek (stdoutput, 0, 0);
1302 bfd_write (the_object_file, 1, object_file_size, stdoutput);
1305 /* Write the data to the file */
1306 output_file_append (the_object_file, object_file_size, out_file_name);
1308 } /* non vms output */
1311 * Now do the VMS-dependent part of writing the object file
1313 VMS_write_object_file (H_GET_TEXT_SIZE (&headers),
1314 H_GET_DATA_SIZE (&headers),
1315 H_GET_BSS_SIZE (&headers),
1316 text_frag_root, data_frag_root);
1318 #else /* BFD_ASSEMBLER */
1320 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *)0);
1322 /* Set up symbol table, and write it out. */
1329 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1333 if (! symp->sy_resolved)
1335 if (symp->sy_value.X_op == O_constant)
1337 /* This is the normal case; skip the call. */
1340 + symp->sy_frag->fr_address));
1341 symp->sy_resolved = 1;
1344 resolve_symbol_value (symp);
1347 /* So far, common symbols have been treated like undefined symbols.
1348 Put them in the common section now. */
1349 if (S_IS_DEFINED (symp) == 0
1350 && S_GET_VALUE (symp) != 0)
1351 S_SET_SEGMENT (symp, &bfd_com_section);
1353 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1354 S_GET_NAME (symp), symp,
1357 segment_name (symp->bsym->section));
1360 #ifdef obj_frob_symbol
1361 obj_frob_symbol (symp, punt);
1363 #ifdef tc_frob_symbol
1364 if (! punt || symp->sy_used_in_reloc)
1365 tc_frob_symbol (symp, punt);
1368 /* If we don't want to keep this symbol, splice it out of
1369 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1370 want section symbols. Otherwise, we skip local symbols
1371 and symbols that the frob_symbol macros told us to punt,
1372 but we keep such symbols if they are used in relocs. */
1373 if ((! EMIT_SECTION_SYMBOLS
1374 && (symp->bsym->flags & BSF_SECTION_SYM) != 0)
1375 || ((S_IS_LOCAL (symp) || punt)
1376 && ! symp->sy_used_in_reloc))
1378 symbolS *prev, *next;
1380 prev = symbol_previous (symp);
1381 next = symbol_next (symp);
1383 verify_symbol_chain_2 (symp);
1387 symbol_next (prev) = next;
1390 else if (symp == symbol_rootP)
1391 symbol_rootP = next;
1395 symbol_previous (next) = prev;
1397 symbol_lastP = prev;
1400 verify_symbol_chain_2 (prev);
1402 verify_symbol_chain_2 (next);
1407 /* Make sure we really got a value for the symbol. */
1408 if (! symp->sy_resolved)
1410 as_bad ("can't resolve value for symbol \"%s\"",
1412 symp->sy_resolved = 1;
1415 /* Set the value into the BFD symbol. Up til now the value
1416 has only been kept in the gas symbolS struct. */
1417 symp->bsym->value = S_GET_VALUE (symp);
1426 extern PTR bfd_alloc PARAMS ((bfd *, size_t));
1428 asympp = (asymbol **) bfd_alloc (stdoutput,
1429 n * sizeof (asymbol *));
1430 symp = symbol_rootP;
1431 for (i = 0; i < n; i++, symp = symbol_next (symp))
1433 asympp[i] = symp->bsym;
1436 result = bfd_set_symtab (stdoutput, asympp, n);
1437 assert (result == true);
1445 #ifdef obj_frob_file
1446 /* If obj_frob_file changes the symbol value at this point, it is
1447 responsible for moving the changed value into symp->bsym->value
1448 as well. Hopefully all symbol value changing can be done in
1449 {obj,tc}_frob_symbol. */
1453 /* Now that all the sizes are known, and contents correct, we can
1454 start writing the file. */
1455 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1457 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1458 #endif /* BFD_ASSEMBLER */
1465 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1470 * After this, all frags in this segment have addresses that are correct
1471 * within the segment. Since segments live in different file addresses,
1472 * these frag addresses may not be the same as final object-file addresses.
1475 #ifndef md_relax_frag
1477 /* Subroutines of relax_segment. */
1483 for (; f1; f1 = f1->fr_next)
1484 if (f1->fr_next == f2)
1489 #endif /* ! defined (md_relax_frag) */
1491 /* Relax_align. Advance location counter to next address that has 'alignment'
1492 lowest order bits all 0s, return size of adjustment made. */
1493 static relax_addressT
1494 relax_align (address, alignment)
1495 register relax_addressT address; /* Address now. */
1496 register int alignment; /* Alignment (binary). */
1498 relax_addressT mask;
1499 relax_addressT new_address;
1501 mask = ~((~0) << alignment);
1502 new_address = (address + mask) & (~mask);
1504 /* We must provide lots of padding, so the linker can discard it
1505 when needed. The linker will not add extra space, ever. */
1506 new_address += (1 << alignment);
1507 return (new_address - address);
1511 relax_segment (segment_frag_root, segment)
1512 struct frag *segment_frag_root;
1515 register struct frag *fragP;
1516 register relax_addressT address;
1517 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1518 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
1520 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1521 subseg_change (segment, 0);
1523 /* For each frag in segment: count and store (a 1st guess of)
1526 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1528 fragP->fr_address = address;
1529 address += fragP->fr_fix;
1531 switch (fragP->fr_type)
1534 address += fragP->fr_offset * fragP->fr_var;
1539 int offset = relax_align (address, (int) fragP->fr_offset);
1540 if (offset % fragP->fr_var != 0)
1542 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1543 offset, (long) fragP->fr_var);
1544 offset -= (offset % fragP->fr_var);
1551 /* Assume .org is nugatory. It will grow with 1st relax. */
1554 case rs_machine_dependent:
1555 address += md_estimate_size_before_relax (fragP, segment);
1558 #ifndef WORKING_DOT_WORD
1559 /* Broken words don't concern us yet */
1560 case rs_broken_word:
1565 BAD_CASE (fragP->fr_type);
1567 } /* switch(fr_type) */
1568 } /* for each frag in the segment */
1572 long stretch; /* May be any size, 0 or negative. */
1573 /* Cumulative number of addresses we have */
1574 /* relaxed this pass. */
1575 /* We may have relaxed more than one address. */
1576 long stretched; /* Have we stretched on this pass? */
1577 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1578 grew, and another shrank. If a branch instruction doesn't fit anymore,
1579 we could be scrod. */
1583 stretch = stretched = 0;
1584 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
1587 unsigned long was_address;
1593 was_address = fragP->fr_address;
1594 address = fragP->fr_address += stretch;
1595 symbolP = fragP->fr_symbol;
1596 offset = fragP->fr_offset;
1598 switch (fragP->fr_type)
1600 case rs_fill: /* .fill never relaxes. */
1604 #ifndef WORKING_DOT_WORD
1605 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1606 for it I do not want to write it. I do not want to have
1607 anything to do with it. This is not the proper way to
1608 implement this misfeature. */
1609 case rs_broken_word:
1611 struct broken_word *lie;
1612 struct broken_word *untruth;
1614 /* Yes this is ugly (storing the broken_word pointer
1615 in the symbol slot). Still, this whole chunk of
1616 code is ugly, and I don't feel like doing anything
1617 about it. Think of it as stubbornness in action. */
1619 for (lie = (struct broken_word *) (fragP->fr_symbol);
1620 lie && lie->dispfrag == fragP;
1621 lie = lie->next_broken_word)
1627 offset = (lie->add->sy_frag->fr_address
1628 + S_GET_VALUE (lie->add)
1630 - (lie->sub->sy_frag->fr_address
1631 + S_GET_VALUE (lie->sub)));
1632 if (offset <= -32768 || offset >= 32767)
1637 sprint_value (buf, (addressT) lie->addnum);
1638 as_warn (".word %s-%s+%s didn't fit",
1639 S_GET_NAME (lie->add),
1640 S_GET_NAME (lie->sub),
1644 if (fragP->fr_subtype == 0)
1646 fragP->fr_subtype++;
1647 growth += md_short_jump_size;
1649 for (untruth = lie->next_broken_word;
1650 untruth && untruth->dispfrag == lie->dispfrag;
1651 untruth = untruth->next_broken_word)
1652 if ((untruth->add->sy_frag == lie->add->sy_frag)
1653 && S_GET_VALUE (untruth->add) == S_GET_VALUE (lie->add))
1656 untruth->use_jump = lie;
1658 growth += md_long_jump_size;
1663 } /* case rs_broken_word */
1666 growth = (relax_align ((relax_addressT) (address
1669 - relax_align ((relax_addressT) (was_address
1679 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1680 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1681 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1682 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
1683 || S_GET_SEGMENT (symbolP) == SEG_BSS);
1684 know (symbolP->sy_frag);
1685 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1686 || (symbolP->sy_frag == &zero_address_frag));
1688 target += S_GET_VALUE (symbolP)
1689 + symbolP->sy_frag->fr_address;
1690 } /* if we have a symbol */
1692 know (fragP->fr_next);
1693 after = fragP->fr_next->fr_address;
1694 growth = ((target - after) > 0) ? (target - after) : 0;
1695 /* Growth may be negative, but variable part of frag
1696 cannot have fewer than 0 chars. That is, we can't
1699 growth -= stretch; /* This is an absolute growth factor */
1702 case rs_machine_dependent:
1703 #ifdef md_relax_frag
1704 growth = md_relax_frag (fragP, stretch);
1706 /* The default way to relax a frag is to look through
1709 const relax_typeS *this_type;
1710 const relax_typeS *start_type;
1711 relax_substateT next_state;
1712 relax_substateT this_state;
1715 this_state = fragP->fr_subtype;
1716 start_type = this_type = md_relax_table + this_state;
1721 #ifndef DIFF_EXPR_OK
1722 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1723 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
1724 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
1725 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
1726 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
1728 know (symbolP->sy_frag);
1730 know (!(S_GET_SEGMENT (symbolP) == absolute_section)
1731 || symbolP->sy_frag == &zero_address_frag);
1733 S_GET_VALUE (symbolP)
1734 + symbolP->sy_frag->fr_address;
1736 /* If frag has yet to be reached on this pass,
1737 assume it will move by STRETCH just as we did.
1738 If this is not so, it will be because some frag
1739 between grows, and that will force another pass.
1741 Beware zero-length frags.
1743 There should be a faster way to do this. */
1745 if (symbolP->sy_frag->fr_address >= was_address
1746 && is_dnrange (fragP, symbolP->sy_frag))
1752 aim = target - address - fragP->fr_fix;
1753 /* The displacement is affected by the instruction size
1754 for the 32k architecture. I think we ought to be able
1755 to add fragP->fr_pcrel_adjust in all cases (it should be
1756 zero if not used), but just in case it breaks something
1757 else we'll put this inside #ifdef NS32K ... #endif */
1759 if (fragP->fr_pcrel_adjust)
1762 aim += fragP->fr_pcrel_adjust;
1766 /* Look backwards. */
1767 for (next_state = this_type->rlx_more; next_state;)
1768 if (aim >= this_type->rlx_backward)
1772 /* Grow to next state. */
1773 this_state = next_state;
1774 this_type = md_relax_table + this_state;
1775 next_state = this_type->rlx_more;
1780 #ifdef M68K_AIM_KLUDGE
1781 M68K_AIM_KLUDGE (aim, this_state, this_type);
1783 /* Look forwards. */
1784 for (next_state = this_type->rlx_more; next_state;)
1785 if (aim <= this_type->rlx_forward)
1789 /* Grow to next state. */
1790 this_state = next_state;
1791 this_type = md_relax_table + this_state;
1792 next_state = this_type->rlx_more;
1796 growth = this_type->rlx_length - start_type->rlx_length;
1798 fragP->fr_subtype = this_state;
1804 BAD_CASE (fragP->fr_type);
1812 } /* For each frag in the segment. */
1814 while (stretched); /* Until nothing further to relax. */
1818 * We now have valid fr_address'es for each frag.
1822 * All fr_address's are correct, relative to their own segment.
1823 * We have made all the fixS we will ever make.
1825 } /* relax_segment() */
1827 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1831 Go through all the fixS's in a segment and see which ones can be
1832 handled now. (These consist of fixS where we have since discovered
1833 the value of a symbol, or the address of the frag involved.)
1834 For each one, call md_apply_fix to put the fix into the frag data.
1836 Result is a count of how many relocation structs will be needed to
1837 handle the remaining fixS's that we couldn't completely handle here.
1838 These will be output later by emit_relocations(). */
1841 fixup_segment (fixP, this_segment_type)
1842 register fixS *fixP;
1843 segT this_segment_type; /* N_TYPE bits for segment. */
1845 long seg_reloc_count = 0;
1846 symbolS *add_symbolP;
1847 symbolS *sub_symbolP;
1854 segT add_symbol_segment = absolute_section;
1856 /* If the linker is doing the relaxing, we must not do any fixups.
1858 Well, strictly speaking that's not true -- we could do any that are
1859 PC-relative and don't cross regions that could change size. And for the
1860 i960 (the only machine for which we've got a relaxing linker right now),
1861 we might be able to turn callx/callj into bal anyways in cases where we
1862 know the maximum displacement. */
1865 for (; fixP; fixP = fixP->fx_next)
1867 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1868 return seg_reloc_count;
1871 for (; fixP; fixP = fixP->fx_next)
1873 fragP = fixP->fx_frag;
1875 where = fixP->fx_where;
1876 place = fragP->fr_literal + where;
1877 size = fixP->fx_size;
1878 add_symbolP = fixP->fx_addsy;
1879 #ifdef TC_VALIDATE_FIX
1880 TC_VALIDATE_FIX (fixP, this_segment_type, skip);
1882 sub_symbolP = fixP->fx_subsy;
1883 add_number = fixP->fx_offset;
1884 pcrel = fixP->fx_pcrel;
1887 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
1894 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
1895 add_number -= S_GET_VALUE (sub_symbolP);
1897 && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
1899 /* Should try converting to a constant. */
1904 as_bad ("Negative of non-absolute symbol %s",
1905 S_GET_NAME (sub_symbolP));
1907 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
1908 && (SEG_NORMAL (add_symbol_segment)
1909 || (add_symbol_segment == absolute_section)))
1911 /* Difference of 2 symbols from same segment.
1912 Can't make difference of 2 undefineds: 'value' means
1913 something different for N_UNDF. */
1915 /* Makes no sense to use the difference of 2 arbitrary symbols
1916 as the target of a call instruction. */
1918 as_bad ("callj to difference of 2 symbols");
1919 #endif /* TC_I960 */
1920 add_number += S_GET_VALUE (add_symbolP) -
1921 S_GET_VALUE (sub_symbolP);
1925 /* Let the target machine make the final determination
1926 as to whether or not a relocation will be needed to
1927 handle this fixup. */
1928 if (!TC_FORCE_RELOCATION (fixP))
1930 fixP->fx_addsy = NULL;
1935 /* Different segments in subtraction. */
1936 know (!(S_IS_EXTERNAL (sub_symbolP)
1937 && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
1939 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
1940 add_number -= S_GET_VALUE (sub_symbolP);
1943 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
1944 #if 0 /* Do this even if it's already described as pc-relative. For example,
1945 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
1946 pc-relative mode. */
1951 /* Make it pc-relative. */
1952 add_number += (md_pcrel_from (fixP)
1953 - S_GET_VALUE (sub_symbolP));
1960 #ifdef BFD_ASSEMBLER
1961 else if (fixP->fx_r_type == BFD_RELOC_GPREL32
1962 || fixP->fx_r_type == BFD_RELOC_GPREL16)
1964 /* Leave it alone. */
1970 sprint_value (buf, fragP->fr_address + where);
1971 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1972 segment_name (S_GET_SEGMENT (sub_symbolP)),
1973 S_GET_NAME (sub_symbolP), buf);
1980 if (add_symbol_segment == this_segment_type && pcrel)
1983 * This fixup was made when the symbol's segment was
1984 * SEG_UNKNOWN, but it is now in the local segment.
1985 * So we know how to do the address without relocation.
1988 /* reloc_callj() may replace a 'call' with a 'calls' or a
1989 'bal', in which cases it modifies *fixP as appropriate.
1990 In the case of a 'calls', no further work is required,
1991 and *fixP has been set up to make the rest of the code
1994 #endif /* TC_I960 */
1996 add_number += S_GET_VALUE (add_symbolP);
1997 add_number -= md_pcrel_from (fixP);
1998 pcrel = 0; /* Lie. Don't want further pcrel processing. */
2000 /* Let the target machine make the final determination
2001 as to whether or not a relocation will be needed to
2002 handle this fixup. */
2003 if (!TC_FORCE_RELOCATION (fixP))
2006 fixP->fx_addsy = NULL;
2011 if (add_symbol_segment == absolute_section)
2014 /* See comment about reloc_callj() above. */
2016 #endif /* TC_I960 */
2017 add_number += S_GET_VALUE (add_symbolP);
2019 /* Let the target machine make the final determination
2020 as to whether or not a relocation will be needed to
2021 handle this fixup. */
2022 if (!TC_FORCE_RELOCATION (fixP))
2024 fixP->fx_addsy = NULL;
2028 else if (add_symbol_segment == undefined_section
2029 #ifdef BFD_ASSEMBLER
2030 || bfd_is_com_section (add_symbol_segment)
2035 if ((int) fixP->fx_bit_fixP == 13)
2037 /* This is a COBR instruction. They have only a
2038 * 13-bit displacement and are only to be used
2039 * for local branches: flag as error, don't generate
2042 as_bad ("can't use COBR format with external label");
2043 fixP->fx_addsy = NULL;
2047 #endif /* TC_I960 */
2051 if (S_IS_COMMON (add_symbolP))
2052 add_number += S_GET_VALUE (add_symbolP);
2053 #endif /* TE_I386AIX */
2054 #endif /* OBJ_COFF */
2060 add_number += S_GET_VALUE (add_symbolP);
2067 add_number -= md_pcrel_from (fixP);
2068 if (add_symbolP == 0)
2070 fixP->fx_addsy = &abs_symbol;
2075 if (!fixP->fx_bit_fixP && size > 0)
2078 if (size < sizeof (mask))
2080 /* set all bits to one */
2082 /* Technically, combining these produces an undefined result
2083 if size is sizeof (valueT), though I think these two
2084 half-way operations should both be defined. And the
2085 compiler should be able to combine them if it's valid on
2086 the host architecture. */
2089 if ((add_number & mask) != 0
2090 && (add_number & mask) != mask)
2092 char buf[50], buf2[50];
2093 sprint_value (buf, fragP->fr_address + where);
2094 if (add_number > 1000)
2095 sprint_value (buf2, add_number);
2097 sprintf (buf2, "%ld", (long) add_number);
2098 as_bad_where (fixP->fx_file, fixP->fx_line,
2099 "Value of %s too large for field of %d bytes at %s",
2101 } /* generic error checking */
2103 #ifdef WARN_SIGNED_OVERFLOW_WORD
2104 /* Warn if a .word value is too large when treated as a signed
2105 number. We already know it is not too negative. This is to
2106 catch over-large switches generated by gcc on the 68k. */
2109 && add_number > 0x7fff)
2110 as_bad_where (fixP->fx_file, fixP->fx_line,
2111 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2113 (unsigned long) (fragP->fr_address + where));
2115 } /* not a bit fix */
2119 #ifdef BFD_ASSEMBLER
2120 md_apply_fix (fixP, &add_number);
2122 md_apply_fix (fixP, add_number);
2125 #ifndef TC_HANDLES_FX_DONE
2126 /* If the tc-* files haven't been converted, assume it's handling
2127 it the old way, where a null fx_addsy means that the fix has
2128 been applied completely, and no further work is needed. */
2129 if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2133 #ifdef TC_VALIDATE_FIX
2137 } /* For each fixS in this segment. */
2139 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2140 return seg_reloc_count;
2143 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2146 number_to_chars_bigendian (buf, val, n)
2151 if (n > sizeof (val)|| n <= 0)
2155 buf[n] = val & 0xff;
2161 number_to_chars_littleendian (buf, val, n)
2166 if (n > sizeof (val) || n <= 0)
2170 *buf++ = val & 0xff;
2175 /* end of write.c */