* dwarf2dbg.c (out_debug_abbrev): Add support for the DW_AT_name field.
[binutils.git] / gas / write.c
blob17c323209fe52ac8d61439ab84701540384b96a1
1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
23 /* This thing should be set up to do byteordering correctly. But... */
25 #include "as.h"
26 #include "subsegs.h"
27 #include "obstack.h"
28 #include "output-file.h"
29 #include "dwarf2dbg.h"
31 #ifndef TC_ADJUST_RELOC_COUNT
32 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
33 #endif
35 #ifndef TC_FORCE_RELOCATION
36 #define TC_FORCE_RELOCATION(FIX) \
37 (S_FORCE_RELOC ((FIX)->fx_addsy))
38 #endif
40 #ifndef TC_FORCE_RELOCATION_ABS
41 #define TC_FORCE_RELOCATION_ABS(FIX) \
42 (TC_FORCE_RELOCATION (FIX))
43 #endif
45 #ifndef TC_FORCE_RELOCATION_LOCAL
46 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
47 (!(FIX)->fx_pcrel \
48 || (FIX)->fx_plt \
49 || TC_FORCE_RELOCATION (FIX))
50 #endif
52 #ifndef TC_FORCE_RELOCATION_SUB_SAME
53 #define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
54 (! SEG_NORMAL (SEG))
55 #endif
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX) \
59 (S_FORCE_RELOC ((FIX)->fx_subsy))
60 #endif
62 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #ifdef DIFF_EXPR_OK
64 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) \
65 (S_FORCE_RELOC ((FIX)->fx_subsy))
66 #else
67 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX) 1
68 #endif
69 #endif
71 #ifndef TC_VALIDATE_FIX_SUB
72 #ifdef UNDEFINED_DIFFERENCE_OK
73 /* The PA needs this for PIC code generation. */
74 #define TC_VALIDATE_FIX_SUB(FIX) 1
75 #else
76 #ifdef BFD_ASSEMBLER
77 #define TC_VALIDATE_FIX_SUB(FIX) \
78 ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
79 || (FIX)->fx_r_type == BFD_RELOC_GPREL16)
80 #else
81 #define TC_VALIDATE_FIX_SUB(FIX) 0
82 #endif
83 #endif
84 #endif
86 #ifndef TC_LINKRELAX_FIXUP
87 #define TC_LINKRELAX_FIXUP(SEG) 1
88 #endif
90 #ifndef MD_APPLY_SYM_VALUE
91 #define MD_APPLY_SYM_VALUE(FIX) 1
92 #endif
94 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
95 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
96 #endif
98 #ifndef MD_PCREL_FROM_SECTION
99 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
100 #endif
102 #ifndef WORKING_DOT_WORD
103 extern const int md_short_jump_size;
104 extern const int md_long_jump_size;
105 #endif
107 /* Used to control final evaluation of expressions. */
108 int finalize_syms = 0;
110 int symbol_table_frozen;
112 symbolS *abs_section_sym;
114 void print_fixup PARAMS ((fixS *));
116 #ifdef BFD_ASSEMBLER
117 static void renumber_sections PARAMS ((bfd *, asection *, PTR));
119 /* We generally attach relocs to frag chains. However, after we have
120 chained these all together into a segment, any relocs we add after
121 that must be attached to a segment. This will include relocs added
122 in md_estimate_size_for_relax, for example. */
123 static int frags_chained = 0;
124 #endif
126 #ifndef BFD_ASSEMBLER
128 #ifndef MANY_SEGMENTS
129 struct frag *text_frag_root;
130 struct frag *data_frag_root;
131 struct frag *bss_frag_root;
133 struct frag *text_last_frag; /* Last frag in segment. */
134 struct frag *data_last_frag; /* Last frag in segment. */
135 static struct frag *bss_last_frag; /* Last frag in segment. */
136 #endif
138 #ifndef BFD
139 static object_headers headers;
140 #endif
142 long string_byte_count;
143 char *next_object_file_charP; /* Tracks object file bytes. */
145 #ifndef OBJ_VMS
146 int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
147 #endif
149 #endif /* BFD_ASSEMBLER */
151 static int n_fixups;
153 #ifdef BFD_ASSEMBLER
154 #define RELOC_ENUM enum bfd_reloc_code_real
155 #else
156 #define RELOC_ENUM int
157 #endif
159 static fixS *fix_new_internal PARAMS ((fragS *, int where, int size,
160 symbolS *add, symbolS *sub,
161 offsetT offset, int pcrel,
162 RELOC_ENUM r_type));
163 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
164 static long fixup_segment PARAMS ((fixS *, segT));
165 #endif
166 static relax_addressT relax_align PARAMS ((relax_addressT addr, int align));
167 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
168 static fragS *chain_frchains_together_1 PARAMS ((segT, struct frchain *));
169 #endif
170 #ifdef BFD_ASSEMBLER
171 static void chain_frchains_together PARAMS ((bfd *, segT, PTR));
172 static void cvt_frag_to_fill PARAMS ((segT, fragS *));
173 static void adjust_reloc_syms PARAMS ((bfd *, asection *, PTR));
174 static void fix_segment PARAMS ((bfd *, asection *, PTR));
175 static void write_relocs PARAMS ((bfd *, asection *, PTR));
176 static void write_contents PARAMS ((bfd *, asection *, PTR));
177 static void set_symtab PARAMS ((void));
178 #endif
179 #if defined (BFD_ASSEMBLER) || (! defined (BFD) && ! defined (OBJ_AOUT))
180 static void merge_data_into_text PARAMS ((void));
181 #endif
182 #if ! defined (BFD_ASSEMBLER) && ! defined (BFD)
183 static void cvt_frag_to_fill PARAMS ((object_headers *, segT, fragS *));
184 static void remove_subsegs PARAMS ((frchainS *, int, fragS **, fragS **));
185 static void relax_and_size_all_segments PARAMS ((void));
186 #endif
187 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
188 static void set_segment_vma PARAMS ((bfd *, asection *, PTR));
189 #endif
191 /* Create a fixS in obstack 'notes'. */
193 static fixS *
194 fix_new_internal (frag, where, size, add_symbol, sub_symbol, offset, pcrel,
195 r_type)
196 fragS *frag; /* Which frag? */
197 int where; /* Where in that frag? */
198 int size; /* 1, 2, or 4 usually. */
199 symbolS *add_symbol; /* X_add_symbol. */
200 symbolS *sub_symbol; /* X_op_symbol. */
201 offsetT offset; /* X_add_number. */
202 int pcrel; /* TRUE if PC-relative relocation. */
203 RELOC_ENUM r_type ATTRIBUTE_UNUSED; /* Relocation type. */
205 fixS *fixP;
207 n_fixups++;
209 fixP = (fixS *) obstack_alloc (&notes, sizeof (fixS));
211 fixP->fx_frag = frag;
212 fixP->fx_where = where;
213 fixP->fx_size = size;
214 /* We've made fx_size a narrow field; check that it's wide enough. */
215 if (fixP->fx_size != size)
217 as_bad (_("field fx_size too small to hold %d"), size);
218 abort ();
220 fixP->fx_addsy = add_symbol;
221 fixP->fx_subsy = sub_symbol;
222 fixP->fx_offset = offset;
223 fixP->fx_pcrel = pcrel;
224 fixP->fx_plt = 0;
225 #if defined(NEED_FX_R_TYPE) || defined (BFD_ASSEMBLER)
226 fixP->fx_r_type = r_type;
227 #endif
228 fixP->fx_im_disp = 0;
229 fixP->fx_pcrel_adjust = 0;
230 fixP->fx_bit_fixP = 0;
231 fixP->fx_addnumber = 0;
232 fixP->fx_tcbit = 0;
233 fixP->fx_done = 0;
234 fixP->fx_no_overflow = 0;
235 fixP->fx_signed = 0;
237 #ifdef USING_CGEN
238 fixP->fx_cgen.insn = NULL;
239 fixP->fx_cgen.opinfo = 0;
240 #endif
242 #ifdef TC_FIX_TYPE
243 TC_INIT_FIX_DATA (fixP);
244 #endif
246 as_where (&fixP->fx_file, &fixP->fx_line);
248 /* Usually, we want relocs sorted numerically, but while
249 comparing to older versions of gas that have relocs
250 reverse sorted, it is convenient to have this compile
251 time option. xoxorich. */
254 #ifdef BFD_ASSEMBLER
255 fixS **seg_fix_rootP = (frags_chained
256 ? &seg_info (now_seg)->fix_root
257 : &frchain_now->fix_root);
258 fixS **seg_fix_tailP = (frags_chained
259 ? &seg_info (now_seg)->fix_tail
260 : &frchain_now->fix_tail);
261 #endif
263 #ifdef REVERSE_SORT_RELOCS
265 fixP->fx_next = *seg_fix_rootP;
266 *seg_fix_rootP = fixP;
268 #else /* REVERSE_SORT_RELOCS */
270 fixP->fx_next = NULL;
272 if (*seg_fix_tailP)
273 (*seg_fix_tailP)->fx_next = fixP;
274 else
275 *seg_fix_rootP = fixP;
276 *seg_fix_tailP = fixP;
278 #endif /* REVERSE_SORT_RELOCS */
281 return fixP;
284 /* Create a fixup relative to a symbol (plus a constant). */
286 fixS *
287 fix_new (frag, where, size, add_symbol, offset, pcrel, r_type)
288 fragS *frag; /* Which frag? */
289 int where; /* Where in that frag? */
290 int size; /* 1, 2, or 4 usually. */
291 symbolS *add_symbol; /* X_add_symbol. */
292 offsetT offset; /* X_add_number. */
293 int pcrel; /* TRUE if PC-relative relocation. */
294 RELOC_ENUM r_type; /* Relocation type. */
296 return fix_new_internal (frag, where, size, add_symbol,
297 (symbolS *) NULL, offset, pcrel, r_type);
300 /* Create a fixup for an expression. Currently we only support fixups
301 for difference expressions. That is itself more than most object
302 file formats support anyhow. */
304 fixS *
305 fix_new_exp (frag, where, size, exp, pcrel, r_type)
306 fragS *frag; /* Which frag? */
307 int where; /* Where in that frag? */
308 int size; /* 1, 2, or 4 usually. */
309 expressionS *exp; /* Expression. */
310 int pcrel; /* TRUE if PC-relative relocation. */
311 RELOC_ENUM r_type; /* Relocation type. */
313 symbolS *add = NULL;
314 symbolS *sub = NULL;
315 offsetT off = 0;
317 switch (exp->X_op)
319 case O_absent:
320 break;
322 case O_register:
323 as_bad (_("register value used as expression"));
324 break;
326 case O_add:
327 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
328 the difference expression cannot immediately be reduced. */
330 symbolS *stmp = make_expr_symbol (exp);
332 exp->X_op = O_symbol;
333 exp->X_op_symbol = 0;
334 exp->X_add_symbol = stmp;
335 exp->X_add_number = 0;
337 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
340 case O_symbol_rva:
341 add = exp->X_add_symbol;
342 off = exp->X_add_number;
344 #if defined(BFD_ASSEMBLER)
345 r_type = BFD_RELOC_RVA;
346 #else
347 #if defined(TC_RVA_RELOC)
348 r_type = TC_RVA_RELOC;
349 #else
350 as_fatal (_("rva not supported"));
351 #endif
352 #endif
353 break;
355 case O_uminus:
356 sub = exp->X_add_symbol;
357 off = exp->X_add_number;
358 break;
360 case O_subtract:
361 sub = exp->X_op_symbol;
362 /* Fall through. */
363 case O_symbol:
364 add = exp->X_add_symbol;
365 /* Fall through. */
366 case O_constant:
367 off = exp->X_add_number;
368 break;
370 default:
371 add = make_expr_symbol (exp);
372 break;
375 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
378 /* Append a string onto another string, bumping the pointer along. */
379 void
380 append (charPP, fromP, length)
381 char **charPP;
382 char *fromP;
383 unsigned long length;
385 /* Don't trust memcpy() of 0 chars. */
386 if (length == 0)
387 return;
389 memcpy (*charPP, fromP, length);
390 *charPP += length;
393 #ifndef BFD_ASSEMBLER
394 int section_alignment[SEG_MAXIMUM_ORDINAL];
395 #endif
397 /* This routine records the largest alignment seen for each segment.
398 If the beginning of the segment is aligned on the worst-case
399 boundary, all of the other alignments within it will work. At
400 least one object format really uses this info. */
402 void
403 record_alignment (seg, align)
404 /* Segment to which alignment pertains. */
405 segT seg;
406 /* Alignment, as a power of 2 (e.g., 1 => 2-byte boundary, 2 => 4-byte
407 boundary, etc.) */
408 int align;
410 if (seg == absolute_section)
411 return;
412 #ifdef BFD_ASSEMBLER
413 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
414 bfd_set_section_alignment (stdoutput, seg, align);
415 #else
416 if (align > section_alignment[(int) seg])
417 section_alignment[(int) seg] = align;
418 #endif
422 get_recorded_alignment (seg)
423 segT seg;
425 if (seg == absolute_section)
426 return 0;
427 #ifdef BFD_ASSEMBLER
428 return bfd_get_section_alignment (stdoutput, seg);
429 #else
430 return section_alignment[(int) seg];
431 #endif
434 #ifdef BFD_ASSEMBLER
436 /* Reset the section indices after removing the gas created sections. */
438 static void
439 renumber_sections (abfd, sec, countparg)
440 bfd *abfd ATTRIBUTE_UNUSED;
441 asection *sec;
442 PTR countparg;
444 int *countp = (int *) countparg;
446 sec->index = *countp;
447 ++*countp;
450 #endif /* defined (BFD_ASSEMBLER) */
452 #if defined (BFD_ASSEMBLER) || ! defined (BFD)
454 static fragS *
455 chain_frchains_together_1 (section, frchp)
456 segT section;
457 struct frchain *frchp;
459 fragS dummy, *prev_frag = &dummy;
460 #ifdef BFD_ASSEMBLER
461 fixS fix_dummy, *prev_fix = &fix_dummy;
462 #endif
464 for (; frchp && frchp->frch_seg == section; frchp = frchp->frch_next)
466 prev_frag->fr_next = frchp->frch_root;
467 prev_frag = frchp->frch_last;
468 assert (prev_frag->fr_type != 0);
469 #ifdef BFD_ASSEMBLER
470 if (frchp->fix_root != (fixS *) NULL)
472 if (seg_info (section)->fix_root == (fixS *) NULL)
473 seg_info (section)->fix_root = frchp->fix_root;
474 prev_fix->fx_next = frchp->fix_root;
475 seg_info (section)->fix_tail = frchp->fix_tail;
476 prev_fix = frchp->fix_tail;
478 #endif
480 assert (prev_frag->fr_type != 0);
481 prev_frag->fr_next = 0;
482 return prev_frag;
485 #endif
487 #ifdef BFD_ASSEMBLER
489 static void
490 chain_frchains_together (abfd, section, xxx)
491 bfd *abfd ATTRIBUTE_UNUSED;
492 segT section;
493 PTR xxx ATTRIBUTE_UNUSED;
495 segment_info_type *info;
497 /* BFD may have introduced its own sections without using
498 subseg_new, so it is possible that seg_info is NULL. */
499 info = seg_info (section);
500 if (info != (segment_info_type *) NULL)
501 info->frchainP->frch_last
502 = chain_frchains_together_1 (section, info->frchainP);
504 /* Now that we've chained the frags together, we must add new fixups
505 to the segment, not to the frag chain. */
506 frags_chained = 1;
509 #endif
511 #if !defined (BFD) && !defined (BFD_ASSEMBLER)
513 static void
514 remove_subsegs (head, seg, root, last)
515 frchainS *head;
516 int seg;
517 fragS **root;
518 fragS **last;
520 *root = head->frch_root;
521 *last = chain_frchains_together_1 (seg, head);
524 #endif /* BFD */
526 #if defined (BFD_ASSEMBLER) || !defined (BFD)
528 #ifdef BFD_ASSEMBLER
529 static void
530 cvt_frag_to_fill (sec, fragP)
531 segT sec ATTRIBUTE_UNUSED;
532 fragS *fragP;
533 #else
534 static void
535 cvt_frag_to_fill (headersP, sec, fragP)
536 object_headers *headersP;
537 segT sec;
538 fragS *fragP;
539 #endif
541 switch (fragP->fr_type)
543 case rs_align:
544 case rs_align_code:
545 case rs_align_test:
546 case rs_org:
547 case rs_space:
548 #ifdef HANDLE_ALIGN
549 HANDLE_ALIGN (fragP);
550 #endif
551 know (fragP->fr_next != NULL);
552 fragP->fr_offset = (fragP->fr_next->fr_address
553 - fragP->fr_address
554 - fragP->fr_fix) / fragP->fr_var;
555 if (fragP->fr_offset < 0)
557 as_bad_where (fragP->fr_file, fragP->fr_line,
558 _("attempt to .org/.space backwards? (%ld)"),
559 (long) fragP->fr_offset);
560 fragP->fr_offset = 0;
562 fragP->fr_type = rs_fill;
563 break;
565 case rs_fill:
566 break;
568 case rs_leb128:
570 valueT value = S_GET_VALUE (fragP->fr_symbol);
571 int size;
573 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
574 fragP->fr_subtype);
576 fragP->fr_fix += size;
577 fragP->fr_type = rs_fill;
578 fragP->fr_var = 0;
579 fragP->fr_offset = 0;
580 fragP->fr_symbol = NULL;
582 break;
584 case rs_cfa:
585 eh_frame_convert_frag (fragP);
586 break;
588 case rs_dwarf2dbg:
589 dwarf2dbg_convert_frag (fragP);
590 break;
592 case rs_machine_dependent:
593 #ifdef BFD_ASSEMBLER
594 md_convert_frag (stdoutput, sec, fragP);
595 #else
596 md_convert_frag (headersP, sec, fragP);
597 #endif
599 assert (fragP->fr_next == NULL
600 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
601 == fragP->fr_fix));
603 /* After md_convert_frag, we make the frag into a ".space 0".
604 md_convert_frag() should set up any fixSs and constants
605 required. */
606 frag_wane (fragP);
607 break;
609 #ifndef WORKING_DOT_WORD
610 case rs_broken_word:
612 struct broken_word *lie;
614 if (fragP->fr_subtype)
616 fragP->fr_fix += md_short_jump_size;
617 for (lie = (struct broken_word *) (fragP->fr_symbol);
618 lie && lie->dispfrag == fragP;
619 lie = lie->next_broken_word)
620 if (lie->added == 1)
621 fragP->fr_fix += md_long_jump_size;
623 frag_wane (fragP);
625 break;
626 #endif
628 default:
629 BAD_CASE (fragP->fr_type);
630 break;
634 #endif /* defined (BFD_ASSEMBLER) || !defined (BFD) */
636 #ifdef BFD_ASSEMBLER
637 static void relax_seg PARAMS ((bfd *, asection *, PTR));
638 static void
639 relax_seg (abfd, sec, xxx)
640 bfd *abfd ATTRIBUTE_UNUSED;
641 asection *sec;
642 PTR xxx;
644 segment_info_type *seginfo = seg_info (sec);
646 if (seginfo && seginfo->frchainP
647 && relax_segment (seginfo->frchainP->frch_root, sec))
649 int *result = (int *) xxx;
650 *result = 1;
654 static void size_seg PARAMS ((bfd *, asection *, PTR));
655 static void
656 size_seg (abfd, sec, xxx)
657 bfd *abfd;
658 asection *sec;
659 PTR xxx ATTRIBUTE_UNUSED;
661 flagword flags;
662 fragS *fragp;
663 segment_info_type *seginfo;
664 int x;
665 valueT size, newsize;
667 subseg_change (sec, 0);
669 seginfo = seg_info (sec);
670 if (seginfo && seginfo->frchainP)
672 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
673 cvt_frag_to_fill (sec, fragp);
674 for (fragp = seginfo->frchainP->frch_root;
675 fragp->fr_next;
676 fragp = fragp->fr_next)
677 /* Walk to last elt. */
679 size = fragp->fr_address + fragp->fr_fix;
681 else
682 size = 0;
684 flags = bfd_get_section_flags (abfd, sec);
686 if (size > 0 && ! seginfo->bss)
687 flags |= SEC_HAS_CONTENTS;
689 /* @@ This is just an approximation. */
690 if (seginfo && seginfo->fix_root)
691 flags |= SEC_RELOC;
692 else
693 flags &= ~SEC_RELOC;
694 x = bfd_set_section_flags (abfd, sec, flags);
695 assert (x == true);
697 newsize = md_section_align (sec, size);
698 x = bfd_set_section_size (abfd, sec, newsize);
699 assert (x == true);
701 /* If the size had to be rounded up, add some padding in the last
702 non-empty frag. */
703 assert (newsize >= size);
704 if (size != newsize)
706 fragS *last = seginfo->frchainP->frch_last;
707 fragp = seginfo->frchainP->frch_root;
708 while (fragp->fr_next != last)
709 fragp = fragp->fr_next;
710 last->fr_address = size;
711 if ((newsize - size) % fragp->fr_var == 0)
712 fragp->fr_offset += (newsize - size) / fragp->fr_var;
713 else
714 /* If we hit this abort, it's likely due to subsegs_finish not
715 providing sufficient alignment on the last frag, and the
716 machine dependent code using alignment frags with fr_var
717 greater than 1. */
718 abort ();
721 #ifdef tc_frob_section
722 tc_frob_section (sec);
723 #endif
724 #ifdef obj_frob_section
725 obj_frob_section (sec);
726 #endif
729 #ifdef DEBUG2
730 static void
731 dump_section_relocs (abfd, sec, stream_)
732 bfd *abfd ATTRIBUTE_UNUSED;
733 asection *sec;
734 char *stream_;
736 FILE *stream = (FILE *) stream_;
737 segment_info_type *seginfo = seg_info (sec);
738 fixS *fixp = seginfo->fix_root;
740 if (!fixp)
741 return;
743 fprintf (stream, "sec %s relocs:\n", sec->name);
744 while (fixp)
746 symbolS *s = fixp->fx_addsy;
748 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
749 (int) fixp->fx_r_type);
750 if (s == NULL)
751 fprintf (stream, "no sym\n");
752 else
754 print_symbol_value_1 (stream, s);
755 fprintf (stream, "\n");
757 fixp = fixp->fx_next;
760 #else
761 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
762 #endif
764 #ifndef EMIT_SECTION_SYMBOLS
765 #define EMIT_SECTION_SYMBOLS 1
766 #endif
768 /* This pass over fixups decides whether symbols can be replaced with
769 section symbols. */
771 static void
772 adjust_reloc_syms (abfd, sec, xxx)
773 bfd *abfd ATTRIBUTE_UNUSED;
774 asection *sec;
775 PTR xxx ATTRIBUTE_UNUSED;
777 segment_info_type *seginfo = seg_info (sec);
778 fixS *fixp;
780 if (seginfo == NULL)
781 return;
783 dump_section_relocs (abfd, sec, stderr);
785 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
786 if (fixp->fx_done)
787 /* Ignore it. */
789 else if (fixp->fx_addsy)
791 symbolS *sym;
792 asection *symsec;
794 #ifdef DEBUG5
795 fprintf (stderr, "\n\nadjusting fixup:\n");
796 print_fixup (fixp);
797 #endif
799 sym = fixp->fx_addsy;
801 /* All symbols should have already been resolved at this
802 point. It is possible to see unresolved expression
803 symbols, though, since they are not in the regular symbol
804 table. */
805 resolve_symbol_value (sym);
807 if (fixp->fx_subsy != NULL)
808 resolve_symbol_value (fixp->fx_subsy);
810 /* If this symbol is equated to an undefined symbol, convert
811 the fixup to being against that symbol. */
812 if (symbol_equated_reloc_p (sym))
814 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
815 sym = symbol_get_value_expression (sym)->X_add_symbol;
816 fixp->fx_addsy = sym;
819 if (symbol_mri_common_p (sym))
821 /* These symbols are handled specially in fixup_segment. */
822 continue;
825 /* If the symbol is undefined, common, weak, or global (ELF
826 shared libs), we can't replace it with the section symbol. */
827 if (S_FORCE_RELOC (fixp->fx_addsy))
828 continue;
830 /* Is there some other (target cpu dependent) reason we can't adjust
831 this one? (E.g. relocations involving function addresses on
832 the PA. */
833 #ifdef tc_fix_adjustable
834 if (! tc_fix_adjustable (fixp))
835 continue;
836 #endif
838 /* Since we're reducing to section symbols, don't attempt to reduce
839 anything that's already using one. */
840 if (symbol_section_p (sym))
841 continue;
843 symsec = S_GET_SEGMENT (sym);
844 if (symsec == NULL)
845 abort ();
847 if (bfd_is_abs_section (symsec))
849 /* The fixup_segment routine normally will not use this
850 symbol in a relocation. */
851 continue;
854 /* Don't try to reduce relocs which refer to non-local symbols
855 in .linkonce sections. It can lead to confusion when a
856 debugging section refers to a .linkonce section. I hope
857 this will always be correct. */
858 if (symsec != sec && ! S_IS_LOCAL (sym))
860 if ((symsec->flags & SEC_LINK_ONCE) != 0
861 || (IS_ELF
862 /* The GNU toolchain uses an extension for ELF: a
863 section beginning with the magic string
864 .gnu.linkonce is a linkonce section. */
865 && strncmp (segment_name (symsec), ".gnu.linkonce",
866 sizeof ".gnu.linkonce" - 1) == 0))
867 continue;
870 /* Never adjust a reloc against local symbol in a merge section
871 with non-zero addend. */
872 if ((symsec->flags & SEC_MERGE) != 0 && fixp->fx_offset != 0)
873 continue;
875 /* Never adjust a reloc against TLS local symbol. */
876 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
877 continue;
879 /* We refetch the segment when calling section_symbol, rather
880 than using symsec, because S_GET_VALUE may wind up changing
881 the section when it calls resolve_symbol_value. */
882 fixp->fx_offset += S_GET_VALUE (sym);
883 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
884 #ifdef DEBUG5
885 fprintf (stderr, "\nadjusted fixup:\n");
886 print_fixup (fixp);
887 #endif
890 dump_section_relocs (abfd, sec, stderr);
893 static void
894 fix_segment (abfd, sec, xxx)
895 bfd *abfd ATTRIBUTE_UNUSED;
896 asection *sec;
897 PTR xxx ATTRIBUTE_UNUSED;
899 segment_info_type *seginfo = seg_info (sec);
901 fixup_segment (seginfo->fix_root, sec);
904 static void
905 write_relocs (abfd, sec, xxx)
906 bfd *abfd;
907 asection *sec;
908 PTR xxx ATTRIBUTE_UNUSED;
910 segment_info_type *seginfo = seg_info (sec);
911 unsigned int i;
912 unsigned int n;
913 arelent **relocs;
914 fixS *fixp;
915 char *err;
917 /* If seginfo is NULL, we did not create this section; don't do
918 anything with it. */
919 if (seginfo == NULL)
920 return;
922 n = 0;
923 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
924 n++;
926 #ifndef RELOC_EXPANSION_POSSIBLE
927 /* Set up reloc information as well. */
928 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
929 memset ((char *) relocs, 0, n * sizeof (arelent *));
931 i = 0;
932 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
934 arelent *reloc;
935 bfd_reloc_status_type s;
936 symbolS *sym;
938 if (fixp->fx_done)
940 n--;
941 continue;
944 /* If this is an undefined symbol which was equated to another
945 symbol, then generate the reloc against the latter symbol
946 rather than the former. */
947 sym = fixp->fx_addsy;
948 while (symbol_equated_reloc_p (sym))
950 symbolS *n;
952 /* We must avoid looping, as that can occur with a badly
953 written program. */
954 n = symbol_get_value_expression (sym)->X_add_symbol;
955 if (n == sym)
956 break;
957 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
958 sym = n;
960 fixp->fx_addsy = sym;
962 reloc = tc_gen_reloc (sec, fixp);
963 if (!reloc)
965 n--;
966 continue;
969 #if 0
970 /* This test is triggered inappropriately for the SH. */
971 if (fixp->fx_where + fixp->fx_size
972 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
973 abort ();
974 #endif
976 s = bfd_install_relocation (stdoutput, reloc,
977 fixp->fx_frag->fr_literal,
978 fixp->fx_frag->fr_address,
979 sec, &err);
980 switch (s)
982 case bfd_reloc_ok:
983 break;
984 case bfd_reloc_overflow:
985 as_bad_where (fixp->fx_file, fixp->fx_line,
986 _("relocation overflow"));
987 break;
988 case bfd_reloc_outofrange:
989 as_bad_where (fixp->fx_file, fixp->fx_line,
990 _("relocation out of range"));
991 break;
992 default:
993 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
994 fixp->fx_file, fixp->fx_line, s);
996 relocs[i++] = reloc;
998 #else
999 n = n * MAX_RELOC_EXPANSION;
1000 /* Set up reloc information as well. */
1001 relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1003 i = 0;
1004 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1006 arelent **reloc;
1007 char *data;
1008 bfd_reloc_status_type s;
1009 symbolS *sym;
1010 int j;
1012 if (fixp->fx_done)
1014 n--;
1015 continue;
1018 /* If this is an undefined symbol which was equated to another
1019 symbol, then generate the reloc against the latter symbol
1020 rather than the former. */
1021 sym = fixp->fx_addsy;
1022 while (symbol_equated_reloc_p (sym))
1024 symbolS *n;
1026 /* We must avoid looping, as that can occur with a badly
1027 written program. */
1028 n = symbol_get_value_expression (sym)->X_add_symbol;
1029 if (n == sym)
1030 break;
1031 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
1032 sym = n;
1034 fixp->fx_addsy = sym;
1036 reloc = tc_gen_reloc (sec, fixp);
1038 for (j = 0; reloc[j]; j++)
1040 relocs[i++] = reloc[j];
1041 assert (i <= n);
1043 data = fixp->fx_frag->fr_literal + fixp->fx_where;
1044 if (fixp->fx_where + fixp->fx_size
1045 > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1046 as_bad_where (fixp->fx_file, fixp->fx_line,
1047 _("internal error: fixup not contained within frag"));
1048 for (j = 0; reloc[j]; j++)
1050 s = bfd_install_relocation (stdoutput, reloc[j],
1051 fixp->fx_frag->fr_literal,
1052 fixp->fx_frag->fr_address,
1053 sec, &err);
1054 switch (s)
1056 case bfd_reloc_ok:
1057 break;
1058 case bfd_reloc_overflow:
1059 as_bad_where (fixp->fx_file, fixp->fx_line,
1060 _("relocation overflow"));
1061 break;
1062 case bfd_reloc_outofrange:
1063 as_bad_where (fixp->fx_file, fixp->fx_line,
1064 _("relocation out of range"));
1065 break;
1066 default:
1067 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1068 fixp->fx_file, fixp->fx_line, s);
1072 n = i;
1073 #endif
1075 #ifdef DEBUG4
1077 int i, j, nsyms;
1078 asymbol **sympp;
1079 sympp = bfd_get_outsymbols (stdoutput);
1080 nsyms = bfd_get_symcount (stdoutput);
1081 for (i = 0; i < n; i++)
1082 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1084 for (j = 0; j < nsyms; j++)
1085 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1086 break;
1087 if (j == nsyms)
1088 abort ();
1091 #endif
1093 if (n)
1094 bfd_set_reloc (stdoutput, sec, relocs, n);
1095 else
1096 bfd_set_section_flags (abfd, sec,
1097 (bfd_get_section_flags (abfd, sec)
1098 & (flagword) ~SEC_RELOC));
1100 #ifdef SET_SECTION_RELOCS
1101 SET_SECTION_RELOCS (sec, relocs, n);
1102 #endif
1104 #ifdef DEBUG3
1106 int i;
1107 arelent *r;
1108 asymbol *s;
1109 fprintf (stderr, "relocs for sec %s\n", sec->name);
1110 for (i = 0; i < n; i++)
1112 r = relocs[i];
1113 s = *r->sym_ptr_ptr;
1114 fprintf (stderr, " reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1115 i, r, r->address, s->name, r->addend);
1118 #endif
1121 static void
1122 write_contents (abfd, sec, xxx)
1123 bfd *abfd ATTRIBUTE_UNUSED;
1124 asection *sec;
1125 PTR xxx ATTRIBUTE_UNUSED;
1127 segment_info_type *seginfo = seg_info (sec);
1128 unsigned long offset = 0;
1129 fragS *f;
1131 /* Write out the frags. */
1132 if (seginfo == NULL
1133 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1134 return;
1136 for (f = seginfo->frchainP->frch_root;
1138 f = f->fr_next)
1140 int x;
1141 unsigned long fill_size;
1142 char *fill_literal;
1143 long count;
1145 assert (f->fr_type == rs_fill);
1146 if (f->fr_fix)
1148 x = bfd_set_section_contents (stdoutput, sec,
1149 f->fr_literal, (file_ptr) offset,
1150 (bfd_size_type) f->fr_fix);
1151 if (x == false)
1153 bfd_perror (stdoutput->filename);
1154 as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1155 exit (EXIT_FAILURE);
1157 offset += f->fr_fix;
1159 fill_literal = f->fr_literal + f->fr_fix;
1160 fill_size = f->fr_var;
1161 count = f->fr_offset;
1162 assert (count >= 0);
1163 if (fill_size && count)
1165 char buf[256];
1166 if (fill_size > sizeof (buf))
1168 /* Do it the old way. Can this ever happen? */
1169 while (count--)
1171 x = bfd_set_section_contents (stdoutput, sec,
1172 fill_literal,
1173 (file_ptr) offset,
1174 (bfd_size_type) fill_size);
1175 if (x == false)
1177 bfd_perror (stdoutput->filename);
1178 as_perror (_("FATAL: Can't write %s"),
1179 stdoutput->filename);
1180 exit (EXIT_FAILURE);
1182 offset += fill_size;
1185 else
1187 /* Build a buffer full of fill objects and output it as
1188 often as necessary. This saves on the overhead of
1189 potentially lots of bfd_set_section_contents calls. */
1190 int n_per_buf, i;
1191 if (fill_size == 1)
1193 n_per_buf = sizeof (buf);
1194 memset (buf, *fill_literal, n_per_buf);
1196 else
1198 char *bufp;
1199 n_per_buf = sizeof (buf) / fill_size;
1200 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1201 memcpy (bufp, fill_literal, fill_size);
1203 for (; count > 0; count -= n_per_buf)
1205 n_per_buf = n_per_buf > count ? count : n_per_buf;
1206 x = bfd_set_section_contents
1207 (stdoutput, sec, buf, (file_ptr) offset,
1208 (bfd_size_type) n_per_buf * fill_size);
1209 if (x != true)
1210 as_fatal (_("cannot write to output file"));
1211 offset += n_per_buf * fill_size;
1217 #endif
1219 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1220 static void
1221 merge_data_into_text ()
1223 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1224 seg_info (text_section)->frchainP->frch_last->fr_next =
1225 seg_info (data_section)->frchainP->frch_root;
1226 seg_info (text_section)->frchainP->frch_last =
1227 seg_info (data_section)->frchainP->frch_last;
1228 seg_info (data_section)->frchainP = 0;
1229 #else
1230 fixS *tmp;
1232 text_last_frag->fr_next = data_frag_root;
1233 text_last_frag = data_last_frag;
1234 data_last_frag = NULL;
1235 data_frag_root = NULL;
1236 if (text_fix_root)
1238 for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1239 tmp->fx_next = data_fix_root;
1240 text_fix_tail = data_fix_tail;
1242 else
1243 text_fix_root = data_fix_root;
1244 data_fix_root = NULL;
1245 #endif
1247 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT) */
1249 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1250 static void
1251 relax_and_size_all_segments ()
1253 fragS *fragP;
1255 relax_segment (text_frag_root, SEG_TEXT);
1256 relax_segment (data_frag_root, SEG_DATA);
1257 relax_segment (bss_frag_root, SEG_BSS);
1259 /* Now the addresses of frags are correct within the segment. */
1260 know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1261 H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1262 text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1264 /* Join the 2 segments into 1 huge segment.
1265 To do this, re-compute every rn_address in the SEG_DATA frags.
1266 Then join the data frags after the text frags.
1268 Determine a_data [length of data segment]. */
1269 if (data_frag_root)
1271 register relax_addressT slide;
1273 know ((text_last_frag->fr_type == rs_fill)
1274 && (text_last_frag->fr_offset == 0));
1276 H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1277 data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1278 slide = H_GET_TEXT_SIZE (&headers); /* & in file of the data segment. */
1279 #ifdef OBJ_BOUT
1280 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1281 /* For b.out: If the data section has a strict alignment
1282 requirement, its load address in the .o file will be
1283 rounded up from the size of the text section. These
1284 two values are *not* the same! Similarly for the bss
1285 section.... */
1286 slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1287 #endif
1289 for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1290 fragP->fr_address += slide;
1292 know (text_last_frag != 0);
1293 text_last_frag->fr_next = data_frag_root;
1295 else
1297 H_SET_DATA_SIZE (&headers, 0);
1300 #ifdef OBJ_BOUT
1301 /* See above comments on b.out data section address. */
1303 long bss_vma;
1304 if (data_last_frag == 0)
1305 bss_vma = H_GET_TEXT_SIZE (&headers);
1306 else
1307 bss_vma = data_last_frag->fr_address;
1308 bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1309 bss_address_frag.fr_address = bss_vma;
1311 #else /* ! OBJ_BOUT */
1312 bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1313 H_GET_DATA_SIZE (&headers));
1315 #endif /* ! OBJ_BOUT */
1317 /* Slide all the frags. */
1318 if (bss_frag_root)
1320 relax_addressT slide = bss_address_frag.fr_address;
1322 for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1323 fragP->fr_address += slide;
1326 if (bss_last_frag)
1327 H_SET_BSS_SIZE (&headers,
1328 bss_last_frag->fr_address - bss_frag_root->fr_address);
1329 else
1330 H_SET_BSS_SIZE (&headers, 0);
1332 #endif /* ! BFD_ASSEMBLER && ! BFD */
1334 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1336 #ifdef BFD_ASSEMBLER
1337 static void
1338 set_symtab ()
1340 int nsyms;
1341 asymbol **asympp;
1342 symbolS *symp;
1343 boolean result;
1344 extern PTR bfd_alloc PARAMS ((bfd *, bfd_size_type));
1346 /* Count symbols. We can't rely on a count made by the loop in
1347 write_object_file, because *_frob_file may add a new symbol or
1348 two. */
1349 nsyms = 0;
1350 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1351 nsyms++;
1353 if (nsyms)
1355 int i;
1356 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1358 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1359 symp = symbol_rootP;
1360 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1362 asympp[i] = symbol_get_bfdsym (symp);
1363 symbol_mark_written (symp);
1366 else
1367 asympp = 0;
1368 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1369 assert (result == true);
1370 symbol_table_frozen = 1;
1372 #endif
1374 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1375 static void
1376 set_segment_vma (abfd, sec, xxx)
1377 bfd *abfd;
1378 asection *sec;
1379 PTR xxx ATTRIBUTE_UNUSED;
1381 static bfd_vma addr = 0;
1383 bfd_set_section_vma (abfd, sec, addr);
1384 addr += bfd_section_size (abfd, sec);
1386 #endif /* BFD_ASSEMBLER && OBJ_COFF && !TE_PE */
1388 /* Finish the subsegments. After every sub-segment, we fake an
1389 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1390 ".fill 0" because that is the kind of frag that requires least
1391 thought. ".align" frags like to have a following frag since that
1392 makes calculating their intended length trivial. */
1394 #ifndef SUB_SEGMENT_ALIGN
1395 #ifdef HANDLE_ALIGN
1396 /* The last subsegment gets an aligment corresponding to the alignment
1397 of the section. This allows proper nop-filling at the end of
1398 code-bearing sections. */
1399 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1400 (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
1401 ? get_recorded_alignment (SEG) : 0)
1402 #else
1403 #ifdef BFD_ASSEMBLER
1404 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1405 #else
1406 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 2
1407 #endif
1408 #endif
1409 #endif
1411 void
1412 subsegs_finish ()
1414 struct frchain *frchainP;
1416 for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1418 int alignment = 0;
1420 subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1422 /* This now gets called even if we had errors. In that case,
1423 any alignment is meaningless, and, moreover, will look weird
1424 if we are generating a listing. */
1425 if (!had_errors ())
1426 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1428 if (subseg_text_p (now_seg))
1429 frag_align_code (alignment, 0);
1430 else
1431 frag_align (alignment, 0, 0);
1433 /* frag_align will have left a new frag.
1434 Use this last frag for an empty ".fill".
1436 For this segment ...
1437 Create a last frag. Do not leave a "being filled in frag". */
1438 frag_wane (frag_now);
1439 frag_now->fr_fix = 0;
1440 know (frag_now->fr_next == NULL);
1444 /* Write the object file. */
1446 void
1447 write_object_file ()
1449 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1450 fragS *fragP; /* Track along all frags. */
1451 #endif
1453 /* Do we really want to write it? */
1455 int n_warns, n_errs;
1456 n_warns = had_warnings ();
1457 n_errs = had_errors ();
1458 /* The -Z flag indicates that an object file should be generated,
1459 regardless of warnings and errors. */
1460 if (flag_always_generate_output)
1462 if (n_warns || n_errs)
1463 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1464 n_errs, n_errs == 1 ? "" : "s",
1465 n_warns, n_warns == 1 ? "" : "s");
1467 else
1469 if (n_errs)
1470 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1471 n_errs, n_errs == 1 ? "" : "s",
1472 n_warns, n_warns == 1 ? "" : "s");
1476 #ifdef OBJ_VMS
1477 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1478 a routine to check for the definition of the procedure "_main",
1479 and if so -- fix it up so that it can be program entry point. */
1480 vms_check_for_main ();
1481 #endif /* OBJ_VMS */
1483 /* From now on, we don't care about sub-segments. Build one frag chain
1484 for each segment. Linked thru fr_next. */
1486 #ifdef BFD_ASSEMBLER
1487 /* Remove the sections created by gas for its own purposes. */
1489 asection **seclist;
1490 int i;
1492 seclist = &stdoutput->sections;
1493 while (*seclist)
1495 if (*seclist == reg_section || *seclist == expr_section)
1497 bfd_section_list_remove (stdoutput, seclist);
1498 stdoutput->section_count--;
1500 else
1501 seclist = &(*seclist)->next;
1503 i = 0;
1504 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1507 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1508 #else
1509 remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1510 remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1511 remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1512 #endif
1514 /* We have two segments. If user gave -R flag, then we must put the
1515 data frags into the text segment. Do this before relaxing so
1516 we know to take advantage of -R and make shorter addresses. */
1517 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1518 if (flag_readonly_data_in_text)
1520 merge_data_into_text ();
1522 #endif
1524 #ifdef BFD_ASSEMBLER
1525 while (1)
1527 int changed;
1529 #ifndef WORKING_DOT_WORD
1530 /* We need to reset the markers in the broken word list and
1531 associated frags between calls to relax_segment (via
1532 relax_seg). Since the broken word list is global, we do it
1533 once per round, rather than locally in relax_segment for each
1534 segment. */
1535 struct broken_word *brokp;
1537 for (brokp = broken_words;
1538 brokp != (struct broken_word *) NULL;
1539 brokp = brokp->next_broken_word)
1541 brokp->added = 0;
1543 if (brokp->dispfrag != (fragS *) NULL
1544 && brokp->dispfrag->fr_type == rs_broken_word)
1545 brokp->dispfrag->fr_subtype = 0;
1547 #endif
1549 changed = 0;
1550 bfd_map_over_sections (stdoutput, relax_seg, &changed);
1551 if (!changed)
1552 break;
1555 /* Note - Most ports will use the default value of
1556 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1557 local symbols to be resolved, removing their frag information.
1558 Some ports however, will not have finished relaxing all of
1559 their frags and will still need the local symbol frag
1560 information. These ports can set
1561 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1562 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1564 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1565 #else
1566 relax_and_size_all_segments ();
1567 #endif /* BFD_ASSEMBLER */
1569 /* Relaxation has completed. Freeze all syms. */
1570 finalize_syms = 1;
1572 #if defined (BFD_ASSEMBLER) && defined (OBJ_COFF) && defined (TE_GO32)
1573 /* Now that the segments have their final sizes, run through the
1574 sections and set their vma and lma. !BFD gas sets them, and BFD gas
1575 should too. Currently, only DJGPP uses this code, but other
1576 COFF targets may need to execute this too. */
1577 bfd_map_over_sections (stdoutput, set_segment_vma, (char *) 0);
1578 #endif
1580 #ifndef BFD_ASSEMBLER
1581 /* Crawl the symbol chain.
1583 For each symbol whose value depends on a frag, take the address of
1584 that frag and subsume it into the value of the symbol.
1585 After this, there is just one way to lookup a symbol value.
1586 Values are left in their final state for object file emission.
1587 We adjust the values of 'L' local symbols, even if we do
1588 not intend to emit them to the object file, because their values
1589 are needed for fix-ups.
1591 Unless we saw a -L flag, remove all symbols that begin with 'L'
1592 from the symbol chain. (They are still pointed to by the fixes.)
1594 Count the remaining symbols.
1595 Assign a symbol number to each symbol.
1596 Count the number of string-table chars we will emit.
1597 Put this info into the headers as appropriate. */
1598 know (zero_address_frag.fr_address == 0);
1599 string_byte_count = sizeof (string_byte_count);
1601 obj_crawl_symbol_chain (&headers);
1603 if (string_byte_count == sizeof (string_byte_count))
1604 string_byte_count = 0;
1606 H_SET_STRING_SIZE (&headers, string_byte_count);
1608 /* Addresses of frags now reflect addresses we use in the object file.
1609 Symbol values are correct.
1610 Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1611 Also converting any machine-dependent frags using md_convert_frag(); */
1612 subseg_change (SEG_TEXT, 0);
1614 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1616 /* At this point we have linked all the frags into a single
1617 chain. However, cvt_frag_to_fill may call md_convert_frag
1618 which may call fix_new. We need to ensure that fix_new adds
1619 the fixup to the right section. */
1620 if (fragP == data_frag_root)
1621 subseg_change (SEG_DATA, 0);
1623 cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1625 /* Some assert macros don't work with # directives mixed in. */
1626 #ifndef NDEBUG
1627 if (!(fragP->fr_next == NULL
1628 #ifdef OBJ_BOUT
1629 || fragP->fr_next == data_frag_root
1630 #endif
1631 || ((fragP->fr_next->fr_address - fragP->fr_address)
1632 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1633 abort ();
1634 #endif
1636 #endif /* ! BFD_ASSEMBLER */
1638 #ifndef WORKING_DOT_WORD
1640 struct broken_word *lie;
1641 struct broken_word **prevP;
1643 prevP = &broken_words;
1644 for (lie = broken_words; lie; lie = lie->next_broken_word)
1645 if (!lie->added)
1647 expressionS exp;
1649 subseg_change (lie->seg, lie->subseg);
1650 exp.X_op = O_subtract;
1651 exp.X_add_symbol = lie->add;
1652 exp.X_op_symbol = lie->sub;
1653 exp.X_add_number = lie->addnum;
1654 #ifdef BFD_ASSEMBLER
1655 #ifdef TC_CONS_FIX_NEW
1656 TC_CONS_FIX_NEW (lie->frag,
1657 lie->word_goes_here - lie->frag->fr_literal,
1658 2, &exp);
1659 #else
1660 fix_new_exp (lie->frag,
1661 lie->word_goes_here - lie->frag->fr_literal,
1662 2, &exp, 0, BFD_RELOC_16);
1663 #endif
1664 #else
1665 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1666 fix_new_exp (lie->frag,
1667 lie->word_goes_here - lie->frag->fr_literal,
1668 2, &exp, 0, NO_RELOC);
1669 #else
1670 #ifdef TC_NS32K
1671 fix_new_ns32k_exp (lie->frag,
1672 lie->word_goes_here - lie->frag->fr_literal,
1673 2, &exp, 0, 0, 2, 0, 0);
1674 #else
1675 fix_new_exp (lie->frag,
1676 lie->word_goes_here - lie->frag->fr_literal,
1677 2, &exp, 0, 0);
1678 #endif /* TC_NS32K */
1679 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE */
1680 #endif /* BFD_ASSEMBLER */
1681 *prevP = lie->next_broken_word;
1683 else
1684 prevP = &(lie->next_broken_word);
1686 for (lie = broken_words; lie;)
1688 struct broken_word *untruth;
1689 char *table_ptr;
1690 addressT table_addr;
1691 addressT from_addr, to_addr;
1692 int n, m;
1694 subseg_change (lie->seg, lie->subseg);
1695 fragP = lie->dispfrag;
1697 /* Find out how many broken_words go here. */
1698 n = 0;
1699 for (untruth = lie;
1700 untruth && untruth->dispfrag == fragP;
1701 untruth = untruth->next_broken_word)
1702 if (untruth->added == 1)
1703 n++;
1705 table_ptr = lie->dispfrag->fr_opcode;
1706 table_addr = (lie->dispfrag->fr_address
1707 + (table_ptr - lie->dispfrag->fr_literal));
1708 /* Create the jump around the long jumps. This is a short
1709 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1710 from_addr = table_addr;
1711 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1712 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1713 lie->add);
1714 table_ptr += md_short_jump_size;
1715 table_addr += md_short_jump_size;
1717 for (m = 0;
1718 lie && lie->dispfrag == fragP;
1719 m++, lie = lie->next_broken_word)
1721 if (lie->added == 2)
1722 continue;
1723 /* Patch the jump table. */
1724 /* This is the offset from ??? to table_ptr+0. */
1725 to_addr = table_addr - S_GET_VALUE (lie->sub);
1726 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1727 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1728 #endif
1729 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1730 for (untruth = lie->next_broken_word;
1731 untruth && untruth->dispfrag == fragP;
1732 untruth = untruth->next_broken_word)
1734 if (untruth->use_jump == lie)
1735 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1738 /* Install the long jump. */
1739 /* This is a long jump from table_ptr+0 to the final target. */
1740 from_addr = table_addr;
1741 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1742 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1743 lie->add);
1744 table_ptr += md_long_jump_size;
1745 table_addr += md_long_jump_size;
1749 #endif /* not WORKING_DOT_WORD */
1751 #ifndef BFD_ASSEMBLER
1752 #ifndef OBJ_VMS
1753 { /* not vms */
1754 char *the_object_file;
1755 long object_file_size;
1756 /* Scan every FixS performing fixups. We had to wait until now to
1757 do this because md_convert_frag() may have made some fixSs. */
1758 int trsize, drsize;
1760 subseg_change (SEG_TEXT, 0);
1761 trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1762 subseg_change (SEG_DATA, 0);
1763 drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1764 H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1766 /* FIXME: Move this stuff into the pre-write-hook. */
1767 H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1768 H_SET_ENTRY_POINT (&headers, 0);
1770 obj_pre_write_hook (&headers); /* Extra coff stuff. */
1772 object_file_size = H_GET_FILE_SIZE (&headers);
1773 next_object_file_charP = the_object_file = xmalloc (object_file_size);
1775 output_file_create (out_file_name);
1777 obj_header_append (&next_object_file_charP, &headers);
1779 know ((next_object_file_charP - the_object_file)
1780 == H_GET_HEADER_SIZE (&headers));
1782 /* Emit code. */
1783 for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1785 register long count;
1786 register char *fill_literal;
1787 register long fill_size;
1789 PROGRESS (1);
1790 know (fragP->fr_type == rs_fill);
1791 append (&next_object_file_charP, fragP->fr_literal,
1792 (unsigned long) fragP->fr_fix);
1793 fill_literal = fragP->fr_literal + fragP->fr_fix;
1794 fill_size = fragP->fr_var;
1795 know (fragP->fr_offset >= 0);
1797 for (count = fragP->fr_offset; count; count--)
1798 append (&next_object_file_charP, fill_literal,
1799 (unsigned long) fill_size);
1802 know ((next_object_file_charP - the_object_file)
1803 == (H_GET_HEADER_SIZE (&headers)
1804 + H_GET_TEXT_SIZE (&headers)
1805 + H_GET_DATA_SIZE (&headers)));
1807 /* Emit relocations. */
1808 obj_emit_relocations (&next_object_file_charP, text_fix_root,
1809 (relax_addressT) 0);
1810 know ((next_object_file_charP - the_object_file)
1811 == (H_GET_HEADER_SIZE (&headers)
1812 + H_GET_TEXT_SIZE (&headers)
1813 + H_GET_DATA_SIZE (&headers)
1814 + H_GET_TEXT_RELOCATION_SIZE (&headers)));
1815 #ifdef TC_I960
1816 /* Make addresses in data relocation directives relative to beginning of
1817 first data fragment, not end of last text fragment: alignment of the
1818 start of the data segment may place a gap between the segments. */
1819 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1820 data0_frchainP->frch_root->fr_address);
1821 #else /* TC_I960 */
1822 obj_emit_relocations (&next_object_file_charP, data_fix_root,
1823 text_last_frag->fr_address);
1824 #endif /* TC_I960 */
1826 know ((next_object_file_charP - the_object_file)
1827 == (H_GET_HEADER_SIZE (&headers)
1828 + H_GET_TEXT_SIZE (&headers)
1829 + H_GET_DATA_SIZE (&headers)
1830 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1831 + H_GET_DATA_RELOCATION_SIZE (&headers)));
1833 /* Emit line number entries. */
1834 OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1835 know ((next_object_file_charP - the_object_file)
1836 == (H_GET_HEADER_SIZE (&headers)
1837 + H_GET_TEXT_SIZE (&headers)
1838 + H_GET_DATA_SIZE (&headers)
1839 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1840 + H_GET_DATA_RELOCATION_SIZE (&headers)
1841 + H_GET_LINENO_SIZE (&headers)));
1843 /* Emit symbols. */
1844 obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1845 know ((next_object_file_charP - the_object_file)
1846 == (H_GET_HEADER_SIZE (&headers)
1847 + H_GET_TEXT_SIZE (&headers)
1848 + H_GET_DATA_SIZE (&headers)
1849 + H_GET_TEXT_RELOCATION_SIZE (&headers)
1850 + H_GET_DATA_RELOCATION_SIZE (&headers)
1851 + H_GET_LINENO_SIZE (&headers)
1852 + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1854 /* Emit strings. */
1855 if (string_byte_count > 0)
1856 obj_emit_strings (&next_object_file_charP);
1858 #ifdef BFD_HEADERS
1859 bfd_seek (stdoutput, (file_ptr) 0, 0);
1860 bfd_bwrite (the_object_file, (bfd_size_type) object_file_size, stdoutput);
1861 #else
1863 /* Write the data to the file. */
1864 output_file_append (the_object_file, object_file_size, out_file_name);
1865 free (the_object_file);
1866 #endif
1868 #else /* OBJ_VMS */
1869 /* Now do the VMS-dependent part of writing the object file. */
1870 vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1871 H_GET_DATA_SIZE (&headers),
1872 H_GET_BSS_SIZE (&headers),
1873 text_frag_root, data_frag_root);
1874 #endif /* OBJ_VMS */
1875 #else /* BFD_ASSEMBLER */
1877 /* Resolve symbol values. This needs to be done before processing
1878 the relocations. */
1879 if (symbol_rootP)
1881 symbolS *symp;
1883 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1884 resolve_symbol_value (symp);
1886 resolve_local_symbol_values ();
1888 PROGRESS (1);
1890 #ifdef tc_frob_file_before_adjust
1891 tc_frob_file_before_adjust ();
1892 #endif
1893 #ifdef obj_frob_file_before_adjust
1894 obj_frob_file_before_adjust ();
1895 #endif
1897 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1899 #ifdef tc_frob_file_before_fix
1900 tc_frob_file_before_fix ();
1901 #endif
1902 #ifdef obj_frob_file_before_fix
1903 obj_frob_file_before_fix ();
1904 #endif
1906 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1908 /* Set up symbol table, and write it out. */
1909 if (symbol_rootP)
1911 symbolS *symp;
1913 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1915 int punt = 0;
1916 const char *name;
1918 if (symbol_mri_common_p (symp))
1920 if (S_IS_EXTERNAL (symp))
1921 as_bad (_("%s: global symbols not supported in common sections"),
1922 S_GET_NAME (symp));
1923 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1924 continue;
1927 name = S_GET_NAME (symp);
1928 if (name)
1930 const char *name2 =
1931 decode_local_label_name ((char *) S_GET_NAME (symp));
1932 /* They only differ if `name' is a fb or dollar local
1933 label name. */
1934 if (name2 != name && ! S_IS_DEFINED (symp))
1935 as_bad (_("local label `%s' is not defined"), name2);
1938 /* Do it again, because adjust_reloc_syms might introduce
1939 more symbols. They'll probably only be section symbols,
1940 but they'll still need to have the values computed. */
1941 resolve_symbol_value (symp);
1943 /* Skip symbols which were equated to undefined or common
1944 symbols. */
1945 if (symbol_equated_reloc_p (symp))
1947 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1948 continue;
1951 /* So far, common symbols have been treated like undefined symbols.
1952 Put them in the common section now. */
1953 if (S_IS_DEFINED (symp) == 0
1954 && S_GET_VALUE (symp) != 0)
1955 S_SET_SEGMENT (symp, bfd_com_section_ptr);
1956 #if 0
1957 printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1958 S_GET_NAME (symp), symp,
1959 S_GET_VALUE (symp),
1960 symbol_get_bfdsym (symp)->flags,
1961 segment_name (S_GET_SEGMENT (symp)));
1962 #endif
1964 #ifdef obj_frob_symbol
1965 obj_frob_symbol (symp, punt);
1966 #endif
1967 #ifdef tc_frob_symbol
1968 if (! punt || symbol_used_in_reloc_p (symp))
1969 tc_frob_symbol (symp, punt);
1970 #endif
1972 /* If we don't want to keep this symbol, splice it out of
1973 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1974 want section symbols. Otherwise, we skip local symbols
1975 and symbols that the frob_symbol macros told us to punt,
1976 but we keep such symbols if they are used in relocs. */
1977 if (symp == abs_section_sym
1978 || (! EMIT_SECTION_SYMBOLS
1979 && symbol_section_p (symp))
1980 /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1981 opposites. Sometimes the former checks flags and the
1982 latter examines the name... */
1983 || (!S_IS_EXTERN (symp)
1984 && (punt || S_IS_LOCAL (symp))
1985 && ! symbol_used_in_reloc_p (symp)))
1987 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1989 /* After symbol_remove, symbol_next(symp) still returns
1990 the one that came after it in the chain. So we don't
1991 need to do any extra cleanup work here. */
1992 continue;
1995 /* Make sure we really got a value for the symbol. */
1996 if (! symbol_resolved_p (symp))
1998 as_bad (_("can't resolve value for symbol `%s'"),
1999 S_GET_NAME (symp));
2000 symbol_mark_resolved (symp);
2003 /* Set the value into the BFD symbol. Up til now the value
2004 has only been kept in the gas symbolS struct. */
2005 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2009 PROGRESS (1);
2011 /* Now do any format-specific adjustments to the symbol table, such
2012 as adding file symbols. */
2013 #ifdef tc_adjust_symtab
2014 tc_adjust_symtab ();
2015 #endif
2016 #ifdef obj_adjust_symtab
2017 obj_adjust_symtab ();
2018 #endif
2020 /* Now that all the sizes are known, and contents correct, we can
2021 start writing to the file. */
2022 set_symtab ();
2024 /* If *_frob_file changes the symbol value at this point, it is
2025 responsible for moving the changed value into symp->bsym->value
2026 as well. Hopefully all symbol value changing can be done in
2027 *_frob_symbol. */
2028 #ifdef tc_frob_file
2029 tc_frob_file ();
2030 #endif
2031 #ifdef obj_frob_file
2032 obj_frob_file ();
2033 #endif
2035 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2037 #ifdef tc_frob_file_after_relocs
2038 tc_frob_file_after_relocs ();
2039 #endif
2040 #ifdef obj_frob_file_after_relocs
2041 obj_frob_file_after_relocs ();
2042 #endif
2044 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2045 #endif /* BFD_ASSEMBLER */
2047 #endif /* ! BFD */
2049 #ifdef TC_GENERIC_RELAX_TABLE
2051 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2053 long
2054 relax_frag (segment, fragP, stretch)
2055 segT segment;
2056 fragS *fragP;
2057 long stretch;
2059 const relax_typeS *this_type;
2060 const relax_typeS *start_type;
2061 relax_substateT next_state;
2062 relax_substateT this_state;
2063 long growth;
2064 offsetT aim;
2065 addressT target;
2066 addressT address;
2067 symbolS *symbolP;
2068 const relax_typeS *table;
2070 target = fragP->fr_offset;
2071 address = fragP->fr_address;
2072 table = TC_GENERIC_RELAX_TABLE;
2073 this_state = fragP->fr_subtype;
2074 start_type = this_type = table + this_state;
2075 symbolP = fragP->fr_symbol;
2077 if (symbolP)
2079 fragS *sym_frag;
2081 sym_frag = symbol_get_frag (symbolP);
2083 #ifndef DIFF_EXPR_OK
2084 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2085 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2086 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2087 || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2088 || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2089 #endif
2090 know (sym_frag != NULL);
2091 #endif
2092 know (S_GET_SEGMENT (symbolP) != absolute_section
2093 || sym_frag == &zero_address_frag);
2094 target += S_GET_VALUE (symbolP);
2096 /* If frag has yet to be reached on this pass,
2097 assume it will move by STRETCH just as we did.
2098 If this is not so, it will be because some frag
2099 between grows, and that will force another pass. */
2101 if (stretch != 0
2102 && sym_frag->relax_marker != fragP->relax_marker
2103 && S_GET_SEGMENT (symbolP) == segment)
2105 target += stretch;
2109 aim = target - address - fragP->fr_fix;
2110 #ifdef TC_PCREL_ADJUST
2111 /* Currently only the ns32k family needs this. */
2112 aim += TC_PCREL_ADJUST (fragP);
2113 /* #else */
2114 /* This machine doesn't want to use pcrel_adjust.
2115 In that case, pcrel_adjust should be zero. */
2116 #if 0
2117 assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
2118 #endif
2119 #endif
2120 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE */
2121 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2122 #endif
2124 if (aim < 0)
2126 /* Look backwards. */
2127 for (next_state = this_type->rlx_more; next_state;)
2128 if (aim >= this_type->rlx_backward)
2129 next_state = 0;
2130 else
2132 /* Grow to next state. */
2133 this_state = next_state;
2134 this_type = table + this_state;
2135 next_state = this_type->rlx_more;
2138 else
2140 /* Look forwards. */
2141 for (next_state = this_type->rlx_more; next_state;)
2142 if (aim <= this_type->rlx_forward)
2143 next_state = 0;
2144 else
2146 /* Grow to next state. */
2147 this_state = next_state;
2148 this_type = table + this_state;
2149 next_state = this_type->rlx_more;
2153 growth = this_type->rlx_length - start_type->rlx_length;
2154 if (growth != 0)
2155 fragP->fr_subtype = this_state;
2156 return growth;
2159 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2161 /* Relax_align. Advance location counter to next address that has 'alignment'
2162 lowest order bits all 0s, return size of adjustment made. */
2163 static relax_addressT
2164 relax_align (address, alignment)
2165 register relax_addressT address; /* Address now. */
2166 register int alignment; /* Alignment (binary). */
2168 relax_addressT mask;
2169 relax_addressT new_address;
2171 mask = ~((~0) << alignment);
2172 new_address = (address + mask) & (~mask);
2173 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2174 if (linkrelax)
2175 /* We must provide lots of padding, so the linker can discard it
2176 when needed. The linker will not add extra space, ever. */
2177 new_address += (1 << alignment);
2178 #endif
2179 return (new_address - address);
2182 /* Now we have a segment, not a crowd of sub-segments, we can make
2183 fr_address values.
2185 Relax the frags.
2187 After this, all frags in this segment have addresses that are correct
2188 within the segment. Since segments live in different file addresses,
2189 these frag addresses may not be the same as final object-file
2190 addresses. */
2193 relax_segment (segment_frag_root, segment)
2194 struct frag *segment_frag_root;
2195 segT segment;
2197 register struct frag *fragP;
2198 register relax_addressT address;
2199 int ret;
2201 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2202 know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2203 #endif
2204 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2205 subseg_change (segment, 0);
2207 /* For each frag in segment: count and store (a 1st guess of)
2208 fr_address. */
2209 address = 0;
2210 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2212 fragP->relax_marker = 0;
2213 fragP->fr_address = address;
2214 address += fragP->fr_fix;
2216 switch (fragP->fr_type)
2218 case rs_fill:
2219 address += fragP->fr_offset * fragP->fr_var;
2220 break;
2222 case rs_align:
2223 case rs_align_code:
2224 case rs_align_test:
2226 addressT offset = relax_align (address, (int) fragP->fr_offset);
2228 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2229 offset = 0;
2231 if (offset % fragP->fr_var != 0)
2233 as_bad_where (fragP->fr_file, fragP->fr_line,
2234 _("alignment padding (%lu bytes) not a multiple of %ld"),
2235 (unsigned long) offset, (long) fragP->fr_var);
2236 offset -= (offset % fragP->fr_var);
2239 address += offset;
2241 break;
2243 case rs_org:
2244 case rs_space:
2245 /* Assume .org is nugatory. It will grow with 1st relax. */
2246 break;
2248 case rs_machine_dependent:
2249 /* If fr_symbol is an expression, this call to
2250 resolve_symbol_value sets up the correct segment, which will
2251 likely be needed in md_estimate_size_before_relax. */
2252 if (fragP->fr_symbol)
2253 resolve_symbol_value (fragP->fr_symbol);
2255 address += md_estimate_size_before_relax (fragP, segment);
2256 break;
2258 #ifndef WORKING_DOT_WORD
2259 /* Broken words don't concern us yet. */
2260 case rs_broken_word:
2261 break;
2262 #endif
2264 case rs_leb128:
2265 /* Initial guess is always 1; doing otherwise can result in
2266 stable solutions that are larger than the minimum. */
2267 address += fragP->fr_offset = 1;
2268 break;
2270 case rs_cfa:
2271 address += eh_frame_estimate_size_before_relax (fragP);
2272 break;
2274 case rs_dwarf2dbg:
2275 address += dwarf2dbg_estimate_size_before_relax (fragP);
2276 break;
2278 default:
2279 BAD_CASE (fragP->fr_type);
2280 break;
2284 /* Do relax(). */
2286 long stretch; /* May be any size, 0 or negative. */
2287 /* Cumulative number of addresses we have relaxed this pass.
2288 We may have relaxed more than one address. */
2289 int stretched; /* Have we stretched on this pass? */
2290 /* This is 'cuz stretch may be zero, when, in fact some piece of code
2291 grew, and another shrank. If a branch instruction doesn't fit anymore,
2292 we could be scrod. */
2296 stretch = 0;
2297 stretched = 0;
2299 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2301 long growth = 0;
2302 addressT was_address;
2303 offsetT offset;
2304 symbolS *symbolP;
2306 fragP->relax_marker ^= 1;
2307 was_address = fragP->fr_address;
2308 address = fragP->fr_address += stretch;
2309 symbolP = fragP->fr_symbol;
2310 offset = fragP->fr_offset;
2312 switch (fragP->fr_type)
2314 case rs_fill: /* .fill never relaxes. */
2315 growth = 0;
2316 break;
2318 #ifndef WORKING_DOT_WORD
2319 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2320 for it I do not want to write it. I do not want to have
2321 anything to do with it. This is not the proper way to
2322 implement this misfeature. */
2323 case rs_broken_word:
2325 struct broken_word *lie;
2326 struct broken_word *untruth;
2328 /* Yes this is ugly (storing the broken_word pointer
2329 in the symbol slot). Still, this whole chunk of
2330 code is ugly, and I don't feel like doing anything
2331 about it. Think of it as stubbornness in action. */
2332 growth = 0;
2333 for (lie = (struct broken_word *) (fragP->fr_symbol);
2334 lie && lie->dispfrag == fragP;
2335 lie = lie->next_broken_word)
2338 if (lie->added)
2339 continue;
2341 offset = (S_GET_VALUE (lie->add)
2342 + lie->addnum
2343 - S_GET_VALUE (lie->sub));
2344 if (offset <= -32768 || offset >= 32767)
2346 if (flag_warn_displacement)
2348 char buf[50];
2349 sprint_value (buf, (addressT) lie->addnum);
2350 as_warn_where (fragP->fr_file, fragP->fr_line,
2351 _(".word %s-%s+%s didn't fit"),
2352 S_GET_NAME (lie->add),
2353 S_GET_NAME (lie->sub),
2354 buf);
2356 lie->added = 1;
2357 if (fragP->fr_subtype == 0)
2359 fragP->fr_subtype++;
2360 growth += md_short_jump_size;
2362 for (untruth = lie->next_broken_word;
2363 untruth && untruth->dispfrag == lie->dispfrag;
2364 untruth = untruth->next_broken_word)
2365 if ((symbol_get_frag (untruth->add)
2366 == symbol_get_frag (lie->add))
2367 && (S_GET_VALUE (untruth->add)
2368 == S_GET_VALUE (lie->add)))
2370 untruth->added = 2;
2371 untruth->use_jump = lie;
2373 growth += md_long_jump_size;
2377 break;
2378 } /* case rs_broken_word */
2379 #endif
2380 case rs_align:
2381 case rs_align_code:
2382 case rs_align_test:
2384 addressT oldoff, newoff;
2386 oldoff = relax_align (was_address + fragP->fr_fix,
2387 (int) offset);
2388 newoff = relax_align (address + fragP->fr_fix,
2389 (int) offset);
2391 if (fragP->fr_subtype != 0)
2393 if (oldoff > fragP->fr_subtype)
2394 oldoff = 0;
2395 if (newoff > fragP->fr_subtype)
2396 newoff = 0;
2399 growth = newoff - oldoff;
2401 break;
2403 case rs_org:
2405 addressT target = offset;
2406 addressT after;
2408 if (symbolP)
2410 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2411 know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2412 || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2413 || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2414 || S_GET_SEGMENT (symbolP) == SEG_BSS);
2415 know (symbolP->sy_frag);
2416 know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2417 || (symbolP->sy_frag == &zero_address_frag));
2418 #endif
2419 /* Convert from an actual address to an octet offset
2420 into the section. Here it is assumed that the
2421 section's VMA is zero, and can omit subtracting it
2422 from the symbol's value to get the address offset. */
2423 know (S_GET_SECTION (symbolP)->vma == 0);
2424 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2427 know (fragP->fr_next);
2428 after = fragP->fr_next->fr_address;
2429 growth = target - after;
2430 if (growth < 0)
2432 /* Growth may be negative, but variable part of frag
2433 cannot have fewer than 0 chars. That is, we can't
2434 .org backwards. */
2435 as_bad_where (fragP->fr_file, fragP->fr_line,
2436 _("attempt to .org backwards"));
2438 /* We've issued an error message. Change the
2439 frag to avoid cascading errors. */
2440 fragP->fr_type = rs_align;
2441 fragP->fr_subtype = 0;
2442 fragP->fr_offset = 0;
2443 fragP->fr_fix = after - address;
2444 growth = stretch;
2447 /* This is an absolute growth factor */
2448 growth -= stretch;
2449 break;
2452 case rs_space:
2453 growth = 0;
2454 if (symbolP)
2456 offsetT amount;
2458 amount = S_GET_VALUE (symbolP);
2459 if (S_GET_SEGMENT (symbolP) != absolute_section
2460 || S_IS_COMMON (symbolP)
2461 || ! S_IS_DEFINED (symbolP))
2463 as_bad_where (fragP->fr_file, fragP->fr_line,
2464 _(".space specifies non-absolute value"));
2465 /* Prevent repeat of this error message. */
2466 fragP->fr_symbol = 0;
2468 else if (amount < 0)
2470 as_warn_where (fragP->fr_file, fragP->fr_line,
2471 _(".space or .fill with negative value, ignored"));
2472 fragP->fr_symbol = 0;
2474 else
2475 growth = (was_address + fragP->fr_fix + amount
2476 - fragP->fr_next->fr_address);
2478 break;
2480 case rs_machine_dependent:
2481 #ifdef md_relax_frag
2482 growth = md_relax_frag (segment, fragP, stretch);
2483 #else
2484 #ifdef TC_GENERIC_RELAX_TABLE
2485 /* The default way to relax a frag is to look through
2486 TC_GENERIC_RELAX_TABLE. */
2487 growth = relax_frag (segment, fragP, stretch);
2488 #endif /* TC_GENERIC_RELAX_TABLE */
2489 #endif
2490 break;
2492 case rs_leb128:
2494 valueT value;
2495 int size;
2497 value = resolve_symbol_value (fragP->fr_symbol);
2498 size = sizeof_leb128 (value, fragP->fr_subtype);
2499 growth = size - fragP->fr_offset;
2500 fragP->fr_offset = size;
2502 break;
2504 case rs_cfa:
2505 growth = eh_frame_relax_frag (fragP);
2506 break;
2508 case rs_dwarf2dbg:
2509 growth = dwarf2dbg_relax_frag (fragP);
2510 break;
2512 default:
2513 BAD_CASE (fragP->fr_type);
2514 break;
2516 if (growth)
2518 stretch += growth;
2519 stretched = 1;
2521 } /* For each frag in the segment. */
2523 while (stretched); /* Until nothing further to relax. */
2524 } /* do_relax */
2526 ret = 0;
2527 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2528 if (fragP->last_fr_address != fragP->fr_address)
2530 fragP->last_fr_address = fragP->fr_address;
2531 ret = 1;
2533 return ret;
2536 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2538 /* fixup_segment()
2540 Go through all the fixS's in a segment and see which ones can be
2541 handled now. (These consist of fixS where we have since discovered
2542 the value of a symbol, or the address of the frag involved.)
2543 For each one, call md_apply_fix3 to put the fix into the frag data.
2545 Result is a count of how many relocation structs will be needed to
2546 handle the remaining fixS's that we couldn't completely handle here.
2547 These will be output later by emit_relocations(). */
2549 static long
2550 fixup_segment (fixP, this_segment)
2551 fixS *fixP;
2552 segT this_segment;
2554 long seg_reloc_count = 0;
2555 valueT add_number;
2556 fragS *fragP;
2557 segT add_symbol_segment = absolute_section;
2559 if (fixP != NULL && abs_section_sym == NULL)
2561 #ifndef BFD_ASSEMBLER
2562 abs_section_sym = &abs_symbol;
2563 #else
2564 abs_section_sym = section_symbol (absolute_section);
2565 #endif
2568 /* If the linker is doing the relaxing, we must not do any fixups.
2570 Well, strictly speaking that's not true -- we could do any that
2571 are PC-relative and don't cross regions that could change size.
2572 And for the i960 we might be able to turn callx/callj into bal
2573 anyways in cases where we know the maximum displacement. */
2574 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
2576 for (; fixP; fixP = fixP->fx_next)
2577 if (!fixP->fx_done)
2579 if (fixP->fx_addsy == NULL)
2581 /* There was no symbol required by this relocation.
2582 However, BFD doesn't really handle relocations
2583 without symbols well. So fake up a local symbol in
2584 the absolute section. */
2585 fixP->fx_addsy = abs_section_sym;
2587 symbol_mark_used_in_reloc (fixP->fx_addsy);
2588 if (fixP->fx_subsy != NULL)
2589 symbol_mark_used_in_reloc (fixP->fx_subsy);
2590 seg_reloc_count++;
2592 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2593 return seg_reloc_count;
2596 for (; fixP; fixP = fixP->fx_next)
2598 #ifdef DEBUG5
2599 fprintf (stderr, "\nprocessing fixup:\n");
2600 print_fixup (fixP);
2601 #endif
2603 fragP = fixP->fx_frag;
2604 know (fragP);
2605 #ifdef TC_VALIDATE_FIX
2606 TC_VALIDATE_FIX (fixP, this_segment, skip);
2607 #endif
2608 add_number = fixP->fx_offset;
2610 if (fixP->fx_addsy != NULL
2611 && symbol_mri_common_p (fixP->fx_addsy))
2613 know (fixP->fx_addsy->sy_value.X_op == O_symbol);
2614 add_number += S_GET_VALUE (fixP->fx_addsy);
2615 fixP->fx_offset = add_number;
2616 fixP->fx_addsy
2617 = symbol_get_value_expression (fixP->fx_addsy)->X_add_symbol;
2620 if (fixP->fx_addsy != NULL)
2621 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
2623 if (fixP->fx_subsy != NULL)
2625 segT sub_symbol_segment;
2626 resolve_symbol_value (fixP->fx_subsy);
2627 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
2628 if (fixP->fx_addsy != NULL
2629 && sub_symbol_segment == add_symbol_segment
2630 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
2632 add_number += S_GET_VALUE (fixP->fx_addsy);
2633 add_number -= S_GET_VALUE (fixP->fx_subsy);
2634 fixP->fx_offset = add_number;
2635 /* If the back-end code has selected a pc-relative
2636 reloc, adjust the value to be pc-relative. */
2637 if (1
2638 #ifdef TC_M68K
2639 /* See the comment below about 68k weirdness. */
2640 && 0
2641 #endif
2642 && fixP->fx_pcrel)
2643 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2644 fixP->fx_addsy = NULL;
2645 fixP->fx_subsy = NULL;
2646 fixP->fx_pcrel = 0;
2648 else if (sub_symbol_segment == absolute_section
2649 && !TC_FORCE_RELOCATION_SUB_ABS (fixP))
2651 add_number -= S_GET_VALUE (fixP->fx_subsy);
2652 fixP->fx_offset = add_number;
2653 fixP->fx_subsy = NULL;
2655 else if (sub_symbol_segment == this_segment
2656 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP))
2658 add_number -= S_GET_VALUE (fixP->fx_subsy);
2659 fixP->fx_offset = add_number;
2661 /* Make it pc-relative. If the back-end code has not
2662 selected a pc-relative reloc, cancel the adjustment
2663 we do later on all pc-relative relocs. */
2664 if (0
2665 #ifdef TC_M68K
2666 /* Do this for m68k even if it's already described
2667 as pc-relative. On the m68k, an operand of
2668 "pc@(foo-.-2)" should address "foo" in a
2669 pc-relative mode. */
2670 || 1
2671 #endif
2672 || !fixP->fx_pcrel)
2673 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
2674 fixP->fx_subsy = NULL;
2675 fixP->fx_pcrel = 1;
2677 else if (!TC_VALIDATE_FIX_SUB (fixP))
2679 as_bad_where (fixP->fx_file, fixP->fx_line,
2680 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2681 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
2682 segment_name (add_symbol_segment),
2683 S_GET_NAME (fixP->fx_subsy),
2684 segment_name (sub_symbol_segment));
2688 if (fixP->fx_addsy)
2690 if (add_symbol_segment == this_segment
2691 && !TC_FORCE_RELOCATION_LOCAL (fixP))
2693 /* This fixup was made when the symbol's segment was
2694 SEG_UNKNOWN, but it is now in the local segment.
2695 So we know how to do the address without relocation. */
2696 add_number += S_GET_VALUE (fixP->fx_addsy);
2697 fixP->fx_offset = add_number;
2698 if (fixP->fx_pcrel)
2699 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2700 fixP->fx_addsy = NULL;
2701 fixP->fx_pcrel = 0;
2703 else if (add_symbol_segment == absolute_section
2704 && !TC_FORCE_RELOCATION_ABS (fixP))
2706 add_number += S_GET_VALUE (fixP->fx_addsy);
2707 fixP->fx_offset = add_number;
2708 fixP->fx_addsy = NULL;
2710 else if (add_symbol_segment != undefined_section
2711 #ifdef BFD_ASSEMBLER
2712 && ! bfd_is_com_section (add_symbol_segment)
2713 #endif
2714 && MD_APPLY_SYM_VALUE (fixP))
2715 add_number += S_GET_VALUE (fixP->fx_addsy);
2718 if (fixP->fx_pcrel)
2720 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2721 if (!fixP->fx_done && fixP->fx_addsy == NULL)
2723 /* There was no symbol required by this relocation.
2724 However, BFD doesn't really handle relocations
2725 without symbols well. So fake up a local symbol in
2726 the absolute section. */
2727 fixP->fx_addsy = abs_section_sym;
2731 if (!fixP->fx_done)
2732 md_apply_fix3 (fixP, &add_number, this_segment);
2734 if (!fixP->fx_done)
2736 ++seg_reloc_count;
2737 if (fixP->fx_addsy == NULL)
2738 fixP->fx_addsy = abs_section_sym;
2739 symbol_mark_used_in_reloc (fixP->fx_addsy);
2740 if (fixP->fx_subsy != NULL)
2741 symbol_mark_used_in_reloc (fixP->fx_subsy);
2744 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
2746 if (fixP->fx_size < sizeof (valueT))
2748 valueT mask;
2750 mask = 0;
2751 mask--; /* Set all bits to one. */
2752 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
2753 if ((add_number & mask) != 0 && (add_number & mask) != mask)
2755 char buf[50], buf2[50];
2756 sprint_value (buf, fragP->fr_address + fixP->fx_where);
2757 if (add_number > 1000)
2758 sprint_value (buf2, add_number);
2759 else
2760 sprintf (buf2, "%ld", (long) add_number);
2761 as_bad_where (fixP->fx_file, fixP->fx_line,
2762 _("value of %s too large for field of %d bytes at %s"),
2763 buf2, fixP->fx_size, buf);
2764 } /* Generic error checking. */
2766 #ifdef WARN_SIGNED_OVERFLOW_WORD
2767 /* Warn if a .word value is too large when treated as a signed
2768 number. We already know it is not too negative. This is to
2769 catch over-large switches generated by gcc on the 68k. */
2770 if (!flag_signed_overflow_ok
2771 && fixP->fx_size == 2
2772 && add_number > 0x7fff)
2773 as_bad_where (fixP->fx_file, fixP->fx_line,
2774 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2775 (long) add_number,
2776 (long) (fragP->fr_address + fixP->fx_where));
2777 #endif
2778 } /* Not a bit fix. */
2780 #ifdef TC_VALIDATE_FIX
2781 skip: ATTRIBUTE_UNUSED_LABEL
2783 #endif
2784 #ifdef DEBUG5
2785 fprintf (stderr, "result:\n");
2786 print_fixup (fixP);
2787 #endif
2788 } /* For each fixS in this segment. */
2790 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2791 return seg_reloc_count;
2794 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2796 void
2797 number_to_chars_bigendian (buf, val, n)
2798 char *buf;
2799 valueT val;
2800 int n;
2802 if (n <= 0)
2803 abort ();
2804 while (n--)
2806 buf[n] = val & 0xff;
2807 val >>= 8;
2811 void
2812 number_to_chars_littleendian (buf, val, n)
2813 char *buf;
2814 valueT val;
2815 int n;
2817 if (n <= 0)
2818 abort ();
2819 while (n--)
2821 *buf++ = val & 0xff;
2822 val >>= 8;
2826 void
2827 write_print_statistics (file)
2828 FILE *file;
2830 fprintf (file, "fixups: %d\n", n_fixups);
2833 /* For debugging. */
2834 extern int indent_level;
2836 void
2837 print_fixup (fixp)
2838 fixS *fixp;
2840 indent_level = 1;
2841 fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2842 if (fixp->fx_pcrel)
2843 fprintf (stderr, " pcrel");
2844 if (fixp->fx_pcrel_adjust)
2845 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2846 if (fixp->fx_im_disp)
2848 #ifdef TC_NS32K
2849 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2850 #else
2851 fprintf (stderr, " im_disp");
2852 #endif
2854 if (fixp->fx_tcbit)
2855 fprintf (stderr, " tcbit");
2856 if (fixp->fx_done)
2857 fprintf (stderr, " done");
2858 fprintf (stderr, "\n size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2859 fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2860 (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2861 #ifdef BFD_ASSEMBLER
2862 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2863 fixp->fx_r_type);
2864 #else
2865 #ifdef NEED_FX_R_TYPE
2866 fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2867 #endif
2868 #endif
2869 if (fixp->fx_addsy)
2871 fprintf (stderr, "\n +<");
2872 print_symbol_value_1 (stderr, fixp->fx_addsy);
2873 fprintf (stderr, ">");
2875 if (fixp->fx_subsy)
2877 fprintf (stderr, "\n -<");
2878 print_symbol_value_1 (stderr, fixp->fx_subsy);
2879 fprintf (stderr, ">");
2881 fprintf (stderr, "\n");
2882 #ifdef TC_FIX_DATA_PRINT
2883 TC_FIX_DATA_PRINT (stderr, fixp);
2884 #endif