1 /* write.c - emit .o file
2 Copyright (C) 1986, 1987, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This thing should be set up to do byteordering correctly. But... */
25 #include "output-file.h"
27 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
28 instruction so that the disassembler does not choke on it. */
30 #define NOP_OPCODE 0x00
33 #ifndef TC_ADJUST_RELOC_COUNT
34 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
37 #ifndef TC_FORCE_RELOCATION
38 #define TC_FORCE_RELOCATION(FIXP) 0
41 #ifndef WORKING_DOT_WORD
42 extern CONST
int md_short_jump_size
;
43 extern CONST
int md_long_jump_size
;
49 struct frag
*text_frag_root
;
50 struct frag
*data_frag_root
;
51 struct frag
*bss_frag_root
;
53 struct frag
*text_last_frag
; /* Last frag in segment. */
54 struct frag
*data_last_frag
; /* Last frag in segment. */
55 static struct frag
*bss_last_frag
; /* Last frag in segment. */
58 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
59 static object_headers headers
;
60 static char *the_object_file
;
63 long string_byte_count
;
64 char *next_object_file_charP
; /* Tracks object file bytes. */
67 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
70 #endif /* BFD_ASSEMBLER */
73 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
74 symbolS
*add
, symbolS
*sub
,
75 offsetT offset
, int pcrel
,
76 bfd_reloc_code_real_type r_type
));
78 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
79 symbolS
*add
, symbolS
*sub
,
80 offsetT offset
, int pcrel
,
83 #if defined (BFD_ASSEMBLER) || !defined (BFD)
84 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
86 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
91 * Create a fixS in obstack 'notes'.
94 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
96 fragS
*frag
; /* Which frag? */
97 int where
; /* Where in that frag? */
98 int size
; /* 1, 2, or 4 usually. */
99 symbolS
*add_symbol
; /* X_add_symbol. */
100 symbolS
*sub_symbol
; /* X_op_symbol. */
101 offsetT offset
; /* X_add_number. */
102 int pcrel
; /* TRUE if PC-relative relocation. */
104 bfd_reloc_code_real_type r_type
; /* Relocation type */
106 int r_type
; /* Relocation type */
111 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
113 fixP
->fx_frag
= frag
;
114 fixP
->fx_where
= where
;
115 fixP
->fx_size
= size
;
116 fixP
->fx_addsy
= add_symbol
;
117 fixP
->fx_subsy
= sub_symbol
;
118 fixP
->fx_offset
= offset
;
119 fixP
->fx_pcrel
= pcrel
;
120 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
121 fixP
->fx_r_type
= r_type
;
123 fixP
->fx_im_disp
= 0;
124 fixP
->fx_pcrel_adjust
= 0;
125 fixP
->fx_bit_fixP
= 0;
126 fixP
->fx_addnumber
= 0;
127 fixP
->tc_fix_data
= NULL
;
134 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
136 /* Usually, we want relocs sorted numerically, but while
137 comparing to older versions of gas that have relocs
138 reverse sorted, it is convenient to have this compile
139 time option. xoxorich. */
144 fixS
**seg_fix_rootP
= & (seg_info (now_seg
)->fix_root
);
145 fixS
**seg_fix_tailP
= & (seg_info (now_seg
)->fix_tail
);
148 #ifdef REVERSE_SORT_RELOCS
150 fixP
->fx_next
= *seg_fix_rootP
;
151 *seg_fix_rootP
= fixP
;
153 #else /* REVERSE_SORT_RELOCS */
155 fixP
->fx_next
= NULL
;
158 (*seg_fix_tailP
)->fx_next
= fixP
;
160 *seg_fix_rootP
= fixP
;
161 *seg_fix_tailP
= fixP
;
163 #endif /* REVERSE_SORT_RELOCS */
170 /* Create a fixup relative to a symbol (plus a constant). */
173 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
174 fragS
*frag
; /* Which frag? */
175 int where
; /* Where in that frag? */
176 short int size
; /* 1, 2, or 4 usually. */
177 symbolS
*add_symbol
; /* X_add_symbol. */
178 offsetT offset
; /* X_add_number. */
179 int pcrel
; /* TRUE if PC-relative relocation. */
181 bfd_reloc_code_real_type r_type
; /* Relocation type */
183 int r_type
; /* Relocation type */
186 return fix_new_internal (frag
, where
, size
, add_symbol
,
187 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
190 /* Create a fixup for an expression. Currently we only support fixups
191 for difference expressions. That is itself more than most object
192 file formats support anyhow. */
195 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
196 fragS
*frag
; /* Which frag? */
197 int where
; /* Where in that frag? */
198 short int size
; /* 1, 2, or 4 usually. */
199 expressionS
*exp
; /* Expression. */
200 int pcrel
; /* TRUE if PC-relative relocation. */
202 bfd_reloc_code_real_type r_type
; /* Relocation type */
204 int r_type
; /* Relocation type */
217 sub
= exp
->X_add_symbol
;
218 off
= exp
->X_add_number
;
222 sub
= exp
->X_op_symbol
;
225 add
= exp
->X_add_symbol
;
228 off
= exp
->X_add_number
;
232 as_bad ("expression too complex for fixup");
235 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
239 /* Append a string onto another string, bumping the pointer along. */
241 append (charPP
, fromP
, length
)
244 unsigned long length
;
246 /* Don't trust memcpy() of 0 chars. */
250 memcpy (*charPP
, fromP
, length
);
254 #ifndef BFD_ASSEMBLER
255 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
259 * This routine records the largest alignment seen for each segment.
260 * If the beginning of the segment is aligned on the worst-case
261 * boundary, all of the other alignments within it will work. At
262 * least one object format really uses this info.
265 record_alignment (seg
, align
)
266 /* Segment to which alignment pertains */
268 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
273 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
274 bfd_set_section_alignment (stdoutput
, seg
, align
);
276 if (align
> section_alignment
[(int) seg
])
277 section_alignment
[(int) seg
] = align
;
281 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
284 chain_frchains_together_1 (section
, frchp
)
286 struct frchain
*frchp
;
288 fragS dummy
, *prev_frag
= &dummy
;
289 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
291 prev_frag
->fr_next
= frchp
->frch_root
;
292 prev_frag
= frchp
->frch_last
;
294 prev_frag
->fr_next
= 0;
303 chain_frchains_together (abfd
, section
, xxx
)
304 bfd
*abfd
; /* unused */
306 PTR xxx
; /* unused */
308 segment_info_type
*info
;
310 /* BFD may have introduced its own sections without using
311 subseg_new, so it is possible that seg_info is NULL. */
312 info
= seg_info (section
);
313 if (info
!= (segment_info_type
*) NULL
)
314 info
->frchainP
->frch_last
315 = chain_frchains_together_1 (section
, info
->frchainP
);
320 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
323 remove_subsegs (head
, seg
, root
, last
)
329 *root
= head
->frch_root
;
330 *last
= chain_frchains_together_1 (seg
, head
);
335 #if defined (BFD_ASSEMBLER) || !defined (BFD)
339 cvt_frag_to_fill (sec
, fragP
)
344 cvt_frag_to_fill (headers
, fragP
)
345 object_headers
*headers
;
349 switch (fragP
->fr_type
)
354 HANDLE_ALIGN (fragP
);
356 fragP
->fr_type
= rs_fill
;
357 know (fragP
->fr_var
== 1);
358 know (fragP
->fr_next
!= NULL
);
360 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
368 case rs_machine_dependent
:
370 md_convert_frag (stdoutput
, sec
, fragP
);
372 md_convert_frag (headers
, fragP
);
375 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
378 * After md_convert_frag, we make the frag into a ".space 0".
379 * Md_convert_frag() should set up any fixSs and constants
385 #ifndef WORKING_DOT_WORD
388 struct broken_word
*lie
;
390 if (fragP
->fr_subtype
)
392 fragP
->fr_fix
+= md_short_jump_size
;
393 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
394 lie
&& lie
->dispfrag
== fragP
;
395 lie
= lie
->next_broken_word
)
397 fragP
->fr_fix
+= md_long_jump_size
;
405 BAD_CASE (fragP
->fr_type
);
410 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
414 relax_and_size_seg (abfd
, sec
, xxx
)
421 segment_info_type
*seginfo
;
423 valueT size
, newsize
;
425 flags
= bfd_get_section_flags (abfd
, sec
);
427 seginfo
= (segment_info_type
*) bfd_get_section_userdata (abfd
, sec
);
428 if (seginfo
&& seginfo
->frchainP
)
430 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
431 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
432 cvt_frag_to_fill (sec
, fragp
);
433 for (fragp
= seginfo
->frchainP
->frch_root
;
435 fragp
= fragp
->fr_next
)
436 /* walk to last elt */;
437 size
= fragp
->fr_address
+ fragp
->fr_fix
;
442 if (size
> 0 && ! seginfo
->bss
)
443 flags
|= SEC_HAS_CONTENTS
;
445 /* @@ This is just an approximation. */
446 if (seginfo
&& seginfo
->fix_root
)
450 x
= bfd_set_section_flags (abfd
, sec
, flags
);
453 newsize
= md_section_align (sec
, size
);
454 x
= bfd_set_section_size (abfd
, sec
, newsize
);
457 /* If the size had to be rounded up, add some padding in the last
459 assert (newsize
>= size
);
462 fragS
*last
= seginfo
->frchainP
->frch_last
;
463 fragp
= seginfo
->frchainP
->frch_root
;
464 while (fragp
->fr_next
!= last
)
465 fragp
= fragp
->fr_next
;
466 last
->fr_address
= size
;
467 fragp
->fr_offset
+= newsize
- size
;
470 #ifdef tc_frob_section
471 tc_frob_section (sec
);
473 #ifdef obj_frob_section
474 obj_frob_section (sec
);
480 dump_section_relocs (abfd
, sec
, stream_
)
485 FILE *stream
= (FILE *) stream_
;
486 segment_info_type
*seginfo
= seg_info (sec
);
487 fixS
*fixp
= seginfo
->fix_root
;
492 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
495 symbolS
*s
= fixp
->fx_addsy
;
497 fprintf (stream
, " %08x: %s(%s+%x)+%x\n", fixp
,
498 S_GET_NAME (s
), s
->bsym
->section
->name
,
499 S_GET_VALUE (s
), fixp
->fx_offset
);
501 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
502 fixp
= fixp
->fx_next
;
506 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
510 adjust_reloc_syms (abfd
, sec
, xxx
)
515 segment_info_type
*seginfo
= seg_info (sec
);
521 dump_section_relocs (abfd
, sec
, stderr
);
523 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
526 symbolS
*sym
= fixp
->fx_addsy
;
527 asection
*symsec
= sym
->bsym
->section
;
528 segment_info_type
*symseginfo
= seg_info (symsec
);
530 /* If it's one of these sections, assume the symbol is
531 definitely going to be output. The code in
532 md_estimate_size_before_relax in tc-mips.c uses this test
533 as well, so if you change this code you should look at that
535 if (symsec
== &bfd_und_section
536 || symsec
== &bfd_abs_section
537 || bfd_is_com_section (symsec
))
539 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
543 /* Since we're reducing to section symbols, don't attempt to reduce
544 anything that's already using one. */
545 if (sym
->bsym
== symsec
->symbol
)
547 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
551 /* Is there some other reason we can't adjust this one? (E.g.,
552 call/bal links in i960-bout symbols.) */
553 #ifdef obj_fix_adjustable
554 if (! obj_fix_adjustable (fixp
))
556 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
561 /* Is there some other (target cpu dependent) reason we can't adjust
562 this one? (E.g. relocations involving function addresses on
564 #ifdef tc_fix_adjustable
565 if (! tc_fix_adjustable (fixp
))
567 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
572 /* If the section symbol isn't going to be output, the relocs
573 at least should still work. If not, figure out what to do
574 when we run into that case. */
575 fixp
->fx_offset
+= S_GET_VALUE (sym
);
577 fixp
->fx_offset
+= sym
->sy_frag
->fr_address
;
578 fixp
->fx_addsy
= section_symbol (symsec
);
579 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
581 #ifdef RELOC_REQUIRES_SYMBOL
584 /* There was no symbol required by this relocation. However,
585 BFD doesn't really handle relocations without symbols well.
586 (At least, the COFF support doesn't.) So for now we fake up
587 a local symbol in the absolute section. */
588 static symbolS
*abs_sym
;
591 abs_sym
= symbol_new ("*absolute0zero*", &bfd_abs_section
, 0,
593 abs_sym
->sy_used_in_reloc
= 1;
595 fixp
->fx_addsy
= abs_sym
;
599 dump_section_relocs (abfd
, sec
, stderr
);
603 write_relocs (abfd
, sec
, xxx
)
608 segment_info_type
*seginfo
= seg_info (sec
);
614 /* If seginfo is NULL, we did not create this section; don't do
619 fixup_segment (seginfo
->fix_root
, sec
);
622 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
625 #ifndef RELOC_EXPANSION_POSSIBLE
626 /* Set up reloc information as well. */
627 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
628 n
* sizeof (arelent
*));
629 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
632 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
636 bfd_reloc_status_type s
;
638 if (fixp
->fx_addsy
== 0)
640 /* @@ Need some other flag to indicate which have already
645 reloc
= tc_gen_reloc (sec
, fixp
);
651 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
652 if (fixp
->fx_where
+ fixp
->fx_size
653 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
656 if (reloc
->howto
->partial_inplace
== false
657 && reloc
->howto
->pcrel_offset
== true
658 && reloc
->howto
->pc_relative
== true)
660 /* bfd_perform_relocation screws this up */
661 reloc
->addend
+= reloc
->address
;
663 /* Pass bogus address so that when bfd_perform_relocation adds
664 `reloc->address' back in, it'll come up with `data', which is where
665 we want it to operate. We can't just do it by fudging reloc->address,
666 since that might be used in the calculations(?). */
667 s
= bfd_perform_relocation (stdoutput
, reloc
, data
- reloc
->address
,
674 as_fatal ("bad return from bfd_perform_relocation");
679 n
= n
* MAX_RELOC_EXPANSION
;
680 /* Set up reloc information as well. */
681 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
682 n
* sizeof (arelent
*));
685 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
689 bfd_reloc_status_type s
;
692 if (fixp
->fx_addsy
== 0)
694 /* @@ Need some other flag to indicate which have already
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
,
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
));
738 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
739 for (i
= 0; i
< n
; i
++)
743 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
744 i
, r
, r
->address
, s
->name
, r
->addend
);
751 write_contents (abfd
, sec
, xxx
)
756 segment_info_type
*seginfo
= seg_info (sec
);
757 unsigned long offset
= 0;
760 /* Write out the frags. */
762 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
765 for (f
= seginfo
->frchainP
->frch_root
;
770 unsigned long fill_size
;
774 assert (f
->fr_type
== rs_fill
);
777 x
= bfd_set_section_contents (stdoutput
, sec
,
778 f
->fr_literal
, (file_ptr
) offset
,
779 (bfd_size_type
) f
->fr_fix
);
783 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
784 fill_size
= f
->fr_var
;
785 count
= f
->fr_offset
;
787 if (fill_size
&& count
)
790 x
= bfd_set_section_contents (stdoutput
, sec
,
791 fill_literal
, (file_ptr
) offset
,
792 (bfd_size_type
) fill_size
);
800 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
802 merge_data_into_text ()
804 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
805 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
806 seg_info (data_section
)->frchainP
->frch_root
;
807 seg_info (text_section
)->frchainP
->frch_last
=
808 seg_info (data_section
)->frchainP
->frch_last
;
809 seg_info (data_section
)->frchainP
= 0;
813 text_last_frag
->fr_next
= data_frag_root
;
814 text_last_frag
= data_last_frag
;
815 data_last_frag
= NULL
;
816 data_frag_root
= NULL
;
819 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
820 tmp
->fx_next
= data_fix_root
;
821 text_fix_tail
= data_fix_tail
;
824 text_fix_root
= data_fix_root
;
825 data_fix_root
= NULL
;
828 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
830 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
832 relax_and_size_all_segments ()
836 relax_segment (text_frag_root
, SEG_TEXT
);
837 relax_segment (data_frag_root
, SEG_DATA
);
838 relax_segment (bss_frag_root
, SEG_BSS
);
840 * Now the addresses of frags are correct within the segment.
843 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
844 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
845 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
848 * Join the 2 segments into 1 huge segment.
849 * To do this, re-compute every rn_address in the SEG_DATA frags.
850 * Then join the data frags after the text frags.
852 * Determine a_data [length of data segment].
856 register relax_addressT slide
;
858 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
860 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
861 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
862 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
864 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
865 /* For b.out: If the data section has a strict alignment
866 requirement, its load address in the .o file will be
867 rounded up from the size of the text section. These
868 two values are *not* the same! Similarly for the bss
870 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
873 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
875 fragP
->fr_address
+= slide
;
876 } /* for each data frag */
878 know (text_last_frag
!= 0);
879 text_last_frag
->fr_next
= data_frag_root
;
883 H_SET_DATA_SIZE (&headers
, 0);
887 /* See above comments on b.out data section address. */
890 if (data_last_frag
== 0)
891 bss_vma
= H_GET_TEXT_SIZE (&headers
);
893 bss_vma
= data_last_frag
->fr_address
;
894 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
895 bss_address_frag
.fr_address
= bss_vma
;
897 #else /* ! OBJ_BOUT */
898 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
899 H_GET_DATA_SIZE (&headers
));
901 #endif /* ! OBJ_BOUT */
903 /* Slide all the frags */
906 relax_addressT slide
= bss_address_frag
.fr_address
;
908 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
910 fragP
->fr_address
+= slide
;
911 } /* for each bss frag */
915 H_SET_BSS_SIZE (&headers
,
916 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
918 H_SET_BSS_SIZE (&headers
, 0);
920 #endif /* ! BFD_ASSEMBLER && ! BFD */
922 #if defined (BFD_ASSEMBLER) || !defined (BFD)
927 register struct frchain
*frchainP
; /* Track along all frchains. */
928 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
929 register fragS
*fragP
; /* Track along all frags. */
931 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
932 long object_file_size
;
935 /* Do we really want to write it? */
938 n_warns
= had_warnings ();
939 n_errs
= had_errors ();
940 /* The -Z flag indicates that an object file should be generated,
941 regardless of warnings and errors. */
944 if (n_warns
|| n_errs
)
945 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
946 n_errs
, n_errs
== 1 ? "" : "s",
947 n_warns
, n_warns
== 1 ? "" : "s");
952 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
953 n_errs
, n_errs
== 1 ? "" : "s",
954 n_warns
, n_warns
== 1 ? "" : "s");
960 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
961 * call a routine to check for the definition of the procedure
962 * "_main", and if so -- fix it up so that it can be program
965 VMS_Check_For_Main ();
968 /* After every sub-segment, we fake an ".align ...". This conforms to
969 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
970 frag that requires least thought. ".align" frags like to have a
971 following frag since that makes calculating their intended length
974 @@ Is this really necessary?? */
975 #ifndef SUB_SEGMENT_ALIGN
977 #define SUB_SEGMENT_ALIGN(SEG) (0)
979 #define SUB_SEGMENT_ALIGN(SEG) (2)
982 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
984 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
985 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
986 /* frag_align will have left a new frag.
987 Use this last frag for an empty ".fill".
990 Create a last frag. Do not leave a "being filled in frag". */
991 frag_wane (frag_now
);
992 frag_now
->fr_fix
= 0;
993 know (frag_now
->fr_next
== NULL
);
996 /* From now on, we don't care about sub-segments. Build one frag chain
997 for each segment. Linked thru fr_next. */
1000 /* Remove the sections created by gas for its own purposes. */
1002 asection
**seclist
, *sec
;
1003 seclist
= &stdoutput
->sections
;
1004 while (seclist
&& *seclist
)
1007 while (sec
== reg_section
|| sec
== expr_section
)
1011 stdoutput
->section_count
--;
1016 seclist
= &(*seclist
)->next
;
1020 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1022 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1023 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1024 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1027 /* We have two segments. If user gave -R flag, then we must put the
1028 data frags into the text segment. Do this before relaxing so
1029 we know to take advantage of -R and make shorter addresses. */
1030 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1033 merge_data_into_text ();
1037 #ifdef BFD_ASSEMBLER
1038 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1040 relax_and_size_all_segments ();
1041 #endif /* BFD_ASSEMBLER */
1043 #ifndef BFD_ASSEMBLER
1046 * Crawl the symbol chain.
1048 * For each symbol whose value depends on a frag, take the address of
1049 * that frag and subsume it into the value of the symbol.
1050 * After this, there is just one way to lookup a symbol value.
1051 * Values are left in their final state for object file emission.
1052 * We adjust the values of 'L' local symbols, even if we do
1053 * not intend to emit them to the object file, because their values
1054 * are needed for fix-ups.
1056 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1057 * from the symbol chain. (They are still pointed to by the fixes.)
1059 * Count the remaining symbols.
1060 * Assign a symbol number to each symbol.
1061 * Count the number of string-table chars we will emit.
1062 * Put this info into the headers as appropriate.
1065 know (zero_address_frag
.fr_address
== 0);
1066 string_byte_count
= sizeof (string_byte_count
);
1068 obj_crawl_symbol_chain (&headers
);
1070 if (string_byte_count
== sizeof (string_byte_count
))
1071 string_byte_count
= 0;
1073 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1076 * Addresses of frags now reflect addresses we use in the object file.
1077 * Symbol values are correct.
1078 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1079 * Also converting any machine-dependent frags using md_convert_frag();
1081 subseg_change (SEG_TEXT
, 0);
1083 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1085 cvt_frag_to_fill (&headers
, fragP
);
1087 /* Some assert macros don't work with # directives mixed in. */
1089 if (!(fragP
->fr_next
== NULL
1091 || fragP
->fr_next
== data_frag_root
1093 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1094 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1098 #endif /* ! BFD_ASSEMBLER */
1100 #ifndef WORKING_DOT_WORD
1102 struct broken_word
*lie
;
1103 struct broken_word
**prevP
;
1105 prevP
= &broken_words
;
1106 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1111 exp
.X_op
= O_subtract
;
1112 exp
.X_add_symbol
= lie
->add
;
1113 exp
.X_op_symbol
= lie
->sub
;
1114 exp
.X_add_number
= lie
->addnum
;
1115 #ifdef BFD_ASSEMBLER
1116 fix_new_exp (lie
->frag
,
1117 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1118 2, &exp
, 0, BFD_RELOC_NONE
);
1120 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1121 fix_new_exp (lie
->frag
,
1122 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1123 2, &exp
, 0, NO_RELOC
);
1126 fix_new_ns32k_exp (lie
->frag
,
1127 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1128 2, &exp
, 0, 0, 2, 0, 0);
1130 fix_new_exp (lie
->frag
,
1131 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1133 #endif /* TC_NS32K */
1134 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1135 #endif /* BFD_ASSEMBLER */
1136 *prevP
= lie
->next_broken_word
;
1139 prevP
= &(lie
->next_broken_word
);
1141 for (lie
= broken_words
; lie
;)
1143 struct broken_word
*untruth
;
1145 addressT table_addr
;
1146 addressT from_addr
, to_addr
;
1149 fragP
= lie
->dispfrag
;
1151 /* Find out how many broken_words go here. */
1153 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1154 if (untruth
->added
== 1)
1157 table_ptr
= lie
->dispfrag
->fr_opcode
;
1158 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1159 /* Create the jump around the long jumps. This is a short
1160 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1161 from_addr
= table_addr
;
1162 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1163 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1164 table_ptr
+= md_short_jump_size
;
1165 table_addr
+= md_short_jump_size
;
1167 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1169 if (lie
->added
== 2)
1171 /* Patch the jump table */
1172 /* This is the offset from ??? to table_ptr+0 */
1173 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1174 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1175 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1177 if (untruth
->use_jump
== lie
)
1178 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1181 /* Install the long jump */
1182 /* this is a long jump from table_ptr+0 to the final target */
1183 from_addr
= table_addr
;
1184 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1185 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1186 table_ptr
+= md_long_jump_size
;
1187 table_addr
+= md_long_jump_size
;
1191 #endif /* not WORKING_DOT_WORD */
1193 #ifndef BFD_ASSEMBLER
1197 * Scan every FixS performing fixups. We had to wait until now to do
1198 * this because md_convert_frag() may have made some fixSs.
1202 subseg_change (SEG_TEXT
, 0);
1203 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1204 subseg_change (SEG_DATA
, 0);
1205 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1206 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1208 /* FIXME move this stuff into the pre-write-hook */
1209 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1210 H_SET_ENTRY_POINT (&headers
, 0);
1212 obj_pre_write_hook (&headers
); /* extra coff stuff */
1214 object_file_size
= H_GET_FILE_SIZE (&headers
);
1215 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1217 output_file_create (out_file_name
);
1219 obj_header_append (&next_object_file_charP
, &headers
);
1221 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1226 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1228 register long count
;
1229 register char *fill_literal
;
1230 register long fill_size
;
1232 know (fragP
->fr_type
== rs_fill
);
1233 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1234 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1235 fill_size
= fragP
->fr_var
;
1236 know (fragP
->fr_offset
>= 0);
1238 for (count
= fragP
->fr_offset
; count
; count
--)
1240 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1243 } /* for each code frag. */
1245 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1250 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1251 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
)));
1253 /* Make addresses in data relocation directives relative to beginning of
1254 * first data fragment, not end of last text fragment: alignment of the
1255 * start of the data segment may place a gap between the segments.
1257 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1259 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1260 #endif /* TC_I960 */
1262 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
) + H_GET_DATA_RELOCATION_SIZE (&headers
)));
1265 * Emit line number entries.
1267 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1268 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
) + H_GET_TEXT_RELOCATION_SIZE (&headers
) + H_GET_DATA_RELOCATION_SIZE (&headers
) + H_GET_LINENO_SIZE (&headers
)));
1273 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1274 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
)));
1280 if (string_byte_count
> 0)
1282 obj_emit_strings (&next_object_file_charP
);
1283 } /* only if we have a string table */
1286 bfd_seek (stdoutput
, 0, 0);
1287 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1290 /* Write the data to the file */
1291 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1293 } /* non vms output */
1296 * Now do the VMS-dependent part of writing the object file
1298 VMS_write_object_file (H_GET_TEXT_SIZE (&headers
),
1299 H_GET_DATA_SIZE (&headers
),
1300 H_GET_BSS_SIZE (&headers
),
1301 text_frag_root
, data_frag_root
);
1303 #else /* BFD_ASSEMBLER */
1305 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1307 /* Set up symbol table, and write it out. */
1314 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1316 if (! symp
->sy_resolved
)
1318 if (symp
->sy_value
.X_op
== O_constant
)
1320 /* This is the normal case; skip the call. */
1323 + symp
->sy_frag
->fr_address
));
1324 symp
->sy_resolved
= 1;
1327 resolve_symbol_value (symp
);
1330 /* So far, common symbols have been treated like undefined symbols.
1331 Put them in the common section now. */
1332 if (S_IS_DEFINED (symp
) == 0
1333 && S_GET_VALUE (symp
) != 0)
1334 S_SET_SEGMENT (symp
, &bfd_com_section
);
1336 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1337 S_GET_NAME (symp
), symp
,
1340 segment_name (symp
->bsym
->section
));
1343 #ifdef obj_frob_symbol
1346 obj_frob_symbol (symp
, punt
);
1351 #ifdef tc_frob_symbol
1354 tc_frob_symbol (symp
, punt
);
1360 /* If we don't want to keep this symbol, splice it out of the
1362 if (S_IS_LOCAL (symp
))
1365 if (! symp
->sy_used_in_reloc
)
1367 symbolS
*prev
, *next
;
1368 prev
= symbol_previous (symp
);
1369 next
= symbol_next (symp
);
1371 verify_symbol_chain_2 (symp
);
1375 symbol_next (prev
) = next
;
1378 else if (symp
== symbol_rootP
)
1379 symbol_rootP
= next
;
1383 symbol_previous (next
) = prev
;
1385 symbol_lastP
= prev
;
1388 verify_symbol_chain_2 (prev
);
1390 verify_symbol_chain_2 (next
);
1396 /* Make sure we really got a value for the symbol. */
1397 if (! symp
->sy_resolved
)
1399 as_bad ("can't resolve value for symbol \"%s\"",
1401 symp
->sy_resolved
= 1;
1404 /* Set the value into the BFD symbol. Up til now the value
1405 has only been kept in the gas symbolS struct. */
1406 symp
->bsym
->value
= S_GET_VALUE (symp
);
1415 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1417 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1418 n
* sizeof (asymbol
*));
1419 symp
= symbol_rootP
;
1420 for (i
= 0; i
< n
; i
++, symp
= symbol_next (symp
))
1422 asympp
[i
] = symp
->bsym
;
1425 result
= bfd_set_symtab (stdoutput
, asympp
, n
);
1426 assert (result
== true);
1431 #ifdef obj_frob_file
1432 /* If obj_frob_file changes the symbol value at this point, it is
1433 responsible for moving the changed value into symp->bsym->value
1434 as well. Hopefully all symbol value changing can be done in
1435 {obj,tc}_frob_symbol. */
1439 /* Now that all the sizes are known, and contents correct, we can
1440 start writing the file. */
1441 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1443 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1444 #endif /* BFD_ASSEMBLER */
1451 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1456 * After this, all frags in this segment have addresses that are correct
1457 * within the segment. Since segments live in different file addresses,
1458 * these frag addresses may not be the same as final object-file addresses.
1461 #ifndef md_relax_frag
1463 /* Subroutines of relax_segment. */
1469 for (; f1
; f1
= f1
->fr_next
)
1470 if (f1
->fr_next
== f2
)
1475 #endif /* ! defined (md_relax_frag) */
1477 /* Relax_align. Advance location counter to next address that has 'alignment'
1478 lowest order bits all 0s, return size of adjustment made. */
1479 static relax_addressT
1480 relax_align (address
, alignment
)
1481 register relax_addressT address
; /* Address now. */
1482 register int alignment
; /* Alignment (binary). */
1484 relax_addressT mask
;
1485 relax_addressT new_address
;
1487 mask
= ~((~0) << alignment
);
1488 new_address
= (address
+ mask
) & (~mask
);
1490 /* We must provide lots of padding, so the linker can discard it
1491 when needed. The linker will not add extra space, ever. */
1492 new_address
+= (1 << alignment
);
1493 return (new_address
- address
);
1497 relax_segment (segment_frag_root
, segment
)
1498 struct frag
*segment_frag_root
;
1501 register struct frag
*fragP
;
1502 register relax_addressT address
;
1503 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1504 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1506 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1507 subseg_change (segment
, 0);
1509 /* For each frag in segment: count and store (a 1st guess of)
1512 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1514 fragP
->fr_address
= address
;
1515 address
+= fragP
->fr_fix
;
1517 switch (fragP
->fr_type
)
1520 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1524 address
+= relax_align (address
, (int) fragP
->fr_offset
);
1528 /* Assume .org is nugatory. It will grow with 1st relax. */
1531 case rs_machine_dependent
:
1532 address
+= md_estimate_size_before_relax (fragP
, segment
);
1535 #ifndef WORKING_DOT_WORD
1536 /* Broken words don't concern us yet */
1537 case rs_broken_word
:
1542 BAD_CASE (fragP
->fr_type
);
1544 } /* switch(fr_type) */
1545 } /* for each frag in the segment */
1549 long stretch
; /* May be any size, 0 or negative. */
1550 /* Cumulative number of addresses we have */
1551 /* relaxed this pass. */
1552 /* We may have relaxed more than one address. */
1553 long stretched
; /* Have we stretched on this pass? */
1554 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1555 grew, and another shrank. If a branch instruction doesn't fit anymore,
1556 we could be scrod. */
1560 stretch
= stretched
= 0;
1561 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1564 unsigned long was_address
;
1570 was_address
= fragP
->fr_address
;
1571 address
= fragP
->fr_address
+= stretch
;
1572 symbolP
= fragP
->fr_symbol
;
1573 offset
= fragP
->fr_offset
;
1575 switch (fragP
->fr_type
)
1577 case rs_fill
: /* .fill never relaxes. */
1581 #ifndef WORKING_DOT_WORD
1582 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1583 for it I do not want to write it. I do not want to have
1584 anything to do with it. This is not the proper way to
1585 implement this misfeature. */
1586 case rs_broken_word
:
1588 struct broken_word
*lie
;
1589 struct broken_word
*untruth
;
1591 /* Yes this is ugly (storing the broken_word pointer
1592 in the symbol slot). Still, this whole chunk of
1593 code is ugly, and I don't feel like doing anything
1594 about it. Think of it as stubbornness in action. */
1596 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1597 lie
&& lie
->dispfrag
== fragP
;
1598 lie
= lie
->next_broken_word
)
1604 offset
= (lie
->add
->sy_frag
->fr_address
1605 + S_GET_VALUE (lie
->add
)
1607 - (lie
->sub
->sy_frag
->fr_address
1608 + S_GET_VALUE (lie
->sub
)));
1609 if (offset
<= -32768 || offset
>= 32767)
1614 sprint_value (buf
, (addressT
) lie
->addnum
);
1615 as_warn (".word %s-%s+%s didn't fit",
1616 S_GET_NAME (lie
->add
),
1617 S_GET_NAME (lie
->sub
),
1621 if (fragP
->fr_subtype
== 0)
1623 fragP
->fr_subtype
++;
1624 growth
+= md_short_jump_size
;
1626 for (untruth
= lie
->next_broken_word
;
1627 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1628 untruth
= untruth
->next_broken_word
)
1629 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1630 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1633 untruth
->use_jump
= lie
;
1635 growth
+= md_long_jump_size
;
1640 } /* case rs_broken_word */
1643 growth
= (relax_align ((relax_addressT
) (address
1646 - relax_align ((relax_addressT
) (was_address
1656 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1657 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1658 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1659 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1660 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1661 know (symbolP
->sy_frag
);
1662 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1663 || (symbolP
->sy_frag
== &zero_address_frag
));
1665 target
+= S_GET_VALUE (symbolP
)
1666 + symbolP
->sy_frag
->fr_address
;
1667 } /* if we have a symbol */
1669 know (fragP
->fr_next
);
1670 after
= fragP
->fr_next
->fr_address
;
1671 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1672 /* Growth may be negative, but variable part of frag
1673 cannot have fewer than 0 chars. That is, we can't
1676 growth
-= stretch
; /* This is an absolute growth factor */
1679 case rs_machine_dependent
:
1680 #ifdef md_relax_frag
1681 growth
= md_relax_frag (fragP
, stretch
);
1683 /* The default way to relax a frag is to look through
1686 const relax_typeS
*this_type
;
1687 const relax_typeS
*start_type
;
1688 relax_substateT next_state
;
1689 relax_substateT this_state
;
1692 this_state
= fragP
->fr_subtype
;
1693 start_type
= this_type
= md_relax_table
+ this_state
;
1698 #ifndef DIFF_EXPR_OK
1699 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1700 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1701 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1702 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1703 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1705 know (symbolP
->sy_frag
);
1707 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1708 || symbolP
->sy_frag
== &zero_address_frag
);
1710 S_GET_VALUE (symbolP
)
1711 + symbolP
->sy_frag
->fr_address
;
1713 /* If frag has yet to be reached on this pass,
1714 assume it will move by STRETCH just as we did.
1715 If this is not so, it will be because some frag
1716 between grows, and that will force another pass.
1718 Beware zero-length frags.
1720 There should be a faster way to do this. */
1722 if (symbolP
->sy_frag
->fr_address
>= was_address
1723 && is_dnrange (fragP
, symbolP
->sy_frag
))
1729 aim
= target
- address
- fragP
->fr_fix
;
1730 /* The displacement is affected by the instruction size
1731 for the 32k architecture. I think we ought to be able
1732 to add fragP->fr_pcrel_adjust in all cases (it should be
1733 zero if not used), but just in case it breaks something
1734 else we'll put this inside #ifdef NS32K ... #endif */
1736 if (fragP
->fr_pcrel_adjust
)
1739 aim
+= fragP
->fr_pcrel_adjust
;
1743 /* Look backwards. */
1744 for (next_state
= this_type
->rlx_more
; next_state
;)
1745 if (aim
>= this_type
->rlx_backward
)
1749 /* Grow to next state. */
1750 this_state
= next_state
;
1751 this_type
= md_relax_table
+ this_state
;
1752 next_state
= this_type
->rlx_more
;
1757 #ifdef M68K_AIM_KLUDGE
1758 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
1760 /* Look forwards. */
1761 for (next_state
= this_type
->rlx_more
; next_state
;)
1762 if (aim
<= this_type
->rlx_forward
)
1766 /* Grow to next state. */
1767 this_state
= next_state
;
1768 this_type
= md_relax_table
+ this_state
;
1769 next_state
= this_type
->rlx_more
;
1773 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1775 fragP
->fr_subtype
= this_state
;
1781 BAD_CASE (fragP
->fr_type
);
1789 } /* For each frag in the segment. */
1791 while (stretched
); /* Until nothing further to relax. */
1795 * We now have valid fr_address'es for each frag.
1799 * All fr_address's are correct, relative to their own segment.
1800 * We have made all the fixS we will ever make.
1802 } /* relax_segment() */
1804 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1808 Go through all the fixS's in a segment and see which ones can be
1809 handled now. (These consist of fixS where we have since discovered
1810 the value of a symbol, or the address of the frag involved.)
1811 For each one, call md_apply_fix to put the fix into the frag data.
1813 Result is a count of how many relocation structs will be needed to
1814 handle the remaining fixS's that we couldn't completely handle here.
1815 These will be output later by emit_relocations(). */
1818 fixup_segment (fixP
, this_segment_type
)
1819 register fixS
*fixP
;
1820 segT this_segment_type
; /* N_TYPE bits for segment. */
1822 long seg_reloc_count
= 0;
1823 symbolS
*add_symbolP
;
1824 symbolS
*sub_symbolP
;
1831 segT add_symbol_segment
= absolute_section
;
1833 /* If the linker is doing the relaxing, we must not do any fixups.
1835 Well, strictly speaking that's not true -- we could do any that are
1836 PC-relative and don't cross regions that could change size. And for the
1837 i960 (the only machine for which we've got a relaxing linker right now),
1838 we might be able to turn callx/callj into bal anyways in cases where we
1839 know the maximum displacement. */
1842 for (; fixP
; fixP
= fixP
->fx_next
)
1844 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
1845 return seg_reloc_count
;
1848 for (; fixP
; fixP
= fixP
->fx_next
)
1850 fragP
= fixP
->fx_frag
;
1852 where
= fixP
->fx_where
;
1853 place
= fragP
->fr_literal
+ where
;
1854 size
= fixP
->fx_size
;
1855 add_symbolP
= fixP
->fx_addsy
;
1856 #ifdef TC_VALIDATE_FIX
1857 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
1859 sub_symbolP
= fixP
->fx_subsy
;
1860 add_number
= fixP
->fx_offset
;
1861 pcrel
= fixP
->fx_pcrel
;
1864 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
1871 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
1872 add_number
-= S_GET_VALUE (sub_symbolP
);
1874 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
1876 /* Should try converting to a constant. */
1881 as_bad ("Negative of non-absolute symbol %s",
1882 S_GET_NAME (sub_symbolP
));
1884 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
1885 && (SEG_NORMAL (add_symbol_segment
)
1886 || (add_symbol_segment
== absolute_section
)))
1888 /* Difference of 2 symbols from same segment.
1889 Can't make difference of 2 undefineds: 'value' means
1890 something different for N_UNDF. */
1892 /* Makes no sense to use the difference of 2 arbitrary symbols
1893 as the target of a call instruction. */
1895 as_bad ("callj to difference of 2 symbols");
1896 #endif /* TC_I960 */
1897 add_number
+= S_GET_VALUE (add_symbolP
) -
1898 S_GET_VALUE (sub_symbolP
);
1902 /* Let the target machine make the final determination
1903 as to whether or not a relocation will be needed to
1904 handle this fixup. */
1905 if (!TC_FORCE_RELOCATION (fixP
))
1906 fixP
->fx_addsy
= NULL
;
1910 /* Different segments in subtraction. */
1911 know (!(S_IS_EXTERNAL (sub_symbolP
)
1912 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
1914 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
1915 add_number
-= S_GET_VALUE (sub_symbolP
);
1918 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
1919 #if 0 /* Do this even if it's already described as pc-relative. For example,
1920 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
1921 pc-relative mode. */
1926 /* Make it pc-relative. */
1927 add_number
+= (md_pcrel_from (fixP
)
1928 - S_GET_VALUE (sub_symbolP
));
1938 sprint_value (buf
, fragP
->fr_address
+ where
);
1939 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1940 segment_name (S_GET_SEGMENT (sub_symbolP
)),
1941 S_GET_NAME (sub_symbolP
), buf
);
1948 if (add_symbol_segment
== this_segment_type
&& pcrel
)
1951 * This fixup was made when the symbol's segment was
1952 * SEG_UNKNOWN, but it is now in the local segment.
1953 * So we know how to do the address without relocation.
1956 /* reloc_callj() may replace a 'call' with a 'calls' or a
1957 'bal', in which cases it modifies *fixP as appropriate.
1958 In the case of a 'calls', no further work is required,
1959 and *fixP has been set up to make the rest of the code
1962 #endif /* TC_I960 */
1964 add_number
+= S_GET_VALUE (add_symbolP
);
1965 add_number
-= md_pcrel_from (fixP
);
1966 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
1968 /* Let the target machine make the final determination
1969 as to whether or not a relocation will be needed to
1970 handle this fixup. */
1971 if (!TC_FORCE_RELOCATION (fixP
))
1972 fixP
->fx_addsy
= NULL
;
1976 if (add_symbol_segment
== absolute_section
)
1979 /* See comment about reloc_callj() above. */
1981 #endif /* TC_I960 */
1982 add_number
+= S_GET_VALUE (add_symbolP
);
1984 /* Let the target machine make the final determination
1985 as to whether or not a relocation will be needed to
1986 handle this fixup. */
1987 if (!TC_FORCE_RELOCATION (fixP
))
1989 fixP
->fx_addsy
= NULL
;
1993 else if (add_symbol_segment
== undefined_section
1994 #ifdef BFD_ASSEMBLER
1995 || bfd_is_com_section (add_symbol_segment
)
2000 if ((int) fixP
->fx_bit_fixP
== 13)
2002 /* This is a COBR instruction. They have only a
2003 * 13-bit displacement and are only to be used
2004 * for local branches: flag as error, don't generate
2007 as_bad ("can't use COBR format with external label");
2009 /* Let the target machine make the final determination
2010 as to whether or not a relocation will be needed to
2011 handle this fixup. */
2012 if (!TC_FORCE_RELOCATION (fixP
))
2013 fixP
->fx_addsy
= NULL
;
2016 #endif /* TC_I960 */
2020 if (S_IS_COMMON (add_symbolP
))
2021 add_number
+= S_GET_VALUE (add_symbolP
);
2022 #endif /* TE_I386AIX */
2023 #endif /* OBJ_COFF */
2029 add_number
+= S_GET_VALUE (add_symbolP
);
2036 add_number
-= md_pcrel_from (fixP
);
2037 if (add_symbolP
== 0)
2039 fixP
->fx_addsy
= &abs_symbol
;
2041 } /* if there's an add_symbol */
2044 if (!fixP
->fx_bit_fixP
&& size
> 0)
2047 /* set all bits to one */
2049 /* Technically speaking, combining these produces an
2050 undefined result if size is sizeof (valueT), though I
2051 think these two half-way operations should both be
2055 if ((add_number
& mask
) != 0
2056 && (add_number
& mask
) != mask
)
2058 char buf
[50], buf2
[50];
2059 sprint_value (buf
, fragP
->fr_address
+ where
);
2060 if (add_number
> 1000)
2061 sprint_value (buf2
, add_number
);
2063 sprintf (buf2
, "%ld", (long) add_number
);
2064 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2065 "Value of %s too large for field of %d bytes at %s",
2067 } /* generic error checking */
2068 #ifdef WARN_SIGNED_OVERFLOW_WORD
2069 /* Warn if a .word value is too large when treated as a signed
2070 number. We already know it is not too negative. This is to
2071 catch over-large switches generated by gcc on the 68k. */
2074 && add_number
> 0x7fff)
2075 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2076 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2078 (unsigned long) (fragP
->fr_address
+ where
));
2080 } /* not a bit fix */
2082 #ifdef BFD_ASSEMBLER
2083 md_apply_fix (fixP
, &add_number
);
2085 md_apply_fix (fixP
, add_number
);
2089 } /* For each fixS in this segment. */
2091 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2092 return seg_reloc_count
;
2095 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2098 number_to_chars_bigendian (buf
, val
, n
)
2103 if (n
> sizeof (val
)|| n
<= 0)
2107 buf
[n
] = val
& 0xff;
2113 number_to_chars_littleendian (buf
, val
, n
)
2118 if (n
> sizeof (val
) || n
<= 0)
2122 *buf
++ = val
& 0xff;
2127 /* end of write.c */