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 static object_headers headers
;
51 long string_byte_count
;
52 static char *the_object_file
;
53 char *next_object_file_charP
; /* Tracks object file bytes. */
56 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
59 #endif /* BFD_ASSEMBLER */
61 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
62 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
63 void relax_segment
PARAMS ((struct frag
* seg_frag_root
, segT seg_type
));
68 * Create a fixS in obstack 'notes'.
71 fix_new (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
, r_type
)
72 fragS
*frag
; /* Which frag? */
73 int where
; /* Where in that frag? */
74 short int size
; /* 1, 2, or 4 usually. */
75 symbolS
*add_symbol
; /* X_add_symbol. */
76 symbolS
*sub_symbol
; /* X_subtract_symbol. */
77 offsetT offset
; /* X_add_number. */
78 int pcrel
; /* TRUE if PC-relative relocation. */
80 bfd_reloc_code_real_type r_type
; /* Relocation type */
82 int r_type
; /* Relocation type */
87 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
90 fixP
->fx_where
= where
;
92 fixP
->fx_addsy
= add_symbol
;
93 fixP
->fx_subsy
= sub_symbol
;
94 fixP
->fx_offset
= offset
;
95 fixP
->fx_pcrel
= pcrel
;
96 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
97 fixP
->fx_r_type
= r_type
;
100 fixP
->fx_pcrel_adjust
= 0;
101 fixP
->fx_bit_fixP
= 0;
102 fixP
->fx_addnumber
= 0;
111 /* Usually, we want relocs sorted numerically, but while
112 comparing to older versions of gas that have relocs
113 reverse sorted, it is convenient to have this compile
114 time option. xoxorich. */
119 fixS
**seg_fix_rootP
= & (seg_info (now_seg
)->fix_root
);
120 fixS
**seg_fix_tailP
= & (seg_info (now_seg
)->fix_tail
);
123 #ifdef REVERSE_SORT_RELOCS
125 fixP
->fx_next
= *seg_fix_rootP
;
126 *seg_fix_rootP
= fixP
;
128 #else /* REVERSE_SORT_RELOCS */
130 fixP
->fx_next
= NULL
;
133 (*seg_fix_tailP
)->fx_next
= fixP
;
135 *seg_fix_rootP
= fixP
;
136 *seg_fix_tailP
= fixP
;
138 #endif /* REVERSE_SORT_RELOCS */
145 /* Append a string onto another string, bumping the pointer along. */
147 append (charPP
, fromP
, length
)
150 unsigned long length
;
152 /* Don't trust memcpy() of 0 chars. */
156 memcpy (*charPP
, fromP
, (int) length
);
160 #ifndef BFD_ASSEMBLER
161 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
165 * This routine records the largest alignment seen for each segment.
166 * If the beginning of the segment is aligned on the worst-case
167 * boundary, all of the other alignments within it will work. At
168 * least one object format really uses this info.
171 record_alignment (seg
, align
)
172 /* Segment to which alignment pertains */
174 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
179 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
180 bfd_set_section_alignment (stdoutput
, seg
, align
);
182 if (align
> section_alignment
[(int) seg
])
183 section_alignment
[(int) seg
] = align
;
187 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
190 chain_frchains_together_1 (section
, frchp
)
192 struct frchain
*frchp
;
194 fragS dummy
, *prev_frag
= &dummy
;
195 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
197 prev_frag
->fr_next
= frchp
->frch_root
;
198 prev_frag
= frchp
->frch_last
;
200 prev_frag
->fr_next
= 0;
209 chain_frchains_together (abfd
, section
, xxx
)
210 bfd
*abfd
; /* unused */
212 char *xxx
; /* unused */
214 segment_info_type
*info
;
216 /* BFD may have introduced its own sections without using
217 subseg_new, so it is possible that seg_info is NULL. */
218 info
= seg_info (section
);
219 if (info
!= (segment_info_type
*) NULL
)
220 chain_frchains_together_1 (section
, info
->frchainP
);
225 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
228 remove_subsegs (head
, seg
, root
, last
)
234 *root
= head
->frch_root
;
235 *last
= chain_frchains_together_1 (seg
, head
);
241 cvt_frag_to_fill (x
, fragP
)
252 object_headers
*headers
= x
;
255 switch (fragP
->fr_type
)
260 HANDLE_ALIGN (fragP
);
262 fragP
->fr_type
= rs_fill
;
263 know (fragP
->fr_var
== 1);
264 know (fragP
->fr_next
!= NULL
);
266 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
274 case rs_machine_dependent
:
276 md_convert_frag (stdoutput
, sec
, fragP
);
278 md_convert_frag (headers
, fragP
);
281 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
284 * After md_convert_frag, we make the frag into a ".space 0".
285 * Md_convert_frag() should set up any fixSs and constants
291 #ifndef WORKING_DOT_WORD
294 struct broken_word
*lie
;
296 if (fragP
->fr_subtype
)
298 fragP
->fr_fix
+= md_short_jump_size
;
299 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
300 lie
&& lie
->dispfrag
== fragP
;
301 lie
= lie
->next_broken_word
)
303 fragP
->fr_fix
+= md_long_jump_size
;
311 BAD_CASE (fragP
->fr_type
);
318 relax_and_size_seg (abfd
, sec
, xxx
)
325 flags
= bfd_get_section_flags (abfd
, sec
);
327 if (/*flags & SEC_ALLOC*/ 1)
330 segment_info_type
*seginfo
;
332 valueT size
, newsize
;
334 seginfo
= (segment_info_type
*) bfd_get_section_userdata (abfd
, sec
);
335 if (seginfo
&& seginfo
->frchainP
)
337 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
338 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
339 cvt_frag_to_fill (sec
, fragp
);
340 for (fragp
= seginfo
->frchainP
->frch_root
;
342 fragp
= fragp
->fr_next
)
343 /* walk to last elt */;
344 size
= fragp
->fr_address
+ fragp
->fr_fix
;
350 flags
|= SEC_HAS_CONTENTS
;
351 /* @@ This is just an approximation. */
352 if (seginfo
->fix_root
)
356 x
= bfd_set_section_flags (abfd
, sec
, flags
);
359 size
= md_section_align (sec
, size
);
360 x
= bfd_set_section_size (abfd
, sec
, size
);
363 /* If the size had to be rounded up, add some padding in the last
365 newsize
= bfd_get_section_size_before_reloc (sec
);
366 assert (newsize
>= size
);
369 fragS
*last
= seginfo
->frchainP
->frch_last
;
370 fragp
= seginfo
->frchainP
->frch_root
;
371 while (fragp
->fr_next
!= last
)
372 fragp
= fragp
->fr_next
;
373 last
->fr_address
= size
;
374 fragp
->fr_offset
+= newsize
- size
;
377 #ifdef tc_frob_section
378 tc_frob_section (sec
);
380 #ifdef obj_frob_section
381 obj_frob_section (sec
);
387 dump_section_relocs (abfd
, sec
, stream_
)
392 FILE *stream
= (FILE *) stream_
;
393 segment_info_type
*seginfo
= seg_info (sec
);
394 fixS
*fixp
= seginfo
->fix_root
;
399 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
402 symbolS
*s
= fixp
->fx_addsy
;
404 fprintf (stream
, " %08x: %s(%s+%x)+%x\n", fixp
,
405 S_GET_NAME (s
), s
->bsym
->section
->name
,
406 S_GET_VALUE (s
), fixp
->fx_offset
);
408 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
409 fixp
= fixp
->fx_next
;
413 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
417 adjust_reloc_syms (abfd
, sec
, xxx
)
422 segment_info_type
*seginfo
= seg_info (sec
);
428 dump_section_relocs (abfd
, sec
, stderr
);
430 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
433 symbolS
*sym
= fixp
->fx_addsy
;
434 asection
*symsec
= sym
->bsym
->section
;
435 segment_info_type
*symseginfo
= seg_info (symsec
);
437 /* If it's one of these sections, assume the symbol is definitely
438 going to be output. */
439 if (symsec
== &bfd_und_section
440 || symsec
== &bfd_abs_section
441 || bfd_is_com_section (symsec
))
444 /* Since we're reducing to section symbols, don't attempt to reduce
445 anything that's already using one. */
446 if (sym
->bsym
== symsec
->symbol
)
449 /* Is there some other reason we can't adjust this one? (E.g.,
450 call/bal links in i960-bout symbols.) */
451 #ifdef obj_fix_adjustable
452 if (! obj_fix_adjustable (fixp
))
455 /* If the section symbol isn't going to be output, the relocs
456 at least should still work. If not, figure out what to do
457 when we run into that case. */
458 fixp
->fx_offset
+= S_GET_VALUE (sym
);
460 fixp
->fx_offset
+= sym
->sy_frag
->fr_address
;
462 fixp
->fx_addsy
= symseginfo
->sym
;
465 fixp
->fx_addsy
= symbol_find (symsec
->name
);
468 fixp
->fx_addsy
= symbol_make (symsec
->name
);
469 fixp
->fx_addsy
->bsym
= symsec
->symbol
;
471 symseginfo
->sym
= fixp
->fx_addsy
;
475 dump_section_relocs (abfd
, sec
, stderr
);
479 write_contents (abfd
, sec
, xxx
)
484 segment_info_type
*seginfo
= seg_info (sec
);
485 unsigned long offset
= 0;
491 /* If seginfo is NULL, we did not create this section; don't do
496 fixup_segment (seginfo
->fix_root
, sec
);
499 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
502 #ifndef RELOC_EXPANSION_POSSIBLE
503 /* Set up reloc information as well. */
504 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
505 n
* sizeof (arelent
*));
506 bzero ((char*)relocs
, n
* sizeof (arelent
*));
509 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
512 extern arelent
*tc_gen_reloc ();
514 bfd_reloc_status_type s
;
516 if (fixp
->fx_addsy
== 0)
518 /* @@ Need some other flag to indicate which have already
523 reloc
= tc_gen_reloc (sec
, fixp
);
529 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
530 if (fixp
->fx_where
+ 4
531 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
533 /* Pass bogus address so that when bfd_perform_relocation adds
534 `address' back in, it'll come up with `data', which is where
535 we want it to operate. */
536 s
= bfd_perform_relocation (stdoutput
, reloc
, data
- reloc
->address
,
543 as_fatal ("bad return from bfd_perform_relocation");
548 n
= n
* MAX_RELOC_EXPANSION
;
549 /* Set up reloc information as well. */
550 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
551 n
* sizeof (arelent
*));
554 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
557 extern arelent
*tc_gen_reloc ();
559 bfd_reloc_status_type s
;
562 if (fixp
->fx_addsy
== 0)
564 /* @@ Need some other flag to indicate which have already
569 reloc
= tc_gen_reloc (sec
, fixp
);
571 for (j
= 0; reloc
[j
]; j
++)
573 relocs
[i
++] = reloc
[j
];
576 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
577 if (fixp
->fx_where
+ 4
578 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
580 for (j
= 0; reloc
[j
]; j
++)
582 s
= bfd_perform_relocation (stdoutput
, reloc
[j
], data
- reloc
[j
]->address
,
589 as_fatal ("bad return from bfd_perform_relocation");
597 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
599 bfd_set_section_flags (abfd
, sec
,
600 bfd_get_section_flags (abfd
, sec
) & ~SEC_RELOC
);
606 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
607 for (i
= 0; i
< n
; i
++)
611 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
612 i
, r
, r
->address
, s
->name
, r
->addend
);
617 /* Force calculations (size, vma) to get done. */
618 bfd_set_section_contents (stdoutput
, sec
, "", 0, (addressT
) 0);
620 /* Write out the frags. */
621 if (! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
624 for (frags
= seginfo
->frchainP
->frch_root
;
626 frags
= frags
->fr_next
)
629 unsigned long fill_size
;
633 assert (frags
->fr_type
== rs_fill
);
636 x
= bfd_set_section_contents (stdoutput
, sec
,
637 frags
->fr_literal
, offset
,
640 offset
+= frags
->fr_fix
;
642 fill_literal
= frags
->fr_literal
+ frags
->fr_fix
;
643 fill_size
= frags
->fr_var
;
644 count
= frags
->fr_offset
;
646 if (fill_size
&& count
)
649 x
= bfd_set_section_contents (stdoutput
, sec
,
650 fill_literal
, offset
,
651 (bfd_size_type
) fill_size
);
659 #if defined (BFD_ASSEMBLER) || !defined (BFD)
664 register struct frchain
*frchainP
; /* Track along all frchains. */
665 register fragS
*fragP
; /* Track along all frags. */
667 #if !defined (BFD_ASSEMBLER) && !defined (OBJ_VMS)
668 long object_file_size
;
671 /* Do we really want to write it? */
674 n_warns
= had_warnings ();
675 n_errs
= had_errors ();
676 /* The -Z flag indicates that an object file should be generated,
677 regardless of warnings and errors. */
680 if (n_warns
|| n_errs
)
681 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
682 n_errs
, n_errs
== 1 ? "" : "s",
683 n_warns
, n_warns
== 1 ? "" : "s");
688 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
689 n_errs
, n_errs
== 1 ? "" : "s",
690 n_warns
, n_warns
== 1 ? "" : "s");
696 * Under VMS we try to be compatible with VAX-11 "C". Thus, we
697 * call a routine to check for the definition of the procedure
698 * "_main", and if so -- fix it up so that it can be program
701 VMS_Check_For_Main ();
704 /* After every sub-segment, we fake an ".align ...". This conforms to
705 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
706 frag that requires least thought. ".align" frags like to have a
707 following frag since that makes calculating their intended length
710 @@ Is this really necessary?? */
711 #ifndef SUB_SEGMENT_ALIGN
713 #define SUB_SEGMENT_ALIGN(SEG) (0)
715 #define SUB_SEGMENT_ALIGN(SEG) (2)
718 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
721 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
723 subseg_new (frchainP
->frch_seg
, frchainP
->frch_subseg
);
725 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
726 /* frag_align will have left a new frag.
727 Use this last frag for an empty ".fill".
730 Create a last frag. Do not leave a "being filled in frag". */
731 frag_wane (frag_now
);
732 frag_now
->fr_fix
= 0;
733 know (frag_now
->fr_next
== NULL
);
734 /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
735 /* Above shows we haven't left a half-completed object on obstack. */
738 /* From now on, we don't care about sub-segments. Build one frag chain
739 for each segment. Linked thru fr_next. */
742 /* Remove the sections created by gas for its own purposes. */
744 asection
**seclist
, *sec
;
745 seclist
= &stdoutput
->sections
;
746 while (seclist
&& *seclist
)
749 while (sec
== big_section
750 || sec
== reg_section
751 || sec
== pass1_section
752 || sec
== diff_section
753 || sec
== absent_section
)
757 stdoutput
->section_count
--;
762 seclist
= &(*seclist
)->next
;
766 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
768 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
769 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
770 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
773 /* We have two segments. If user gave -R flag, then we must put the
774 data frags into the text segment. Do this before relaxing so
775 we know to take advantage of -R and make shorter addresses. */
776 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
780 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
781 seg_info (data_section
)->frchainP
->frch_root
;
782 seg_info (text_section
)->frchainP
->frch_last
=
783 seg_info (data_section
)->frchainP
->frch_last
;
784 seg_info (data_section
)->frchainP
= 0;
788 text_last_frag
->fr_next
= data_frag_root
;
789 text_last_frag
= data_last_frag
;
790 data_last_frag
= NULL
;
791 data_frag_root
= NULL
;
794 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
795 tmp
->fx_next
= data_fix_root
;
796 text_fix_tail
= data_fix_tail
;
799 text_fix_root
= data_fix_root
;
800 data_fix_root
= NULL
;
807 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
809 relax_segment (text_frag_root
, SEG_TEXT
);
810 relax_segment (data_frag_root
, SEG_DATA
);
811 relax_segment (bss_frag_root
, SEG_BSS
);
813 * Now the addresses of frags are correct within the segment.
816 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
817 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
818 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
821 * Join the 2 segments into 1 huge segment.
822 * To do this, re-compute every rn_address in the SEG_DATA frags.
823 * Then join the data frags after the text frags.
825 * Determine a_data [length of data segment].
829 register relax_addressT slide
;
831 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
833 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
834 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
835 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
837 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
838 /* For b.out: If the data section has a strict alignment
839 requirement, its load address in the .o file will be
840 rounded up from the size of the text section. These
841 two values are *not* the same! Similarly for the bss
843 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
846 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
848 fragP
->fr_address
+= slide
;
849 } /* for each data frag */
851 know (text_last_frag
!= 0);
852 text_last_frag
->fr_next
= data_frag_root
;
856 H_SET_DATA_SIZE (&headers
, 0);
860 /* See above comments on b.out data section address. */
863 if (data_last_frag
== 0)
864 bss_vma
= H_GET_TEXT_SIZE (&headers
);
866 bss_vma
= data_last_frag
->fr_address
;
867 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
868 bss_address_frag
.fr_address
= bss_vma
;
870 #else /* ! OBJ_BOUT */
871 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
872 H_GET_DATA_SIZE (&headers
));
875 /* Slide all the frags */
878 relax_addressT slide
= bss_address_frag
.fr_address
;
880 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
882 fragP
->fr_address
+= slide
;
883 } /* for each bss frag */
886 #endif /* ! OBJ_BOUT */
889 H_SET_BSS_SIZE (&headers
,
890 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
892 H_SET_BSS_SIZE (&headers
, 0);
893 #endif /* BFD_ASSEMBLER */
895 #ifndef BFD_ASSEMBLER
898 * Crawl the symbol chain.
900 * For each symbol whose value depends on a frag, take the address of
901 * that frag and subsume it into the value of the symbol.
902 * After this, there is just one way to lookup a symbol value.
903 * Values are left in their final state for object file emission.
904 * We adjust the values of 'L' local symbols, even if we do
905 * not intend to emit them to the object file, because their values
906 * are needed for fix-ups.
908 * Unless we saw a -L flag, remove all symbols that begin with 'L'
909 * from the symbol chain. (They are still pointed to by the fixes.)
911 * Count the remaining symbols.
912 * Assign a symbol number to each symbol.
913 * Count the number of string-table chars we will emit.
914 * Put this info into the headers as appropriate.
917 know (zero_address_frag
.fr_address
== 0);
918 string_byte_count
= sizeof (string_byte_count
);
920 obj_crawl_symbol_chain (&headers
);
922 if (string_byte_count
== sizeof (string_byte_count
))
923 string_byte_count
= 0;
925 H_SET_STRING_SIZE (&headers
, string_byte_count
);
928 * Addresses of frags now reflect addresses we use in the object file.
929 * Symbol values are correct.
930 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
931 * Also converting any machine-dependent frags using md_convert_frag();
933 subseg_change (SEG_TEXT
, 0);
935 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
937 cvt_frag_to_fill (&headers
, fragP
);
939 /* Some assert macros don't work with # directives mixed in. */
941 if (!(fragP
->fr_next
== NULL
943 || fragP
->fr_next
== data_frag_root
945 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
946 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
950 #endif /* ! BFD_ASSEMBLER */
952 #ifndef WORKING_DOT_WORD
954 struct broken_word
*lie
;
955 struct broken_word
**prevP
;
957 prevP
= &broken_words
;
958 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
962 fix_new (lie
->frag
, lie
->word_goes_here
- lie
->frag
->fr_literal
,
963 2, lie
->add
, lie
->sub
, lie
->addnum
, 0,
966 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
967 fix_new (lie
->frag
, lie
->word_goes_here
- lie
->frag
->fr_literal
,
969 lie
->sub
, lie
->addnum
,
973 fix_new_ns32k (lie
->frag
,
974 lie
->word_goes_here
- lie
->frag
->fr_literal
,
981 fix_new (lie
->frag
, lie
->word_goes_here
- lie
->frag
->fr_literal
,
983 lie
->sub
, lie
->addnum
,
985 #endif /* TC_NS32K */
986 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
987 #endif /* BFD_ASSEMBLER */
988 *prevP
= lie
->next_broken_word
;
991 prevP
= &(lie
->next_broken_word
);
993 for (lie
= broken_words
; lie
;)
995 struct broken_word
*untruth
;
998 addressT from_addr
, to_addr
;
1001 fragP
= lie
->dispfrag
;
1003 /* Find out how many broken_words go here. */
1005 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1006 if (untruth
->added
== 1)
1009 table_ptr
= lie
->dispfrag
->fr_opcode
;
1010 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1011 /* Create the jump around the long jumps. This is a short
1012 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1013 from_addr
= table_addr
;
1014 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1015 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1016 table_ptr
+= md_short_jump_size
;
1017 table_addr
+= md_short_jump_size
;
1019 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1021 if (lie
->added
== 2)
1023 /* Patch the jump table */
1024 /* This is the offset from ??? to table_ptr+0 */
1025 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1026 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1027 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1029 if (untruth
->use_jump
== lie
)
1030 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1033 /* Install the long jump */
1034 /* this is a long jump from table_ptr+0 to the final target */
1035 from_addr
= table_addr
;
1036 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1037 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1038 table_ptr
+= md_long_jump_size
;
1039 table_addr
+= md_long_jump_size
;
1043 #endif /* not WORKING_DOT_WORD */
1045 #ifndef BFD_ASSEMBLER
1049 * Scan every FixS performing fixups. We had to wait until now to do
1050 * this because md_convert_frag() may have made some fixSs.
1054 subseg_change (SEG_TEXT
, 0);
1055 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1056 subseg_change (SEG_DATA
, 0);
1057 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1058 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1060 /* FIXME move this stuff into the pre-write-hook */
1061 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1062 H_SET_ENTRY_POINT (&headers
, 0);
1064 obj_pre_write_hook (&headers
); /* extra coff stuff */
1066 object_file_size
= H_GET_FILE_SIZE (&headers
);
1067 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1069 output_file_create (out_file_name
);
1071 obj_header_append (&next_object_file_charP
, &headers
);
1073 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1078 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1080 register long count
;
1081 register char *fill_literal
;
1082 register long fill_size
;
1084 know (fragP
->fr_type
== rs_fill
);
1085 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1086 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1087 fill_size
= fragP
->fr_var
;
1088 know (fragP
->fr_offset
>= 0);
1090 for (count
= fragP
->fr_offset
; count
; count
--)
1092 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1095 } /* for each code frag. */
1097 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1102 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1103 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
)));
1105 /* Make addresses in data relocation directives relative to beginning of
1106 * first data fragment, not end of last text fragment: alignment of the
1107 * start of the data segment may place a gap between the segments.
1109 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1111 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1112 #endif /* TC_I960 */
1114 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
)));
1117 * Emit line number entries.
1119 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1120 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
)));
1125 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1126 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
)));
1132 if (string_byte_count
> 0)
1134 obj_emit_strings (&next_object_file_charP
);
1135 } /* only if we have a string table */
1138 bfd_seek (stdoutput
, 0, 0);
1139 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1142 /* Write the data to the file */
1143 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1146 output_file_close (out_file_name
);
1147 } /* non vms output */
1150 * Now do the VMS-dependent part of writing the object file
1152 VMS_write_object_file (H_GET_TEXT_SIZE (&headers
),
1153 H_GET_DATA_SIZE (&headers
),
1154 H_GET_BSS_SIZE (&headers
),
1155 text_frag_root
, data_frag_root
);
1157 #else /* BFD_ASSEMBLER */
1159 #ifdef obj_check_file_symbols
1160 obj_check_file_symbols ();
1163 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1165 /* Set up symbol table, and write it out. */
1171 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1175 if (! symp
->sy_resolved
)
1177 if (symp
->sy_value
.X_seg
== absolute_section
)
1179 /* This is the normal case; skip the call. */
1182 + symp
->sy_frag
->fr_address
));
1183 symp
->sy_resolved
= 1;
1186 resolve_symbol_value (symp
);
1189 /* So far, common symbols have been treated like undefined symbols.
1190 Put them in the common section now. */
1191 if (S_IS_DEFINED (symp
) == 0
1192 && S_GET_VALUE (symp
) != 0)
1193 S_SET_SEGMENT (symp
, &bfd_com_section
);
1195 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1196 S_GET_NAME (symp
), symp
,
1199 segment_name (symp
->bsym
->section
));
1203 #ifdef obj_frob_symbol
1204 obj_frob_symbol (symp
, punt
);
1208 #ifdef tc_frob_symbol
1209 tc_frob_symbol (symp
, punt
);
1214 /* If we don't want to keep this symbol, splice it out of the
1216 if (S_IS_LOCAL (symp
))
1218 symbolS
*prev
, *next
;
1220 prev
= symbol_previous (symp
);
1221 next
= symbol_next (symp
);
1223 verify_symbol_chain_2 (symp
);
1227 symbol_next (prev
) = next
;
1230 else if (symp
== symbol_rootP
)
1231 symbol_rootP
= next
;
1235 symbol_previous (next
) = prev
;
1237 symbol_lastP
= prev
;
1240 verify_symbol_chain_2 (prev
);
1242 verify_symbol_chain_2 (next
);
1247 /* Set the value into the BFD symbol. Up til now the value
1248 has only been kept in the gas symbolS struct. */
1249 symp
->bsym
->value
= S_GET_VALUE (symp
);
1258 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1260 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1261 n
* sizeof (asymbol
*));
1262 symp
= symbol_rootP
;
1263 for (i
= 0; i
< n
; i
++, symp
= symbol_next (symp
))
1265 asympp
[i
] = symp
->bsym
;
1268 result
= bfd_set_symtab (stdoutput
, asympp
, n
);
1269 assert (result
== true);
1274 #ifdef obj_frob_file
1275 /* If obj_frob_file changes the symbol value at this point, it is
1276 responsible for moving the changed value into symp->bsym->value
1277 as well. Hopefully all symbol value changing can be done in
1278 {obj,tc}_frob_symbol. */
1282 /* Now that all the sizes are known, and contents correct, we can
1283 start writing the file. */
1284 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1286 output_file_close (out_file_name
);
1287 #endif /* BFD_ASSEMBLER */
1294 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1299 * After this, all frags in this segment have addresses that are correct
1300 * within the segment. Since segments live in different file addresses,
1301 * these frag addresses may not be the same as final object-file addresses.
1304 /* Subroutines of relax_segment. */
1310 for (; f1
; f1
= f1
->fr_next
)
1311 if (f1
->fr_next
== f2
)
1316 /* Relax_align. Advance location counter to next address that has 'alignment'
1317 lowest order bits all 0s, return size of adjustment made. */
1318 static relax_addressT
1319 relax_align (address
, alignment
)
1320 register relax_addressT address
; /* Address now. */
1321 register int alignment
; /* Alignment (binary). */
1323 relax_addressT mask
;
1324 relax_addressT new_address
;
1326 mask
= ~((~0) << alignment
);
1327 new_address
= (address
+ mask
) & (~mask
);
1329 /* We must provide lots of padding, so the linker can discard it
1330 when needed. The linker will not add extra space, ever. */
1331 new_address
+= (1 << alignment
);
1332 return (new_address
- address
);
1336 relax_segment (segment_frag_root
, segment
)
1337 struct frag
*segment_frag_root
;
1340 register struct frag
*fragP
;
1341 register relax_addressT address
;
1342 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1343 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1345 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1346 subseg_change (segment
, 0);
1348 /* For each frag in segment: count and store (a 1st guess of)
1351 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1353 fragP
->fr_address
= address
;
1354 address
+= fragP
->fr_fix
;
1356 switch (fragP
->fr_type
)
1359 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1363 address
+= relax_align (address
, (int) fragP
->fr_offset
);
1367 /* Assume .org is nugatory. It will grow with 1st relax. */
1370 case rs_machine_dependent
:
1371 address
+= md_estimate_size_before_relax (fragP
, segment
);
1374 #ifndef WORKING_DOT_WORD
1375 /* Broken words don't concern us yet */
1376 case rs_broken_word
:
1381 BAD_CASE (fragP
->fr_type
);
1383 } /* switch(fr_type) */
1384 } /* for each frag in the segment */
1388 long stretch
; /* May be any size, 0 or negative. */
1389 /* Cumulative number of addresses we have */
1390 /* relaxed this pass. */
1391 /* We may have relaxed more than one address. */
1392 long stretched
; /* Have we stretched on this pass? */
1393 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1394 grew, and another shrank. If a branch instruction doesn't fit anymore,
1395 we could be scrod. */
1399 stretch
= stretched
= 0;
1400 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1403 unsigned long was_address
;
1410 was_address
= fragP
->fr_address
;
1411 address
= fragP
->fr_address
+= stretch
;
1412 symbolP
= fragP
->fr_symbol
;
1413 offset
= fragP
->fr_offset
;
1415 switch (fragP
->fr_type
)
1417 case rs_fill
: /* .fill never relaxes. */
1421 #ifndef WORKING_DOT_WORD
1422 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1423 for it I do not want to write it. I do not want to have
1424 anything to do with it. This is not the proper way to
1425 implement this misfeature. */
1426 case rs_broken_word
:
1428 struct broken_word
*lie
;
1429 struct broken_word
*untruth
;
1431 /* Yes this is ugly (storing the broken_word pointer
1432 in the symbol slot). Still, this whole chunk of
1433 code is ugly, and I don't feel like doing anything
1434 about it. Think of it as stubbornness in action. */
1436 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1437 lie
&& lie
->dispfrag
== fragP
;
1438 lie
= lie
->next_broken_word
)
1444 offset
= (lie
->add
->sy_frag
->fr_address
1445 + S_GET_VALUE (lie
->add
)
1447 - (lie
->sub
->sy_frag
->fr_address
1448 + S_GET_VALUE (lie
->sub
)));
1449 if (offset
<= -32768 || offset
>= 32767)
1454 sprint_value (buf
, lie
->addnum
);
1455 as_warn (".word %s-%s+%s didn't fit",
1456 S_GET_NAME (lie
->add
),
1457 S_GET_NAME (lie
->sub
),
1461 if (fragP
->fr_subtype
== 0)
1463 fragP
->fr_subtype
++;
1464 growth
+= md_short_jump_size
;
1466 for (untruth
= lie
->next_broken_word
;
1467 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1468 untruth
= untruth
->next_broken_word
)
1469 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1470 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1473 untruth
->use_jump
= lie
;
1475 growth
+= md_long_jump_size
;
1480 } /* case rs_broken_word */
1483 growth
= (relax_align ((relax_addressT
) (address
1486 - relax_align ((relax_addressT
) (was_address
1496 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1497 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1498 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1499 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1500 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1501 know (symbolP
->sy_frag
);
1502 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1503 || (symbolP
->sy_frag
== &zero_address_frag
));
1505 target
+= S_GET_VALUE (symbolP
)
1506 + symbolP
->sy_frag
->fr_address
;
1507 } /* if we have a symbol */
1509 know (fragP
->fr_next
);
1510 after
= fragP
->fr_next
->fr_address
;
1511 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1512 /* Growth may be negative, but variable part of frag
1513 cannot have fewer than 0 chars. That is, we can't
1516 growth
-= stretch
; /* This is an absolute growth factor */
1519 case rs_machine_dependent
:
1521 const relax_typeS
*this_type
;
1522 const relax_typeS
*start_type
;
1523 relax_substateT next_state
;
1524 relax_substateT this_state
;
1526 this_state
= fragP
->fr_subtype
;
1527 start_type
= this_type
= md_relax_table
+ this_state
;
1532 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1533 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1534 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1535 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1536 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1538 know (symbolP
->sy_frag
);
1539 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1540 || symbolP
->sy_frag
== &zero_address_frag
);
1542 S_GET_VALUE (symbolP
)
1543 + symbolP
->sy_frag
->fr_address
;
1545 /* If frag has yet to be reached on this pass,
1546 assume it will move by STRETCH just as we did.
1547 If this is not so, it will be because some frag
1548 between grows, and that will force another pass.
1550 Beware zero-length frags.
1552 There should be a faster way to do this. */
1554 if (symbolP
->sy_frag
->fr_address
>= was_address
1555 && is_dnrange (fragP
, symbolP
->sy_frag
))
1561 aim
= target
- address
- fragP
->fr_fix
;
1562 /* The displacement is affected by the instruction size
1563 for the 32k architecture. I think we ought to be able
1564 to add fragP->fr_pcrel_adjust in all cases (it should be
1565 zero if not used), but just in case it breaks something
1566 else we'll put this inside #ifdef NS32K ... #endif */
1568 if (fragP
->fr_pcrel_adjust
)
1571 aim
+= fragP
->fr_pcrel_adjust
;
1575 /* Look backwards. */
1576 for (next_state
= this_type
->rlx_more
; next_state
;)
1577 if (aim
>= this_type
->rlx_backward
)
1581 /* Grow to next state. */
1582 this_state
= next_state
;
1583 this_type
= md_relax_table
+ this_state
;
1584 next_state
= this_type
->rlx_more
;
1589 #ifdef M68K_AIM_KLUDGE
1590 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
1592 /* Look forwards. */
1593 for (next_state
= this_type
->rlx_more
; next_state
;)
1594 if (aim
<= this_type
->rlx_forward
)
1598 /* Grow to next state. */
1599 this_state
= next_state
;
1600 this_type
= md_relax_table
+ this_state
;
1601 next_state
= this_type
->rlx_more
;
1605 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
1607 fragP
->fr_subtype
= this_state
;
1612 BAD_CASE (fragP
->fr_type
);
1620 } /* For each frag in the segment. */
1622 while (stretched
); /* Until nothing further to relax. */
1626 * We now have valid fr_address'es for each frag.
1630 * All fr_address's are correct, relative to their own segment.
1631 * We have made all the fixS we will ever make.
1633 } /* relax_segment() */
1637 Go through all the fixS's in a segment and see which ones can be
1638 handled now. (These consist of fixS where we have since discovered
1639 the value of a symbol, or the address of the frag involved.)
1640 For each one, call md_apply_fix to put the fix into the frag data.
1642 Result is a count of how many relocation structs will be needed to
1643 handle the remaining fixS's that we couldn't completely handle here.
1644 These will be output later by emit_relocations(). */
1647 fixup_segment (fixP
, this_segment_type
)
1648 register fixS
*fixP
;
1649 segT this_segment_type
; /* N_TYPE bits for segment. */
1651 register long seg_reloc_count
;
1652 register symbolS
*add_symbolP
;
1653 register symbolS
*sub_symbolP
;
1656 register char *place
;
1657 register long where
;
1658 register char pcrel
;
1659 register fragS
*fragP
;
1660 register segT add_symbol_segment
= absolute_section
;
1662 seg_reloc_count
= 0;
1663 /* If the linker is doing the relaxing, we must not do any fixups */
1665 for (; fixP
; fixP
= fixP
->fx_next
)
1668 for (; fixP
; fixP
= fixP
->fx_next
)
1670 fragP
= fixP
->fx_frag
;
1672 where
= fixP
->fx_where
;
1673 place
= fragP
->fr_literal
+ where
;
1674 size
= fixP
->fx_size
;
1675 add_symbolP
= fixP
->fx_addsy
;
1677 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
1679 /* Relocation should be done via the associated 'bal'
1680 entry point symbol. */
1682 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
1684 as_bad ("No 'bal' entry point for leafproc %s",
1685 S_GET_NAME (add_symbolP
));
1688 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
1691 sub_symbolP
= fixP
->fx_subsy
;
1692 add_number
= fixP
->fx_offset
;
1693 pcrel
= fixP
->fx_pcrel
;
1696 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
1703 if (S_GET_SEGMENT (sub_symbolP
) != absolute_section
)
1704 as_bad ("Negative of non-absolute symbol %s",
1705 S_GET_NAME (sub_symbolP
));
1707 add_number
-= S_GET_VALUE (sub_symbolP
);
1709 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
1710 && (SEG_NORMAL (add_symbol_segment
)
1711 || (add_symbol_segment
== absolute_section
)))
1713 /* Difference of 2 symbols from same segment.
1714 Can't make difference of 2 undefineds: 'value' means
1715 something different for N_UNDF. */
1717 /* Makes no sense to use the difference of 2 arbitrary symbols
1718 as the target of a call instruction. */
1721 as_bad ("callj to difference of 2 symbols");
1723 #endif /* TC_I960 */
1724 add_number
+= S_GET_VALUE (add_symbolP
) -
1725 S_GET_VALUE (sub_symbolP
);
1728 fixP
->fx_addsy
= NULL
;
1732 /* Different segments in subtraction. */
1733 know (!(S_IS_EXTERNAL (sub_symbolP
)
1734 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
1736 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
1738 add_number
-= S_GET_VALUE (sub_symbolP
);
1743 sprint_value (buf
, fragP
->fr_address
+ where
);
1744 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
1745 segment_name (S_GET_SEGMENT (sub_symbolP
)),
1746 S_GET_NAME (sub_symbolP
), buf
);
1753 if (add_symbol_segment
== this_segment_type
&& pcrel
)
1756 * This fixup was made when the symbol's segment was
1757 * SEG_UNKNOWN, but it is now in the local segment.
1758 * So we know how to do the address without relocation.
1761 /* reloc_callj() may replace a 'call' with a 'calls' or a
1762 'bal', in which cases it modifies *fixP as appropriate.
1763 In the case of a 'calls', no further work is required,
1764 and *fixP has been set up to make the rest of the code
1767 #endif /* TC_I960 */
1769 add_number
+= S_GET_VALUE (add_symbolP
);
1770 add_number
-= md_pcrel_from (fixP
);
1771 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
1772 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1776 if (add_symbol_segment
== absolute_section
)
1779 /* See comment about reloc_callj() above. */
1781 #endif /* TC_I960 */
1782 add_number
+= S_GET_VALUE (add_symbolP
);
1783 fixP
->fx_addsy
= NULL
;
1786 else if (add_symbol_segment
== undefined_section
1787 #ifdef BFD_ASSEMBLER
1788 || add_symbol_segment
== &bfd_com_section
1793 if ((int) fixP
->fx_bit_fixP
== 13)
1795 /* This is a COBR instruction. They have only a
1796 * 13-bit displacement and are only to be used
1797 * for local branches: flag as error, don't generate
1800 as_bad ("can't use COBR format with external label");
1801 fixP
->fx_addsy
= NULL
; /* No relocations please. */
1804 #endif /* TC_I960 */
1808 if (S_IS_COMMON (add_symbolP
))
1809 add_number
+= S_GET_VALUE (add_symbolP
);
1810 #endif /* TE_I386AIX */
1811 #endif /* OBJ_COFF */
1817 add_number
+= S_GET_VALUE (add_symbolP
);
1819 } /* if not in local seg */
1820 } /* if there was a + symbol */
1824 add_number
-= md_pcrel_from (fixP
);
1825 if (add_symbolP
== 0)
1827 fixP
->fx_addsy
= &abs_symbol
;
1829 } /* if there's an add_symbol */
1832 if (!fixP
->fx_bit_fixP
)
1835 && (add_number
& ~0xFF)
1836 && ((add_number
& ~0xFF) != (-1 & ~0xFF)))
1838 && (add_number
& ~0xFFFF)
1839 && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF)))
1841 && (add_number
& ~(valueT
)0xFFFFFFFF)
1842 && ((add_number
& ~(valueT
)0xFFFFFFFF) != (-1 & ~(valueT
)0xFFFFFFFF)))
1846 sprint_value (buf
, fragP
->fr_address
+ where
);
1847 as_bad ("Value of %d too large for field of %d bytes at %s",
1848 add_number
, size
, buf
);
1849 } /* generic error checking */
1850 #ifdef WARN_SIGNED_OVERFLOW_WORD
1851 /* Warn if a .word value is too large when treated as a signed
1852 number. We already know it is not too negative. This is to
1853 catch over-large switches generated by gcc on the 68k. */
1856 && add_number
> 0x7fff)
1857 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
1858 add_number
, fragP
->fr_address
+ where
);
1860 } /* not a bit fix */
1862 #ifdef BFD_ASSEMBLER
1863 md_apply_fix (fixP
, &add_number
);
1865 md_apply_fix (fixP
, add_number
);
1867 } /* For each fixS in this segment. */
1874 /* two relocs per callj under coff. */
1875 for (fixP
= topP
; fixP
; fixP
= fixP
->fx_next
)
1877 if (fixP
->fx_callj
&& fixP
->fx_addsy
!= 0)
1880 } /* if callj and not already fixed. */
1881 } /* for each fix */
1883 #endif /* TC_I960 */
1885 #endif /* OBJ_COFF */
1886 return (seg_reloc_count
);
1889 /* end of write.c */