1 /* write.c - emit .o file
2 Copyright (C) 1986, 87, 90, 91, 92, 93, 1994 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* This thing should be set up to do byteordering correctly. But... */
25 #include "output-file.h"
27 /* This looks like a good idea. Let's try turning it on always, for now. */
28 #undef BFD_FAST_SECTION_FILL
29 #define BFD_FAST_SECTION_FILL
31 /* The NOP_OPCODE is for the alignment fill value. Fill it with a nop
32 instruction so that the disassembler does not choke on it. */
34 #define NOP_OPCODE 0x00
37 #ifndef TC_ADJUST_RELOC_COUNT
38 #define TC_ADJUST_RELOC_COUNT(FIXP,COUNT)
41 #ifndef TC_FORCE_RELOCATION
42 #define TC_FORCE_RELOCATION(FIXP) 0
45 #ifndef WORKING_DOT_WORD
46 extern CONST
int md_short_jump_size
;
47 extern CONST
int md_long_jump_size
;
50 int symbol_table_frozen
;
51 void print_fixup
PARAMS ((fixS
*));
54 static void renumber_sections
PARAMS ((bfd
*, asection
*, PTR
));
56 /* We generally attach relocs to frag chains. However, after we have
57 chained these all together into a segment, any relocs we add after
58 that must be attached to a segment. This will include relocs added
59 in md_estimate_size_for_relax, for example. */
60 static int frags_chained
= 0;
66 struct frag
*text_frag_root
;
67 struct frag
*data_frag_root
;
68 struct frag
*bss_frag_root
;
70 struct frag
*text_last_frag
; /* Last frag in segment. */
71 struct frag
*data_last_frag
; /* Last frag in segment. */
72 static struct frag
*bss_last_frag
; /* Last frag in segment. */
76 static object_headers headers
;
79 long string_byte_count
;
80 char *next_object_file_charP
; /* Tracks object file bytes. */
83 int magic_number_for_object_file
= DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE
;
86 #endif /* BFD_ASSEMBLER */
89 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
90 symbolS
*add
, symbolS
*sub
,
91 offsetT offset
, int pcrel
,
92 bfd_reloc_code_real_type r_type
));
94 static fixS
*fix_new_internal
PARAMS ((fragS
*, int where
, int size
,
95 symbolS
*add
, symbolS
*sub
,
96 offsetT offset
, int pcrel
,
99 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
100 static long fixup_segment
PARAMS ((fixS
* fixP
, segT this_segment_type
));
102 static relax_addressT relax_align
PARAMS ((relax_addressT addr
, int align
));
107 * Create a fixS in obstack 'notes'.
110 fix_new_internal (frag
, where
, size
, add_symbol
, sub_symbol
, offset
, pcrel
,
112 fragS
*frag
; /* Which frag? */
113 int where
; /* Where in that frag? */
114 int size
; /* 1, 2, or 4 usually. */
115 symbolS
*add_symbol
; /* X_add_symbol. */
116 symbolS
*sub_symbol
; /* X_op_symbol. */
117 offsetT offset
; /* X_add_number. */
118 int pcrel
; /* TRUE if PC-relative relocation. */
120 bfd_reloc_code_real_type r_type
; /* Relocation type */
122 int r_type
; /* Relocation type */
127 fixP
= (fixS
*) obstack_alloc (¬es
, sizeof (fixS
));
129 fixP
->fx_frag
= frag
;
130 fixP
->fx_where
= where
;
131 fixP
->fx_size
= size
;
132 fixP
->fx_addsy
= add_symbol
;
133 fixP
->fx_subsy
= sub_symbol
;
134 fixP
->fx_offset
= offset
;
135 fixP
->fx_pcrel
= pcrel
;
137 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
138 fixP
->fx_r_type
= r_type
;
140 fixP
->fx_im_disp
= 0;
141 fixP
->fx_pcrel_adjust
= 0;
142 fixP
->fx_bit_fixP
= 0;
143 fixP
->fx_addnumber
= 0;
144 fixP
->tc_fix_data
= NULL
;
148 #if defined (TC_I960) || defined (TC_NS32K)
152 as_where (&fixP
->fx_file
, &fixP
->fx_line
);
154 /* Usually, we want relocs sorted numerically, but while
155 comparing to older versions of gas that have relocs
156 reverse sorted, it is convenient to have this compile
157 time option. xoxorich. */
162 fixS
**seg_fix_rootP
= (frags_chained
163 ? &seg_info (now_seg
)->fix_root
164 : &frchain_now
->fix_root
);
165 fixS
**seg_fix_tailP
= (frags_chained
166 ? &seg_info (now_seg
)->fix_tail
167 : &frchain_now
->fix_tail
);
170 #ifdef REVERSE_SORT_RELOCS
172 fixP
->fx_next
= *seg_fix_rootP
;
173 *seg_fix_rootP
= fixP
;
175 #else /* REVERSE_SORT_RELOCS */
177 fixP
->fx_next
= NULL
;
180 (*seg_fix_tailP
)->fx_next
= fixP
;
182 *seg_fix_rootP
= fixP
;
183 *seg_fix_tailP
= fixP
;
185 #endif /* REVERSE_SORT_RELOCS */
192 /* Create a fixup relative to a symbol (plus a constant). */
195 fix_new (frag
, where
, size
, add_symbol
, offset
, pcrel
, r_type
)
196 fragS
*frag
; /* Which frag? */
197 int where
; /* Where in that frag? */
198 short int size
; /* 1, 2, or 4 usually. */
199 symbolS
*add_symbol
; /* X_add_symbol. */
200 offsetT offset
; /* X_add_number. */
201 int pcrel
; /* TRUE if PC-relative relocation. */
203 bfd_reloc_code_real_type r_type
; /* Relocation type */
205 int r_type
; /* Relocation type */
208 return fix_new_internal (frag
, where
, size
, add_symbol
,
209 (symbolS
*) NULL
, offset
, pcrel
, r_type
);
212 /* Create a fixup for an expression. Currently we only support fixups
213 for difference expressions. That is itself more than most object
214 file formats support anyhow. */
217 fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
)
218 fragS
*frag
; /* Which frag? */
219 int where
; /* Where in that frag? */
220 short int size
; /* 1, 2, or 4 usually. */
221 expressionS
*exp
; /* Expression. */
222 int pcrel
; /* TRUE if PC-relative relocation. */
224 bfd_reloc_code_real_type r_type
; /* Relocation type */
226 int r_type
; /* Relocation type */
239 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
240 the difference expression cannot immediately be reduced. */
242 extern symbolS
*make_expr_symbol ();
243 symbolS
*stmp
= make_expr_symbol (exp
);
244 exp
->X_op
= O_symbol
;
245 exp
->X_op_symbol
= 0;
246 exp
->X_add_symbol
= stmp
;
247 exp
->X_add_number
= 0;
248 return fix_new_exp (frag
, where
, size
, exp
, pcrel
, r_type
);
252 sub
= exp
->X_add_symbol
;
253 off
= exp
->X_add_number
;
257 sub
= exp
->X_op_symbol
;
260 add
= exp
->X_add_symbol
;
263 off
= exp
->X_add_number
;
267 as_bad ("expression too complex for fixup");
270 return fix_new_internal (frag
, where
, size
, add
, sub
, off
,
274 /* Append a string onto another string, bumping the pointer along. */
276 append (charPP
, fromP
, length
)
279 unsigned long length
;
281 /* Don't trust memcpy() of 0 chars. */
285 memcpy (*charPP
, fromP
, length
);
289 #ifndef BFD_ASSEMBLER
290 int section_alignment
[SEG_MAXIMUM_ORDINAL
];
294 * This routine records the largest alignment seen for each segment.
295 * If the beginning of the segment is aligned on the worst-case
296 * boundary, all of the other alignments within it will work. At
297 * least one object format really uses this info.
300 record_alignment (seg
, align
)
301 /* Segment to which alignment pertains */
303 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
308 if (align
> bfd_get_section_alignment (stdoutput
, seg
))
309 bfd_set_section_alignment (stdoutput
, seg
, align
);
311 if (align
> section_alignment
[(int) seg
])
312 section_alignment
[(int) seg
] = align
;
318 /* Reset the section indices after removing the gas created sections. */
321 renumber_sections (abfd
, sec
, countparg
)
326 int *countp
= (int *) countparg
;
328 sec
->index
= *countp
;
332 #endif /* defined (BFD_ASSEMBLER) */
334 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
337 chain_frchains_together_1 (section
, frchp
)
339 struct frchain
*frchp
;
341 fragS dummy
, *prev_frag
= &dummy
;
343 fixS fix_dummy
, *prev_fix
= &fix_dummy
;
346 for (; frchp
&& frchp
->frch_seg
== section
; frchp
= frchp
->frch_next
)
348 prev_frag
->fr_next
= frchp
->frch_root
;
349 prev_frag
= frchp
->frch_last
;
351 if (frchp
->fix_root
!= (fixS
*) NULL
)
353 if (seg_info (section
)->fix_root
== (fixS
*) NULL
)
354 seg_info (section
)->fix_root
= frchp
->fix_root
;
355 prev_fix
->fx_next
= frchp
->fix_root
;
356 seg_info (section
)->fix_tail
= frchp
->fix_tail
;
357 prev_fix
= frchp
->fix_tail
;
361 prev_frag
->fr_next
= 0;
370 chain_frchains_together (abfd
, section
, xxx
)
371 bfd
*abfd
; /* unused */
373 PTR xxx
; /* unused */
375 segment_info_type
*info
;
377 /* BFD may have introduced its own sections without using
378 subseg_new, so it is possible that seg_info is NULL. */
379 info
= seg_info (section
);
380 if (info
!= (segment_info_type
*) NULL
)
381 info
->frchainP
->frch_last
382 = chain_frchains_together_1 (section
, info
->frchainP
);
384 /* Now that we've chained the frags together, we must add new fixups
385 to the segment, not to the frag chain. */
391 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
394 remove_subsegs (head
, seg
, root
, last
)
400 *root
= head
->frch_root
;
401 *last
= chain_frchains_together_1 (seg
, head
);
406 #if defined (BFD_ASSEMBLER) || !defined (BFD)
410 cvt_frag_to_fill (sec
, fragP
)
415 cvt_frag_to_fill (headersP
, fragP
)
416 object_headers
*headersP
;
420 switch (fragP
->fr_type
)
427 HANDLE_ALIGN (fragP
);
429 know (fragP
->fr_next
!= NULL
);
430 fragP
->fr_offset
= (fragP
->fr_next
->fr_address
432 - fragP
->fr_fix
) / fragP
->fr_var
;
433 assert (fragP
->fr_offset
>= 0);
434 fragP
->fr_type
= rs_fill
;
440 case rs_machine_dependent
:
442 md_convert_frag (stdoutput
, sec
, fragP
);
444 md_convert_frag (headersP
, fragP
);
447 assert (fragP
->fr_next
== NULL
|| (fragP
->fr_next
->fr_address
- fragP
->fr_address
== fragP
->fr_fix
));
450 * After md_convert_frag, we make the frag into a ".space 0".
451 * Md_convert_frag() should set up any fixSs and constants
457 #ifndef WORKING_DOT_WORD
460 struct broken_word
*lie
;
462 if (fragP
->fr_subtype
)
464 fragP
->fr_fix
+= md_short_jump_size
;
465 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
466 lie
&& lie
->dispfrag
== fragP
;
467 lie
= lie
->next_broken_word
)
469 fragP
->fr_fix
+= md_long_jump_size
;
477 BAD_CASE (fragP
->fr_type
);
482 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
486 relax_and_size_seg (abfd
, sec
, xxx
)
493 segment_info_type
*seginfo
;
495 valueT size
, newsize
;
497 flags
= bfd_get_section_flags (abfd
, sec
);
499 seginfo
= seg_info (sec
);
500 if (seginfo
&& seginfo
->frchainP
)
502 relax_segment (seginfo
->frchainP
->frch_root
, sec
);
503 for (fragp
= seginfo
->frchainP
->frch_root
; fragp
; fragp
= fragp
->fr_next
)
504 cvt_frag_to_fill (sec
, fragp
);
505 for (fragp
= seginfo
->frchainP
->frch_root
;
507 fragp
= fragp
->fr_next
)
508 /* walk to last elt */;
509 size
= fragp
->fr_address
+ fragp
->fr_fix
;
514 if (size
> 0 && ! seginfo
->bss
)
515 flags
|= SEC_HAS_CONTENTS
;
517 /* @@ This is just an approximation. */
518 if (seginfo
&& seginfo
->fix_root
)
522 x
= bfd_set_section_flags (abfd
, sec
, flags
);
525 newsize
= md_section_align (sec
, size
);
526 x
= bfd_set_section_size (abfd
, sec
, newsize
);
529 /* If the size had to be rounded up, add some padding in the last
531 assert (newsize
>= size
);
534 fragS
*last
= seginfo
->frchainP
->frch_last
;
535 fragp
= seginfo
->frchainP
->frch_root
;
536 while (fragp
->fr_next
!= last
)
537 fragp
= fragp
->fr_next
;
538 last
->fr_address
= size
;
539 fragp
->fr_offset
+= newsize
- size
;
542 #ifdef tc_frob_section
543 tc_frob_section (sec
);
545 #ifdef obj_frob_section
546 obj_frob_section (sec
);
552 dump_section_relocs (abfd
, sec
, stream_
)
557 FILE *stream
= (FILE *) stream_
;
558 segment_info_type
*seginfo
= seg_info (sec
);
559 fixS
*fixp
= seginfo
->fix_root
;
564 fprintf (stream
, "sec %s relocs:\n", sec
->name
);
567 symbolS
*s
= fixp
->fx_addsy
;
570 fprintf (stream
, " %08x: %s(%s", fixp
, S_GET_NAME (s
),
571 s
->bsym
->section
->name
);
572 if (s
->bsym
->flags
& BSF_SECTION_SYM
)
574 fprintf (stream
, " section sym");
576 fprintf (stream
, "+%x", S_GET_VALUE (s
));
579 fprintf (stream
, "+%x", S_GET_VALUE (s
));
580 fprintf (stream
, ")+%x\n", fixp
->fx_offset
);
583 fprintf (stream
, " %08x: type %d no sym\n", fixp
, fixp
->fx_r_type
);
584 fixp
= fixp
->fx_next
;
588 #define dump_section_relocs(ABFD,SEC,STREAM) (void)(ABFD,SEC,STREAM)
591 #ifndef EMIT_SECTION_SYMBOLS
592 #define EMIT_SECTION_SYMBOLS 1
596 adjust_reloc_syms (abfd
, sec
, xxx
)
601 segment_info_type
*seginfo
= seg_info (sec
);
607 dump_section_relocs (abfd
, sec
, stderr
);
609 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
612 else if (fixp
->fx_addsy
)
620 fprintf (stderr
, "\n\nadjusting fixup:\n");
624 sym
= fixp
->fx_addsy
;
625 symsec
= sym
->bsym
->section
;
627 /* If it's one of these sections, assume the symbol is
628 definitely going to be output. The code in
629 md_estimate_size_before_relax in tc-mips.c uses this test
630 as well, so if you change this code you should look at that
632 if (bfd_is_und_section (symsec
)
633 || bfd_is_abs_section (symsec
)
634 || bfd_is_com_section (symsec
))
636 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
640 /* Since we're reducing to section symbols, don't attempt to reduce
641 anything that's already using one. */
642 if (sym
->bsym
->flags
& BSF_SECTION_SYM
)
644 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
648 /* Is there some other reason we can't adjust this one? (E.g.,
649 call/bal links in i960-bout symbols.) */
650 #ifdef obj_fix_adjustable
651 if (! obj_fix_adjustable (fixp
))
653 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
658 /* Is there some other (target cpu dependent) reason we can't adjust
659 this one? (E.g. relocations involving function addresses on
661 #ifdef tc_fix_adjustable
662 if (! tc_fix_adjustable (fixp
))
664 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
669 /* For PIC support: We may get expressions like
670 "_GLOBAL_OFFSET_TABLE_+(.-L5)" where "." and "L5" may not
671 necessarily have had a fixed difference initially. But now
672 it should be a known constant, so we can reduce it. Since
673 we can't easily handle a symbol value that looks like
674 someUndefinedSymbol+const, though, we convert the fixup to
675 access the undefined symbol directly, and discard the
676 intermediate symbol. */
677 if (S_GET_SEGMENT (sym
) == expr_section
678 && sym
->sy_value
.X_op
== O_add
679 && (resolve_symbol_value (sym
->sy_value
.X_add_symbol
),
680 S_GET_SEGMENT (sym
->sy_value
.X_add_symbol
) == undefined_section
)
681 && (resolve_symbol_value (sym
->sy_value
.X_op_symbol
),
682 S_GET_SEGMENT (sym
->sy_value
.X_op_symbol
) == absolute_section
))
684 fixp
->fx_offset
+= S_GET_VALUE (sym
->sy_value
.X_op_symbol
);
685 fixp
->fx_offset
+= sym
->sy_value
.X_add_number
;
686 fixp
->fx_addsy
= sym
->sy_value
.X_add_symbol
;
690 /* If the section symbol isn't going to be output, the relocs
691 at least should still work. If not, figure out what to do
692 when we run into that case. */
693 fixp
->fx_offset
+= S_GET_VALUE (sym
);
694 fixp
->fx_addsy
= section_symbol (symsec
);
695 fixp
->fx_addsy
->sy_used_in_reloc
= 1;
700 #if 1/*def RELOC_REQUIRES_SYMBOL*/
703 /* There was no symbol required by this relocation. However,
704 BFD doesn't really handle relocations without symbols well.
705 (At least, the COFF support doesn't.) So for now we fake up
706 a local symbol in the absolute section. */
708 fixp
->fx_addsy
= section_symbol (absolute_section
);
709 /* fixp->fx_addsy->sy_used_in_reloc = 1; */
713 dump_section_relocs (abfd
, sec
, stderr
);
717 write_relocs (abfd
, sec
, xxx
)
722 segment_info_type
*seginfo
= seg_info (sec
);
729 /* If seginfo is NULL, we did not create this section; don't do
734 fixup_segment (seginfo
->fix_root
, sec
);
737 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= fixp
->fx_next
)
740 #ifndef RELOC_EXPANSION_POSSIBLE
741 /* Set up reloc information as well. */
742 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
743 n
* sizeof (arelent
*));
744 memset ((char*)relocs
, 0, n
* sizeof (arelent
*));
747 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
750 bfd_reloc_status_type s
;
757 reloc
= tc_gen_reloc (sec
, fixp
);
763 if (fixp
->fx_where
+ fixp
->fx_size
764 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
767 s
= bfd_install_relocation (stdoutput
, reloc
,
768 fixp
->fx_frag
->fr_literal
,
769 fixp
->fx_frag
->fr_address
,
775 case bfd_reloc_overflow
:
776 as_bad_where (fixp
->fx_file
, fixp
->fx_line
, "relocation overflow");
779 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
780 fixp
->fx_file
, fixp
->fx_line
);
785 n
= n
* MAX_RELOC_EXPANSION
;
786 /* Set up reloc information as well. */
787 relocs
= (arelent
**) bfd_alloc_by_size_t (stdoutput
,
788 n
* sizeof (arelent
*));
791 for (fixp
= seginfo
->fix_root
; fixp
!= (fixS
*) NULL
; fixp
= fixp
->fx_next
)
795 bfd_reloc_status_type s
;
803 reloc
= tc_gen_reloc (sec
, fixp
);
805 for (j
= 0; reloc
[j
]; j
++)
807 relocs
[i
++] = reloc
[j
];
810 data
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
811 if (fixp
->fx_where
+ fixp
->fx_size
812 > fixp
->fx_frag
->fr_fix
+ fixp
->fx_frag
->fr_offset
)
814 for (j
= 0; reloc
[j
]; j
++)
816 s
= bfd_install_relocation (stdoutput
, reloc
[j
],
817 fixp
->fx_frag
->fr_literal
,
818 fixp
->fx_frag
->fr_address
,
824 case bfd_reloc_overflow
:
825 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
826 "relocation overflow");
829 as_fatal ("%s:%u: bad return from bfd_perform_relocation",
830 fixp
->fx_file
, fixp
->fx_line
);
841 sympp
= bfd_get_outsymbols (stdoutput
);
842 nsyms
= bfd_get_symcount (stdoutput
);
843 for (i
= 0; i
< n
; i
++)
844 if (((*relocs
[i
]->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
846 for (j
= 0; j
< nsyms
; j
++)
847 if (sympp
[j
] == *relocs
[i
]->sym_ptr_ptr
)
856 bfd_set_reloc (stdoutput
, sec
, relocs
, n
);
858 bfd_set_section_flags (abfd
, sec
,
859 (bfd_get_section_flags (abfd
, sec
)
860 & (flagword
) ~SEC_RELOC
));
867 fprintf (stderr
, "relocs for sec %s\n", sec
->name
);
868 for (i
= 0; i
< n
; i
++)
872 fprintf (stderr
, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
873 i
, r
, r
->address
, s
->name
, r
->addend
);
880 write_contents (abfd
, sec
, xxx
)
885 segment_info_type
*seginfo
= seg_info (sec
);
886 unsigned long offset
= 0;
889 /* Write out the frags. */
891 || ! (bfd_get_section_flags (abfd
, sec
) & SEC_HAS_CONTENTS
))
894 for (f
= seginfo
->frchainP
->frch_root
;
899 unsigned long fill_size
;
903 assert (f
->fr_type
== rs_fill
);
906 x
= bfd_set_section_contents (stdoutput
, sec
,
907 f
->fr_literal
, (file_ptr
) offset
,
908 (bfd_size_type
) f
->fr_fix
);
911 bfd_perror (stdoutput
->filename
);
912 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
917 fill_literal
= f
->fr_literal
+ f
->fr_fix
;
918 fill_size
= f
->fr_var
;
919 count
= f
->fr_offset
;
921 if (fill_size
&& count
)
922 #ifdef BFD_FAST_SECTION_FILL
925 if (fill_size
> sizeof(buf
)) {
926 /* Do it the old way. Can this ever happen? */
929 x
= bfd_set_section_contents (stdoutput
, sec
,
930 fill_literal
, (file_ptr
) offset
,
931 (bfd_size_type
) fill_size
);
934 bfd_perror (stdoutput
->filename
);
935 as_perror ("FATAL: Can't write %s", stdoutput
->filename
);
942 /* Build a buffer full of fill objects and output it as
943 * often as necessary. This saves on the overhead of potentially
944 * lots of bfd_set_section_contents calls.
949 n_per_buf
= sizeof (buf
);
950 memset (buf
, *fill_literal
, n_per_buf
);
955 n_per_buf
= sizeof(buf
)/fill_size
;
956 for (i
= n_per_buf
, bufp
= buf
; i
; i
--, bufp
+= fill_size
)
957 memcpy(bufp
, fill_literal
, fill_size
);
959 for (; count
> 0; count
-= n_per_buf
)
961 n_per_buf
= n_per_buf
> count
? count
: n_per_buf
;
962 x
= bfd_set_section_contents (stdoutput
, sec
,
963 buf
, (file_ptr
) offset
,
964 (bfd_size_type
) n_per_buf
* fill_size
);
966 offset
+= n_per_buf
* fill_size
;
973 x
= bfd_set_section_contents (stdoutput
, sec
,
974 fill_literal
, (file_ptr
) offset
,
975 (bfd_size_type
) fill_size
);
984 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
986 merge_data_into_text ()
988 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
989 seg_info (text_section
)->frchainP
->frch_last
->fr_next
=
990 seg_info (data_section
)->frchainP
->frch_root
;
991 seg_info (text_section
)->frchainP
->frch_last
=
992 seg_info (data_section
)->frchainP
->frch_last
;
993 seg_info (data_section
)->frchainP
= 0;
997 text_last_frag
->fr_next
= data_frag_root
;
998 text_last_frag
= data_last_frag
;
999 data_last_frag
= NULL
;
1000 data_frag_root
= NULL
;
1003 for (tmp
= text_fix_root
; tmp
->fx_next
; tmp
= tmp
->fx_next
);;
1004 tmp
->fx_next
= data_fix_root
;
1005 text_fix_tail
= data_fix_tail
;
1008 text_fix_root
= data_fix_root
;
1009 data_fix_root
= NULL
;
1012 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1014 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1016 relax_and_size_all_segments ()
1020 relax_segment (text_frag_root
, SEG_TEXT
);
1021 relax_segment (data_frag_root
, SEG_DATA
);
1022 relax_segment (bss_frag_root
, SEG_BSS
);
1024 * Now the addresses of frags are correct within the segment.
1027 know (text_last_frag
->fr_type
== rs_fill
&& text_last_frag
->fr_offset
== 0);
1028 H_SET_TEXT_SIZE (&headers
, text_last_frag
->fr_address
);
1029 text_last_frag
->fr_address
= H_GET_TEXT_SIZE (&headers
);
1032 * Join the 2 segments into 1 huge segment.
1033 * To do this, re-compute every rn_address in the SEG_DATA frags.
1034 * Then join the data frags after the text frags.
1036 * Determine a_data [length of data segment].
1040 register relax_addressT slide
;
1042 know ((text_last_frag
->fr_type
== rs_fill
) && (text_last_frag
->fr_offset
== 0));
1044 H_SET_DATA_SIZE (&headers
, data_last_frag
->fr_address
);
1045 data_last_frag
->fr_address
= H_GET_DATA_SIZE (&headers
);
1046 slide
= H_GET_TEXT_SIZE (&headers
); /* & in file of the data segment. */
1048 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1049 /* For b.out: If the data section has a strict alignment
1050 requirement, its load address in the .o file will be
1051 rounded up from the size of the text section. These
1052 two values are *not* the same! Similarly for the bss
1054 slide
= RoundUp (slide
, 1 << section_alignment
[SEG_DATA
]);
1057 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1059 fragP
->fr_address
+= slide
;
1060 } /* for each data frag */
1062 know (text_last_frag
!= 0);
1063 text_last_frag
->fr_next
= data_frag_root
;
1067 H_SET_DATA_SIZE (&headers
, 0);
1071 /* See above comments on b.out data section address. */
1074 if (data_last_frag
== 0)
1075 bss_vma
= H_GET_TEXT_SIZE (&headers
);
1077 bss_vma
= data_last_frag
->fr_address
;
1078 bss_vma
= RoundUp (bss_vma
, 1 << section_alignment
[SEG_BSS
]);
1079 bss_address_frag
.fr_address
= bss_vma
;
1081 #else /* ! OBJ_BOUT */
1082 bss_address_frag
.fr_address
= (H_GET_TEXT_SIZE (&headers
) +
1083 H_GET_DATA_SIZE (&headers
));
1085 #endif /* ! OBJ_BOUT */
1087 /* Slide all the frags */
1090 relax_addressT slide
= bss_address_frag
.fr_address
;
1092 for (fragP
= bss_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1094 fragP
->fr_address
+= slide
;
1095 } /* for each bss frag */
1099 H_SET_BSS_SIZE (&headers
,
1100 bss_last_frag
->fr_address
- bss_frag_root
->fr_address
);
1102 H_SET_BSS_SIZE (&headers
, 0);
1104 #endif /* ! BFD_ASSEMBLER && ! BFD */
1106 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1108 #ifdef BFD_ASSEMBLER
1116 extern PTR bfd_alloc
PARAMS ((bfd
*, size_t));
1118 /* Count symbols. We can't rely on a count made by the loop in
1119 write_object_file, because *_frob_file may add a new symbol or
1122 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1129 asympp
= (asymbol
**) bfd_alloc (stdoutput
,
1130 nsyms
* sizeof (asymbol
*));
1131 symp
= symbol_rootP
;
1132 for (i
= 0; i
< nsyms
; i
++, symp
= symbol_next (symp
))
1134 asympp
[i
] = symp
->bsym
;
1140 result
= bfd_set_symtab (stdoutput
, asympp
, nsyms
);
1141 assert (result
== true);
1142 symbol_table_frozen
= 1;
1147 write_object_file ()
1149 struct frchain
*frchainP
; /* Track along all frchains. */
1150 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1151 fragS
*fragP
; /* Track along all frags. */
1154 /* Do we really want to write it? */
1156 int n_warns
, n_errs
;
1157 n_warns
= had_warnings ();
1158 n_errs
= had_errors ();
1159 /* The -Z flag indicates that an object file should be generated,
1160 regardless of warnings and errors. */
1161 if (flag_always_generate_output
)
1163 if (n_warns
|| n_errs
)
1164 as_warn ("%d error%s, %d warning%s, generating bad object file.\n",
1165 n_errs
, n_errs
== 1 ? "" : "s",
1166 n_warns
, n_warns
== 1 ? "" : "s");
1171 as_fatal ("%d error%s, %d warning%s, no object file generated.\n",
1172 n_errs
, n_errs
== 1 ? "" : "s",
1173 n_warns
, n_warns
== 1 ? "" : "s");
1178 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1179 a routine to check for the definition of the procedure "_main",
1180 and if so -- fix it up so that it can be program entry point. */
1181 vms_check_for_main ();
1182 #endif /* OBJ_VMS */
1184 /* After every sub-segment, we fake an ".align ...". This conforms to
1185 BSD4.2 brane-damage. We then fake ".fill 0" because that is the kind of
1186 frag that requires least thought. ".align" frags like to have a
1187 following frag since that makes calculating their intended length
1190 @@ Is this really necessary?? */
1191 #ifndef SUB_SEGMENT_ALIGN
1192 #ifdef BFD_ASSEMBLER
1193 #define SUB_SEGMENT_ALIGN(SEG) (0)
1195 #define SUB_SEGMENT_ALIGN(SEG) (2)
1198 for (frchainP
= frchain_root
; frchainP
; frchainP
= frchainP
->frch_next
)
1200 subseg_set (frchainP
->frch_seg
, frchainP
->frch_subseg
);
1201 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1202 /* frag_align will have left a new frag.
1203 Use this last frag for an empty ".fill".
1205 For this segment ...
1206 Create a last frag. Do not leave a "being filled in frag". */
1207 frag_wane (frag_now
);
1208 frag_now
->fr_fix
= 0;
1209 know (frag_now
->fr_next
== NULL
);
1212 /* From now on, we don't care about sub-segments. Build one frag chain
1213 for each segment. Linked thru fr_next. */
1215 #ifdef BFD_ASSEMBLER
1216 /* Remove the sections created by gas for its own purposes. */
1218 asection
**seclist
, *sec
;
1221 seclist
= &stdoutput
->sections
;
1222 while (seclist
&& *seclist
)
1225 while (sec
== reg_section
|| sec
== expr_section
)
1229 stdoutput
->section_count
--;
1234 seclist
= &(*seclist
)->next
;
1237 bfd_map_over_sections (stdoutput
, renumber_sections
, &i
);
1240 bfd_map_over_sections (stdoutput
, chain_frchains_together
, (char *) 0);
1242 remove_subsegs (frchain_root
, SEG_TEXT
, &text_frag_root
, &text_last_frag
);
1243 remove_subsegs (data0_frchainP
, SEG_DATA
, &data_frag_root
, &data_last_frag
);
1244 remove_subsegs (bss0_frchainP
, SEG_BSS
, &bss_frag_root
, &bss_last_frag
);
1247 /* We have two segments. If user gave -R flag, then we must put the
1248 data frags into the text segment. Do this before relaxing so
1249 we know to take advantage of -R and make shorter addresses. */
1250 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1251 if (flag_readonly_data_in_text
)
1253 merge_data_into_text ();
1257 #ifdef BFD_ASSEMBLER
1258 bfd_map_over_sections (stdoutput
, relax_and_size_seg
, (char *) 0);
1260 relax_and_size_all_segments ();
1261 #endif /* BFD_ASSEMBLER */
1263 #ifndef BFD_ASSEMBLER
1266 * Crawl the symbol chain.
1268 * For each symbol whose value depends on a frag, take the address of
1269 * that frag and subsume it into the value of the symbol.
1270 * After this, there is just one way to lookup a symbol value.
1271 * Values are left in their final state for object file emission.
1272 * We adjust the values of 'L' local symbols, even if we do
1273 * not intend to emit them to the object file, because their values
1274 * are needed for fix-ups.
1276 * Unless we saw a -L flag, remove all symbols that begin with 'L'
1277 * from the symbol chain. (They are still pointed to by the fixes.)
1279 * Count the remaining symbols.
1280 * Assign a symbol number to each symbol.
1281 * Count the number of string-table chars we will emit.
1282 * Put this info into the headers as appropriate.
1285 know (zero_address_frag
.fr_address
== 0);
1286 string_byte_count
= sizeof (string_byte_count
);
1288 obj_crawl_symbol_chain (&headers
);
1290 if (string_byte_count
== sizeof (string_byte_count
))
1291 string_byte_count
= 0;
1293 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1296 * Addresses of frags now reflect addresses we use in the object file.
1297 * Symbol values are correct.
1298 * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1299 * Also converting any machine-dependent frags using md_convert_frag();
1301 subseg_change (SEG_TEXT
, 0);
1303 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1305 cvt_frag_to_fill (&headers
, fragP
);
1307 /* Some assert macros don't work with # directives mixed in. */
1309 if (!(fragP
->fr_next
== NULL
1311 || fragP
->fr_next
== data_frag_root
1313 || ((fragP
->fr_next
->fr_address
- fragP
->fr_address
)
1314 == (fragP
->fr_fix
+ fragP
->fr_offset
* fragP
->fr_var
))))
1318 #endif /* ! BFD_ASSEMBLER */
1320 #ifndef WORKING_DOT_WORD
1322 struct broken_word
*lie
;
1323 struct broken_word
**prevP
;
1325 prevP
= &broken_words
;
1326 for (lie
= broken_words
; lie
; lie
= lie
->next_broken_word
)
1331 exp
.X_op
= O_subtract
;
1332 exp
.X_add_symbol
= lie
->add
;
1333 exp
.X_op_symbol
= lie
->sub
;
1334 exp
.X_add_number
= lie
->addnum
;
1335 #ifdef BFD_ASSEMBLER
1336 #ifdef TC_CONS_FIX_NEW
1337 TC_CONS_FIX_NEW (lie
->frag
,
1338 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1341 fix_new_exp (lie
->frag
,
1342 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1343 2, &exp
, 0, BFD_RELOC_NONE
);
1346 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1347 fix_new_exp (lie
->frag
,
1348 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1349 2, &exp
, 0, NO_RELOC
);
1352 fix_new_ns32k_exp (lie
->frag
,
1353 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1354 2, &exp
, 0, 0, 2, 0, 0);
1356 fix_new_exp (lie
->frag
,
1357 lie
->word_goes_here
- lie
->frag
->fr_literal
,
1359 #endif /* TC_NS32K */
1360 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1361 #endif /* BFD_ASSEMBLER */
1362 *prevP
= lie
->next_broken_word
;
1365 prevP
= &(lie
->next_broken_word
);
1367 for (lie
= broken_words
; lie
;)
1369 struct broken_word
*untruth
;
1371 addressT table_addr
;
1372 addressT from_addr
, to_addr
;
1375 fragP
= lie
->dispfrag
;
1377 /* Find out how many broken_words go here. */
1379 for (untruth
= lie
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1380 if (untruth
->added
== 1)
1383 table_ptr
= lie
->dispfrag
->fr_opcode
;
1384 table_addr
= lie
->dispfrag
->fr_address
+ (table_ptr
- lie
->dispfrag
->fr_literal
);
1385 /* Create the jump around the long jumps. This is a short
1386 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1387 from_addr
= table_addr
;
1388 to_addr
= table_addr
+ md_short_jump_size
+ n
* md_long_jump_size
;
1389 md_create_short_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1390 table_ptr
+= md_short_jump_size
;
1391 table_addr
+= md_short_jump_size
;
1393 for (m
= 0; lie
&& lie
->dispfrag
== fragP
; m
++, lie
= lie
->next_broken_word
)
1395 if (lie
->added
== 2)
1397 /* Patch the jump table */
1398 /* This is the offset from ??? to table_ptr+0 */
1399 to_addr
= table_addr
- S_GET_VALUE (lie
->sub
);
1400 #ifdef BFD_ASSEMBLER
1401 to_addr
-= lie
->sub
->sy_frag
->fr_address
;
1403 md_number_to_chars (lie
->word_goes_here
, to_addr
, 2);
1404 for (untruth
= lie
->next_broken_word
; untruth
&& untruth
->dispfrag
== fragP
; untruth
= untruth
->next_broken_word
)
1406 if (untruth
->use_jump
== lie
)
1407 md_number_to_chars (untruth
->word_goes_here
, to_addr
, 2);
1410 /* Install the long jump */
1411 /* this is a long jump from table_ptr+0 to the final target */
1412 from_addr
= table_addr
;
1413 to_addr
= S_GET_VALUE (lie
->add
) + lie
->addnum
;
1414 #ifdef BFD_ASSEMBLER
1415 to_addr
+= lie
->add
->sy_frag
->fr_address
;
1417 md_create_long_jump (table_ptr
, from_addr
, to_addr
, lie
->dispfrag
, lie
->add
);
1418 table_ptr
+= md_long_jump_size
;
1419 table_addr
+= md_long_jump_size
;
1423 #endif /* not WORKING_DOT_WORD */
1425 #ifndef BFD_ASSEMBLER
1428 char *the_object_file
;
1429 long object_file_size
;
1431 * Scan every FixS performing fixups. We had to wait until now to do
1432 * this because md_convert_frag() may have made some fixSs.
1436 subseg_change (SEG_TEXT
, 0);
1437 trsize
= md_reloc_size
* fixup_segment (text_fix_root
, SEG_TEXT
);
1438 subseg_change (SEG_DATA
, 0);
1439 drsize
= md_reloc_size
* fixup_segment (data_fix_root
, SEG_DATA
);
1440 H_SET_RELOCATION_SIZE (&headers
, trsize
, drsize
);
1442 /* FIXME move this stuff into the pre-write-hook */
1443 H_SET_MAGIC_NUMBER (&headers
, magic_number_for_object_file
);
1444 H_SET_ENTRY_POINT (&headers
, 0);
1446 obj_pre_write_hook (&headers
); /* extra coff stuff */
1448 object_file_size
= H_GET_FILE_SIZE (&headers
);
1449 next_object_file_charP
= the_object_file
= xmalloc (object_file_size
);
1451 output_file_create (out_file_name
);
1453 obj_header_append (&next_object_file_charP
, &headers
);
1455 know ((next_object_file_charP
- the_object_file
) == H_GET_HEADER_SIZE (&headers
));
1460 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1462 register long count
;
1463 register char *fill_literal
;
1464 register long fill_size
;
1466 know (fragP
->fr_type
== rs_fill
);
1467 append (&next_object_file_charP
, fragP
->fr_literal
, (unsigned long) fragP
->fr_fix
);
1468 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
1469 fill_size
= fragP
->fr_var
;
1470 know (fragP
->fr_offset
>= 0);
1472 for (count
= fragP
->fr_offset
; count
; count
--)
1474 append (&next_object_file_charP
, fill_literal
, (unsigned long) fill_size
);
1477 } /* for each code frag. */
1479 know ((next_object_file_charP
- the_object_file
) == (H_GET_HEADER_SIZE (&headers
) + H_GET_TEXT_SIZE (&headers
) + H_GET_DATA_SIZE (&headers
)));
1484 obj_emit_relocations (&next_object_file_charP
, text_fix_root
, (relax_addressT
) 0);
1485 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
)));
1487 /* Make addresses in data relocation directives relative to beginning of
1488 * first data fragment, not end of last text fragment: alignment of the
1489 * start of the data segment may place a gap between the segments.
1491 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, data0_frchainP
->frch_root
->fr_address
);
1493 obj_emit_relocations (&next_object_file_charP
, data_fix_root
, text_last_frag
->fr_address
);
1494 #endif /* TC_I960 */
1496 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
)));
1499 * Emit line number entries.
1501 OBJ_EMIT_LINENO (&next_object_file_charP
, lineno_rootP
, the_object_file
);
1502 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
)));
1507 obj_emit_symbols (&next_object_file_charP
, symbol_rootP
);
1508 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
)));
1514 if (string_byte_count
> 0)
1516 obj_emit_strings (&next_object_file_charP
);
1517 } /* only if we have a string table */
1520 bfd_seek (stdoutput
, 0, 0);
1521 bfd_write (the_object_file
, 1, object_file_size
, stdoutput
);
1524 /* Write the data to the file */
1525 output_file_append (the_object_file
, object_file_size
, out_file_name
);
1526 free (the_object_file
);
1528 } /* non vms output */
1531 * Now do the VMS-dependent part of writing the object file
1533 vms_write_object_file (H_GET_TEXT_SIZE (&headers
),
1534 H_GET_DATA_SIZE (&headers
),
1535 H_GET_BSS_SIZE (&headers
),
1536 text_frag_root
, data_frag_root
);
1537 #endif /* OBJ_VMS */
1538 #else /* BFD_ASSEMBLER */
1540 /* Resolve symbol values. This needs to be done before processing
1546 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1547 if (!symp
->sy_resolved
)
1548 resolve_symbol_value (symp
);
1551 bfd_map_over_sections (stdoutput
, adjust_reloc_syms
, (char *)0);
1553 /* Set up symbol table, and write it out. */
1558 for (symp
= symbol_rootP
; symp
; symp
= symbol_next (symp
))
1562 /* Do it again, because adjust_reloc_syms might introduce
1563 more symbols. They'll probably only be section symbols,
1564 but they'll still need to have the values computed. */
1565 if (! symp
->sy_resolved
)
1567 if (symp
->sy_value
.X_op
== O_constant
)
1569 /* This is the normal case; skip the call. */
1572 + symp
->sy_frag
->fr_address
));
1573 symp
->sy_resolved
= 1;
1576 resolve_symbol_value (symp
);
1579 /* So far, common symbols have been treated like undefined symbols.
1580 Put them in the common section now. */
1581 if (S_IS_DEFINED (symp
) == 0
1582 && S_GET_VALUE (symp
) != 0)
1583 S_SET_SEGMENT (symp
, bfd_com_section_ptr
);
1585 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1586 S_GET_NAME (symp
), symp
,
1589 segment_name (symp
->bsym
->section
));
1592 #ifdef obj_frob_symbol
1593 obj_frob_symbol (symp
, punt
);
1595 #ifdef tc_frob_symbol
1596 if (! punt
|| symp
->sy_used_in_reloc
)
1597 tc_frob_symbol (symp
, punt
);
1600 /* If we don't want to keep this symbol, splice it out of
1601 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1602 want section symbols. Otherwise, we skip local symbols
1603 and symbols that the frob_symbol macros told us to punt,
1604 but we keep such symbols if they are used in relocs. */
1605 if ((! EMIT_SECTION_SYMBOLS
1606 && (symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0)
1607 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1608 opposites. Sometimes the former checks flags and the
1609 latter examines the name... */
1610 || (!S_IS_EXTERN (symp
)
1611 && (S_IS_LOCAL (symp
) || punt
)
1612 && ! symp
->sy_used_in_reloc
))
1614 symbol_remove (symp
, &symbol_rootP
, &symbol_lastP
);
1615 /* After symbol_remove, symbol_next(symp) still returns
1616 the one that came after it in the chain. So we don't
1617 need to do any extra cleanup work here. */
1622 /* Make sure we really got a value for the symbol. */
1623 if (! symp
->sy_resolved
)
1625 as_bad ("can't resolve value for symbol \"%s\"",
1627 symp
->sy_resolved
= 1;
1630 /* Set the value into the BFD symbol. Up til now the value
1631 has only been kept in the gas symbolS struct. */
1632 symp
->bsym
->value
= S_GET_VALUE (symp
);
1636 /* Now do any format-specific adjustments to the symbol table, such
1637 as adding file symbols. */
1638 #ifdef obj_adjust_symtab
1639 obj_adjust_symtab ();
1642 /* Now that all the sizes are known, and contents correct, we can
1643 start writing to the file. */
1646 /* If *_frob_file changes the symbol value at this point, it is
1647 responsible for moving the changed value into symp->bsym->value
1648 as well. Hopefully all symbol value changing can be done in
1653 #ifdef obj_frob_file
1657 bfd_map_over_sections (stdoutput
, write_relocs
, (char *) 0);
1659 bfd_map_over_sections (stdoutput
, write_contents
, (char *) 0);
1660 #endif /* BFD_ASSEMBLER */
1667 * Now we have a segment, not a crowd of sub-segments, we can make fr_address
1672 * After this, all frags in this segment have addresses that are correct
1673 * within the segment. Since segments live in different file addresses,
1674 * these frag addresses may not be the same as final object-file addresses.
1677 #ifndef md_relax_frag
1679 /* Subroutines of relax_segment. */
1685 for (; f1
; f1
= f1
->fr_next
)
1686 if (f1
->fr_next
== f2
)
1691 #endif /* ! defined (md_relax_frag) */
1693 /* Relax_align. Advance location counter to next address that has 'alignment'
1694 lowest order bits all 0s, return size of adjustment made. */
1695 static relax_addressT
1696 relax_align (address
, alignment
)
1697 register relax_addressT address
; /* Address now. */
1698 register int alignment
; /* Alignment (binary). */
1700 relax_addressT mask
;
1701 relax_addressT new_address
;
1703 mask
= ~((~0) << alignment
);
1704 new_address
= (address
+ mask
) & (~mask
);
1706 /* We must provide lots of padding, so the linker can discard it
1707 when needed. The linker will not add extra space, ever. */
1708 new_address
+= (1 << alignment
);
1709 return (new_address
- address
);
1713 relax_segment (segment_frag_root
, segment
)
1714 struct frag
*segment_frag_root
;
1717 register struct frag
*fragP
;
1718 register relax_addressT address
;
1719 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1720 know (segment
== SEG_DATA
|| segment
== SEG_TEXT
|| segment
== SEG_BSS
);
1722 /* In case md_estimate_size_before_relax() wants to make fixSs. */
1723 subseg_change (segment
, 0);
1725 /* For each frag in segment: count and store (a 1st guess of)
1728 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1730 fragP
->fr_address
= address
;
1731 address
+= fragP
->fr_fix
;
1733 switch (fragP
->fr_type
)
1736 address
+= fragP
->fr_offset
* fragP
->fr_var
;
1742 int offset
= relax_align (address
, (int) fragP
->fr_offset
);
1743 if (offset
% fragP
->fr_var
!= 0)
1745 as_bad ("alignment padding (%d bytes) not a multiple of %ld",
1746 offset
, (long) fragP
->fr_var
);
1747 offset
-= (offset
% fragP
->fr_var
);
1755 /* Assume .org is nugatory. It will grow with 1st relax. */
1758 case rs_machine_dependent
:
1759 address
+= md_estimate_size_before_relax (fragP
, segment
);
1762 #ifndef WORKING_DOT_WORD
1763 /* Broken words don't concern us yet */
1764 case rs_broken_word
:
1769 BAD_CASE (fragP
->fr_type
);
1771 } /* switch(fr_type) */
1772 } /* for each frag in the segment */
1776 long stretch
; /* May be any size, 0 or negative. */
1777 /* Cumulative number of addresses we have */
1778 /* relaxed this pass. */
1779 /* We may have relaxed more than one address. */
1780 long stretched
; /* Have we stretched on this pass? */
1781 /* This is 'cuz stretch may be zero, when, in fact some piece of code
1782 grew, and another shrank. If a branch instruction doesn't fit anymore,
1783 we could be scrod. */
1787 stretch
= stretched
= 0;
1788 for (fragP
= segment_frag_root
; fragP
; fragP
= fragP
->fr_next
)
1791 unsigned long was_address
;
1797 was_address
= fragP
->fr_address
;
1798 address
= fragP
->fr_address
+= stretch
;
1799 symbolP
= fragP
->fr_symbol
;
1800 offset
= fragP
->fr_offset
;
1802 switch (fragP
->fr_type
)
1804 case rs_fill
: /* .fill never relaxes. */
1808 #ifndef WORKING_DOT_WORD
1809 /* JF: This is RMS's idea. I do *NOT* want to be blamed
1810 for it I do not want to write it. I do not want to have
1811 anything to do with it. This is not the proper way to
1812 implement this misfeature. */
1813 case rs_broken_word
:
1815 struct broken_word
*lie
;
1816 struct broken_word
*untruth
;
1818 /* Yes this is ugly (storing the broken_word pointer
1819 in the symbol slot). Still, this whole chunk of
1820 code is ugly, and I don't feel like doing anything
1821 about it. Think of it as stubbornness in action. */
1823 for (lie
= (struct broken_word
*) (fragP
->fr_symbol
);
1824 lie
&& lie
->dispfrag
== fragP
;
1825 lie
= lie
->next_broken_word
)
1831 offset
= (lie
->add
->sy_frag
->fr_address
1832 + S_GET_VALUE (lie
->add
)
1834 - (lie
->sub
->sy_frag
->fr_address
1835 + S_GET_VALUE (lie
->sub
)));
1836 if (offset
<= -32768 || offset
>= 32767)
1838 if (flag_warn_displacement
)
1841 sprint_value (buf
, (addressT
) lie
->addnum
);
1842 as_warn (".word %s-%s+%s didn't fit",
1843 S_GET_NAME (lie
->add
),
1844 S_GET_NAME (lie
->sub
),
1848 if (fragP
->fr_subtype
== 0)
1850 fragP
->fr_subtype
++;
1851 growth
+= md_short_jump_size
;
1853 for (untruth
= lie
->next_broken_word
;
1854 untruth
&& untruth
->dispfrag
== lie
->dispfrag
;
1855 untruth
= untruth
->next_broken_word
)
1856 if ((untruth
->add
->sy_frag
== lie
->add
->sy_frag
)
1857 && S_GET_VALUE (untruth
->add
) == S_GET_VALUE (lie
->add
))
1860 untruth
->use_jump
= lie
;
1862 growth
+= md_long_jump_size
;
1867 } /* case rs_broken_word */
1871 growth
= (relax_align ((relax_addressT
) (address
1874 - relax_align ((relax_addressT
) (was_address
1884 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1885 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1886 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1887 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
)
1888 || S_GET_SEGMENT (symbolP
) == SEG_BSS
);
1889 know (symbolP
->sy_frag
);
1890 know (!(S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1891 || (symbolP
->sy_frag
== &zero_address_frag
));
1893 target
+= S_GET_VALUE (symbolP
)
1894 + symbolP
->sy_frag
->fr_address
;
1895 } /* if we have a symbol */
1897 know (fragP
->fr_next
);
1898 after
= fragP
->fr_next
->fr_address
;
1899 growth
= ((target
- after
) > 0) ? (target
- after
) : 0;
1900 /* Growth may be negative, but variable part of frag
1901 cannot have fewer than 0 chars. That is, we can't
1904 growth
-= stretch
; /* This is an absolute growth factor */
1910 growth
= S_GET_VALUE (symbolP
);
1911 if (symbolP
->sy_frag
!= &zero_address_frag
)
1912 as_bad (".space specifies non-absolute value");
1913 fragP
->fr_symbol
= 0;
1916 as_warn (".space or .fill with negative value, ignored");
1924 case rs_machine_dependent
:
1925 #ifdef md_relax_frag
1926 growth
= md_relax_frag (fragP
, stretch
);
1928 /* The default way to relax a frag is to look through
1931 const relax_typeS
*this_type
;
1932 const relax_typeS
*start_type
;
1933 relax_substateT next_state
;
1934 relax_substateT this_state
;
1937 this_state
= fragP
->fr_subtype
;
1938 start_type
= this_type
= md_relax_table
+ this_state
;
1943 #ifndef DIFF_EXPR_OK
1944 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
1945 know ((S_GET_SEGMENT (symbolP
) == SEG_ABSOLUTE
)
1946 || (S_GET_SEGMENT (symbolP
) == SEG_DATA
)
1947 || (S_GET_SEGMENT (symbolP
) == SEG_BSS
)
1948 || (S_GET_SEGMENT (symbolP
) == SEG_TEXT
));
1950 know (symbolP
->sy_frag
);
1952 know (!(S_GET_SEGMENT (symbolP
) == absolute_section
)
1953 || symbolP
->sy_frag
== &zero_address_frag
);
1955 S_GET_VALUE (symbolP
)
1956 + symbolP
->sy_frag
->fr_address
;
1958 /* If frag has yet to be reached on this pass,
1959 assume it will move by STRETCH just as we did.
1960 If this is not so, it will be because some frag
1961 between grows, and that will force another pass.
1963 Beware zero-length frags.
1965 There should be a faster way to do this. */
1967 if (symbolP
->sy_frag
->fr_address
>= was_address
1968 && is_dnrange (fragP
, symbolP
->sy_frag
))
1974 aim
= target
- address
- fragP
->fr_fix
;
1975 #ifdef TC_PCREL_ADJUST
1976 /* Currently only the ns32k family needs this */
1977 aim
+= TC_PCREL_ADJUST(fragP
);
1979 /* This machine doesn't want to use pcrel_adjust.
1980 In that case, pcrel_adjust should be zero. */
1981 assert (fragP
->fr_pcrel_adjust
== 0);
1986 /* Look backwards. */
1987 for (next_state
= this_type
->rlx_more
; next_state
;)
1988 if (aim
>= this_type
->rlx_backward
)
1992 /* Grow to next state. */
1993 this_state
= next_state
;
1994 this_type
= md_relax_table
+ this_state
;
1995 next_state
= this_type
->rlx_more
;
2000 #ifdef M68K_AIM_KLUDGE
2001 M68K_AIM_KLUDGE (aim
, this_state
, this_type
);
2003 /* Look forwards. */
2004 for (next_state
= this_type
->rlx_more
; next_state
;)
2005 if (aim
<= this_type
->rlx_forward
)
2009 /* Grow to next state. */
2010 this_state
= next_state
;
2011 this_type
= md_relax_table
+ this_state
;
2012 next_state
= this_type
->rlx_more
;
2016 growth
= this_type
->rlx_length
- start_type
->rlx_length
;
2018 fragP
->fr_subtype
= this_state
;
2024 BAD_CASE (fragP
->fr_type
);
2032 } /* For each frag in the segment. */
2034 while (stretched
); /* Until nothing further to relax. */
2038 * We now have valid fr_address'es for each frag.
2042 * All fr_address's are correct, relative to their own segment.
2043 * We have made all the fixS we will ever make.
2045 } /* relax_segment() */
2047 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2049 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2050 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2055 Go through all the fixS's in a segment and see which ones can be
2056 handled now. (These consist of fixS where we have since discovered
2057 the value of a symbol, or the address of the frag involved.)
2058 For each one, call md_apply_fix to put the fix into the frag data.
2060 Result is a count of how many relocation structs will be needed to
2061 handle the remaining fixS's that we couldn't completely handle here.
2062 These will be output later by emit_relocations(). */
2065 fixup_segment (fixP
, this_segment_type
)
2066 register fixS
*fixP
;
2067 segT this_segment_type
; /* N_TYPE bits for segment. */
2069 long seg_reloc_count
= 0;
2070 symbolS
*add_symbolP
;
2071 symbolS
*sub_symbolP
;
2078 segT add_symbol_segment
= absolute_section
;
2080 /* If the linker is doing the relaxing, we must not do any fixups.
2082 Well, strictly speaking that's not true -- we could do any that are
2083 PC-relative and don't cross regions that could change size. And for the
2084 i960 (the only machine for which we've got a relaxing linker right now),
2085 we might be able to turn callx/callj into bal anyways in cases where we
2086 know the maximum displacement. */
2089 for (; fixP
; fixP
= fixP
->fx_next
)
2091 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2092 return seg_reloc_count
;
2095 for (; fixP
; fixP
= fixP
->fx_next
)
2098 fprintf (stderr
, "\nprocessing fixup:\n");
2102 fragP
= fixP
->fx_frag
;
2104 where
= fixP
->fx_where
;
2105 place
= fragP
->fr_literal
+ where
;
2106 size
= fixP
->fx_size
;
2107 add_symbolP
= fixP
->fx_addsy
;
2108 #ifdef TC_VALIDATE_FIX
2109 TC_VALIDATE_FIX (fixP
, this_segment_type
, skip
);
2111 sub_symbolP
= fixP
->fx_subsy
;
2112 add_number
= fixP
->fx_offset
;
2113 pcrel
= fixP
->fx_pcrel
;
2117 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2124 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
2125 add_number
-= S_GET_VALUE (sub_symbolP
);
2127 && S_GET_SEGMENT (sub_symbolP
) == this_segment_type
)
2129 /* Should try converting to a constant. */
2134 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2135 "Negative of non-absolute symbol %s",
2136 S_GET_NAME (sub_symbolP
));
2138 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2139 && (SEG_NORMAL (add_symbol_segment
)
2140 || (add_symbol_segment
== absolute_section
)))
2142 /* Difference of 2 symbols from same segment.
2143 Can't make difference of 2 undefineds: 'value' means
2144 something different for N_UNDF. */
2146 /* Makes no sense to use the difference of 2 arbitrary symbols
2147 as the target of a call instruction. */
2149 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2150 "callj to difference of 2 symbols");
2151 #endif /* TC_I960 */
2152 add_number
+= S_GET_VALUE (add_symbolP
) -
2153 S_GET_VALUE (sub_symbolP
);
2157 /* Let the target machine make the final determination
2158 as to whether or not a relocation will be needed to
2159 handle this fixup. */
2160 if (!TC_FORCE_RELOCATION (fixP
))
2162 fixP
->fx_addsy
= NULL
;
2167 /* Different segments in subtraction. */
2168 know (!(S_IS_EXTERNAL (sub_symbolP
)
2169 && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
2171 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
2172 add_number
-= S_GET_VALUE (sub_symbolP
);
2175 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
2176 #if 0 /* Do this even if it's already described as pc-relative. For example,
2177 on the m68k, an operand of "pc@(foo-.-2)" should address "foo" in a
2178 pc-relative mode. */
2183 /* Make it pc-relative. */
2184 add_number
+= (md_pcrel_from (fixP
)
2185 - S_GET_VALUE (sub_symbolP
));
2192 #ifdef BFD_ASSEMBLER
2193 else if (fixP
->fx_r_type
== BFD_RELOC_GPREL32
2194 || fixP
->fx_r_type
== BFD_RELOC_GPREL16
)
2196 /* Leave it alone. */
2202 sprint_value (buf
, fragP
->fr_address
+ where
);
2203 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2204 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %s.",
2205 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2206 S_GET_NAME (sub_symbolP
), buf
);
2213 if (add_symbol_segment
== this_segment_type
&& pcrel
&& !plt
2214 && TC_RELOC_RTSYM_LOC_FIXUP (fixP
->fx_r_type
))
2217 * This fixup was made when the symbol's segment was
2218 * SEG_UNKNOWN, but it is now in the local segment.
2219 * So we know how to do the address without relocation.
2222 /* reloc_callj() may replace a 'call' with a 'calls' or a
2223 'bal', in which cases it modifies *fixP as appropriate.
2224 In the case of a 'calls', no further work is required,
2225 and *fixP has been set up to make the rest of the code
2228 #endif /* TC_I960 */
2230 add_number
+= S_GET_VALUE (add_symbolP
);
2231 add_number
-= md_pcrel_from (fixP
);
2232 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2234 /* Let the target machine make the final determination
2235 as to whether or not a relocation will be needed to
2236 handle this fixup. */
2237 if (!TC_FORCE_RELOCATION (fixP
))
2240 fixP
->fx_addsy
= NULL
;
2245 if (add_symbol_segment
== absolute_section
)
2248 /* See comment about reloc_callj() above. */
2250 #endif /* TC_I960 */
2251 add_number
+= S_GET_VALUE (add_symbolP
);
2253 /* Let the target machine make the final determination
2254 as to whether or not a relocation will be needed to
2255 handle this fixup. */
2256 if (!TC_FORCE_RELOCATION (fixP
))
2258 fixP
->fx_addsy
= NULL
;
2262 else if (add_symbol_segment
== undefined_section
2263 #ifdef BFD_ASSEMBLER
2264 || bfd_is_com_section (add_symbol_segment
)
2269 if ((int) fixP
->fx_bit_fixP
== 13)
2271 /* This is a COBR instruction. They have only a
2272 * 13-bit displacement and are only to be used
2273 * for local branches: flag as error, don't generate
2276 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2277 "can't use COBR format with external label");
2278 fixP
->fx_addsy
= NULL
;
2282 #endif /* TC_I960 */
2286 if (S_IS_COMMON (add_symbolP
))
2287 add_number
+= S_GET_VALUE (add_symbolP
);
2288 #endif /* TE_I386AIX */
2289 #endif /* OBJ_COFF */
2295 #if !defined (TC_I386) || !(defined (OBJ_ELF) || defined (OBJ_COFF))
2296 add_number
+= S_GET_VALUE (add_symbolP
);
2304 add_number
-= md_pcrel_from (fixP
);
2305 if (add_symbolP
== 0)
2307 #ifndef BFD_ASSEMBLER
2308 fixP
->fx_addsy
= &abs_symbol
;
2310 fixP
->fx_addsy
= section_symbol (absolute_section
);
2312 fixP
->fx_addsy
->sy_used_in_reloc
= 1;
2317 if (!fixP
->fx_bit_fixP
&& size
> 0)
2320 if (size
< sizeof (mask
))
2322 /* set all bits to one */
2324 /* Technically, combining these produces an undefined result
2325 if size is sizeof (valueT), though I think these two
2326 half-way operations should both be defined. And the
2327 compiler should be able to combine them if it's valid on
2328 the host architecture. */
2331 if ((add_number
& mask
) != 0
2332 && (add_number
& mask
) != mask
)
2334 char buf
[50], buf2
[50];
2335 sprint_value (buf
, fragP
->fr_address
+ where
);
2336 if (add_number
> 1000)
2337 sprint_value (buf2
, add_number
);
2339 sprintf (buf2
, "%ld", (long) add_number
);
2340 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2341 "Value of %s too large for field of %d bytes at %s",
2343 } /* generic error checking */
2345 #ifdef WARN_SIGNED_OVERFLOW_WORD
2346 /* Warn if a .word value is too large when treated as a signed
2347 number. We already know it is not too negative. This is to
2348 catch over-large switches generated by gcc on the 68k. */
2349 if (!flag_signed_overflow_ok
2351 && add_number
> 0x7fff)
2352 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2353 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
2355 (unsigned long) (fragP
->fr_address
+ where
));
2357 } /* not a bit fix */
2361 #ifdef MD_APPLY_FIX3
2362 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
2364 #ifdef BFD_ASSEMBLER
2365 md_apply_fix (fixP
, &add_number
);
2367 md_apply_fix (fixP
, add_number
);
2371 #ifndef TC_HANDLES_FX_DONE
2372 /* If the tc-* files haven't been converted, assume it's handling
2373 it the old way, where a null fx_addsy means that the fix has
2374 been applied completely, and no further work is needed. */
2375 if (fixP
->fx_addsy
== 0 && fixP
->fx_pcrel
== 0)
2379 #ifdef TC_VALIDATE_FIX
2383 fprintf (stderr
, "result:\n");
2386 } /* For each fixS in this segment. */
2388 TC_ADJUST_RELOC_COUNT (fixP
, seg_reloc_count
);
2389 return seg_reloc_count
;
2392 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2395 number_to_chars_bigendian (buf
, val
, n
)
2400 if (n
> sizeof (val
)|| n
<= 0)
2404 buf
[n
] = val
& 0xff;
2410 number_to_chars_littleendian (buf
, val
, n
)
2415 if (n
> sizeof (val
) || n
<= 0)
2419 *buf
++ = val
& 0xff;
2425 extern int indent_level
;
2426 extern void print_symbol_value_1 ();
2433 fprintf (stderr
, "fix %lx %s:%d", (long) fixp
, fixp
->fx_file
, fixp
->fx_line
);
2435 fprintf (stderr
, " pcrel");
2436 if (fixp
->fx_pcrel_adjust
)
2437 fprintf (stderr
, " pcrel_adjust=%d", fixp
->fx_pcrel_adjust
);
2438 if (fixp
->fx_im_disp
)
2441 fprintf (stderr
, " im_disp=%d", fixp
->fx_im_disp
);
2443 fprintf (stderr
, " im_disp");
2447 fprintf (stderr
, " tcbit");
2449 fprintf (stderr
, " done");
2450 fprintf (stderr
, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2451 fixp
->fx_size
, (long) fixp
->fx_frag
, (long) fixp
->fx_where
,
2452 (long) fixp
->fx_offset
, (long) fixp
->fx_addnumber
);
2453 #ifdef BFD_ASSEMBLER
2454 fprintf (stderr
, "\n %s (%d)", bfd_get_reloc_code_name (fixp
->fx_r_type
),
2457 #ifdef NEED_FX_R_TYPE
2458 fprintf (stderr
, " r_type=%d", fixp
->fx_r_type
);
2463 fprintf (stderr
, "\n +<");
2464 print_symbol_value_1 (stderr
, fixp
->fx_addsy
);
2465 fprintf (stderr
, ">");
2469 fprintf (stderr
, "\n -<");
2470 print_symbol_value_1 (stderr
, fixp
->fx_subsy
);
2471 fprintf (stderr
, ">");
2473 fprintf (stderr
, "\n");
2476 /* end of write.c */