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 WORKING_DOT_WORD
34 extern CONST
int md_short_jump_size
;
35 extern CONST
int md_long_jump_size
;
41 struct frag
*text_frag_root
;
42 struct frag
*data_frag_root
;
43 struct frag
*bss_frag_root
;
45 struct frag
*text_last_frag
; /* Last frag in segment. */
46 struct frag
*data_last_frag
; /* Last frag in segment. */
47 static struct frag
*bss_last_frag
; /* Last frag in segment. */
50 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
51 static object_headers headers
;
52 static char *the_object_file
;
55 long string_byte_count
;
56 char *next_object_file_charP
; /* Tracks object file bytes. */
59 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
62 #endif /* BFD_ASSEMBLER */
65 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
66 symbolS
*add
, symbolS
*sub
,
67 offsetT offset
, int pcrel
,
68 bfd_reloc_code_real_type r_type
));
70 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
71 symbolS
*add
, symbolS
*sub
,
72 offsetT offset
, int pcrel
,
75 #if defined (BFD_ASSEMBLER) || !defined (BFD)
76 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
78 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
83 * Create a fixS in obstack 'notes'.
86 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
88 fragS
*frag
; /* Which frag? */
89 int where
; /* Where in that frag? */
90 int size
; /* 1, 2, or 4 usually. */
91 symbolS
*add_symbol
; /* X_add_symbol. */
92 symbolS
*sub_symbol
; /* X_op_symbol. */
93 offsetT offset
; /* X_add_number. */
94 int pcrel
; /* TRUE if PC-relative relocation. */
96 bfd_reloc_code_real_type r_type
; /* Relocation type */
98 int r_type
; /* Relocation type */
103 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
105 fixP
->fx_frag
= frag
;
106 fixP
->fx_where
= where
;
107 fixP
->fx_size
= size
;
108 fixP
->fx_addsy
= add_symbol
;
109 fixP
->fx_subsy
= sub_symbol
;
110 fixP
->fx_offset
= offset
;
111 fixP
->fx_pcrel
= pcrel
;
112 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
113 fixP
->fx_r_type
= r_type
;
115 fixP
->fx_im_disp
= 0;
116 fixP
->fx_pcrel_adjust
= 0;
117 fixP
->fx_bit_fixP
= 0;
118 fixP
->fx_addnumber
= 0;
119 fixP
->tc_fix_data
= NULL
;
128 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
130 /* Usually, we want relocs sorted numerically, but while
131 comparing to older versions of gas that have relocs
132 reverse sorted, it is convenient to have this compile
133 time option. xoxorich. */
138 fixS
**seg_fix_rootP
= & (seg_info (now_seg
)->fix_root
);
139 fixS
**seg_fix_tailP
= & (seg_info (now_seg
)->fix_tail
);
142 #ifdef REVERSE_SORT_RELOCS
144 fixP
->fx_next
= *seg_fix_rootP
;
145 *seg_fix_rootP
= fixP
;
147 #else /* REVERSE_SORT_RELOCS */
149 fixP
->fx_next
= NULL
;
152 (*seg_fix_tailP
)->fx_next
= fixP
;
154 *seg_fix_rootP
= fixP
;
155 *seg_fix_tailP
= fixP
;
157 #endif /* REVERSE_SORT_RELOCS */
164 /* Create a fixup relative to a symbol (plus a constant). */
167 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
168 fragS
*frag
; /* Which frag? */
169 int where
; /* Where in that frag? */
170 short int size
; /* 1, 2, or 4 usually. */
171 symbolS
*add_symbol
; /* X_add_symbol. */
172 offsetT offset
; /* X_add_number. */
173 int pcrel
; /* TRUE if PC-relative relocation. */
175 bfd_reloc_code_real_type r_type
; /* Relocation type */
177 int r_type
; /* Relocation type */
180 return fix_new_internal (frag
, where
, size
, add_symbol
,
181 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
184 /* Create a fixup for an expression. Currently we only support fixups
185 for difference expressions. That is itself more than most object
186 file formats support anyhow. */
189 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
190 fragS
*frag
; /* Which frag? */
191 int where
; /* Where in that frag? */
192 short int size
; /* 1, 2, or 4 usually. */
193 expressionS
*exp
; /* Expression. */
194 int pcrel
; /* TRUE if PC-relative relocation. */
196 bfd_reloc_code_real_type r_type
; /* Relocation type */
198 int r_type
; /* Relocation type */
211 sub
= exp
->X_add_symbol
;
212 off
= exp
->X_add_number
;
216 sub
= exp
->X_op_symbol
;
219 add
= exp
->X_add_symbol
;
222 off
= exp
->X_add_number
;
226 as_bad ("expression too complex for fixup");
229 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
233 /* Append a string onto another string, bumping the pointer along. */
235 append (charPP
, fromP
, length
)
238 unsigned long length
;
240 /* Don't trust memcpy() of 0 chars. */
244 memcpy (*charPP
, fromP
, length
);
248 #ifndef BFD_ASSEMBLER
249 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
253 * This routine records the largest alignment seen for each segment.
254 * If the beginning of the segment is aligned on the worst-case
255 * boundary, all of the other alignments within it will work. At
256 * least one object format really uses this info.
259 record_alignment (seg
, align
)
260 /* Segment to which alignment pertains */
262 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
267 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
268 bfd_set_section_alignment (stdoutput
, seg
, align
);
270 if (align
> section_alignment
[(int) seg
])
271 section_alignment
[(int) seg
] = align
;
275 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
278 chain_frchains_together_1 (section
, frchp
)
280 struct frchain
*frchp
;
282 fragS dummy
, *prev_frag
= &dummy
;
283 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
285 prev_frag
->fr_next
= frchp
->frch_root
;
286 prev_frag
= frchp
->frch_last
;
288 prev_frag
->fr_next
= 0;
297 chain_frchains_together (abfd
, section
, xxx
)
298 bfd
*abfd
; /* unused */
300 char *xxx
; /* unused */
302 segment_info_type
*info
;
304 /* BFD may have introduced its own sections without using
305 subseg_new, so it is possible that seg_info is NULL. */
306 info
= seg_info (section
);
307 if (info
!= (segment_info_type
*) NULL
)
308 chain_frchains_together_1 (section
, info
->frchainP
);
313 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
316 remove_subsegs (head
, seg
, root
, last
)
322 *root
= head
->frch_root
;
323 *last
= chain_frchains_together_1 (seg
, head
);
328 #if defined (BFD_ASSEMBLER) || !defined (BFD)
332 cvt_frag_to_fill (sec
, fragP
)
337 cvt_frag_to_fill (headers
, fragP
)
338 object_headers
*headers
;
342 switch (fragP
->fr_type
)
347 HANDLE_ALIGN (fragP
);
349 fragP
->fr_type
= rs_fill
;
350 know (fragP
->fr_var
== 1);
351 know (fragP
->fr_next
!= NULL
);
353 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
361 case rs_machine_dependent
:
363 md_convert_frag (stdoutput
, sec
, fragP
);
365 md_convert_frag (headers
, fragP
);
368 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
371 * After md_convert_frag, we make the frag into a ".space 0".
372 * Md_convert_frag() should set up any fixSs and constants
378 #ifndef WORKING_DOT_WORD
381 struct broken_word
*lie
;
383 if (fragP
->fr_subtype
)
385 fragP
->fr_fix
+= md_short_jump_size
;
386 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
387 lie
&& lie
->dispfrag
== fragP
;
388 lie
= lie
->next_broken_word
)
390 fragP
->fr_fix
+= md_long_jump_size
;
398 BAD_CASE (fragP
->fr_type
);
403 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
407 relax_and_size_seg (abfd
, sec
, xxx
)
414 segment_info_type
*seginfo
;
416 valueT size
, newsize
;
418 flags
= bfd_get_section_flags (abfd
, sec
);
420 seginfo
= (segment_info_type
*) bfd_get_section_userdata (abfd
, sec
);
421 if (seginfo
&& seginfo
->frchainP
)
423 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
424 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
425 cvt_frag_to_fill (sec
, fragp
);
426 for (fragp
= seginfo
->frchainP
->frch_root
;
428 fragp
= fragp
->fr_next
)
429 /* walk to last elt */;
430 size
= fragp
->fr_address
+ fragp
->fr_fix
;
436 flags
|= SEC_HAS_CONTENTS
;
437 /* @@ This is just an approximation. */
438 if (seginfo
->fix_root
)
442 x
= bfd_set_section_flags (abfd
, sec
, flags
);
445 newsize
= md_section_align (sec
, size
);
446 x
= bfd_set_section_size (abfd
, sec
, newsize
);
449 /* If the size had to be rounded up, add some padding in the last
451 assert (newsize
>= size
);
454 fragS
*last
= seginfo
->frchainP
->frch_last
;
455 fragp
= seginfo
->frchainP
->frch_root
;
456 while (fragp
->fr_next
!= last
)
457 fragp
= fragp
->fr_next
;
458 last
->fr_address
= size
;
459 fragp
->fr_offset
+= newsize
- size
;
462 #ifdef tc_frob_section
463 tc_frob_section (sec
);
465 #ifdef obj_frob_section
466 obj_frob_section (sec
);
472 dump_section_relocs (abfd
, sec
, stream_
)
477 FILE *stream
= (FILE *) stream_
;
478 segment_info_type
*seginfo
= seg_info (sec
);
479 fixS
*fixp
= seginfo
->fix_root
;
484 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
487 symbolS
*s
= fixp
->fx_addsy
;
489 fprintf (stream
, " %08x: %s(%s+%x)+%x\n", fixp
,
490 S_GET_NAME (s
), s
->bsym
->section
->name
,
491 S_GET_VALUE (s
), fixp
->fx_offset
);
493 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
494 fixp
= fixp
->fx_next
;
498 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
502 adjust_reloc_syms (abfd
, sec
, xxx
)
507 segment_info_type
*seginfo
= seg_info (sec
);
513 dump_section_relocs (abfd
, sec
, stderr
);
515 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
518 symbolS
*sym
= fixp
->fx_addsy
;
519 asection
*symsec
= sym
->bsym
->section
;
520 segment_info_type
*symseginfo
= seg_info (symsec
);
522 /* If it's one of these sections, assume the symbol is definitely
523 going to be output. */
524 if (symsec
== &bfd_und_section
525 || symsec
== &bfd_abs_section
526 || bfd_is_com_section (symsec
))
528 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
532 /* Since we're reducing to section symbols, don't attempt to reduce
533 anything that's already using one. */
534 if (sym
->bsym
== symsec
->symbol
)
536 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
540 /* Is there some other reason we can't adjust this one? (E.g.,
541 call/bal links in i960-bout symbols.) */
542 #ifdef obj_fix_adjustable
543 if (! obj_fix_adjustable (fixp
))
545 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
550 /* Is there some other (target cpu dependent) reason we can't adjust
551 this one? (E.g. relocations involving function addresses on
553 #ifdef tc_fix_adjustable
554 if (! tc_fix_adjustable (fixp
))
556 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
561 /* If the section symbol isn't going to be output, the relocs
562 at least should still work. If not, figure out what to do
563 when we run into that case. */
564 fixp
->fx_offset
+= S_GET_VALUE (sym
);
566 fixp
->fx_offset
+= sym
->sy_frag
->fr_address
;
568 fixp
->fx_addsy
= symseginfo
->sym
;
571 fixp
->fx_addsy
= symbol_find (symsec
->name
);
574 fixp
->fx_addsy
= symbol_make (symsec
->name
);
575 fixp
->fx_addsy
->bsym
= symsec
->symbol
;
577 symseginfo
->sym
= fixp
->fx_addsy
;
579 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
582 dump_section_relocs (abfd
, sec
, stderr
);
586 write_relocs (abfd
, sec
, xxx
)
591 segment_info_type
*seginfo
= seg_info (sec
);
597 /* If seginfo is NULL, we did not create this section; don't do
602 fixup_segment (seginfo
->fix_root
, sec
);
605 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
608 #ifndef RELOC_EXPANSION_POSSIBLE
609 /* Set up reloc information as well. */
610 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
611 n
* sizeof (arelent
*));
612 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
615 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
619 bfd_reloc_status_type s
;
621 if (fixp
->fx_addsy
== 0)
623 /* @@ Need some other flag to indicate which have already
628 reloc
= tc_gen_reloc (sec
, fixp
);
634 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
635 if (fixp
->fx_where
+ fixp
->fx_size
636 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
638 /* Pass bogus address so that when bfd_perform_relocation adds
639 `address' back in, it'll come up with `data', which is where
640 we want it to operate. */
641 if (reloc
->howto
->partial_inplace
== false
642 && reloc
->howto
->pcrel_offset
== true
643 && reloc
->howto
->pc_relative
== true)
645 /* bfd_perform_relocation screws this up */
646 reloc
->addend
+= reloc
->address
;
648 s
= bfd_perform_relocation (stdoutput
, reloc
, data
- reloc
->address
,
655 as_fatal ("bad return from bfd_perform_relocation");
660 n
= n
* MAX_RELOC_EXPANSION
;
661 /* Set up reloc information as well. */
662 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
663 n
* sizeof (arelent
*));
666 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
670 bfd_reloc_status_type s
;
673 if (fixp
->fx_addsy
== 0)
675 /* @@ Need some other flag to indicate which have already
680 reloc
= tc_gen_reloc (sec
, fixp
);
682 for (j
= 0; reloc
[j
]; j
++)
684 relocs
[i
++] = reloc
[j
];
687 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
688 if (fixp
->fx_where
+ fixp
->fx_size
689 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
691 for (j
= 0; reloc
[j
]; j
++)
693 s
= bfd_perform_relocation (stdoutput
, reloc
[j
], data
- reloc
[j
]->address
,
700 as_fatal ("bad return from bfd_perform_relocation");
708 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
710 bfd_set_section_flags (abfd
, sec
,
711 (bfd_get_section_flags (abfd
, sec
)
712 & (flagword
) ~SEC_RELOC
));
718 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
719 for (i
= 0; i
< n
; i
++)
723 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
724 i
, r
, r
->address
, s
->name
, r
->addend
);
731 write_contents (abfd
, sec
, xxx
)
736 segment_info_type
*seginfo
= seg_info (sec
);
737 unsigned long offset
= 0;
740 /* Write out the frags. */
742 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
745 for (f
= seginfo
->frchainP
->frch_root
;
750 unsigned long fill_size
;
754 assert (f
->fr_type
== rs_fill
);
757 x
= bfd_set_section_contents (stdoutput
, sec
,
758 f
->fr_literal
, (file_ptr
) offset
,
759 (bfd_size_type
) f
->fr_fix
);
763 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
764 fill_size
= f
->fr_var
;
765 count
= f
->fr_offset
;
767 if (fill_size
&& count
)
770 x
= bfd_set_section_contents (stdoutput
, sec
,
771 fill_literal
, (file_ptr
) offset
,
772 (bfd_size_type
) fill_size
);
780 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
782 merge_data_into_text ()
784 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
785 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
786 seg_info (data_section
)->frchainP
->frch_root
;
787 seg_info (text_section
)->frchainP
->frch_last
=
788 seg_info (data_section
)->frchainP
->frch_last
;
789 seg_info (data_section
)->frchainP
= 0;
793 text_last_frag
->fr_next
= data_frag_root
;
794 text_last_frag
= data_last_frag
;
795 data_last_frag
= NULL
;
796 data_frag_root
= NULL
;
799 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
800 tmp
->fx_next
= data_fix_root
;
801 text_fix_tail
= data_fix_tail
;
804 text_fix_root
= data_fix_root
;
805 data_fix_root
= NULL
;
808 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
810 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
812 relax_and_size_all_segments ()
816 relax_segment (text_frag_root
, SEG_TEXT
);
817 relax_segment (data_frag_root
, SEG_DATA
);
818 relax_segment (bss_frag_root
, SEG_BSS
);
820 * Now the addresses of frags are correct within the segment.
823 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
824 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
825 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
828 * Join the 2 segments into 1 huge segment.
829 * To do this, re-compute every rn_address in the SEG_DATA frags.
830 * Then join the data frags after the text frags.
832 * Determine a_data [length of data segment].
836 register relax_addressT slide
;
838 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
840 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
841 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
842 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
844 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
845 /* For b.out: If the data section has a strict alignment
846 requirement, its load address in the .o file will be
847 rounded up from the size of the text section. These
848 two values are *not* the same! Similarly for the bss
850 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
853 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
855 fragP
->fr_address
+= slide
;
856 } /* for each data frag */
858 know (text_last_frag
!= 0);
859 text_last_frag
->fr_next
= data_frag_root
;
863 H_SET_DATA_SIZE (&headers
, 0);
867 /* See above comments on b.out data section address. */
870 if (data_last_frag
== 0)
871 bss_vma
= H_GET_TEXT_SIZE (&headers
);
873 bss_vma
= data_last_frag
->fr_address
;
874 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
875 bss_address_frag
.fr_address
= bss_vma
;
877 #else /* ! OBJ_BOUT */
878 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
879 H_GET_DATA_SIZE (&headers
));
881 #endif /* ! OBJ_BOUT */
883 /* Slide all the frags */
886 relax_addressT slide
= bss_address_frag
.fr_address
;
888 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
890 fragP
->fr_address
+= slide
;
891 } /* for each bss frag */
895 H_SET_BSS_SIZE (&headers
,
896 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
898 H_SET_BSS_SIZE (&headers
, 0);
900 #endif /* ! BFD_ASSEMBLER && ! BFD */
902 #if defined (BFD_ASSEMBLER) || !defined (BFD)
907 register struct frchain
*frchainP
; /* Track along all frchains. */
908 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
909 register fragS
*fragP
; /* Track along all frags. */
911 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
912 long object_file_size
;
915 /* Do we really want to write it? */
918 n_warns
= had_warnings ();
919 n_errs
= had_errors ();
920 /* The -Z flag indicates that an object file should be generated,
921 regardless of warnings and errors. */
924 if (n_warns
|| n_errs
)
925 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
926 n_errs
, n_errs
== 1 ? "" : "s",
927 n_warns
, n_warns
== 1 ? "" : "s");
932 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
933 n_errs
, n_errs
== 1 ? "" : "s",
934 n_warns
, n_warns
== 1 ? "" : "s");
940 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
941 * call a routine to check for the definition of the procedure
942 * "_main", and if so -- fix it up so that it can be program
945 VMS_Check_For_Main ();
948 /* After every sub-segment, we fake an ".align ...". This conforms to
949 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
950 frag that requires least thought. ".align" frags like to have a
951 following frag since that makes calculating their intended length
954 @@ Is this really necessary?? */
955 #ifndef SUB_SEGMENT_ALIGN
957 #define SUB_SEGMENT_ALIGN(SEG) (0)
959 #define SUB_SEGMENT_ALIGN(SEG) (2)
962 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
964 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
965 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
966 /* frag_align will have left a new frag.
967 Use this last frag for an empty ".fill".
970 Create a last frag. Do not leave a "being filled in frag". */
971 frag_wane (frag_now
);
972 frag_now
->fr_fix
= 0;
973 know (frag_now
->fr_next
== NULL
);
976 /* From now on, we don't care about sub-segments. Build one frag chain
977 for each segment. Linked thru fr_next. */
980 /* Remove the sections created by gas for its own purposes. */
982 asection
**seclist
, *sec
;
983 seclist
= &stdoutput
->sections
;
984 while (seclist
&& *seclist
)
987 while (sec
== reg_section
|| sec
== expr_section
)
991 stdoutput
->section_count
--;
996 seclist
= &(*seclist
)->next
;
1000 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1002 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1003 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1004 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1007 /* We have two segments. If user gave -R flag, then we must put the
1008 data frags into the text segment. Do this before relaxing so
1009 we know to take advantage of -R and make shorter addresses. */
1010 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1013 merge_data_into_text ();
1017 #ifdef BFD_ASSEMBLER
1018 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1020 relax_and_size_all_segments ();
1021 #endif /* BFD_ASSEMBLER */
1023 #ifndef BFD_ASSEMBLER
1026 * Crawl the symbol chain.
1028 * For each symbol whose value depends on a frag, take the address of
1029 * that frag and subsume it into the value of the symbol.
1030 * After this, there is just one way to lookup a symbol value.
1031 * Values are left in their final state for object file emission.
1032 * We adjust the values of 'L' local symbols, even if we do
1033 * not intend to emit them to the object file, because their values
1034 * are needed for fix-ups.
1036 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1037 * from the symbol chain. (They are still pointed to by the fixes.)
1039 * Count the remaining symbols.
1040 * Assign a symbol number to each symbol.
1041 * Count the number of string-table chars we will emit.
1042 * Put this info into the headers as appropriate.
1045 know (zero_address_frag
.fr_address
== 0);
1046 string_byte_count
= sizeof (string_byte_count
);
1048 obj_crawl_symbol_chain (&headers
);
1050 if (string_byte_count
== sizeof (string_byte_count
))
1051 string_byte_count
= 0;
1053 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1056 * Addresses of frags now reflect addresses we use in the object file.
1057 * Symbol values are correct.
1058 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1059 * Also converting any machine-dependent frags using md_convert_frag();
1061 subseg_change (SEG_TEXT
, 0);
1063 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1065 cvt_frag_to_fill (&headers
, fragP
);
1067 /* Some assert macros don't work with # directives mixed in. */
1069 if (!(fragP
->fr_next
== NULL
1071 || fragP
->fr_next
== data_frag_root
1073 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1074 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1078 #endif /* ! BFD_ASSEMBLER */
1080 #ifndef WORKING_DOT_WORD
1082 struct broken_word
*lie
;
1083 struct broken_word
**prevP
;
1085 prevP
= &broken_words
;
1086 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1091 exp
.X_op
= O_subtract
;
1092 exp
.X_add_symbol
= lie
->add
;
1093 exp
.X_op_symbol
= lie
->sub
;
1094 exp
.X_add_number
= lie
->addnum
;
1095 #ifdef BFD_ASSEMBLER
1096 fix_new_exp (lie
->frag
,
1097 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1098 2, &exp
, 0, BFD_RELOC_NONE
);
1100 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1101 fix_new_exp (lie
->frag
,
1102 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1103 2, &exp
, 0, NO_RELOC
);
1106 fix_new_ns32k_exp (lie
->frag
,
1107 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1108 2, &exp
, 0, 0, 2, 0, 0);
1110 fix_new_exp (lie
->frag
,
1111 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1113 #endif /* TC_NS32K */
1114 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1115 #endif /* BFD_ASSEMBLER */
1116 *prevP
= lie
->next_broken_word
;
1119 prevP
= &(lie
->next_broken_word
);
1121 for (lie
= broken_words
; lie
;)
1123 struct broken_word
*untruth
;
1125 addressT table_addr
;
1126 addressT from_addr
, to_addr
;
1129 fragP
= lie
->dispfrag
;
1131 /* Find out how many broken_words go here. */
1133 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1134 if (untruth
->added
== 1)
1137 table_ptr
= lie
->dispfrag
->fr_opcode
;
1138 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1139 /* Create the jump around the long jumps. This is a short
1140 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1141 from_addr
= table_addr
;
1142 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1143 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1144 table_ptr
+= md_short_jump_size
;
1145 table_addr
+= md_short_jump_size
;
1147 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1149 if (lie
->added
== 2)
1151 /* Patch the jump table */
1152 /* This is the offset from ??? to table_ptr+0 */
1153 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1154 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1155 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1157 if (untruth
->use_jump
== lie
)
1158 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1161 /* Install the long jump */
1162 /* this is a long jump from table_ptr+0 to the final target */
1163 from_addr
= table_addr
;
1164 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1165 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1166 table_ptr
+= md_long_jump_size
;
1167 table_addr
+= md_long_jump_size
;
1171 #endif /* not WORKING_DOT_WORD */
1173 #ifndef BFD_ASSEMBLER
1177 * Scan every FixS performing fixups. We had to wait until now to do
1178 * this because md_convert_frag() may have made some fixSs.
1182 subseg_change (SEG_TEXT
, 0);
1183 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1184 subseg_change (SEG_DATA
, 0);
1185 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1186 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1188 /* FIXME move this stuff into the pre-write-hook */
1189 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1190 H_SET_ENTRY_POINT (&headers
, 0);
1192 obj_pre_write_hook (&headers
); /* extra coff stuff */
1194 object_file_size
= H_GET_FILE_SIZE (&headers
);
1195 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1197 output_file_create (out_file_name
);
1199 obj_header_append (&next_object_file_charP
, &headers
);
1201 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1206 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1208 register long count
;
1209 register char *fill_literal
;
1210 register long fill_size
;
1212 know (fragP
->fr_type
== rs_fill
);
1213 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1214 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1215 fill_size
= fragP
->fr_var
;
1216 know (fragP
->fr_offset
>= 0);
1218 for (count
= fragP
->fr_offset
; count
; count
--)
1220 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1223 } /* for each code frag. */
1225 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1230 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1231 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
)));
1233 /* Make addresses in data relocation directives relative to beginning of
1234 * first data fragment, not end of last text fragment: alignment of the
1235 * start of the data segment may place a gap between the segments.
1237 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1239 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1240 #endif /* TC_I960 */
1242 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
)));
1245 * Emit line number entries.
1247 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1248 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
)));
1253 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1254 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
)));
1260 if (string_byte_count
> 0)
1262 obj_emit_strings (&next_object_file_charP
);
1263 } /* only if we have a string table */
1266 bfd_seek (stdoutput
, 0, 0);
1267 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1270 /* Write the data to the file */
1271 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1274 output_file_close (out_file_name
);
1275 } /* non vms output */
1278 * Now do the VMS-dependent part of writing the object file
1280 VMS_write_object_file (H_GET_TEXT_SIZE (&headers
),
1281 H_GET_DATA_SIZE (&headers
),
1282 H_GET_BSS_SIZE (&headers
),
1283 text_frag_root
, data_frag_root
);
1285 #else /* BFD_ASSEMBLER */
1287 #ifdef obj_check_file_symbols
1288 obj_check_file_symbols ();
1291 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1293 /* Set up symbol table, and write it out. */
1300 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1302 if (! symp
->sy_resolved
)
1304 if (symp
->sy_value
.X_op
== O_constant
)
1306 /* This is the normal case; skip the call. */
1309 + symp
->sy_frag
->fr_address
));
1310 symp
->sy_resolved
= 1;
1313 resolve_symbol_value (symp
);
1316 /* So far, common symbols have been treated like undefined symbols.
1317 Put them in the common section now. */
1318 if (S_IS_DEFINED (symp
) == 0
1319 && S_GET_VALUE (symp
) != 0)
1320 S_SET_SEGMENT (symp
, &bfd_com_section
);
1322 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1323 S_GET_NAME (symp
), symp
,
1326 segment_name (symp
->bsym
->section
));
1328 if (! symp
->sy_used_in_reloc
)
1330 #ifdef obj_frob_symbol
1333 obj_frob_symbol (symp
, punt
);
1338 #ifdef tc_frob_symbol
1341 tc_frob_symbol (symp
, punt
);
1348 /* If we don't want to keep this symbol, splice it out of the
1350 if (! symp
->sy_used_in_reloc
1351 && S_IS_LOCAL (symp
))
1353 symbolS
*prev
, *next
;
1354 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1357 prev
= symbol_previous (symp
);
1358 next
= symbol_next (symp
);
1360 verify_symbol_chain_2 (symp
);
1364 symbol_next (prev
) = next
;
1367 else if (symp
== symbol_rootP
)
1368 symbol_rootP
= next
;
1372 symbol_previous (next
) = prev
;
1374 symbol_lastP
= prev
;
1377 verify_symbol_chain_2 (prev
);
1379 verify_symbol_chain_2 (next
);
1384 /* Make sure we really got a value for the symbol. */
1385 if (! symp
->sy_resolved
)
1387 as_bad ("can't resolve value for symbol \"%s\"",
1389 symp
->sy_resolved
= 1;
1392 /* Set the value into the BFD symbol. Up til now the value
1393 has only been kept in the gas symbolS struct. */
1394 symp
->bsym
->value
= S_GET_VALUE (symp
);
1403 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1405 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1406 n
* sizeof (asymbol
*));
1407 symp
= symbol_rootP
;
1408 for (i
= 0; i
< n
; i
++, symp
= symbol_next (symp
))
1410 asympp
[i
] = symp
->bsym
;
1413 result
= bfd_set_symtab (stdoutput
, asympp
, n
);
1414 assert (result
== true);
1419 #ifdef obj_frob_file
1420 /* If obj_frob_file changes the symbol value at this point, it is
1421 responsible for moving the changed value into symp->bsym->value
1422 as well. Hopefully all symbol value changing can be done in
1423 {obj,tc}_frob_symbol. */
1427 /* Now that all the sizes are known, and contents correct, we can
1428 start writing the file. */
1429 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1431 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1433 output_file_close (out_file_name
);
1434 #endif /* BFD_ASSEMBLER */
1441 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1446 * After this, all frags in this segment have addresses that are correct
1447 * within the segment. Since segments live in different file addresses,
1448 * these frag addresses may not be the same as final object-file addresses.
1451 /* Subroutines of relax_segment. */
1457 for (; f1
; f1
= f1
->fr_next
)
1458 if (f1
->fr_next
== f2
)
1463 /* Relax_align. Advance location counter to next address that has 'alignment'
1464 lowest order bits all 0s, return size of adjustment made. */
1465 static relax_addressT
1466 relax_align (address
, alignment
)
1467 register relax_addressT address
; /* Address now. */
1468 register int alignment
; /* Alignment (binary). */
1470 relax_addressT mask
;
1471 relax_addressT new_address
;
1473 mask
= ~((~0) << alignment
);
1474 new_address
= (address
+ mask
) & (~mask
);
1476 /* We must provide lots of padding, so the linker can discard it
1477 when needed. The linker will not add extra space, ever. */
1478 new_address
+= (1 << alignment
);
1479 return (new_address
- address
);
1483 relax_segment (segment_frag_root
, segment
)
1484 struct frag
*segment_frag_root
;
1487 register struct frag
*fragP
;
1488 register relax_addressT address
;
1489 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1490 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1492 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1493 subseg_change (segment
, 0);
1495 /* For each frag in segment: count and store (a 1st guess of)
1498 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1500 fragP
->fr_address
= address
;
1501 address
+= fragP
->fr_fix
;
1503 switch (fragP
->fr_type
)
1506 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1510 address
+= relax_align (address
, (int) fragP
->fr_offset
);
1514 /* Assume .org is nugatory. It will grow with 1st relax. */
1517 case rs_machine_dependent
:
1518 address
+= md_estimate_size_before_relax (fragP
, segment
);
1521 #ifndef WORKING_DOT_WORD
1522 /* Broken words don't concern us yet */
1523 case rs_broken_word
:
1528 BAD_CASE (fragP
->fr_type
);
1530 } /* switch(fr_type) */
1531 } /* for each frag in the segment */
1535 long stretch
; /* May be any size, 0 or negative. */
1536 /* Cumulative number of addresses we have */
1537 /* relaxed this pass. */
1538 /* We may have relaxed more than one address. */
1539 long stretched
; /* Have we stretched on this pass? */
1540 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1541 grew, and another shrank. If a branch instruction doesn't fit anymore,
1542 we could be scrod. */
1546 stretch
= stretched
= 0;
1547 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1550 unsigned long was_address
;
1556 was_address
= fragP
->fr_address
;
1557 address
= fragP
->fr_address
+= stretch
;
1558 symbolP
= fragP
->fr_symbol
;
1559 offset
= fragP
->fr_offset
;
1561 switch (fragP
->fr_type
)
1563 case rs_fill
: /* .fill never relaxes. */
1567 #ifndef WORKING_DOT_WORD
1568 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1569 for it I do not want to write it. I do not want to have
1570 anything to do with it. This is not the proper way to
1571 implement this misfeature. */
1572 case rs_broken_word
:
1574 struct broken_word
*lie
;
1575 struct broken_word
*untruth
;
1577 /* Yes this is ugly (storing the broken_word pointer
1578 in the symbol slot). Still, this whole chunk of
1579 code is ugly, and I don't feel like doing anything
1580 about it. Think of it as stubbornness in action. */
1582 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1583 lie
&& lie
->dispfrag
== fragP
;
1584 lie
= lie
->next_broken_word
)
1590 offset
= (lie
->add
->sy_frag
->fr_address
1591 + S_GET_VALUE (lie
->add
)
1593 - (lie
->sub
->sy_frag
->fr_address
1594 + S_GET_VALUE (lie
->sub
)));
1595 if (offset
<= -32768 || offset
>= 32767)
1600 sprint_value (buf
, (addressT
) lie
->addnum
);
1601 as_warn (".word %s-%s+%s didn't fit",
1602 S_GET_NAME (lie
->add
),
1603 S_GET_NAME (lie
->sub
),
1607 if (fragP
->fr_subtype
== 0)
1609 fragP
->fr_subtype
++;
1610 growth
+= md_short_jump_size
;
1612 for (untruth
= lie
->next_broken_word
;
1613 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1614 untruth
= untruth
->next_broken_word
)
1615 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1616 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1619 untruth
->use_jump
= lie
;
1621 growth
+= md_long_jump_size
;
1626 } /* case rs_broken_word */
1629 growth
= (relax_align ((relax_addressT
) (address
1632 - relax_align ((relax_addressT
) (was_address
1642 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1643 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1644 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1645 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1646 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1647 know (symbolP
->sy_frag
);
1648 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1649 || (symbolP
->sy_frag
== &zero_address_frag
));
1651 target
+= S_GET_VALUE (symbolP
)
1652 + symbolP
->sy_frag
->fr_address
;
1653 } /* if we have a symbol */
1655 know (fragP
->fr_next
);
1656 after
= fragP
->fr_next
->fr_address
;
1657 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1658 /* Growth may be negative, but variable part of frag
1659 cannot have fewer than 0 chars. That is, we can't
1662 growth
-= stretch
; /* This is an absolute growth factor */
1665 case rs_machine_dependent
:
1667 const relax_typeS
*this_type
;
1668 const relax_typeS
*start_type
;
1669 relax_substateT next_state
;
1670 relax_substateT this_state
;
1673 this_state
= fragP
->fr_subtype
;
1674 start_type
= this_type
= md_relax_table
+ this_state
;
1679 #ifndef DIFF_EXPR_OK
1680 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1681 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1682 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1683 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1684 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1686 know (symbolP
->sy_frag
);
1688 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1689 || symbolP
->sy_frag
== &zero_address_frag
);
1691 S_GET_VALUE (symbolP
)
1692 + symbolP
->sy_frag
->fr_address
;
1694 /* If frag has yet to be reached on this pass,
1695 assume it will move by STRETCH just as we did.
1696 If this is not so, it will be because some frag
1697 between grows, and that will force another pass.
1699 Beware zero-length frags.
1701 There should be a faster way to do this. */
1703 if (symbolP
->sy_frag
->fr_address
>= was_address
1704 && is_dnrange (fragP
, symbolP
->sy_frag
))
1710 aim
= target
- address
- fragP
->fr_fix
;
1711 /* The displacement is affected by the instruction size
1712 for the 32k architecture. I think we ought to be able
1713 to add fragP->fr_pcrel_adjust in all cases (it should be
1714 zero if not used), but just in case it breaks something
1715 else we'll put this inside #ifdef NS32K ... #endif */
1717 if (fragP
->fr_pcrel_adjust
)
1720 aim
+= fragP
->fr_pcrel_adjust
;
1724 /* Look backwards. */
1725 for (next_state
= this_type
->rlx_more
; next_state
;)
1726 if (aim
>= this_type
->rlx_backward
)
1730 /* Grow to next state. */
1731 this_state
= next_state
;
1732 this_type
= md_relax_table
+ this_state
;
1733 next_state
= this_type
->rlx_more
;
1738 #ifdef M68K_AIM_KLUDGE
1739 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
1741 /* Look forwards. */
1742 for (next_state
= this_type
->rlx_more
; next_state
;)
1743 if (aim
<= this_type
->rlx_forward
)
1747 /* Grow to next state. */
1748 this_state
= next_state
;
1749 this_type
= md_relax_table
+ this_state
;
1750 next_state
= this_type
->rlx_more
;
1754 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1756 fragP
->fr_subtype
= this_state
;
1761 BAD_CASE (fragP
->fr_type
);
1769 } /* For each frag in the segment. */
1771 while (stretched
); /* Until nothing further to relax. */
1775 * We now have valid fr_address'es for each frag.
1779 * All fr_address's are correct, relative to their own segment.
1780 * We have made all the fixS we will ever make.
1782 } /* relax_segment() */
1784 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1788 Go through all the fixS's in a segment and see which ones can be
1789 handled now. (These consist of fixS where we have since discovered
1790 the value of a symbol, or the address of the frag involved.)
1791 For each one, call md_apply_fix to put the fix into the frag data.
1793 Result is a count of how many relocation structs will be needed to
1794 handle the remaining fixS's that we couldn't completely handle here.
1795 These will be output later by emit_relocations(). */
1798 fixup_segment (fixP
, this_segment_type
)
1799 register fixS
*fixP
;
1800 segT this_segment_type
; /* N_TYPE bits for segment. */
1802 register long seg_reloc_count
;
1803 register symbolS
*add_symbolP
;
1804 register symbolS
*sub_symbolP
;
1807 register char *place
;
1808 register long where
;
1809 register char pcrel
;
1810 register fragS
*fragP
;
1811 register segT add_symbol_segment
= absolute_section
;
1813 seg_reloc_count
= 0;
1814 /* If the linker is doing the relaxing, we must not do any fixups. */
1815 /* Well, strictly speaking that's not true -- we could do any that
1816 are PC-relative and don't cross regions that could change size.
1817 And for the i960 (the only machine for which we've got a relaxing
1818 linker right now), we might be able to turn callx/callj into bal
1819 in cases where we know the maximum displacement. */
1821 for (; fixP
; fixP
= fixP
->fx_next
)
1824 for (; fixP
; fixP
= fixP
->fx_next
)
1826 fragP
= fixP
->fx_frag
;
1828 where
= fixP
->fx_where
;
1829 place
= fragP
->fr_literal
+ where
;
1830 size
= fixP
->fx_size
;
1831 add_symbolP
= fixP
->fx_addsy
;
1833 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
1835 /* Relocation should be done via the associated 'bal'
1836 entry point symbol. */
1838 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
1840 as_bad ("No 'bal' entry point for leafproc %s",
1841 S_GET_NAME (add_symbolP
));
1844 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
1847 sub_symbolP
= fixP
->fx_subsy
;
1848 add_number
= fixP
->fx_offset
;
1849 pcrel
= fixP
->fx_pcrel
;
1852 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
1859 /* @@ Should try converting to pcrel ref to fixed addr. */
1860 if (S_GET_SEGMENT (sub_symbolP
) != absolute_section
)
1861 as_bad ("Negative of non-absolute symbol %s",
1862 S_GET_NAME (sub_symbolP
));
1864 add_number
-= S_GET_VALUE (sub_symbolP
);
1866 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
1867 && (SEG_NORMAL (add_symbol_segment
)
1868 || (add_symbol_segment
== absolute_section
)))
1870 /* Difference of 2 symbols from same segment.
1871 Can't make difference of 2 undefineds: 'value' means
1872 something different for N_UNDF. */
1874 /* Makes no sense to use the difference of 2 arbitrary symbols
1875 as the target of a call instruction. */
1878 as_bad ("callj to difference of 2 symbols");
1880 #endif /* TC_I960 */
1881 add_number
+= S_GET_VALUE (add_symbolP
) -
1882 S_GET_VALUE (sub_symbolP
);
1885 fixP
->fx_addsy
= NULL
;
1887 #if !defined(SEG_DIFF_ALLOWED) && !defined (GLOBAL_DIFF_ALLOWED)
1890 /* Different segments in subtraction. */
1891 know (!(S_IS_EXTERNAL (sub_symbolP
)
1892 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
1894 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
1896 add_number
-= S_GET_VALUE (sub_symbolP
);
1900 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
1902 /* Make it pc-relative. */
1903 add_number
+= (md_pcrel_from (fixP
)
1904 - S_GET_VALUE (sub_symbolP
));
1914 sprint_value (buf
, fragP
->fr_address
+ where
);
1915 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1916 segment_name (S_GET_SEGMENT (sub_symbolP
)),
1917 S_GET_NAME (sub_symbolP
), buf
);
1924 fixP
->fx_addnumber
= add_number
; /* Remember value for emit_reloc */
1932 if (add_symbol_segment
== this_segment_type
&& pcrel
)
1935 * This fixup was made when the symbol's segment was
1936 * SEG_UNKNOWN, but it is now in the local segment.
1937 * So we know how to do the address without relocation.
1940 /* reloc_callj() may replace a 'call' with a 'calls' or a
1941 'bal', in which cases it modifies *fixP as appropriate.
1942 In the case of a 'calls', no further work is required,
1943 and *fixP has been set up to make the rest of the code
1946 #endif /* TC_I960 */
1948 add_number
+= S_GET_VALUE (add_symbolP
);
1949 add_number
-= md_pcrel_from (fixP
);
1950 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
1952 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1957 if (add_symbol_segment
== absolute_section
)
1960 /* See comment about reloc_callj() above. */
1962 #endif /* TC_I960 */
1963 add_number
+= S_GET_VALUE (add_symbolP
);
1964 fixP
->fx_addsy
= NULL
;
1967 else if (add_symbol_segment
== undefined_section
1968 #ifdef BFD_ASSEMBLER
1969 || bfd_is_com_section (add_symbol_segment
)
1974 if ((int) fixP
->fx_bit_fixP
== 13)
1976 /* This is a COBR instruction. They have only a
1977 * 13-bit displacement and are only to be used
1978 * for local branches: flag as error, don't generate
1981 as_bad ("can't use COBR format with external label");
1982 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1985 #endif /* TC_I960 */
1989 if (S_IS_COMMON (add_symbolP
))
1990 add_number
+= S_GET_VALUE (add_symbolP
);
1991 #endif /* TE_I386AIX */
1992 #endif /* OBJ_COFF */
1998 add_number
+= S_GET_VALUE (add_symbolP
);
2005 add_number
-= md_pcrel_from (fixP
);
2006 if (add_symbolP
== 0)
2008 fixP
->fx_addsy
= &abs_symbol
;
2010 } /* if there's an add_symbol */
2013 if (!fixP
->fx_bit_fixP
&& size
> 0)
2016 /* set all bits to one */
2018 /* Technically speaking, combining these produces an
2019 undefined result if size is sizeof (valueT), though I
2020 think these two half-way operations should both be
2024 if ((add_number
& mask
) != 0
2025 && (add_number
& mask
) != mask
)
2027 char buf
[50], buf2
[50];
2028 sprint_value (buf
, fragP
->fr_address
+ where
);
2029 if (add_number
> 1000)
2030 sprint_value (buf2
, add_number
);
2032 sprintf (buf2
, "%ld", (long) add_number
);
2033 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2034 "Value of %s too large for field of %d bytes at %s",
2036 } /* generic error checking */
2037 #ifdef WARN_SIGNED_OVERFLOW_WORD
2038 /* Warn if a .word value is too large when treated as a signed
2039 number. We already know it is not too negative. This is to
2040 catch over-large switches generated by gcc on the 68k. */
2043 && add_number
> 0x7fff)
2044 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2045 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2047 (unsigned long) (fragP
->fr_address
+ where
));
2049 } /* not a bit fix */
2051 #ifdef BFD_ASSEMBLER
2052 md_apply_fix (fixP
, &add_number
);
2054 md_apply_fix (fixP
, add_number
);
2056 } /* For each fixS in this segment. */
2058 #if defined (OBJ_COFF) && defined (TC_I960)
2062 /* two relocs per callj under coff. */
2063 for (fixP
= topP
; fixP
; fixP
= fixP
->fx_next
)
2064 if (fixP
->fx_callj
&& fixP
->fx_addsy
!= 0)
2067 #endif /* OBJ_COFF && TC_I960 */
2069 return (seg_reloc_count
);
2072 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2074 /* end of write.c */