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
;
296 if (frchp
->fix_root
!= (fixS
*) NULL
)
298 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
299 seg_info (section
)->fix_root
= frchp
->fix_root
;
300 prev_fix
->fx_next
= frchp
->fix_root
;
301 prev_fix
= frchp
->fix_tail
;
304 prev_frag
->fr_next
= 0;
313 chain_frchains_together (abfd
, section
, xxx
)
314 bfd
*abfd
; /* unused */
316 PTR xxx
; /* unused */
318 segment_info_type
*info
;
320 /* BFD may have introduced its own sections without using
321 subseg_new, so it is possible that seg_info is NULL. */
322 info
= seg_info (section
);
323 if (info
!= (segment_info_type
*) NULL
)
324 info
->frchainP
->frch_last
325 = chain_frchains_together_1 (section
, info
->frchainP
);
330 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
333 remove_subsegs (head
, seg
, root
, last
)
339 *root
= head
->frch_root
;
340 *last
= chain_frchains_together_1 (seg
, head
);
345 #if defined (BFD_ASSEMBLER) || !defined (BFD)
349 cvt_frag_to_fill (sec
, fragP
)
354 cvt_frag_to_fill (headers
, fragP
)
355 object_headers
*headers
;
359 switch (fragP
->fr_type
)
364 HANDLE_ALIGN (fragP
);
366 fragP
->fr_type
= rs_fill
;
367 know (fragP
->fr_next
!= NULL
);
368 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
370 - fragP
->fr_fix
) / fragP
->fr_var
;
376 case rs_machine_dependent
:
378 md_convert_frag (stdoutput
, sec
, fragP
);
380 md_convert_frag (headers
, fragP
);
383 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
386 * After md_convert_frag, we make the frag into a ".space 0".
387 * Md_convert_frag() should set up any fixSs and constants
393 #ifndef WORKING_DOT_WORD
396 struct broken_word
*lie
;
398 if (fragP
->fr_subtype
)
400 fragP
->fr_fix
+= md_short_jump_size
;
401 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
402 lie
&& lie
->dispfrag
== fragP
;
403 lie
= lie
->next_broken_word
)
405 fragP
->fr_fix
+= md_long_jump_size
;
413 BAD_CASE (fragP
->fr_type
);
418 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
422 relax_and_size_seg (abfd
, sec
, xxx
)
429 segment_info_type
*seginfo
;
431 valueT size
, newsize
;
433 flags
= bfd_get_section_flags (abfd
, sec
);
435 seginfo
= (segment_info_type
*) bfd_get_section_userdata (abfd
, sec
);
436 if (seginfo
&& seginfo
->frchainP
)
438 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
439 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
440 cvt_frag_to_fill (sec
, fragp
);
441 for (fragp
= seginfo
->frchainP
->frch_root
;
443 fragp
= fragp
->fr_next
)
444 /* walk to last elt */;
445 size
= fragp
->fr_address
+ fragp
->fr_fix
;
450 if (size
> 0 && ! seginfo
->bss
)
451 flags
|= SEC_HAS_CONTENTS
;
453 /* @@ This is just an approximation. */
454 if (seginfo
&& seginfo
->fix_root
)
458 x
= bfd_set_section_flags (abfd
, sec
, flags
);
461 newsize
= md_section_align (sec
, size
);
462 x
= bfd_set_section_size (abfd
, sec
, newsize
);
465 /* If the size had to be rounded up, add some padding in the last
467 assert (newsize
>= size
);
470 fragS
*last
= seginfo
->frchainP
->frch_last
;
471 fragp
= seginfo
->frchainP
->frch_root
;
472 while (fragp
->fr_next
!= last
)
473 fragp
= fragp
->fr_next
;
474 last
->fr_address
= size
;
475 fragp
->fr_offset
+= newsize
- size
;
478 #ifdef tc_frob_section
479 tc_frob_section (sec
);
481 #ifdef obj_frob_section
482 obj_frob_section (sec
);
488 dump_section_relocs (abfd
, sec
, stream_
)
493 FILE *stream
= (FILE *) stream_
;
494 segment_info_type
*seginfo
= seg_info (sec
);
495 fixS
*fixp
= seginfo
->fix_root
;
500 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
503 symbolS
*s
= fixp
->fx_addsy
;
505 fprintf (stream
, " %08x: %s(%s+%x)+%x\n", fixp
,
506 S_GET_NAME (s
), s
->bsym
->section
->name
,
507 S_GET_VALUE (s
), fixp
->fx_offset
);
509 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
510 fixp
= fixp
->fx_next
;
514 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
517 #ifndef EMIT_SECTION_SYMBOLS
518 #define EMIT_SECTION_SYMBOLS 1
522 adjust_reloc_syms (abfd
, sec
, xxx
)
527 segment_info_type
*seginfo
= seg_info (sec
);
533 dump_section_relocs (abfd
, sec
, stderr
);
535 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
538 else if (fixp
->fx_addsy
)
540 symbolS
*sym
= fixp
->fx_addsy
;
541 asection
*symsec
= sym
->bsym
->section
;
543 /* If it's one of these sections, assume the symbol is
544 definitely going to be output. The code in
545 md_estimate_size_before_relax in tc-mips.c uses this test
546 as well, so if you change this code you should look at that
548 if (symsec
== &bfd_und_section
549 || symsec
== &bfd_abs_section
550 || bfd_is_com_section (symsec
))
552 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
556 /* Since we're reducing to section symbols, don't attempt to reduce
557 anything that's already using one. */
558 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
560 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
564 /* Is there some other reason we can't adjust this one? (E.g.,
565 call/bal links in i960-bout symbols.) */
566 #ifdef obj_fix_adjustable
567 if (! obj_fix_adjustable (fixp
))
569 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
574 /* Is there some other (target cpu dependent) reason we can't adjust
575 this one? (E.g. relocations involving function addresses on
577 #ifdef tc_fix_adjustable
578 if (! tc_fix_adjustable (fixp
))
580 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
585 /* If the section symbol isn't going to be output, the relocs
586 at least should still work. If not, figure out what to do
587 when we run into that case. */
588 fixp
->fx_offset
+= S_GET_VALUE (sym
);
590 fixp
->fx_offset
+= sym
->sy_frag
->fr_address
;
591 fixp
->fx_addsy
= section_symbol (symsec
);
592 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
594 #ifdef RELOC_REQUIRES_SYMBOL
597 /* There was no symbol required by this relocation. However,
598 BFD doesn't really handle relocations without symbols well.
599 (At least, the COFF support doesn't.) So for now we fake up
600 a local symbol in the absolute section. */
601 static symbolS
*abs_sym
;
604 abs_sym
= section_symbol (absolute_section
);
605 abs_sym
->sy_used_in_reloc
= 1;
607 fixp
->fx_addsy
= abs_sym
;
611 dump_section_relocs (abfd
, sec
, stderr
);
615 write_relocs (abfd
, sec
, xxx
)
620 segment_info_type
*seginfo
= seg_info (sec
);
627 /* If seginfo is NULL, we did not create this section; don't do
632 fixup_segment (seginfo
->fix_root
, sec
);
635 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
638 #ifndef RELOC_EXPANSION_POSSIBLE
639 /* Set up reloc information as well. */
640 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
641 n
* sizeof (arelent
*));
642 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
645 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
649 bfd_reloc_status_type s
;
656 reloc
= tc_gen_reloc (sec
, fixp
);
662 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
663 if (fixp
->fx_where
+ fixp
->fx_size
664 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
667 if (reloc
->howto
->partial_inplace
== false
668 && reloc
->howto
->pcrel_offset
== true
669 && reloc
->howto
->pc_relative
== true)
671 /* bfd_perform_relocation screws this up */
672 reloc
->addend
+= reloc
->address
;
674 /* Pass bogus address so that when bfd_perform_relocation adds
675 `reloc->address' back in, it'll come up with `data', which is where
676 we want it to operate. We can't just do it by fudging reloc->address,
677 since that might be used in the calculations(?). */
678 s
= bfd_perform_relocation (stdoutput
, reloc
, data
- reloc
->address
,
679 sec
, stdoutput
, &err
);
685 as_fatal ("bad return from bfd_perform_relocation");
690 n
= n
* MAX_RELOC_EXPANSION
;
691 /* Set up reloc information as well. */
692 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
693 n
* sizeof (arelent
*));
696 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
700 bfd_reloc_status_type s
;
708 reloc
= tc_gen_reloc (sec
, fixp
);
710 for (j
= 0; reloc
[j
]; j
++)
712 relocs
[i
++] = reloc
[j
];
715 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
716 if (fixp
->fx_where
+ fixp
->fx_size
717 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
719 for (j
= 0; reloc
[j
]; j
++)
721 s
= bfd_perform_relocation (stdoutput
, reloc
[j
],
722 data
- reloc
[0]->address
,
723 sec
, stdoutput
, &err
);
729 as_fatal ("bad return from bfd_perform_relocation");
737 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
739 bfd_set_section_flags (abfd
, sec
,
740 (bfd_get_section_flags (abfd
, sec
)
741 & (flagword
) ~SEC_RELOC
));
748 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
749 for (i
= 0; i
< n
; i
++)
753 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
754 i
, r
, r
->address
, s
->name
, r
->addend
);
761 write_contents (abfd
, sec
, xxx
)
766 segment_info_type
*seginfo
= seg_info (sec
);
767 unsigned long offset
= 0;
770 /* Write out the frags. */
772 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
775 for (f
= seginfo
->frchainP
->frch_root
;
780 unsigned long fill_size
;
784 assert (f
->fr_type
== rs_fill
);
787 x
= bfd_set_section_contents (stdoutput
, sec
,
788 f
->fr_literal
, (file_ptr
) offset
,
789 (bfd_size_type
) f
->fr_fix
);
793 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
794 fill_size
= f
->fr_var
;
795 count
= f
->fr_offset
;
797 if (fill_size
&& count
)
800 x
= bfd_set_section_contents (stdoutput
, sec
,
801 fill_literal
, (file_ptr
) offset
,
802 (bfd_size_type
) fill_size
);
810 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
812 merge_data_into_text ()
814 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
815 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
816 seg_info (data_section
)->frchainP
->frch_root
;
817 seg_info (text_section
)->frchainP
->frch_last
=
818 seg_info (data_section
)->frchainP
->frch_last
;
819 seg_info (data_section
)->frchainP
= 0;
823 text_last_frag
->fr_next
= data_frag_root
;
824 text_last_frag
= data_last_frag
;
825 data_last_frag
= NULL
;
826 data_frag_root
= NULL
;
829 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
830 tmp
->fx_next
= data_fix_root
;
831 text_fix_tail
= data_fix_tail
;
834 text_fix_root
= data_fix_root
;
835 data_fix_root
= NULL
;
838 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
840 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
842 relax_and_size_all_segments ()
846 relax_segment (text_frag_root
, SEG_TEXT
);
847 relax_segment (data_frag_root
, SEG_DATA
);
848 relax_segment (bss_frag_root
, SEG_BSS
);
850 * Now the addresses of frags are correct within the segment.
853 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
854 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
855 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
858 * Join the 2 segments into 1 huge segment.
859 * To do this, re-compute every rn_address in the SEG_DATA frags.
860 * Then join the data frags after the text frags.
862 * Determine a_data [length of data segment].
866 register relax_addressT slide
;
868 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
870 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
871 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
872 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
874 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
875 /* For b.out: If the data section has a strict alignment
876 requirement, its load address in the .o file will be
877 rounded up from the size of the text section. These
878 two values are *not* the same! Similarly for the bss
880 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
883 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
885 fragP
->fr_address
+= slide
;
886 } /* for each data frag */
888 know (text_last_frag
!= 0);
889 text_last_frag
->fr_next
= data_frag_root
;
893 H_SET_DATA_SIZE (&headers
, 0);
897 /* See above comments on b.out data section address. */
900 if (data_last_frag
== 0)
901 bss_vma
= H_GET_TEXT_SIZE (&headers
);
903 bss_vma
= data_last_frag
->fr_address
;
904 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
905 bss_address_frag
.fr_address
= bss_vma
;
907 #else /* ! OBJ_BOUT */
908 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
909 H_GET_DATA_SIZE (&headers
));
911 #endif /* ! OBJ_BOUT */
913 /* Slide all the frags */
916 relax_addressT slide
= bss_address_frag
.fr_address
;
918 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
920 fragP
->fr_address
+= slide
;
921 } /* for each bss frag */
925 H_SET_BSS_SIZE (&headers
,
926 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
928 H_SET_BSS_SIZE (&headers
, 0);
930 #endif /* ! BFD_ASSEMBLER && ! BFD */
932 #if defined (BFD_ASSEMBLER) || !defined (BFD)
937 register struct frchain
*frchainP
; /* Track along all frchains. */
938 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
939 register fragS
*fragP
; /* Track along all frags. */
941 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
942 long object_file_size
;
945 /* Do we really want to write it? */
948 n_warns
= had_warnings ();
949 n_errs
= had_errors ();
950 /* The -Z flag indicates that an object file should be generated,
951 regardless of warnings and errors. */
954 if (n_warns
|| n_errs
)
955 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
956 n_errs
, n_errs
== 1 ? "" : "s",
957 n_warns
, n_warns
== 1 ? "" : "s");
962 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
963 n_errs
, n_errs
== 1 ? "" : "s",
964 n_warns
, n_warns
== 1 ? "" : "s");
970 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
971 * call a routine to check for the definition of the procedure
972 * "_main", and if so -- fix it up so that it can be program
975 VMS_Check_For_Main ();
978 /* After every sub-segment, we fake an ".align ...". This conforms to
979 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
980 frag that requires least thought. ".align" frags like to have a
981 following frag since that makes calculating their intended length
984 @@ Is this really necessary?? */
985 #ifndef SUB_SEGMENT_ALIGN
987 #define SUB_SEGMENT_ALIGN(SEG) (0)
989 #define SUB_SEGMENT_ALIGN(SEG) (2)
992 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
994 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
995 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
996 /* frag_align will have left a new frag.
997 Use this last frag for an empty ".fill".
1000 Create a last frag. Do not leave a "being filled in frag". */
1001 frag_wane (frag_now
);
1002 frag_now
->fr_fix
= 0;
1003 know (frag_now
->fr_next
== NULL
);
1006 /* From now on, we don't care about sub-segments. Build one frag chain
1007 for each segment. Linked thru fr_next. */
1009 #ifdef BFD_ASSEMBLER
1010 /* Remove the sections created by gas for its own purposes. */
1012 asection
**seclist
, *sec
;
1013 seclist
= &stdoutput
->sections
;
1014 while (seclist
&& *seclist
)
1017 while (sec
== reg_section
|| sec
== expr_section
)
1021 stdoutput
->section_count
--;
1026 seclist
= &(*seclist
)->next
;
1030 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1032 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1033 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1034 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1037 /* We have two segments. If user gave -R flag, then we must put the
1038 data frags into the text segment. Do this before relaxing so
1039 we know to take advantage of -R and make shorter addresses. */
1040 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1043 merge_data_into_text ();
1047 #ifdef BFD_ASSEMBLER
1048 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1050 relax_and_size_all_segments ();
1051 #endif /* BFD_ASSEMBLER */
1053 #ifndef BFD_ASSEMBLER
1056 * Crawl the symbol chain.
1058 * For each symbol whose value depends on a frag, take the address of
1059 * that frag and subsume it into the value of the symbol.
1060 * After this, there is just one way to lookup a symbol value.
1061 * Values are left in their final state for object file emission.
1062 * We adjust the values of 'L' local symbols, even if we do
1063 * not intend to emit them to the object file, because their values
1064 * are needed for fix-ups.
1066 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1067 * from the symbol chain. (They are still pointed to by the fixes.)
1069 * Count the remaining symbols.
1070 * Assign a symbol number to each symbol.
1071 * Count the number of string-table chars we will emit.
1072 * Put this info into the headers as appropriate.
1075 know (zero_address_frag
.fr_address
== 0);
1076 string_byte_count
= sizeof (string_byte_count
);
1078 obj_crawl_symbol_chain (&headers
);
1080 if (string_byte_count
== sizeof (string_byte_count
))
1081 string_byte_count
= 0;
1083 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1086 * Addresses of frags now reflect addresses we use in the object file.
1087 * Symbol values are correct.
1088 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1089 * Also converting any machine-dependent frags using md_convert_frag();
1091 subseg_change (SEG_TEXT
, 0);
1093 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1095 cvt_frag_to_fill (&headers
, fragP
);
1097 /* Some assert macros don't work with # directives mixed in. */
1099 if (!(fragP
->fr_next
== NULL
1101 || fragP
->fr_next
== data_frag_root
1103 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1104 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1108 #endif /* ! BFD_ASSEMBLER */
1110 #ifndef WORKING_DOT_WORD
1112 struct broken_word
*lie
;
1113 struct broken_word
**prevP
;
1115 prevP
= &broken_words
;
1116 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1121 exp
.X_op
= O_subtract
;
1122 exp
.X_add_symbol
= lie
->add
;
1123 exp
.X_op_symbol
= lie
->sub
;
1124 exp
.X_add_number
= lie
->addnum
;
1125 #ifdef BFD_ASSEMBLER
1126 fix_new_exp (lie
->frag
,
1127 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1128 2, &exp
, 0, BFD_RELOC_NONE
);
1130 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1131 fix_new_exp (lie
->frag
,
1132 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1133 2, &exp
, 0, NO_RELOC
);
1136 fix_new_ns32k_exp (lie
->frag
,
1137 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1138 2, &exp
, 0, 0, 2, 0, 0);
1140 fix_new_exp (lie
->frag
,
1141 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1143 #endif /* TC_NS32K */
1144 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1145 #endif /* BFD_ASSEMBLER */
1146 *prevP
= lie
->next_broken_word
;
1149 prevP
= &(lie
->next_broken_word
);
1151 for (lie
= broken_words
; lie
;)
1153 struct broken_word
*untruth
;
1155 addressT table_addr
;
1156 addressT from_addr
, to_addr
;
1159 fragP
= lie
->dispfrag
;
1161 /* Find out how many broken_words go here. */
1163 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1164 if (untruth
->added
== 1)
1167 table_ptr
= lie
->dispfrag
->fr_opcode
;
1168 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1169 /* Create the jump around the long jumps. This is a short
1170 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1171 from_addr
= table_addr
;
1172 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1173 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1174 table_ptr
+= md_short_jump_size
;
1175 table_addr
+= md_short_jump_size
;
1177 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1179 if (lie
->added
== 2)
1181 /* Patch the jump table */
1182 /* This is the offset from ??? to table_ptr+0 */
1183 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1184 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1185 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1187 if (untruth
->use_jump
== lie
)
1188 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1191 /* Install the long jump */
1192 /* this is a long jump from table_ptr+0 to the final target */
1193 from_addr
= table_addr
;
1194 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1195 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1196 table_ptr
+= md_long_jump_size
;
1197 table_addr
+= md_long_jump_size
;
1201 #endif /* not WORKING_DOT_WORD */
1203 #ifndef BFD_ASSEMBLER
1207 * Scan every FixS performing fixups. We had to wait until now to do
1208 * this because md_convert_frag() may have made some fixSs.
1212 subseg_change (SEG_TEXT
, 0);
1213 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1214 subseg_change (SEG_DATA
, 0);
1215 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1216 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1218 /* FIXME move this stuff into the pre-write-hook */
1219 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1220 H_SET_ENTRY_POINT (&headers
, 0);
1222 obj_pre_write_hook (&headers
); /* extra coff stuff */
1224 object_file_size
= H_GET_FILE_SIZE (&headers
);
1225 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1227 output_file_create (out_file_name
);
1229 obj_header_append (&next_object_file_charP
, &headers
);
1231 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1236 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1238 register long count
;
1239 register char *fill_literal
;
1240 register long fill_size
;
1242 know (fragP
->fr_type
== rs_fill
);
1243 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1244 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1245 fill_size
= fragP
->fr_var
;
1246 know (fragP
->fr_offset
>= 0);
1248 for (count
= fragP
->fr_offset
; count
; count
--)
1250 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1253 } /* for each code frag. */
1255 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1260 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1261 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
)));
1263 /* Make addresses in data relocation directives relative to beginning of
1264 * first data fragment, not end of last text fragment: alignment of the
1265 * start of the data segment may place a gap between the segments.
1267 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1269 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1270 #endif /* TC_I960 */
1272 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
)));
1275 * Emit line number entries.
1277 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1278 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
)));
1283 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1284 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
)));
1290 if (string_byte_count
> 0)
1292 obj_emit_strings (&next_object_file_charP
);
1293 } /* only if we have a string table */
1296 bfd_seek (stdoutput
, 0, 0);
1297 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1300 /* Write the data to the file */
1301 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1303 } /* non vms output */
1306 * Now do the VMS-dependent part of writing the object file
1308 VMS_write_object_file (H_GET_TEXT_SIZE (&headers
),
1309 H_GET_DATA_SIZE (&headers
),
1310 H_GET_BSS_SIZE (&headers
),
1311 text_frag_root
, data_frag_root
);
1313 #else /* BFD_ASSEMBLER */
1315 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1317 /* Set up symbol table, and write it out. */
1324 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1328 if (! symp
->sy_resolved
)
1330 if (symp
->sy_value
.X_op
== O_constant
)
1332 /* This is the normal case; skip the call. */
1335 + symp
->sy_frag
->fr_address
));
1336 symp
->sy_resolved
= 1;
1339 resolve_symbol_value (symp
);
1342 /* So far, common symbols have been treated like undefined symbols.
1343 Put them in the common section now. */
1344 if (S_IS_DEFINED (symp
) == 0
1345 && S_GET_VALUE (symp
) != 0)
1346 S_SET_SEGMENT (symp
, &bfd_com_section
);
1348 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1349 S_GET_NAME (symp
), symp
,
1352 segment_name (symp
->bsym
->section
));
1355 #ifdef obj_frob_symbol
1356 obj_frob_symbol (symp
, punt
);
1358 #ifdef tc_frob_symbol
1359 if (! punt
|| symp
->sy_used_in_reloc
)
1360 tc_frob_symbol (symp
, punt
);
1363 /* If we don't want to keep this symbol, splice it out of
1364 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1365 want section symbols. Otherwise, we skip local symbols
1366 and symbols that the frob_symbol macros told us to punt,
1367 but we keep such symbols if they are used in relocs. */
1368 if ((! EMIT_SECTION_SYMBOLS
1369 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1370 || ((S_IS_LOCAL (symp
) || punt
)
1371 && ! symp
->sy_used_in_reloc
))
1373 symbolS
*prev
, *next
;
1375 prev
= symbol_previous (symp
);
1376 next
= symbol_next (symp
);
1378 verify_symbol_chain_2 (symp
);
1382 symbol_next (prev
) = next
;
1385 else if (symp
== symbol_rootP
)
1386 symbol_rootP
= next
;
1390 symbol_previous (next
) = prev
;
1392 symbol_lastP
= prev
;
1395 verify_symbol_chain_2 (prev
);
1397 verify_symbol_chain_2 (next
);
1402 /* Make sure we really got a value for the symbol. */
1403 if (! symp
->sy_resolved
)
1405 as_bad ("can't resolve value for symbol \"%s\"",
1407 symp
->sy_resolved
= 1;
1410 /* Set the value into the BFD symbol. Up til now the value
1411 has only been kept in the gas symbolS struct. */
1412 symp
->bsym
->value
= S_GET_VALUE (symp
);
1421 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1423 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1424 n
* sizeof (asymbol
*));
1425 symp
= symbol_rootP
;
1426 for (i
= 0; i
< n
; i
++, symp
= symbol_next (symp
))
1428 asympp
[i
] = symp
->bsym
;
1431 result
= bfd_set_symtab (stdoutput
, asympp
, n
);
1432 assert (result
== true);
1440 #ifdef obj_frob_file
1441 /* If obj_frob_file changes the symbol value at this point, it is
1442 responsible for moving the changed value into symp->bsym->value
1443 as well. Hopefully all symbol value changing can be done in
1444 {obj,tc}_frob_symbol. */
1448 /* Now that all the sizes are known, and contents correct, we can
1449 start writing the file. */
1450 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1452 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1453 #endif /* BFD_ASSEMBLER */
1460 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1465 * After this, all frags in this segment have addresses that are correct
1466 * within the segment. Since segments live in different file addresses,
1467 * these frag addresses may not be the same as final object-file addresses.
1470 #ifndef md_relax_frag
1472 /* Subroutines of relax_segment. */
1478 for (; f1
; f1
= f1
->fr_next
)
1479 if (f1
->fr_next
== f2
)
1484 #endif /* ! defined (md_relax_frag) */
1486 /* Relax_align. Advance location counter to next address that has 'alignment'
1487 lowest order bits all 0s, return size of adjustment made. */
1488 static relax_addressT
1489 relax_align (address
, alignment
)
1490 register relax_addressT address
; /* Address now. */
1491 register int alignment
; /* Alignment (binary). */
1493 relax_addressT mask
;
1494 relax_addressT new_address
;
1496 mask
= ~((~0) << alignment
);
1497 new_address
= (address
+ mask
) & (~mask
);
1499 /* We must provide lots of padding, so the linker can discard it
1500 when needed. The linker will not add extra space, ever. */
1501 new_address
+= (1 << alignment
);
1502 return (new_address
- address
);
1506 relax_segment (segment_frag_root
, segment
)
1507 struct frag
*segment_frag_root
;
1510 register struct frag
*fragP
;
1511 register relax_addressT address
;
1512 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1513 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1515 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1516 subseg_change (segment
, 0);
1518 /* For each frag in segment: count and store (a 1st guess of)
1521 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1523 fragP
->fr_address
= address
;
1524 address
+= fragP
->fr_fix
;
1526 switch (fragP
->fr_type
)
1529 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1534 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1535 if (offset
% fragP
->fr_var
!= 0)
1537 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1538 offset
, (long) fragP
->fr_var
);
1539 offset
-= (offset
% fragP
->fr_var
);
1546 /* Assume .org is nugatory. It will grow with 1st relax. */
1549 case rs_machine_dependent
:
1550 address
+= md_estimate_size_before_relax (fragP
, segment
);
1553 #ifndef WORKING_DOT_WORD
1554 /* Broken words don't concern us yet */
1555 case rs_broken_word
:
1560 BAD_CASE (fragP
->fr_type
);
1562 } /* switch(fr_type) */
1563 } /* for each frag in the segment */
1567 long stretch
; /* May be any size, 0 or negative. */
1568 /* Cumulative number of addresses we have */
1569 /* relaxed this pass. */
1570 /* We may have relaxed more than one address. */
1571 long stretched
; /* Have we stretched on this pass? */
1572 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1573 grew, and another shrank. If a branch instruction doesn't fit anymore,
1574 we could be scrod. */
1578 stretch
= stretched
= 0;
1579 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1582 unsigned long was_address
;
1588 was_address
= fragP
->fr_address
;
1589 address
= fragP
->fr_address
+= stretch
;
1590 symbolP
= fragP
->fr_symbol
;
1591 offset
= fragP
->fr_offset
;
1593 switch (fragP
->fr_type
)
1595 case rs_fill
: /* .fill never relaxes. */
1599 #ifndef WORKING_DOT_WORD
1600 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1601 for it I do not want to write it. I do not want to have
1602 anything to do with it. This is not the proper way to
1603 implement this misfeature. */
1604 case rs_broken_word
:
1606 struct broken_word
*lie
;
1607 struct broken_word
*untruth
;
1609 /* Yes this is ugly (storing the broken_word pointer
1610 in the symbol slot). Still, this whole chunk of
1611 code is ugly, and I don't feel like doing anything
1612 about it. Think of it as stubbornness in action. */
1614 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1615 lie
&& lie
->dispfrag
== fragP
;
1616 lie
= lie
->next_broken_word
)
1622 offset
= (lie
->add
->sy_frag
->fr_address
1623 + S_GET_VALUE (lie
->add
)
1625 - (lie
->sub
->sy_frag
->fr_address
1626 + S_GET_VALUE (lie
->sub
)));
1627 if (offset
<= -32768 || offset
>= 32767)
1632 sprint_value (buf
, (addressT
) lie
->addnum
);
1633 as_warn (".word %s-%s+%s didn't fit",
1634 S_GET_NAME (lie
->add
),
1635 S_GET_NAME (lie
->sub
),
1639 if (fragP
->fr_subtype
== 0)
1641 fragP
->fr_subtype
++;
1642 growth
+= md_short_jump_size
;
1644 for (untruth
= lie
->next_broken_word
;
1645 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1646 untruth
= untruth
->next_broken_word
)
1647 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1648 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1651 untruth
->use_jump
= lie
;
1653 growth
+= md_long_jump_size
;
1658 } /* case rs_broken_word */
1661 growth
= (relax_align ((relax_addressT
) (address
1664 - relax_align ((relax_addressT
) (was_address
1674 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1675 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1676 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1677 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1678 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1679 know (symbolP
->sy_frag
);
1680 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1681 || (symbolP
->sy_frag
== &zero_address_frag
));
1683 target
+= S_GET_VALUE (symbolP
)
1684 + symbolP
->sy_frag
->fr_address
;
1685 } /* if we have a symbol */
1687 know (fragP
->fr_next
);
1688 after
= fragP
->fr_next
->fr_address
;
1689 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1690 /* Growth may be negative, but variable part of frag
1691 cannot have fewer than 0 chars. That is, we can't
1694 growth
-= stretch
; /* This is an absolute growth factor */
1697 case rs_machine_dependent
:
1698 #ifdef md_relax_frag
1699 growth
= md_relax_frag (fragP
, stretch
);
1701 /* The default way to relax a frag is to look through
1704 const relax_typeS
*this_type
;
1705 const relax_typeS
*start_type
;
1706 relax_substateT next_state
;
1707 relax_substateT this_state
;
1710 this_state
= fragP
->fr_subtype
;
1711 start_type
= this_type
= md_relax_table
+ this_state
;
1716 #ifndef DIFF_EXPR_OK
1717 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1718 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1719 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1720 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1721 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1723 know (symbolP
->sy_frag
);
1725 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1726 || symbolP
->sy_frag
== &zero_address_frag
);
1728 S_GET_VALUE (symbolP
)
1729 + symbolP
->sy_frag
->fr_address
;
1731 /* If frag has yet to be reached on this pass,
1732 assume it will move by STRETCH just as we did.
1733 If this is not so, it will be because some frag
1734 between grows, and that will force another pass.
1736 Beware zero-length frags.
1738 There should be a faster way to do this. */
1740 if (symbolP
->sy_frag
->fr_address
>= was_address
1741 && is_dnrange (fragP
, symbolP
->sy_frag
))
1747 aim
= target
- address
- fragP
->fr_fix
;
1748 /* The displacement is affected by the instruction size
1749 for the 32k architecture. I think we ought to be able
1750 to add fragP->fr_pcrel_adjust in all cases (it should be
1751 zero if not used), but just in case it breaks something
1752 else we'll put this inside #ifdef NS32K ... #endif */
1754 if (fragP
->fr_pcrel_adjust
)
1757 aim
+= fragP
->fr_pcrel_adjust
;
1761 /* Look backwards. */
1762 for (next_state
= this_type
->rlx_more
; next_state
;)
1763 if (aim
>= this_type
->rlx_backward
)
1767 /* Grow to next state. */
1768 this_state
= next_state
;
1769 this_type
= md_relax_table
+ this_state
;
1770 next_state
= this_type
->rlx_more
;
1775 #ifdef M68K_AIM_KLUDGE
1776 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
1778 /* Look forwards. */
1779 for (next_state
= this_type
->rlx_more
; next_state
;)
1780 if (aim
<= this_type
->rlx_forward
)
1784 /* Grow to next state. */
1785 this_state
= next_state
;
1786 this_type
= md_relax_table
+ this_state
;
1787 next_state
= this_type
->rlx_more
;
1791 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1793 fragP
->fr_subtype
= this_state
;
1799 BAD_CASE (fragP
->fr_type
);
1807 } /* For each frag in the segment. */
1809 while (stretched
); /* Until nothing further to relax. */
1813 * We now have valid fr_address'es for each frag.
1817 * All fr_address's are correct, relative to their own segment.
1818 * We have made all the fixS we will ever make.
1820 } /* relax_segment() */
1822 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1826 Go through all the fixS's in a segment and see which ones can be
1827 handled now. (These consist of fixS where we have since discovered
1828 the value of a symbol, or the address of the frag involved.)
1829 For each one, call md_apply_fix to put the fix into the frag data.
1831 Result is a count of how many relocation structs will be needed to
1832 handle the remaining fixS's that we couldn't completely handle here.
1833 These will be output later by emit_relocations(). */
1836 fixup_segment (fixP
, this_segment_type
)
1837 register fixS
*fixP
;
1838 segT this_segment_type
; /* N_TYPE bits for segment. */
1840 long seg_reloc_count
= 0;
1841 symbolS
*add_symbolP
;
1842 symbolS
*sub_symbolP
;
1849 segT add_symbol_segment
= absolute_section
;
1851 /* If the linker is doing the relaxing, we must not do any fixups.
1853 Well, strictly speaking that's not true -- we could do any that are
1854 PC-relative and don't cross regions that could change size. And for the
1855 i960 (the only machine for which we've got a relaxing linker right now),
1856 we might be able to turn callx/callj into bal anyways in cases where we
1857 know the maximum displacement. */
1860 for (; fixP
; fixP
= fixP
->fx_next
)
1862 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
1863 return seg_reloc_count
;
1866 for (; fixP
; fixP
= fixP
->fx_next
)
1868 fragP
= fixP
->fx_frag
;
1870 where
= fixP
->fx_where
;
1871 place
= fragP
->fr_literal
+ where
;
1872 size
= fixP
->fx_size
;
1873 add_symbolP
= fixP
->fx_addsy
;
1874 #ifdef TC_VALIDATE_FIX
1875 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
1877 sub_symbolP
= fixP
->fx_subsy
;
1878 add_number
= fixP
->fx_offset
;
1879 pcrel
= fixP
->fx_pcrel
;
1882 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
1889 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
1890 add_number
-= S_GET_VALUE (sub_symbolP
);
1892 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
1894 /* Should try converting to a constant. */
1899 as_bad ("Negative of non-absolute symbol %s",
1900 S_GET_NAME (sub_symbolP
));
1902 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
1903 && (SEG_NORMAL (add_symbol_segment
)
1904 || (add_symbol_segment
== absolute_section
)))
1906 /* Difference of 2 symbols from same segment.
1907 Can't make difference of 2 undefineds: 'value' means
1908 something different for N_UNDF. */
1910 /* Makes no sense to use the difference of 2 arbitrary symbols
1911 as the target of a call instruction. */
1913 as_bad ("callj to difference of 2 symbols");
1914 #endif /* TC_I960 */
1915 add_number
+= S_GET_VALUE (add_symbolP
) -
1916 S_GET_VALUE (sub_symbolP
);
1920 /* Let the target machine make the final determination
1921 as to whether or not a relocation will be needed to
1922 handle this fixup. */
1923 if (!TC_FORCE_RELOCATION (fixP
))
1925 fixP
->fx_addsy
= NULL
;
1930 /* Different segments in subtraction. */
1931 know (!(S_IS_EXTERNAL (sub_symbolP
)
1932 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
1934 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
1935 add_number
-= S_GET_VALUE (sub_symbolP
);
1938 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
1939 #if 0 /* Do this even if it's already described as pc-relative. For example,
1940 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
1941 pc-relative mode. */
1946 /* Make it pc-relative. */
1947 add_number
+= (md_pcrel_from (fixP
)
1948 - S_GET_VALUE (sub_symbolP
));
1955 #ifdef BFD_ASSEMBLER
1956 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
1957 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
1959 /* Leave it alone. */
1965 sprint_value (buf
, fragP
->fr_address
+ where
);
1966 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1967 segment_name (S_GET_SEGMENT (sub_symbolP
)),
1968 S_GET_NAME (sub_symbolP
), buf
);
1975 if (add_symbol_segment
== this_segment_type
&& pcrel
)
1978 * This fixup was made when the symbol's segment was
1979 * SEG_UNKNOWN, but it is now in the local segment.
1980 * So we know how to do the address without relocation.
1983 /* reloc_callj() may replace a 'call' with a 'calls' or a
1984 'bal', in which cases it modifies *fixP as appropriate.
1985 In the case of a 'calls', no further work is required,
1986 and *fixP has been set up to make the rest of the code
1989 #endif /* TC_I960 */
1991 add_number
+= S_GET_VALUE (add_symbolP
);
1992 add_number
-= md_pcrel_from (fixP
);
1993 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
1995 /* Let the target machine make the final determination
1996 as to whether or not a relocation will be needed to
1997 handle this fixup. */
1998 if (!TC_FORCE_RELOCATION (fixP
))
2001 fixP
->fx_addsy
= NULL
;
2006 if (add_symbol_segment
== absolute_section
)
2009 /* See comment about reloc_callj() above. */
2011 #endif /* TC_I960 */
2012 add_number
+= S_GET_VALUE (add_symbolP
);
2014 /* Let the target machine make the final determination
2015 as to whether or not a relocation will be needed to
2016 handle this fixup. */
2017 if (!TC_FORCE_RELOCATION (fixP
))
2019 fixP
->fx_addsy
= NULL
;
2023 else if (add_symbol_segment
== undefined_section
2024 #ifdef BFD_ASSEMBLER
2025 || bfd_is_com_section (add_symbol_segment
)
2030 if ((int) fixP
->fx_bit_fixP
== 13)
2032 /* This is a COBR instruction. They have only a
2033 * 13-bit displacement and are only to be used
2034 * for local branches: flag as error, don't generate
2037 as_bad ("can't use COBR format with external label");
2038 fixP
->fx_addsy
= NULL
;
2042 #endif /* TC_I960 */
2046 if (S_IS_COMMON (add_symbolP
))
2047 add_number
+= S_GET_VALUE (add_symbolP
);
2048 #endif /* TE_I386AIX */
2049 #endif /* OBJ_COFF */
2055 add_number
+= S_GET_VALUE (add_symbolP
);
2062 add_number
-= md_pcrel_from (fixP
);
2063 if (add_symbolP
== 0)
2065 fixP
->fx_addsy
= &abs_symbol
;
2070 if (!fixP
->fx_bit_fixP
&& size
> 0)
2073 /* set all bits to one */
2075 /* Technically, combining these produces an undefined result
2076 if size is sizeof (valueT), though I think these two
2077 half-way operations should both be defined. And the
2078 compiler should be able to combine them if it's valid on
2079 the host architecture. */
2082 if ((add_number
& mask
) != 0
2083 && (add_number
& mask
) != mask
)
2085 char buf
[50], buf2
[50];
2086 sprint_value (buf
, fragP
->fr_address
+ where
);
2087 if (add_number
> 1000)
2088 sprint_value (buf2
, add_number
);
2090 sprintf (buf2
, "%ld", (long) add_number
);
2091 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2092 "Value of %s too large for field of %d bytes at %s",
2094 } /* generic error checking */
2095 #ifdef WARN_SIGNED_OVERFLOW_WORD
2096 /* Warn if a .word value is too large when treated as a signed
2097 number. We already know it is not too negative. This is to
2098 catch over-large switches generated by gcc on the 68k. */
2101 && add_number
> 0x7fff)
2102 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2103 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2105 (unsigned long) (fragP
->fr_address
+ where
));
2107 } /* not a bit fix */
2111 #ifdef BFD_ASSEMBLER
2112 md_apply_fix (fixP
, &add_number
);
2114 md_apply_fix (fixP
, add_number
);
2117 #ifndef TC_HANDLES_FX_DONE
2118 /* If the tc-* files haven't been converted, assume it's handling
2119 it the old way, where a null fx_addsy means that the fix has
2120 been applied completely, and no further work is needed. */
2121 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2125 #ifdef TC_VALIDATE_FIX
2129 } /* For each fixS in this segment. */
2131 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2132 return seg_reloc_count
;
2135 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2138 number_to_chars_bigendian (buf
, val
, n
)
2143 if (n
> sizeof (val
)|| n
<= 0)
2147 buf
[n
] = val
& 0xff;
2153 number_to_chars_littleendian (buf
, val
, n
)
2158 if (n
> sizeof (val
) || n
<= 0)
2162 *buf
++ = val
& 0xff;
2167 /* end of write.c */