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;
127 /* Usually, we want relocs sorted numerically, but while
128 comparing to older versions of gas that have relocs
129 reverse sorted, it is convenient to have this compile
130 time option. xoxorich. */
135 fixS
**seg_fix_rootP
= & (seg_info (now_seg
)->fix_root
);
136 fixS
**seg_fix_tailP
= & (seg_info (now_seg
)->fix_tail
);
139 #ifdef REVERSE_SORT_RELOCS
141 fixP
->fx_next
= *seg_fix_rootP
;
142 *seg_fix_rootP
= fixP
;
144 #else /* REVERSE_SORT_RELOCS */
146 fixP
->fx_next
= NULL
;
149 (*seg_fix_tailP
)->fx_next
= fixP
;
151 *seg_fix_rootP
= fixP
;
152 *seg_fix_tailP
= fixP
;
154 #endif /* REVERSE_SORT_RELOCS */
161 /* Create a fixup relative to a symbol (plus a constant). */
164 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
165 fragS
*frag
; /* Which frag? */
166 int where
; /* Where in that frag? */
167 short int size
; /* 1, 2, or 4 usually. */
168 symbolS
*add_symbol
; /* X_add_symbol. */
169 offsetT offset
; /* X_add_number. */
170 int pcrel
; /* TRUE if PC-relative relocation. */
172 bfd_reloc_code_real_type r_type
; /* Relocation type */
174 int r_type
; /* Relocation type */
177 return fix_new_internal (frag
, where
, size
, add_symbol
,
178 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
181 /* Create a fixup for an expression. Currently we only support fixups
182 for difference expressions. That is itself more than most object
183 file formats support anyhow. */
186 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
187 fragS
*frag
; /* Which frag? */
188 int where
; /* Where in that frag? */
189 short int size
; /* 1, 2, or 4 usually. */
190 expressionS
*exp
; /* Expression. */
191 int pcrel
; /* TRUE if PC-relative relocation. */
193 bfd_reloc_code_real_type r_type
; /* Relocation type */
195 int r_type
; /* Relocation type */
208 sub
= exp
->X_add_symbol
;
209 off
= exp
->X_add_number
;
213 sub
= exp
->X_op_symbol
;
216 add
= exp
->X_add_symbol
;
219 off
= exp
->X_add_number
;
223 as_bad ("expression too complex for fixup");
226 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
230 /* Append a string onto another string, bumping the pointer along. */
232 append (charPP
, fromP
, length
)
235 unsigned long length
;
237 /* Don't trust memcpy() of 0 chars. */
241 memcpy (*charPP
, fromP
, length
);
245 #ifndef BFD_ASSEMBLER
246 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
250 * This routine records the largest alignment seen for each segment.
251 * If the beginning of the segment is aligned on the worst-case
252 * boundary, all of the other alignments within it will work. At
253 * least one object format really uses this info.
256 record_alignment (seg
, align
)
257 /* Segment to which alignment pertains */
259 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
264 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
265 bfd_set_section_alignment (stdoutput
, seg
, align
);
267 if (align
> section_alignment
[(int) seg
])
268 section_alignment
[(int) seg
] = align
;
272 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
275 chain_frchains_together_1 (section
, frchp
)
277 struct frchain
*frchp
;
279 fragS dummy
, *prev_frag
= &dummy
;
280 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
282 prev_frag
->fr_next
= frchp
->frch_root
;
283 prev_frag
= frchp
->frch_last
;
285 prev_frag
->fr_next
= 0;
294 chain_frchains_together (abfd
, section
, xxx
)
295 bfd
*abfd
; /* unused */
297 char *xxx
; /* unused */
299 segment_info_type
*info
;
301 /* BFD may have introduced its own sections without using
302 subseg_new, so it is possible that seg_info is NULL. */
303 info
= seg_info (section
);
304 if (info
!= (segment_info_type
*) NULL
)
305 chain_frchains_together_1 (section
, info
->frchainP
);
310 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
313 remove_subsegs (head
, seg
, root
, last
)
319 *root
= head
->frch_root
;
320 *last
= chain_frchains_together_1 (seg
, head
);
325 #if defined (BFD_ASSEMBLER) || !defined (BFD)
329 cvt_frag_to_fill (sec
, fragP
)
334 cvt_frag_to_fill (headers
, fragP
)
335 object_headers
*headers
;
339 switch (fragP
->fr_type
)
344 HANDLE_ALIGN (fragP
);
346 fragP
->fr_type
= rs_fill
;
347 know (fragP
->fr_var
== 1);
348 know (fragP
->fr_next
!= NULL
);
350 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
358 case rs_machine_dependent
:
360 md_convert_frag (stdoutput
, sec
, fragP
);
362 md_convert_frag (headers
, fragP
);
365 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
368 * After md_convert_frag, we make the frag into a ".space 0".
369 * Md_convert_frag() should set up any fixSs and constants
375 #ifndef WORKING_DOT_WORD
378 struct broken_word
*lie
;
380 if (fragP
->fr_subtype
)
382 fragP
->fr_fix
+= md_short_jump_size
;
383 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
384 lie
&& lie
->dispfrag
== fragP
;
385 lie
= lie
->next_broken_word
)
387 fragP
->fr_fix
+= md_long_jump_size
;
395 BAD_CASE (fragP
->fr_type
);
400 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
404 relax_and_size_seg (abfd
, sec
, xxx
)
411 segment_info_type
*seginfo
;
413 valueT size
, newsize
;
415 flags
= bfd_get_section_flags (abfd
, sec
);
417 seginfo
= (segment_info_type
*) bfd_get_section_userdata (abfd
, sec
);
418 if (seginfo
&& seginfo
->frchainP
)
420 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
421 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
422 cvt_frag_to_fill (sec
, fragp
);
423 for (fragp
= seginfo
->frchainP
->frch_root
;
425 fragp
= fragp
->fr_next
)
426 /* walk to last elt */;
427 size
= fragp
->fr_address
+ fragp
->fr_fix
;
433 flags
|= SEC_HAS_CONTENTS
;
434 /* @@ This is just an approximation. */
435 if (seginfo
->fix_root
)
439 x
= bfd_set_section_flags (abfd
, sec
, flags
);
442 size
= md_section_align (sec
, size
);
443 x
= bfd_set_section_size (abfd
, sec
, size
);
446 /* If the size had to be rounded up, add some padding in the last
448 newsize
= bfd_get_section_size_before_reloc (sec
);
449 assert (newsize
>= size
);
452 fragS
*last
= seginfo
->frchainP
->frch_last
;
453 fragp
= seginfo
->frchainP
->frch_root
;
454 while (fragp
->fr_next
!= last
)
455 fragp
= fragp
->fr_next
;
456 last
->fr_address
= size
;
457 fragp
->fr_offset
+= newsize
- size
;
460 #ifdef tc_frob_section
461 tc_frob_section (sec
);
463 #ifdef obj_frob_section
464 obj_frob_section (sec
);
470 dump_section_relocs (abfd
, sec
, stream_
)
475 FILE *stream
= (FILE *) stream_
;
476 segment_info_type
*seginfo
= seg_info (sec
);
477 fixS
*fixp
= seginfo
->fix_root
;
482 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
485 symbolS
*s
= fixp
->fx_addsy
;
487 fprintf (stream
, " %08x: %s(%s+%x)+%x\n", fixp
,
488 S_GET_NAME (s
), s
->bsym
->section
->name
,
489 S_GET_VALUE (s
), fixp
->fx_offset
);
491 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
492 fixp
= fixp
->fx_next
;
496 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
500 adjust_reloc_syms (abfd
, sec
, xxx
)
505 segment_info_type
*seginfo
= seg_info (sec
);
511 dump_section_relocs (abfd
, sec
, stderr
);
513 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
516 symbolS
*sym
= fixp
->fx_addsy
;
517 asection
*symsec
= sym
->bsym
->section
;
518 segment_info_type
*symseginfo
= seg_info (symsec
);
520 /* If it's one of these sections, assume the symbol is definitely
521 going to be output. */
522 if (symsec
== &bfd_und_section
523 || symsec
== &bfd_abs_section
524 || bfd_is_com_section (symsec
))
526 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
530 /* Since we're reducing to section symbols, don't attempt to reduce
531 anything that's already using one. */
532 if (sym
->bsym
== symsec
->symbol
)
534 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
538 /* Is there some other reason we can't adjust this one? (E.g.,
539 call/bal links in i960-bout symbols.) */
540 #ifdef obj_fix_adjustable
541 if (! obj_fix_adjustable (fixp
))
543 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
547 /* If the section symbol isn't going to be output, the relocs
548 at least should still work. If not, figure out what to do
549 when we run into that case. */
550 fixp
->fx_offset
+= S_GET_VALUE (sym
);
552 fixp
->fx_offset
+= sym
->sy_frag
->fr_address
;
554 fixp
->fx_addsy
= symseginfo
->sym
;
557 fixp
->fx_addsy
= symbol_find (symsec
->name
);
560 fixp
->fx_addsy
= symbol_make (symsec
->name
);
561 fixp
->fx_addsy
->bsym
= symsec
->symbol
;
563 symseginfo
->sym
= fixp
->fx_addsy
;
565 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
568 dump_section_relocs (abfd
, sec
, stderr
);
572 write_relocs (abfd
, sec
, xxx
)
577 segment_info_type
*seginfo
= seg_info (sec
);
583 /* If seginfo is NULL, we did not create this section; don't do
588 fixup_segment (seginfo
->fix_root
, sec
);
591 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
594 #ifndef RELOC_EXPANSION_POSSIBLE
595 /* Set up reloc information as well. */
596 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
597 n
* sizeof (arelent
*));
598 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
601 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
605 bfd_reloc_status_type s
;
607 if (fixp
->fx_addsy
== 0)
609 /* @@ Need some other flag to indicate which have already
614 reloc
= tc_gen_reloc (sec
, fixp
);
620 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
621 /* @@ Assumes max size of reloc is 4. */
622 if (fixp
->fx_where
+ 4
623 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
625 /* Pass bogus address so that when bfd_perform_relocation adds
626 `address' back in, it'll come up with `data', which is where
627 we want it to operate. */
628 s
= bfd_perform_relocation (stdoutput
, reloc
, data
- reloc
->address
,
635 as_fatal ("bad return from bfd_perform_relocation");
640 n
= n
* MAX_RELOC_EXPANSION
;
641 /* Set up reloc information as well. */
642 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
643 n
* sizeof (arelent
*));
646 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
650 bfd_reloc_status_type s
;
653 if (fixp
->fx_addsy
== 0)
655 /* @@ Need some other flag to indicate which have already
660 reloc
= tc_gen_reloc (sec
, fixp
);
662 for (j
= 0; reloc
[j
]; j
++)
664 relocs
[i
++] = reloc
[j
];
667 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
668 if (fixp
->fx_where
+ 4
669 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
671 for (j
= 0; reloc
[j
]; j
++)
673 s
= bfd_perform_relocation (stdoutput
, reloc
[j
], data
- reloc
[j
]->address
,
680 as_fatal ("bad return from bfd_perform_relocation");
688 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
690 bfd_set_section_flags (abfd
, sec
,
691 (bfd_get_section_flags (abfd
, sec
)
692 & (flagword
) ~SEC_RELOC
));
698 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
699 for (i
= 0; i
< n
; i
++)
703 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
704 i
, r
, r
->address
, s
->name
, r
->addend
);
711 write_contents (abfd
, sec
, xxx
)
716 segment_info_type
*seginfo
= seg_info (sec
);
717 unsigned long offset
= 0;
720 /* Write out the frags. */
721 if (! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
724 for (f
= seginfo
->frchainP
->frch_root
;
729 unsigned long fill_size
;
733 assert (f
->fr_type
== rs_fill
);
736 x
= bfd_set_section_contents (stdoutput
, sec
,
737 f
->fr_literal
, (file_ptr
) offset
,
738 (bfd_size_type
) f
->fr_fix
);
742 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
743 fill_size
= f
->fr_var
;
744 count
= f
->fr_offset
;
746 if (fill_size
&& count
)
749 x
= bfd_set_section_contents (stdoutput
, sec
,
750 fill_literal
, (file_ptr
) offset
,
751 (bfd_size_type
) fill_size
);
759 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
761 merge_data_into_text ()
763 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
764 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
765 seg_info (data_section
)->frchainP
->frch_root
;
766 seg_info (text_section
)->frchainP
->frch_last
=
767 seg_info (data_section
)->frchainP
->frch_last
;
768 seg_info (data_section
)->frchainP
= 0;
772 text_last_frag
->fr_next
= data_frag_root
;
773 text_last_frag
= data_last_frag
;
774 data_last_frag
= NULL
;
775 data_frag_root
= NULL
;
778 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
779 tmp
->fx_next
= data_fix_root
;
780 text_fix_tail
= data_fix_tail
;
783 text_fix_root
= data_fix_root
;
784 data_fix_root
= NULL
;
787 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
789 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
791 relax_and_size_all_segments ()
795 relax_segment (text_frag_root
, SEG_TEXT
);
796 relax_segment (data_frag_root
, SEG_DATA
);
797 relax_segment (bss_frag_root
, SEG_BSS
);
799 * Now the addresses of frags are correct within the segment.
802 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
803 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
804 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
807 * Join the 2 segments into 1 huge segment.
808 * To do this, re-compute every rn_address in the SEG_DATA frags.
809 * Then join the data frags after the text frags.
811 * Determine a_data [length of data segment].
815 register relax_addressT slide
;
817 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
819 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
820 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
821 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
823 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
824 /* For b.out: If the data section has a strict alignment
825 requirement, its load address in the .o file will be
826 rounded up from the size of the text section. These
827 two values are *not* the same! Similarly for the bss
829 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
832 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
834 fragP
->fr_address
+= slide
;
835 } /* for each data frag */
837 know (text_last_frag
!= 0);
838 text_last_frag
->fr_next
= data_frag_root
;
842 H_SET_DATA_SIZE (&headers
, 0);
846 /* See above comments on b.out data section address. */
849 if (data_last_frag
== 0)
850 bss_vma
= H_GET_TEXT_SIZE (&headers
);
852 bss_vma
= data_last_frag
->fr_address
;
853 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
854 bss_address_frag
.fr_address
= bss_vma
;
856 #else /* ! OBJ_BOUT */
857 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
858 H_GET_DATA_SIZE (&headers
));
861 /* Slide all the frags */
864 relax_addressT slide
= bss_address_frag
.fr_address
;
866 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
868 fragP
->fr_address
+= slide
;
869 } /* for each bss frag */
872 #endif /* ! OBJ_BOUT */
875 H_SET_BSS_SIZE (&headers
,
876 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
878 H_SET_BSS_SIZE (&headers
, 0);
880 #endif /* ! BFD_ASSEMBLER && ! BFD */
882 #if defined (BFD_ASSEMBLER) || !defined (BFD)
887 register struct frchain
*frchainP
; /* Track along all frchains. */
888 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
889 register fragS
*fragP
; /* Track along all frags. */
891 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
892 long object_file_size
;
895 /* Do we really want to write it? */
898 n_warns
= had_warnings ();
899 n_errs
= had_errors ();
900 /* The -Z flag indicates that an object file should be generated,
901 regardless of warnings and errors. */
904 if (n_warns
|| n_errs
)
905 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
906 n_errs
, n_errs
== 1 ? "" : "s",
907 n_warns
, n_warns
== 1 ? "" : "s");
912 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
913 n_errs
, n_errs
== 1 ? "" : "s",
914 n_warns
, n_warns
== 1 ? "" : "s");
920 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
921 * call a routine to check for the definition of the procedure
922 * "_main", and if so -- fix it up so that it can be program
925 VMS_Check_For_Main ();
928 /* After every sub-segment, we fake an ".align ...". This conforms to
929 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
930 frag that requires least thought. ".align" frags like to have a
931 following frag since that makes calculating their intended length
934 @@ Is this really necessary?? */
935 #ifndef SUB_SEGMENT_ALIGN
937 #define SUB_SEGMENT_ALIGN(SEG) (0)
939 #define SUB_SEGMENT_ALIGN(SEG) (2)
942 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
944 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
945 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
946 /* frag_align will have left a new frag.
947 Use this last frag for an empty ".fill".
950 Create a last frag. Do not leave a "being filled in frag". */
951 frag_wane (frag_now
);
952 frag_now
->fr_fix
= 0;
953 know (frag_now
->fr_next
== NULL
);
956 /* From now on, we don't care about sub-segments. Build one frag chain
957 for each segment. Linked thru fr_next. */
960 /* Remove the sections created by gas for its own purposes. */
962 asection
**seclist
, *sec
;
963 seclist
= &stdoutput
->sections
;
964 while (seclist
&& *seclist
)
967 while (sec
== reg_section
|| sec
== expr_section
)
971 stdoutput
->section_count
--;
976 seclist
= &(*seclist
)->next
;
980 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
982 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
983 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
984 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
987 /* We have two segments. If user gave -R flag, then we must put the
988 data frags into the text segment. Do this before relaxing so
989 we know to take advantage of -R and make shorter addresses. */
990 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
993 merge_data_into_text ();
998 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1000 relax_and_size_all_segments ();
1001 #endif /* BFD_ASSEMBLER */
1003 #ifndef BFD_ASSEMBLER
1006 * Crawl the symbol chain.
1008 * For each symbol whose value depends on a frag, take the address of
1009 * that frag and subsume it into the value of the symbol.
1010 * After this, there is just one way to lookup a symbol value.
1011 * Values are left in their final state for object file emission.
1012 * We adjust the values of 'L' local symbols, even if we do
1013 * not intend to emit them to the object file, because their values
1014 * are needed for fix-ups.
1016 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1017 * from the symbol chain. (They are still pointed to by the fixes.)
1019 * Count the remaining symbols.
1020 * Assign a symbol number to each symbol.
1021 * Count the number of string-table chars we will emit.
1022 * Put this info into the headers as appropriate.
1025 know (zero_address_frag
.fr_address
== 0);
1026 string_byte_count
= sizeof (string_byte_count
);
1028 obj_crawl_symbol_chain (&headers
);
1030 if (string_byte_count
== sizeof (string_byte_count
))
1031 string_byte_count
= 0;
1033 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1036 * Addresses of frags now reflect addresses we use in the object file.
1037 * Symbol values are correct.
1038 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1039 * Also converting any machine-dependent frags using md_convert_frag();
1041 subseg_change (SEG_TEXT
, 0);
1043 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1045 cvt_frag_to_fill (&headers
, fragP
);
1047 /* Some assert macros don't work with # directives mixed in. */
1049 if (!(fragP
->fr_next
== NULL
1051 || fragP
->fr_next
== data_frag_root
1053 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1054 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1058 #endif /* ! BFD_ASSEMBLER */
1060 #ifndef WORKING_DOT_WORD
1062 struct broken_word
*lie
;
1063 struct broken_word
**prevP
;
1065 prevP
= &broken_words
;
1066 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1071 exp
.X_op
= O_subtract
;
1072 exp
.X_add_symbol
= lie
->add
;
1073 exp
.X_op_symbol
= lie
->sub
;
1074 exp
.X_add_number
= lie
->addnum
;
1075 #ifdef BFD_ASSEMBLER
1076 fix_new_exp (lie
->frag
,
1077 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1078 2, &exp
, 0, BFD_RELOC_NONE
);
1080 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1081 fix_new_exp (lie
->frag
,
1082 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1083 2, &exp
, 0, NO_RELOC
);
1086 fix_new_ns32k_exp (lie
->frag
,
1087 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1088 2, &exp
, 0, 0, 2, 0, 0);
1090 fix_new_exp (lie
->frag
,
1091 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1093 #endif /* TC_NS32K */
1094 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1095 #endif /* BFD_ASSEMBLER */
1096 *prevP
= lie
->next_broken_word
;
1099 prevP
= &(lie
->next_broken_word
);
1101 for (lie
= broken_words
; lie
;)
1103 struct broken_word
*untruth
;
1105 addressT table_addr
;
1106 addressT from_addr
, to_addr
;
1109 fragP
= lie
->dispfrag
;
1111 /* Find out how many broken_words go here. */
1113 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1114 if (untruth
->added
== 1)
1117 table_ptr
= lie
->dispfrag
->fr_opcode
;
1118 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1119 /* Create the jump around the long jumps. This is a short
1120 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1121 from_addr
= table_addr
;
1122 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1123 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1124 table_ptr
+= md_short_jump_size
;
1125 table_addr
+= md_short_jump_size
;
1127 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1129 if (lie
->added
== 2)
1131 /* Patch the jump table */
1132 /* This is the offset from ??? to table_ptr+0 */
1133 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1134 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1135 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1137 if (untruth
->use_jump
== lie
)
1138 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1141 /* Install the long jump */
1142 /* this is a long jump from table_ptr+0 to the final target */
1143 from_addr
= table_addr
;
1144 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1145 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1146 table_ptr
+= md_long_jump_size
;
1147 table_addr
+= md_long_jump_size
;
1151 #endif /* not WORKING_DOT_WORD */
1153 #ifndef BFD_ASSEMBLER
1157 * Scan every FixS performing fixups. We had to wait until now to do
1158 * this because md_convert_frag() may have made some fixSs.
1162 subseg_change (SEG_TEXT
, 0);
1163 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1164 subseg_change (SEG_DATA
, 0);
1165 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1166 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1168 /* FIXME move this stuff into the pre-write-hook */
1169 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1170 H_SET_ENTRY_POINT (&headers
, 0);
1172 obj_pre_write_hook (&headers
); /* extra coff stuff */
1174 object_file_size
= H_GET_FILE_SIZE (&headers
);
1175 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1177 output_file_create (out_file_name
);
1179 obj_header_append (&next_object_file_charP
, &headers
);
1181 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1186 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1188 register long count
;
1189 register char *fill_literal
;
1190 register long fill_size
;
1192 know (fragP
->fr_type
== rs_fill
);
1193 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1194 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1195 fill_size
= fragP
->fr_var
;
1196 know (fragP
->fr_offset
>= 0);
1198 for (count
= fragP
->fr_offset
; count
; count
--)
1200 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1203 } /* for each code frag. */
1205 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1210 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1211 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
)));
1213 /* Make addresses in data relocation directives relative to beginning of
1214 * first data fragment, not end of last text fragment: alignment of the
1215 * start of the data segment may place a gap between the segments.
1217 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1219 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1220 #endif /* TC_I960 */
1222 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
)));
1225 * Emit line number entries.
1227 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1228 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
)));
1233 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1234 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
)));
1240 if (string_byte_count
> 0)
1242 obj_emit_strings (&next_object_file_charP
);
1243 } /* only if we have a string table */
1246 bfd_seek (stdoutput
, 0, 0);
1247 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1250 /* Write the data to the file */
1251 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1254 output_file_close (out_file_name
);
1255 } /* non vms output */
1258 * Now do the VMS-dependent part of writing the object file
1260 VMS_write_object_file (H_GET_TEXT_SIZE (&headers
),
1261 H_GET_DATA_SIZE (&headers
),
1262 H_GET_BSS_SIZE (&headers
),
1263 text_frag_root
, data_frag_root
);
1265 #else /* BFD_ASSEMBLER */
1267 #ifdef obj_check_file_symbols
1268 obj_check_file_symbols ();
1271 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1273 /* Set up symbol table, and write it out. */
1280 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1282 if (! symp
->sy_resolved
)
1284 if (symp
->sy_value
.X_op
== O_constant
)
1286 /* This is the normal case; skip the call. */
1289 + symp
->sy_frag
->fr_address
));
1290 symp
->sy_resolved
= 1;
1293 resolve_symbol_value (symp
);
1296 /* So far, common symbols have been treated like undefined symbols.
1297 Put them in the common section now. */
1298 if (S_IS_DEFINED (symp
) == 0
1299 && S_GET_VALUE (symp
) != 0)
1300 S_SET_SEGMENT (symp
, &bfd_com_section
);
1302 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1303 S_GET_NAME (symp
), symp
,
1306 segment_name (symp
->bsym
->section
));
1308 if (! symp
->sy_used_in_reloc
)
1310 #ifdef obj_frob_symbol
1313 obj_frob_symbol (symp
, punt
);
1318 #ifdef tc_frob_symbol
1321 tc_frob_symbol (symp
, punt
);
1328 /* If we don't want to keep this symbol, splice it out of the
1330 if (! symp
->sy_used_in_reloc
1331 && S_IS_LOCAL (symp
))
1333 symbolS
*prev
, *next
;
1334 #if defined (obj_frob_symbol) || defined (tc_frob_symbol)
1337 prev
= symbol_previous (symp
);
1338 next
= symbol_next (symp
);
1340 verify_symbol_chain_2 (symp
);
1344 symbol_next (prev
) = next
;
1347 else if (symp
== symbol_rootP
)
1348 symbol_rootP
= next
;
1352 symbol_previous (next
) = prev
;
1354 symbol_lastP
= prev
;
1357 verify_symbol_chain_2 (prev
);
1359 verify_symbol_chain_2 (next
);
1364 /* Make sure we really got a value for the symbol. */
1365 if (! symp
->sy_resolved
)
1367 as_bad ("can't resolve value for symbol \"%s\"",
1369 symp
->sy_resolved
= 1;
1372 /* Set the value into the BFD symbol. Up til now the value
1373 has only been kept in the gas symbolS struct. */
1374 symp
->bsym
->value
= S_GET_VALUE (symp
);
1383 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1385 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1386 n
* sizeof (asymbol
*));
1387 symp
= symbol_rootP
;
1388 for (i
= 0; i
< n
; i
++, symp
= symbol_next (symp
))
1390 asympp
[i
] = symp
->bsym
;
1393 result
= bfd_set_symtab (stdoutput
, asympp
, n
);
1394 assert (result
== true);
1399 #ifdef obj_frob_file
1400 /* If obj_frob_file changes the symbol value at this point, it is
1401 responsible for moving the changed value into symp->bsym->value
1402 as well. Hopefully all symbol value changing can be done in
1403 {obj,tc}_frob_symbol. */
1407 /* Now that all the sizes are known, and contents correct, we can
1408 start writing the file. */
1409 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1411 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1413 output_file_close (out_file_name
);
1414 #endif /* BFD_ASSEMBLER */
1421 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1426 * After this, all frags in this segment have addresses that are correct
1427 * within the segment. Since segments live in different file addresses,
1428 * these frag addresses may not be the same as final object-file addresses.
1431 /* Subroutines of relax_segment. */
1437 for (; f1
; f1
= f1
->fr_next
)
1438 if (f1
->fr_next
== f2
)
1443 /* Relax_align. Advance location counter to next address that has 'alignment'
1444 lowest order bits all 0s, return size of adjustment made. */
1445 static relax_addressT
1446 relax_align (address
, alignment
)
1447 register relax_addressT address
; /* Address now. */
1448 register int alignment
; /* Alignment (binary). */
1450 relax_addressT mask
;
1451 relax_addressT new_address
;
1453 mask
= ~((~0) << alignment
);
1454 new_address
= (address
+ mask
) & (~mask
);
1456 /* We must provide lots of padding, so the linker can discard it
1457 when needed. The linker will not add extra space, ever. */
1458 new_address
+= (1 << alignment
);
1459 return (new_address
- address
);
1463 relax_segment (segment_frag_root
, segment
)
1464 struct frag
*segment_frag_root
;
1467 register struct frag
*fragP
;
1468 register relax_addressT address
;
1469 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1470 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1472 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1473 subseg_change (segment
, 0);
1475 /* For each frag in segment: count and store (a 1st guess of)
1478 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1480 fragP
->fr_address
= address
;
1481 address
+= fragP
->fr_fix
;
1483 switch (fragP
->fr_type
)
1486 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1490 address
+= relax_align (address
, (int) fragP
->fr_offset
);
1494 /* Assume .org is nugatory. It will grow with 1st relax. */
1497 case rs_machine_dependent
:
1498 address
+= md_estimate_size_before_relax (fragP
, segment
);
1501 #ifndef WORKING_DOT_WORD
1502 /* Broken words don't concern us yet */
1503 case rs_broken_word
:
1508 BAD_CASE (fragP
->fr_type
);
1510 } /* switch(fr_type) */
1511 } /* for each frag in the segment */
1515 long stretch
; /* May be any size, 0 or negative. */
1516 /* Cumulative number of addresses we have */
1517 /* relaxed this pass. */
1518 /* We may have relaxed more than one address. */
1519 long stretched
; /* Have we stretched on this pass? */
1520 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1521 grew, and another shrank. If a branch instruction doesn't fit anymore,
1522 we could be scrod. */
1526 stretch
= stretched
= 0;
1527 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1530 unsigned long was_address
;
1536 was_address
= fragP
->fr_address
;
1537 address
= fragP
->fr_address
+= stretch
;
1538 symbolP
= fragP
->fr_symbol
;
1539 offset
= fragP
->fr_offset
;
1541 switch (fragP
->fr_type
)
1543 case rs_fill
: /* .fill never relaxes. */
1547 #ifndef WORKING_DOT_WORD
1548 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1549 for it I do not want to write it. I do not want to have
1550 anything to do with it. This is not the proper way to
1551 implement this misfeature. */
1552 case rs_broken_word
:
1554 struct broken_word
*lie
;
1555 struct broken_word
*untruth
;
1557 /* Yes this is ugly (storing the broken_word pointer
1558 in the symbol slot). Still, this whole chunk of
1559 code is ugly, and I don't feel like doing anything
1560 about it. Think of it as stubbornness in action. */
1562 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1563 lie
&& lie
->dispfrag
== fragP
;
1564 lie
= lie
->next_broken_word
)
1570 offset
= (lie
->add
->sy_frag
->fr_address
1571 + S_GET_VALUE (lie
->add
)
1573 - (lie
->sub
->sy_frag
->fr_address
1574 + S_GET_VALUE (lie
->sub
)));
1575 if (offset
<= -32768 || offset
>= 32767)
1580 sprint_value (buf
, (addressT
) lie
->addnum
);
1581 as_warn (".word %s-%s+%s didn't fit",
1582 S_GET_NAME (lie
->add
),
1583 S_GET_NAME (lie
->sub
),
1587 if (fragP
->fr_subtype
== 0)
1589 fragP
->fr_subtype
++;
1590 growth
+= md_short_jump_size
;
1592 for (untruth
= lie
->next_broken_word
;
1593 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1594 untruth
= untruth
->next_broken_word
)
1595 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1596 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1599 untruth
->use_jump
= lie
;
1601 growth
+= md_long_jump_size
;
1606 } /* case rs_broken_word */
1609 growth
= (relax_align ((relax_addressT
) (address
1612 - relax_align ((relax_addressT
) (was_address
1622 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1623 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1624 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1625 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1626 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1627 know (symbolP
->sy_frag
);
1628 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1629 || (symbolP
->sy_frag
== &zero_address_frag
));
1631 target
+= S_GET_VALUE (symbolP
)
1632 + symbolP
->sy_frag
->fr_address
;
1633 } /* if we have a symbol */
1635 know (fragP
->fr_next
);
1636 after
= fragP
->fr_next
->fr_address
;
1637 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1638 /* Growth may be negative, but variable part of frag
1639 cannot have fewer than 0 chars. That is, we can't
1642 growth
-= stretch
; /* This is an absolute growth factor */
1645 case rs_machine_dependent
:
1647 const relax_typeS
*this_type
;
1648 const relax_typeS
*start_type
;
1649 relax_substateT next_state
;
1650 relax_substateT this_state
;
1653 this_state
= fragP
->fr_subtype
;
1654 start_type
= this_type
= md_relax_table
+ this_state
;
1659 #ifndef DIFF_EXPR_OK
1660 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1661 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1662 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1663 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1664 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1666 know (symbolP
->sy_frag
);
1668 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1669 || symbolP
->sy_frag
== &zero_address_frag
);
1671 S_GET_VALUE (symbolP
)
1672 + symbolP
->sy_frag
->fr_address
;
1674 /* If frag has yet to be reached on this pass,
1675 assume it will move by STRETCH just as we did.
1676 If this is not so, it will be because some frag
1677 between grows, and that will force another pass.
1679 Beware zero-length frags.
1681 There should be a faster way to do this. */
1683 if (symbolP
->sy_frag
->fr_address
>= was_address
1684 && is_dnrange (fragP
, symbolP
->sy_frag
))
1690 aim
= target
- address
- fragP
->fr_fix
;
1691 /* The displacement is affected by the instruction size
1692 for the 32k architecture. I think we ought to be able
1693 to add fragP->fr_pcrel_adjust in all cases (it should be
1694 zero if not used), but just in case it breaks something
1695 else we'll put this inside #ifdef NS32K ... #endif */
1697 if (fragP
->fr_pcrel_adjust
)
1700 aim
+= fragP
->fr_pcrel_adjust
;
1704 /* Look backwards. */
1705 for (next_state
= this_type
->rlx_more
; next_state
;)
1706 if (aim
>= this_type
->rlx_backward
)
1710 /* Grow to next state. */
1711 this_state
= next_state
;
1712 this_type
= md_relax_table
+ this_state
;
1713 next_state
= this_type
->rlx_more
;
1718 #ifdef M68K_AIM_KLUDGE
1719 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
1721 /* Look forwards. */
1722 for (next_state
= this_type
->rlx_more
; next_state
;)
1723 if (aim
<= this_type
->rlx_forward
)
1727 /* Grow to next state. */
1728 this_state
= next_state
;
1729 this_type
= md_relax_table
+ this_state
;
1730 next_state
= this_type
->rlx_more
;
1734 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1736 fragP
->fr_subtype
= this_state
;
1741 BAD_CASE (fragP
->fr_type
);
1749 } /* For each frag in the segment. */
1751 while (stretched
); /* Until nothing further to relax. */
1755 * We now have valid fr_address'es for each frag.
1759 * All fr_address's are correct, relative to their own segment.
1760 * We have made all the fixS we will ever make.
1762 } /* relax_segment() */
1764 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1768 Go through all the fixS's in a segment and see which ones can be
1769 handled now. (These consist of fixS where we have since discovered
1770 the value of a symbol, or the address of the frag involved.)
1771 For each one, call md_apply_fix to put the fix into the frag data.
1773 Result is a count of how many relocation structs will be needed to
1774 handle the remaining fixS's that we couldn't completely handle here.
1775 These will be output later by emit_relocations(). */
1778 fixup_segment (fixP
, this_segment_type
)
1779 register fixS
*fixP
;
1780 segT this_segment_type
; /* N_TYPE bits for segment. */
1782 register long seg_reloc_count
;
1783 register symbolS
*add_symbolP
;
1784 register symbolS
*sub_symbolP
;
1787 register char *place
;
1788 register long where
;
1789 register char pcrel
;
1790 register fragS
*fragP
;
1791 register segT add_symbol_segment
= absolute_section
;
1793 seg_reloc_count
= 0;
1794 /* If the linker is doing the relaxing, we must not do any fixups. */
1795 /* Well, strictly speaking that's not true -- we could do any that
1796 are PC-relative and don't cross regions that could change size.
1797 And for the i960 (the only machine for which we've got a relaxing
1798 linker right now), we might be able to turn callx/callj into bal
1799 in cases where we know the maximum displacement. */
1801 for (; fixP
; fixP
= fixP
->fx_next
)
1804 for (; fixP
; fixP
= fixP
->fx_next
)
1806 fragP
= fixP
->fx_frag
;
1808 where
= fixP
->fx_where
;
1809 place
= fragP
->fr_literal
+ where
;
1810 size
= fixP
->fx_size
;
1811 add_symbolP
= fixP
->fx_addsy
;
1813 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
1815 /* Relocation should be done via the associated 'bal'
1816 entry point symbol. */
1818 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
1820 as_bad ("No 'bal' entry point for leafproc %s",
1821 S_GET_NAME (add_symbolP
));
1824 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
1827 sub_symbolP
= fixP
->fx_subsy
;
1828 add_number
= fixP
->fx_offset
;
1829 pcrel
= fixP
->fx_pcrel
;
1832 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
1839 /* @@ Should try converting to pcrel ref to fixed addr. */
1840 if (S_GET_SEGMENT (sub_symbolP
) != absolute_section
)
1841 as_bad ("Negative of non-absolute symbol %s",
1842 S_GET_NAME (sub_symbolP
));
1844 add_number
-= S_GET_VALUE (sub_symbolP
);
1846 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
1847 && (SEG_NORMAL (add_symbol_segment
)
1848 || (add_symbol_segment
== absolute_section
)))
1850 /* Difference of 2 symbols from same segment.
1851 Can't make difference of 2 undefineds: 'value' means
1852 something different for N_UNDF. */
1854 /* Makes no sense to use the difference of 2 arbitrary symbols
1855 as the target of a call instruction. */
1858 as_bad ("callj to difference of 2 symbols");
1860 #endif /* TC_I960 */
1861 add_number
+= S_GET_VALUE (add_symbolP
) -
1862 S_GET_VALUE (sub_symbolP
);
1865 fixP
->fx_addsy
= NULL
;
1869 /* Different segments in subtraction. */
1870 know (!(S_IS_EXTERNAL (sub_symbolP
)
1871 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
1873 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
1875 add_number
-= S_GET_VALUE (sub_symbolP
);
1879 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
1881 /* Make it pc-relative. */
1882 add_number
+= (md_pcrel_from (fixP
)
1883 - S_GET_VALUE (sub_symbolP
));
1893 sprint_value (buf
, fragP
->fr_address
+ where
);
1894 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1895 segment_name (S_GET_SEGMENT (sub_symbolP
)),
1896 S_GET_NAME (sub_symbolP
), buf
);
1903 if (add_symbol_segment
== this_segment_type
&& pcrel
)
1906 * This fixup was made when the symbol's segment was
1907 * SEG_UNKNOWN, but it is now in the local segment.
1908 * So we know how to do the address without relocation.
1911 /* reloc_callj() may replace a 'call' with a 'calls' or a
1912 'bal', in which cases it modifies *fixP as appropriate.
1913 In the case of a 'calls', no further work is required,
1914 and *fixP has been set up to make the rest of the code
1917 #endif /* TC_I960 */
1919 add_number
+= S_GET_VALUE (add_symbolP
);
1920 add_number
-= md_pcrel_from (fixP
);
1921 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
1922 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1926 if (add_symbol_segment
== absolute_section
)
1929 /* See comment about reloc_callj() above. */
1931 #endif /* TC_I960 */
1932 add_number
+= S_GET_VALUE (add_symbolP
);
1933 fixP
->fx_addsy
= NULL
;
1936 else if (add_symbol_segment
== undefined_section
1937 #ifdef BFD_ASSEMBLER
1938 || bfd_is_com_section (add_symbol_segment
)
1943 if ((int) fixP
->fx_bit_fixP
== 13)
1945 /* This is a COBR instruction. They have only a
1946 * 13-bit displacement and are only to be used
1947 * for local branches: flag as error, don't generate
1950 as_bad ("can't use COBR format with external label");
1951 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1954 #endif /* TC_I960 */
1958 if (S_IS_COMMON (add_symbolP
))
1959 add_number
+= S_GET_VALUE (add_symbolP
);
1960 #endif /* TE_I386AIX */
1961 #endif /* OBJ_COFF */
1967 add_number
+= S_GET_VALUE (add_symbolP
);
1969 } /* if not in local seg */
1970 } /* if there was a + symbol */
1974 add_number
-= md_pcrel_from (fixP
);
1975 if (add_symbolP
== 0)
1977 fixP
->fx_addsy
= &abs_symbol
;
1979 } /* if there's an add_symbol */
1982 if (!fixP
->fx_bit_fixP
)
1985 /* set all bits to one */
1987 /* Technically speaking, combining these produces an
1988 undefined result if size is sizeof (valueT), though I
1989 think these two half-way operations should both be
1993 if ((add_number
& mask
) != 0
1994 && (add_number
& mask
) != mask
)
1997 sprint_value (buf
, fragP
->fr_address
+ where
);
1998 as_bad ("Value of %ld too large for field of %d bytes at %s",
1999 (long) add_number
, size
, buf
);
2000 } /* generic error checking */
2001 #ifdef WARN_SIGNED_OVERFLOW_WORD
2002 /* Warn if a .word value is too large when treated as a signed
2003 number. We already know it is not too negative. This is to
2004 catch over-large switches generated by gcc on the 68k. */
2007 && add_number
> 0x7fff)
2008 as_bad ("Signed .word overflow; switch may be too large; %ld at 0x%lx",
2010 (unsigned long) (fragP
->fr_address
+ where
));
2012 } /* not a bit fix */
2014 #ifdef BFD_ASSEMBLER
2015 md_apply_fix (fixP
, &add_number
);
2017 md_apply_fix (fixP
, add_number
);
2019 } /* For each fixS in this segment. */
2021 #if defined (OBJ_COFF) && defined (TC_I960)
2025 /* two relocs per callj under coff. */
2026 for (fixP
= topP
; fixP
; fixP
= fixP
->fx_next
)
2027 if (fixP
->fx_callj
&& fixP
->fx_addsy
!= 0)
2030 #endif /* OBJ_COFF && TC_I960 */
2032 return (seg_reloc_count
);
2035 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
2037 /* end of write.c */