daily update
[binutils.git] / gas / write.c
blob1af81a7df9ba97232835fcce6567a4c966876ea9
1 /* write.c - emit .o file
2 Copyright 1986, 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, 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"
30 #include "libbfd.h"
32 #ifndef TC_ADJUST_RELOC_COUNT
33 #define TC_ADJUST_RELOC_COUNT(FIX, COUNT)
34 #endif
36 #ifndef TC_FORCE_RELOCATION
37 #define TC_FORCE_RELOCATION(FIX) \
38 (generic_force_reloc (FIX))
39 #endif
41 #ifndef TC_FORCE_RELOCATION_ABS
42 #define TC_FORCE_RELOCATION_ABS(FIX) \
43 (TC_FORCE_RELOCATION (FIX))
44 #endif
46 #ifndef TC_FORCE_RELOCATION_LOCAL
47 #define TC_FORCE_RELOCATION_LOCAL(FIX) \
48 (!(FIX)->fx_pcrel \
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 md_register_arithmetic
58 # define md_register_arithmetic 1
59 #endif
61 #ifndef TC_FORCE_RELOCATION_SUB_ABS
62 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
63 (!md_register_arithmetic && (SEG) == reg_section)
64 #endif
66 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
67 #ifdef DIFF_EXPR_OK
68 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
69 (!md_register_arithmetic && (SEG) == reg_section)
70 #else
71 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
72 #endif
73 #endif
75 #ifndef TC_VALIDATE_FIX_SUB
76 #ifdef UNDEFINED_DIFFERENCE_OK
77 /* The PA needs this for PIC code generation. */
78 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
79 (md_register_arithmetic || (SEG) != reg_section)
80 #else
81 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
82 ((md_register_arithmetic || (SEG) != reg_section) \
83 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
84 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
85 #endif
86 #endif
88 #ifndef TC_LINKRELAX_FIXUP
89 #define TC_LINKRELAX_FIXUP(SEG) 1
90 #endif
92 #ifndef MD_APPLY_SYM_VALUE
93 #define MD_APPLY_SYM_VALUE(FIX) 1
94 #endif
96 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
97 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
98 #endif
100 #ifndef MD_PCREL_FROM_SECTION
101 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
102 #endif
104 #ifndef TC_FAKE_LABEL
105 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
106 #endif
108 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
109 fixups that far past the end of a frag. Having such fixups
110 is of course most most likely a bug in setting fx_size correctly.
111 A negative value disables the fixup check entirely, which is
112 appropriate for something like the Renesas / SuperH SH_COUNT
113 reloc. */
114 #ifndef TC_FX_SIZE_SLACK
115 #define TC_FX_SIZE_SLACK(FIX) 0
116 #endif
118 /* Used to control final evaluation of expressions. */
119 int finalize_syms = 0;
121 int symbol_table_frozen;
123 symbolS *abs_section_sym;
125 /* Remember the value of dot when parsing expressions. */
126 addressT dot_value;
128 /* Relocs generated by ".reloc" pseudo. */
129 struct reloc_list* reloc_list;
131 void print_fixup (fixS *);
133 /* We generally attach relocs to frag chains. However, after we have
134 chained these all together into a segment, any relocs we add after
135 that must be attached to a segment. This will include relocs added
136 in md_estimate_size_for_relax, for example. */
137 static int frags_chained = 0;
139 static int n_fixups;
141 #define RELOC_ENUM enum bfd_reloc_code_real
143 /* Create a fixS in obstack 'notes'. */
145 static fixS *
146 fix_new_internal (fragS *frag, /* Which frag? */
147 int where, /* Where in that frag? */
148 int size, /* 1, 2, or 4 usually. */
149 symbolS *add_symbol, /* X_add_symbol. */
150 symbolS *sub_symbol, /* X_op_symbol. */
151 offsetT offset, /* X_add_number. */
152 int pcrel, /* TRUE if PC-relative relocation. */
153 RELOC_ENUM r_type ATTRIBUTE_UNUSED /* Relocation type. */)
155 fixS *fixP;
157 n_fixups++;
159 fixP = obstack_alloc (&notes, sizeof (fixS));
161 fixP->fx_frag = frag;
162 fixP->fx_where = where;
163 fixP->fx_size = size;
164 /* We've made fx_size a narrow field; check that it's wide enough. */
165 if (fixP->fx_size != size)
167 as_bad (_("field fx_size too small to hold %d"), size);
168 abort ();
170 fixP->fx_addsy = add_symbol;
171 fixP->fx_subsy = sub_symbol;
172 fixP->fx_offset = offset;
173 fixP->fx_dot_value = dot_value;
174 fixP->fx_pcrel = pcrel;
175 fixP->fx_r_type = r_type;
176 fixP->fx_im_disp = 0;
177 fixP->fx_pcrel_adjust = 0;
178 fixP->fx_bit_fixP = 0;
179 fixP->fx_addnumber = 0;
180 fixP->fx_tcbit = 0;
181 fixP->fx_tcbit2 = 0;
182 fixP->fx_done = 0;
183 fixP->fx_no_overflow = 0;
184 fixP->fx_signed = 0;
186 #ifdef USING_CGEN
187 fixP->fx_cgen.insn = NULL;
188 fixP->fx_cgen.opinfo = 0;
189 #endif
191 #ifdef TC_FIX_TYPE
192 TC_INIT_FIX_DATA (fixP);
193 #endif
195 as_where (&fixP->fx_file, &fixP->fx_line);
197 /* Usually, we want relocs sorted numerically, but while
198 comparing to older versions of gas that have relocs
199 reverse sorted, it is convenient to have this compile
200 time option. xoxorich. */
203 fixS **seg_fix_rootP = (frags_chained
204 ? &seg_info (now_seg)->fix_root
205 : &frchain_now->fix_root);
206 fixS **seg_fix_tailP = (frags_chained
207 ? &seg_info (now_seg)->fix_tail
208 : &frchain_now->fix_tail);
210 #ifdef REVERSE_SORT_RELOCS
212 fixP->fx_next = *seg_fix_rootP;
213 *seg_fix_rootP = fixP;
215 #else /* REVERSE_SORT_RELOCS */
217 fixP->fx_next = NULL;
219 if (*seg_fix_tailP)
220 (*seg_fix_tailP)->fx_next = fixP;
221 else
222 *seg_fix_rootP = fixP;
223 *seg_fix_tailP = fixP;
225 #endif /* REVERSE_SORT_RELOCS */
228 return fixP;
231 /* Create a fixup relative to a symbol (plus a constant). */
233 fixS *
234 fix_new (fragS *frag, /* Which frag? */
235 int where, /* Where in that frag? */
236 int size, /* 1, 2, or 4 usually. */
237 symbolS *add_symbol, /* X_add_symbol. */
238 offsetT offset, /* X_add_number. */
239 int pcrel, /* TRUE if PC-relative relocation. */
240 RELOC_ENUM r_type /* Relocation type. */)
242 return fix_new_internal (frag, where, size, add_symbol,
243 (symbolS *) NULL, offset, pcrel, r_type);
246 /* Create a fixup for an expression. Currently we only support fixups
247 for difference expressions. That is itself more than most object
248 file formats support anyhow. */
250 fixS *
251 fix_new_exp (fragS *frag, /* Which frag? */
252 int where, /* Where in that frag? */
253 int size, /* 1, 2, or 4 usually. */
254 expressionS *exp, /* Expression. */
255 int pcrel, /* TRUE if PC-relative relocation. */
256 RELOC_ENUM r_type /* Relocation type. */)
258 symbolS *add = NULL;
259 symbolS *sub = NULL;
260 offsetT off = 0;
262 switch (exp->X_op)
264 case O_absent:
265 break;
267 case O_register:
268 as_bad (_("register value used as expression"));
269 break;
271 case O_add:
272 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
273 the difference expression cannot immediately be reduced. */
275 symbolS *stmp = make_expr_symbol (exp);
277 exp->X_op = O_symbol;
278 exp->X_op_symbol = 0;
279 exp->X_add_symbol = stmp;
280 exp->X_add_number = 0;
282 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
285 case O_symbol_rva:
286 add = exp->X_add_symbol;
287 off = exp->X_add_number;
288 r_type = BFD_RELOC_RVA;
289 break;
291 case O_uminus:
292 sub = exp->X_add_symbol;
293 off = exp->X_add_number;
294 break;
296 case O_subtract:
297 sub = exp->X_op_symbol;
298 /* Fall through. */
299 case O_symbol:
300 add = exp->X_add_symbol;
301 /* Fall through. */
302 case O_constant:
303 off = exp->X_add_number;
304 break;
306 default:
307 add = make_expr_symbol (exp);
308 break;
311 return fix_new_internal (frag, where, size, add, sub, off, pcrel, r_type);
314 /* Generic function to determine whether a fixup requires a relocation. */
316 generic_force_reloc (fixS *fix)
318 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
319 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
320 return 1;
322 if (fix->fx_addsy == NULL)
323 return 0;
325 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
328 /* Append a string onto another string, bumping the pointer along. */
329 void
330 append (char **charPP, char *fromP, unsigned long length)
332 /* Don't trust memcpy() of 0 chars. */
333 if (length == 0)
334 return;
336 memcpy (*charPP, fromP, length);
337 *charPP += length;
340 /* This routine records the largest alignment seen for each segment.
341 If the beginning of the segment is aligned on the worst-case
342 boundary, all of the other alignments within it will work. At
343 least one object format really uses this info. */
345 void
346 record_alignment (/* Segment to which alignment pertains. */
347 segT seg,
348 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
349 boundary, 2 => 4-byte boundary, etc.) */
350 int align)
352 if (seg == absolute_section)
353 return;
355 if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
356 bfd_set_section_alignment (stdoutput, seg, align);
360 get_recorded_alignment (segT seg)
362 if (seg == absolute_section)
363 return 0;
365 return bfd_get_section_alignment (stdoutput, seg);
368 /* Reset the section indices after removing the gas created sections. */
370 static void
371 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
373 int *countp = (int *) countparg;
375 sec->index = *countp;
376 ++*countp;
379 static fragS *
380 chain_frchains_together_1 (segT section, struct frchain *frchp)
382 fragS dummy, *prev_frag = &dummy;
383 fixS fix_dummy, *prev_fix = &fix_dummy;
385 for (; frchp; frchp = frchp->frch_next)
387 prev_frag->fr_next = frchp->frch_root;
388 prev_frag = frchp->frch_last;
389 assert (prev_frag->fr_type != 0);
390 if (frchp->fix_root != (fixS *) NULL)
392 if (seg_info (section)->fix_root == (fixS *) NULL)
393 seg_info (section)->fix_root = frchp->fix_root;
394 prev_fix->fx_next = frchp->fix_root;
395 seg_info (section)->fix_tail = frchp->fix_tail;
396 prev_fix = frchp->fix_tail;
399 assert (prev_frag->fr_type != 0);
400 assert (prev_frag != &dummy);
401 prev_frag->fr_next = 0;
402 return prev_frag;
405 static void
406 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
407 segT section,
408 void *xxx ATTRIBUTE_UNUSED)
410 segment_info_type *info;
412 /* BFD may have introduced its own sections without using
413 subseg_new, so it is possible that seg_info is NULL. */
414 info = seg_info (section);
415 if (info != (segment_info_type *) NULL)
416 info->frchainP->frch_last
417 = chain_frchains_together_1 (section, info->frchainP);
419 /* Now that we've chained the frags together, we must add new fixups
420 to the segment, not to the frag chain. */
421 frags_chained = 1;
424 static void
425 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
427 switch (fragP->fr_type)
429 case rs_align:
430 case rs_align_code:
431 case rs_align_test:
432 case rs_org:
433 case rs_space:
434 #ifdef HANDLE_ALIGN
435 HANDLE_ALIGN (fragP);
436 #endif
437 know (fragP->fr_next != NULL);
438 fragP->fr_offset = (fragP->fr_next->fr_address
439 - fragP->fr_address
440 - fragP->fr_fix) / fragP->fr_var;
441 if (fragP->fr_offset < 0)
443 as_bad_where (fragP->fr_file, fragP->fr_line,
444 _("attempt to .org/.space backwards? (%ld)"),
445 (long) fragP->fr_offset);
446 fragP->fr_offset = 0;
448 fragP->fr_type = rs_fill;
449 break;
451 case rs_fill:
452 break;
454 case rs_leb128:
456 valueT value = S_GET_VALUE (fragP->fr_symbol);
457 int size;
459 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
460 fragP->fr_subtype);
462 fragP->fr_fix += size;
463 fragP->fr_type = rs_fill;
464 fragP->fr_var = 0;
465 fragP->fr_offset = 0;
466 fragP->fr_symbol = NULL;
468 break;
470 case rs_cfa:
471 eh_frame_convert_frag (fragP);
472 break;
474 case rs_dwarf2dbg:
475 dwarf2dbg_convert_frag (fragP);
476 break;
478 case rs_machine_dependent:
479 md_convert_frag (stdoutput, sec, fragP);
481 assert (fragP->fr_next == NULL
482 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
483 == fragP->fr_fix));
485 /* After md_convert_frag, we make the frag into a ".space 0".
486 md_convert_frag() should set up any fixSs and constants
487 required. */
488 frag_wane (fragP);
489 break;
491 #ifndef WORKING_DOT_WORD
492 case rs_broken_word:
494 struct broken_word *lie;
496 if (fragP->fr_subtype)
498 fragP->fr_fix += md_short_jump_size;
499 for (lie = (struct broken_word *) (fragP->fr_symbol);
500 lie && lie->dispfrag == fragP;
501 lie = lie->next_broken_word)
502 if (lie->added == 1)
503 fragP->fr_fix += md_long_jump_size;
505 frag_wane (fragP);
507 break;
508 #endif
510 default:
511 BAD_CASE (fragP->fr_type);
512 break;
514 #ifdef md_frag_check
515 md_frag_check (fragP);
516 #endif
519 struct relax_seg_info
521 int pass;
522 int changed;
525 static void
526 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
528 segment_info_type *seginfo = seg_info (sec);
529 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
531 if (seginfo && seginfo->frchainP
532 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
533 info->changed = 1;
536 static void
537 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
539 flagword flags;
540 fragS *fragp;
541 segment_info_type *seginfo;
542 int x;
543 valueT size, newsize;
545 subseg_change (sec, 0);
547 seginfo = seg_info (sec);
548 if (seginfo && seginfo->frchainP)
550 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
551 cvt_frag_to_fill (sec, fragp);
552 for (fragp = seginfo->frchainP->frch_root;
553 fragp->fr_next;
554 fragp = fragp->fr_next)
555 /* Walk to last elt. */
557 size = fragp->fr_address + fragp->fr_fix;
559 else
560 size = 0;
562 flags = bfd_get_section_flags (abfd, sec);
564 if (size > 0 && ! seginfo->bss)
565 flags |= SEC_HAS_CONTENTS;
567 flags &= ~SEC_RELOC;
568 x = bfd_set_section_flags (abfd, sec, flags);
569 assert (x);
571 newsize = md_section_align (sec, size);
572 x = bfd_set_section_size (abfd, sec, newsize);
573 assert (x);
575 /* If the size had to be rounded up, add some padding in the last
576 non-empty frag. */
577 assert (newsize >= size);
578 if (size != newsize)
580 fragS *last = seginfo->frchainP->frch_last;
581 fragp = seginfo->frchainP->frch_root;
582 while (fragp->fr_next != last)
583 fragp = fragp->fr_next;
584 last->fr_address = size;
585 if ((newsize - size) % fragp->fr_var == 0)
586 fragp->fr_offset += (newsize - size) / fragp->fr_var;
587 else
588 /* If we hit this abort, it's likely due to subsegs_finish not
589 providing sufficient alignment on the last frag, and the
590 machine dependent code using alignment frags with fr_var
591 greater than 1. */
592 abort ();
595 #ifdef tc_frob_section
596 tc_frob_section (sec);
597 #endif
598 #ifdef obj_frob_section
599 obj_frob_section (sec);
600 #endif
603 #ifdef DEBUG2
604 static void
605 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
607 segment_info_type *seginfo = seg_info (sec);
608 fixS *fixp = seginfo->fix_root;
610 if (!fixp)
611 return;
613 fprintf (stream, "sec %s relocs:\n", sec->name);
614 while (fixp)
616 symbolS *s = fixp->fx_addsy;
618 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
619 (int) fixp->fx_r_type);
620 if (s == NULL)
621 fprintf (stream, "no sym\n");
622 else
624 print_symbol_value_1 (stream, s);
625 fprintf (stream, "\n");
627 fixp = fixp->fx_next;
630 #else
631 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
632 #endif
634 #ifndef EMIT_SECTION_SYMBOLS
635 #define EMIT_SECTION_SYMBOLS 1
636 #endif
638 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
639 and check for validity. Convert RELOC_LIST from using U.A fields
640 to U.B fields. */
641 static void
642 resolve_reloc_expr_symbols (void)
644 struct reloc_list *r;
646 for (r = reloc_list; r; r = r->next)
648 expressionS *symval;
649 symbolS *sym;
650 bfd_vma offset, addend;
651 asection *sec;
652 reloc_howto_type *howto;
654 resolve_symbol_value (r->u.a.offset_sym);
655 symval = symbol_get_value_expression (r->u.a.offset_sym);
657 offset = 0;
658 sym = NULL;
659 if (symval->X_op == O_constant)
660 sym = r->u.a.offset_sym;
661 else if (symval->X_op == O_symbol)
663 sym = symval->X_add_symbol;
664 offset = symval->X_add_number;
665 symval = symbol_get_value_expression (symval->X_add_symbol);
667 if (sym == NULL
668 || symval->X_op != O_constant
669 || (sec = S_GET_SEGMENT (sym)) == NULL
670 || !SEG_NORMAL (sec))
672 as_bad_where (r->file, r->line, _("invalid offset expression"));
673 sec = NULL;
675 else
676 offset += S_GET_VALUE (sym);
678 sym = NULL;
679 addend = r->u.a.addend;
680 if (r->u.a.sym != NULL)
682 resolve_symbol_value (r->u.a.sym);
683 symval = symbol_get_value_expression (r->u.a.sym);
684 if (symval->X_op == O_constant)
685 sym = r->u.a.sym;
686 else if (symval->X_op == O_symbol)
688 sym = symval->X_add_symbol;
689 addend += symval->X_add_number;
690 symval = symbol_get_value_expression (symval->X_add_symbol);
692 if (symval->X_op != O_constant)
694 as_bad_where (r->file, r->line, _("invalid reloc expression"));
695 sec = NULL;
697 else if (sym != NULL)
698 symbol_mark_used_in_reloc (sym);
700 if (sym == NULL)
702 if (abs_section_sym == NULL)
703 abs_section_sym = section_symbol (absolute_section);
704 sym = abs_section_sym;
707 howto = r->u.a.howto;
709 r->u.b.sec = sec;
710 r->u.b.s = symbol_get_bfdsym (sym);
711 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
712 r->u.b.r.address = offset;
713 r->u.b.r.addend = addend;
714 r->u.b.r.howto = howto;
718 /* This pass over fixups decides whether symbols can be replaced with
719 section symbols. */
721 static void
722 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
723 asection *sec,
724 void *xxx ATTRIBUTE_UNUSED)
726 segment_info_type *seginfo = seg_info (sec);
727 fixS *fixp;
729 if (seginfo == NULL)
730 return;
732 dump_section_relocs (abfd, sec, stderr);
734 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
735 if (fixp->fx_done)
736 /* Ignore it. */
738 else if (fixp->fx_addsy)
740 symbolS *sym;
741 asection *symsec;
743 #ifdef DEBUG5
744 fprintf (stderr, "\n\nadjusting fixup:\n");
745 print_fixup (fixp);
746 #endif
748 sym = fixp->fx_addsy;
750 /* All symbols should have already been resolved at this
751 point. It is possible to see unresolved expression
752 symbols, though, since they are not in the regular symbol
753 table. */
754 resolve_symbol_value (sym);
756 if (fixp->fx_subsy != NULL)
757 resolve_symbol_value (fixp->fx_subsy);
759 /* If this symbol is equated to an undefined or common symbol,
760 convert the fixup to being against that symbol. */
761 while (symbol_equated_reloc_p (sym)
762 || S_IS_WEAKREFR (sym))
764 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
765 if (sym == newsym)
766 break;
767 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
768 fixp->fx_addsy = newsym;
769 sym = newsym;
772 if (symbol_mri_common_p (sym))
774 fixp->fx_offset += S_GET_VALUE (sym);
775 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
776 continue;
779 /* If the symbol is undefined, common, weak, or global (ELF
780 shared libs), we can't replace it with the section symbol. */
781 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
782 continue;
784 /* Is there some other (target cpu dependent) reason we can't adjust
785 this one? (E.g. relocations involving function addresses on
786 the PA. */
787 #ifdef tc_fix_adjustable
788 if (! tc_fix_adjustable (fixp))
789 continue;
790 #endif
792 /* Since we're reducing to section symbols, don't attempt to reduce
793 anything that's already using one. */
794 if (symbol_section_p (sym))
795 continue;
797 symsec = S_GET_SEGMENT (sym);
798 if (symsec == NULL)
799 abort ();
801 if (bfd_is_abs_section (symsec))
803 /* The fixup_segment routine normally will not use this
804 symbol in a relocation. */
805 continue;
808 /* Don't try to reduce relocs which refer to non-local symbols
809 in .linkonce sections. It can lead to confusion when a
810 debugging section refers to a .linkonce section. I hope
811 this will always be correct. */
812 if (symsec != sec && ! S_IS_LOCAL (sym))
814 if ((symsec->flags & SEC_LINK_ONCE) != 0
815 || (IS_ELF
816 /* The GNU toolchain uses an extension for ELF: a
817 section beginning with the magic string
818 .gnu.linkonce is a linkonce section. */
819 && strncmp (segment_name (symsec), ".gnu.linkonce",
820 sizeof ".gnu.linkonce" - 1) == 0))
821 continue;
824 /* Never adjust a reloc against local symbol in a merge section
825 with non-zero addend. */
826 if ((symsec->flags & SEC_MERGE) != 0
827 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
828 continue;
830 /* Never adjust a reloc against TLS local symbol. */
831 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
832 continue;
834 /* We refetch the segment when calling section_symbol, rather
835 than using symsec, because S_GET_VALUE may wind up changing
836 the section when it calls resolve_symbol_value. */
837 fixp->fx_offset += S_GET_VALUE (sym);
838 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
839 #ifdef DEBUG5
840 fprintf (stderr, "\nadjusted fixup:\n");
841 print_fixup (fixp);
842 #endif
845 dump_section_relocs (abfd, sec, stderr);
848 /* fixup_segment()
850 Go through all the fixS's in a segment and see which ones can be
851 handled now. (These consist of fixS where we have since discovered
852 the value of a symbol, or the address of the frag involved.)
853 For each one, call md_apply_fix to put the fix into the frag data.
855 Result is a count of how many relocation structs will be needed to
856 handle the remaining fixS's that we couldn't completely handle here.
857 These will be output later by emit_relocations(). */
859 static long
860 fixup_segment (fixS *fixP, segT this_segment)
862 long seg_reloc_count = 0;
863 valueT add_number;
864 fragS *fragP;
865 segT add_symbol_segment = absolute_section;
867 if (fixP != NULL && abs_section_sym == NULL)
868 abs_section_sym = section_symbol (absolute_section);
870 /* If the linker is doing the relaxing, we must not do any fixups.
872 Well, strictly speaking that's not true -- we could do any that
873 are PC-relative and don't cross regions that could change size.
874 And for the i960 we might be able to turn callx/callj into bal
875 anyways in cases where we know the maximum displacement. */
876 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
878 for (; fixP; fixP = fixP->fx_next)
879 if (!fixP->fx_done)
881 if (fixP->fx_addsy == NULL)
883 /* There was no symbol required by this relocation.
884 However, BFD doesn't really handle relocations
885 without symbols well. So fake up a local symbol in
886 the absolute section. */
887 fixP->fx_addsy = abs_section_sym;
889 symbol_mark_used_in_reloc (fixP->fx_addsy);
890 if (fixP->fx_subsy != NULL)
891 symbol_mark_used_in_reloc (fixP->fx_subsy);
892 seg_reloc_count++;
894 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
895 return seg_reloc_count;
898 for (; fixP; fixP = fixP->fx_next)
900 #ifdef DEBUG5
901 fprintf (stderr, "\nprocessing fixup:\n");
902 print_fixup (fixP);
903 #endif
905 fragP = fixP->fx_frag;
906 know (fragP);
907 #ifdef TC_VALIDATE_FIX
908 TC_VALIDATE_FIX (fixP, this_segment, skip);
909 #endif
910 add_number = fixP->fx_offset;
912 if (fixP->fx_addsy != NULL)
913 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
915 if (fixP->fx_subsy != NULL)
917 segT sub_symbol_segment;
918 resolve_symbol_value (fixP->fx_subsy);
919 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
920 if (fixP->fx_addsy != NULL
921 && sub_symbol_segment == add_symbol_segment
922 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
924 add_number += S_GET_VALUE (fixP->fx_addsy);
925 add_number -= S_GET_VALUE (fixP->fx_subsy);
926 fixP->fx_offset = add_number;
927 fixP->fx_addsy = NULL;
928 fixP->fx_subsy = NULL;
929 #ifdef TC_M68K
930 /* See the comment below about 68k weirdness. */
931 fixP->fx_pcrel = 0;
932 #endif
934 else if (sub_symbol_segment == absolute_section
935 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
937 add_number -= S_GET_VALUE (fixP->fx_subsy);
938 fixP->fx_offset = add_number;
939 fixP->fx_subsy = NULL;
941 else if (sub_symbol_segment == this_segment
942 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
944 add_number -= S_GET_VALUE (fixP->fx_subsy);
945 fixP->fx_offset = (add_number + fixP->fx_dot_value
946 + fixP->fx_frag->fr_address);
948 /* Make it pc-relative. If the back-end code has not
949 selected a pc-relative reloc, cancel the adjustment
950 we do later on all pc-relative relocs. */
951 if (0
952 #ifdef TC_M68K
953 /* Do this for m68k even if it's already described
954 as pc-relative. On the m68k, an operand of
955 "pc@(foo-.-2)" should address "foo" in a
956 pc-relative mode. */
957 || 1
958 #endif
959 || !fixP->fx_pcrel)
960 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
961 fixP->fx_subsy = NULL;
962 fixP->fx_pcrel = 1;
964 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
966 if (!md_register_arithmetic
967 && (add_symbol_segment == reg_section
968 || sub_symbol_segment == reg_section))
969 as_bad_where (fixP->fx_file, fixP->fx_line,
970 _("register value used as expression"));
971 else
972 as_bad_where (fixP->fx_file, fixP->fx_line,
973 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
974 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
975 segment_name (add_symbol_segment),
976 S_GET_NAME (fixP->fx_subsy),
977 segment_name (sub_symbol_segment));
981 if (fixP->fx_addsy)
983 if (add_symbol_segment == this_segment
984 && !TC_FORCE_RELOCATION_LOCAL (fixP))
986 /* This fixup was made when the symbol's segment was
987 SEG_UNKNOWN, but it is now in the local segment.
988 So we know how to do the address without relocation. */
989 add_number += S_GET_VALUE (fixP->fx_addsy);
990 fixP->fx_offset = add_number;
991 if (fixP->fx_pcrel)
992 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
993 fixP->fx_addsy = NULL;
994 fixP->fx_pcrel = 0;
996 else if (add_symbol_segment == absolute_section
997 && !TC_FORCE_RELOCATION_ABS (fixP))
999 add_number += S_GET_VALUE (fixP->fx_addsy);
1000 fixP->fx_offset = add_number;
1001 fixP->fx_addsy = NULL;
1003 else if (add_symbol_segment != undefined_section
1004 && ! bfd_is_com_section (add_symbol_segment)
1005 && MD_APPLY_SYM_VALUE (fixP))
1006 add_number += S_GET_VALUE (fixP->fx_addsy);
1009 if (fixP->fx_pcrel)
1011 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1012 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1014 /* There was no symbol required by this relocation.
1015 However, BFD doesn't really handle relocations
1016 without symbols well. So fake up a local symbol in
1017 the absolute section. */
1018 fixP->fx_addsy = abs_section_sym;
1022 if (!fixP->fx_done)
1023 md_apply_fix (fixP, &add_number, this_segment);
1025 if (!fixP->fx_done)
1027 ++seg_reloc_count;
1028 if (fixP->fx_addsy == NULL)
1029 fixP->fx_addsy = abs_section_sym;
1030 symbol_mark_used_in_reloc (fixP->fx_addsy);
1031 if (fixP->fx_subsy != NULL)
1032 symbol_mark_used_in_reloc (fixP->fx_subsy);
1035 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1037 if (fixP->fx_size < sizeof (valueT))
1039 valueT mask;
1041 mask = 0;
1042 mask--; /* Set all bits to one. */
1043 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1044 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1046 char buf[50], buf2[50];
1047 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1048 if (add_number > 1000)
1049 sprint_value (buf2, add_number);
1050 else
1051 sprintf (buf2, "%ld", (long) add_number);
1052 as_bad_where (fixP->fx_file, fixP->fx_line,
1053 _("value of %s too large for field of %d bytes at %s"),
1054 buf2, fixP->fx_size, buf);
1055 } /* Generic error checking. */
1057 #ifdef WARN_SIGNED_OVERFLOW_WORD
1058 /* Warn if a .word value is too large when treated as a signed
1059 number. We already know it is not too negative. This is to
1060 catch over-large switches generated by gcc on the 68k. */
1061 if (!flag_signed_overflow_ok
1062 && fixP->fx_size == 2
1063 && add_number > 0x7fff)
1064 as_bad_where (fixP->fx_file, fixP->fx_line,
1065 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1066 (long) add_number,
1067 (long) (fragP->fr_address + fixP->fx_where));
1068 #endif
1069 } /* Not a bit fix. */
1071 #ifdef TC_VALIDATE_FIX
1072 skip: ATTRIBUTE_UNUSED_LABEL
1074 #endif
1075 #ifdef DEBUG5
1076 fprintf (stderr, "result:\n");
1077 print_fixup (fixP);
1078 #endif
1079 } /* For each fixS in this segment. */
1081 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1082 return seg_reloc_count;
1085 static void
1086 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1087 asection *sec,
1088 void *xxx ATTRIBUTE_UNUSED)
1090 segment_info_type *seginfo = seg_info (sec);
1092 fixup_segment (seginfo->fix_root, sec);
1095 static void
1096 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1097 char *file, unsigned int line)
1099 char *err;
1100 bfd_reloc_status_type s;
1101 asymbol *sym;
1103 if (reloc->sym_ptr_ptr != NULL
1104 && (sym = *reloc->sym_ptr_ptr) != NULL
1105 && (sym->flags & BSF_KEEP) == 0
1106 && ((sym->flags & BSF_SECTION_SYM) == 0
1107 || (EMIT_SECTION_SYMBOLS
1108 && !bfd_is_abs_section (sym->section))))
1109 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1111 s = bfd_install_relocation (stdoutput, reloc,
1112 fragp->fr_literal, fragp->fr_address,
1113 sec, &err);
1114 switch (s)
1116 case bfd_reloc_ok:
1117 break;
1118 case bfd_reloc_overflow:
1119 as_bad_where (file, line, _("relocation overflow"));
1120 break;
1121 case bfd_reloc_outofrange:
1122 as_bad_where (file, line, _("relocation out of range"));
1123 break;
1124 default:
1125 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1126 file, line, s);
1130 static void
1131 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1133 segment_info_type *seginfo = seg_info (sec);
1134 unsigned int i;
1135 unsigned int n;
1136 struct reloc_list *my_reloc_list, **rp, *r;
1137 arelent **relocs;
1138 fixS *fixp;
1140 /* If seginfo is NULL, we did not create this section; don't do
1141 anything with it. */
1142 if (seginfo == NULL)
1143 return;
1145 n = 0;
1146 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1147 if (!fixp->fx_done)
1148 n++;
1150 #ifdef RELOC_EXPANSION_POSSIBLE
1151 n *= MAX_RELOC_EXPANSION;
1152 #endif
1154 /* Extract relocs for this section from reloc_list. */
1155 rp = &reloc_list;
1156 my_reloc_list = NULL;
1157 while ((r = *rp) != NULL)
1159 if (r->u.b.sec == sec)
1161 *rp = r->next;
1162 r->next = my_reloc_list;
1163 my_reloc_list = r;
1164 n++;
1166 else
1167 rp = &r->next;
1170 relocs = xcalloc (n, sizeof (arelent *));
1172 i = 0;
1173 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1175 int j;
1176 int fx_size, slack;
1177 offsetT loc;
1179 if (fixp->fx_done)
1180 continue;
1182 fx_size = fixp->fx_size;
1183 slack = TC_FX_SIZE_SLACK (fixp);
1184 if (slack > 0)
1185 fx_size = fx_size > slack ? fx_size - slack : 0;
1186 loc = fixp->fx_where + fx_size;
1187 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1188 as_bad_where (fixp->fx_file, fixp->fx_line,
1189 _("internal error: fixup not contained within frag"));
1191 #ifndef RELOC_EXPANSION_POSSIBLE
1193 arelent *reloc = tc_gen_reloc (sec, fixp);
1195 if (!reloc)
1196 continue;
1197 relocs[i++] = reloc;
1198 j = 1;
1200 #else
1202 arelent **reloc = tc_gen_reloc (sec, fixp);
1204 for (j = 0; reloc[j]; j++)
1205 relocs[i++] = reloc[j];
1207 #endif
1209 for ( ; j != 0; --j)
1210 install_reloc (sec, relocs[i - j], fixp->fx_frag,
1211 fixp->fx_file, fixp->fx_line);
1213 n = i;
1215 #ifdef DEBUG4
1217 unsigned int i, j, nsyms;
1218 asymbol **sympp;
1219 sympp = bfd_get_outsymbols (stdoutput);
1220 nsyms = bfd_get_symcount (stdoutput);
1221 for (i = 0; i < n; i++)
1222 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1224 for (j = 0; j < nsyms; j++)
1225 if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1226 break;
1227 if (j == nsyms)
1228 abort ();
1231 #endif
1233 for (r = my_reloc_list; r != NULL; r = r->next)
1235 fragS *f;
1236 for (f = seginfo->frchainP->frch_root; f; f = f->fr_next)
1237 if (f->fr_address <= r->u.b.r.address
1238 && r->u.b.r.address < f->fr_address + f->fr_fix)
1239 break;
1240 if (f == NULL)
1241 as_bad_where (r->file, r->line,
1242 _("reloc not within (fixed part of) section"));
1243 else
1245 relocs[n++] = &r->u.b.r;
1246 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1250 if (n)
1252 flagword flags = bfd_get_section_flags (abfd, sec);
1253 flags |= SEC_RELOC;
1254 bfd_set_section_flags (abfd, sec, flags);
1255 bfd_set_reloc (stdoutput, sec, relocs, n);
1258 #ifdef SET_SECTION_RELOCS
1259 SET_SECTION_RELOCS (sec, relocs, n);
1260 #endif
1262 #ifdef DEBUG3
1264 unsigned int i;
1265 arelent *r;
1266 asymbol *s;
1267 fprintf (stderr, "relocs for sec %s\n", sec->name);
1268 for (i = 0; i < n; i++)
1270 r = relocs[i];
1271 s = *r->sym_ptr_ptr;
1272 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1273 i, r, (unsigned long)r->address, s->name, (unsigned long)r->addend);
1276 #endif
1279 static void
1280 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1281 asection *sec,
1282 void *xxx ATTRIBUTE_UNUSED)
1284 segment_info_type *seginfo = seg_info (sec);
1285 addressT offset = 0;
1286 fragS *f;
1288 /* Write out the frags. */
1289 if (seginfo == NULL
1290 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1291 return;
1293 for (f = seginfo->frchainP->frch_root;
1295 f = f->fr_next)
1297 int x;
1298 addressT fill_size;
1299 char *fill_literal;
1300 offsetT count;
1302 assert (f->fr_type == rs_fill);
1303 if (f->fr_fix)
1305 x = bfd_set_section_contents (stdoutput, sec,
1306 f->fr_literal, (file_ptr) offset,
1307 (bfd_size_type) f->fr_fix);
1308 if (!x)
1309 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1310 bfd_errmsg (bfd_get_error ()));
1311 offset += f->fr_fix;
1313 fill_literal = f->fr_literal + f->fr_fix;
1314 fill_size = f->fr_var;
1315 count = f->fr_offset;
1316 assert (count >= 0);
1317 if (fill_size && count)
1319 char buf[256];
1320 if (fill_size > sizeof (buf))
1322 /* Do it the old way. Can this ever happen? */
1323 while (count--)
1325 x = bfd_set_section_contents (stdoutput, sec,
1326 fill_literal,
1327 (file_ptr) offset,
1328 (bfd_size_type) fill_size);
1329 if (!x)
1330 as_fatal (_("can't write %s: %s"), stdoutput->filename,
1331 bfd_errmsg (bfd_get_error ()));
1332 offset += fill_size;
1335 else
1337 /* Build a buffer full of fill objects and output it as
1338 often as necessary. This saves on the overhead of
1339 potentially lots of bfd_set_section_contents calls. */
1340 int n_per_buf, i;
1341 if (fill_size == 1)
1343 n_per_buf = sizeof (buf);
1344 memset (buf, *fill_literal, n_per_buf);
1346 else
1348 char *bufp;
1349 n_per_buf = sizeof (buf) / fill_size;
1350 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1351 memcpy (bufp, fill_literal, fill_size);
1353 for (; count > 0; count -= n_per_buf)
1355 n_per_buf = n_per_buf > count ? count : n_per_buf;
1356 x = bfd_set_section_contents
1357 (stdoutput, sec, buf, (file_ptr) offset,
1358 (bfd_size_type) n_per_buf * fill_size);
1359 if (!x)
1360 as_fatal (_("cannot write to output file"));
1361 offset += n_per_buf * fill_size;
1368 static void
1369 merge_data_into_text (void)
1371 seg_info (text_section)->frchainP->frch_last->fr_next =
1372 seg_info (data_section)->frchainP->frch_root;
1373 seg_info (text_section)->frchainP->frch_last =
1374 seg_info (data_section)->frchainP->frch_last;
1375 seg_info (data_section)->frchainP = 0;
1378 static void
1379 set_symtab (void)
1381 int nsyms;
1382 asymbol **asympp;
1383 symbolS *symp;
1384 bfd_boolean result;
1386 /* Count symbols. We can't rely on a count made by the loop in
1387 write_object_file, because *_frob_file may add a new symbol or
1388 two. */
1389 nsyms = 0;
1390 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1391 nsyms++;
1393 if (nsyms)
1395 int i;
1396 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1398 asympp = bfd_alloc (stdoutput, amt);
1399 symp = symbol_rootP;
1400 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1402 asympp[i] = symbol_get_bfdsym (symp);
1403 if (asympp[i]->flags != BSF_SECTION_SYM
1404 || !(bfd_is_const_section (asympp[i]->section)
1405 && asympp[i]->section->symbol == asympp[i]))
1406 asympp[i]->flags |= BSF_KEEP;
1407 symbol_mark_written (symp);
1410 else
1411 asympp = 0;
1412 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1413 assert (result);
1414 symbol_table_frozen = 1;
1417 /* Finish the subsegments. After every sub-segment, we fake an
1418 ".align ...". This conforms to BSD4.2 brane-damage. We then fake
1419 ".fill 0" because that is the kind of frag that requires least
1420 thought. ".align" frags like to have a following frag since that
1421 makes calculating their intended length trivial. */
1423 #ifndef SUB_SEGMENT_ALIGN
1424 #ifdef HANDLE_ALIGN
1425 /* The last subsegment gets an alignment corresponding to the alignment
1426 of the section. This allows proper nop-filling at the end of
1427 code-bearing sections. */
1428 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1429 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1430 #else
1431 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1432 #endif
1433 #endif
1435 void
1436 subsegs_finish (void)
1438 struct frchain *frchainP;
1439 asection *s;
1441 for (s = stdoutput->sections; s; s = s->next)
1443 segment_info_type *seginfo = seg_info (s);
1444 if (!seginfo)
1445 continue;
1447 for (frchainP = seginfo->frchainP;
1448 frchainP != NULL;
1449 frchainP = frchainP->frch_next)
1451 int alignment = 0;
1453 subseg_set (s, frchainP->frch_subseg);
1455 /* This now gets called even if we had errors. In that case,
1456 any alignment is meaningless, and, moreover, will look weird
1457 if we are generating a listing. */
1458 if (!had_errors ())
1460 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1461 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1462 && now_seg->entsize)
1464 unsigned int entsize = now_seg->entsize;
1465 int entalign = 0;
1467 while ((entsize & 1) == 0)
1469 ++entalign;
1470 entsize >>= 1;
1472 if (entalign > alignment)
1473 alignment = entalign;
1477 if (subseg_text_p (now_seg))
1478 frag_align_code (alignment, 0);
1479 else
1480 frag_align (alignment, 0, 0);
1482 /* frag_align will have left a new frag.
1483 Use this last frag for an empty ".fill".
1485 For this segment ...
1486 Create a last frag. Do not leave a "being filled in frag". */
1487 frag_wane (frag_now);
1488 frag_now->fr_fix = 0;
1489 know (frag_now->fr_next == NULL);
1494 /* Write the object file. */
1496 void
1497 write_object_file (void)
1499 struct relax_seg_info rsi;
1500 #ifndef WORKING_DOT_WORD
1501 fragS *fragP; /* Track along all frags. */
1502 #endif
1504 /* Do we really want to write it? */
1506 int n_warns, n_errs;
1507 n_warns = had_warnings ();
1508 n_errs = had_errors ();
1509 /* The -Z flag indicates that an object file should be generated,
1510 regardless of warnings and errors. */
1511 if (flag_always_generate_output)
1513 if (n_warns || n_errs)
1514 as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1515 n_errs, n_errs == 1 ? "" : "s",
1516 n_warns, n_warns == 1 ? "" : "s");
1518 else
1520 if (n_errs)
1521 as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1522 n_errs, n_errs == 1 ? "" : "s",
1523 n_warns, n_warns == 1 ? "" : "s");
1527 #ifdef OBJ_VMS
1528 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call
1529 a routine to check for the definition of the procedure "_main",
1530 and if so -- fix it up so that it can be program entry point. */
1531 vms_check_for_main ();
1532 #endif /* OBJ_VMS */
1534 /* From now on, we don't care about sub-segments. Build one frag chain
1535 for each segment. Linked thru fr_next. */
1537 /* Remove the sections created by gas for its own purposes. */
1539 int i;
1541 bfd_section_list_remove (stdoutput, reg_section);
1542 bfd_section_list_remove (stdoutput, expr_section);
1543 stdoutput->section_count -= 2;
1544 i = 0;
1545 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1548 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1550 /* We have two segments. If user gave -R flag, then we must put the
1551 data frags into the text segment. Do this before relaxing so
1552 we know to take advantage of -R and make shorter addresses. */
1553 if (flag_readonly_data_in_text)
1555 merge_data_into_text ();
1558 rsi.pass = 0;
1559 while (1)
1561 #ifndef WORKING_DOT_WORD
1562 /* We need to reset the markers in the broken word list and
1563 associated frags between calls to relax_segment (via
1564 relax_seg). Since the broken word list is global, we do it
1565 once per round, rather than locally in relax_segment for each
1566 segment. */
1567 struct broken_word *brokp;
1569 for (brokp = broken_words;
1570 brokp != (struct broken_word *) NULL;
1571 brokp = brokp->next_broken_word)
1573 brokp->added = 0;
1575 if (brokp->dispfrag != (fragS *) NULL
1576 && brokp->dispfrag->fr_type == rs_broken_word)
1577 brokp->dispfrag->fr_subtype = 0;
1579 #endif
1581 rsi.changed = 0;
1582 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1583 rsi.pass++;
1584 if (!rsi.changed)
1585 break;
1588 /* Note - Most ports will use the default value of
1589 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1590 local symbols to be resolved, removing their frag information.
1591 Some ports however, will not have finished relaxing all of
1592 their frags and will still need the local symbol frag
1593 information. These ports can set
1594 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1595 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1597 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1599 /* Relaxation has completed. Freeze all syms. */
1600 finalize_syms = 1;
1602 #ifdef md_post_relax_hook
1603 md_post_relax_hook;
1604 #endif
1606 #ifndef WORKING_DOT_WORD
1608 struct broken_word *lie;
1609 struct broken_word **prevP;
1611 prevP = &broken_words;
1612 for (lie = broken_words; lie; lie = lie->next_broken_word)
1613 if (!lie->added)
1615 expressionS exp;
1617 subseg_change (lie->seg, lie->subseg);
1618 exp.X_op = O_subtract;
1619 exp.X_add_symbol = lie->add;
1620 exp.X_op_symbol = lie->sub;
1621 exp.X_add_number = lie->addnum;
1622 #ifdef TC_CONS_FIX_NEW
1623 TC_CONS_FIX_NEW (lie->frag,
1624 lie->word_goes_here - lie->frag->fr_literal,
1625 2, &exp);
1626 #else
1627 fix_new_exp (lie->frag,
1628 lie->word_goes_here - lie->frag->fr_literal,
1629 2, &exp, 0, BFD_RELOC_16);
1630 #endif
1631 *prevP = lie->next_broken_word;
1633 else
1634 prevP = &(lie->next_broken_word);
1636 for (lie = broken_words; lie;)
1638 struct broken_word *untruth;
1639 char *table_ptr;
1640 addressT table_addr;
1641 addressT from_addr, to_addr;
1642 int n, m;
1644 subseg_change (lie->seg, lie->subseg);
1645 fragP = lie->dispfrag;
1647 /* Find out how many broken_words go here. */
1648 n = 0;
1649 for (untruth = lie;
1650 untruth && untruth->dispfrag == fragP;
1651 untruth = untruth->next_broken_word)
1652 if (untruth->added == 1)
1653 n++;
1655 table_ptr = lie->dispfrag->fr_opcode;
1656 table_addr = (lie->dispfrag->fr_address
1657 + (table_ptr - lie->dispfrag->fr_literal));
1658 /* Create the jump around the long jumps. This is a short
1659 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1660 from_addr = table_addr;
1661 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1662 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1663 lie->add);
1664 table_ptr += md_short_jump_size;
1665 table_addr += md_short_jump_size;
1667 for (m = 0;
1668 lie && lie->dispfrag == fragP;
1669 m++, lie = lie->next_broken_word)
1671 if (lie->added == 2)
1672 continue;
1673 /* Patch the jump table. */
1674 /* This is the offset from ??? to table_ptr+0. */
1675 to_addr = table_addr - S_GET_VALUE (lie->sub);
1676 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1677 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1678 #endif
1679 md_number_to_chars (lie->word_goes_here, to_addr, 2);
1680 for (untruth = lie->next_broken_word;
1681 untruth && untruth->dispfrag == fragP;
1682 untruth = untruth->next_broken_word)
1684 if (untruth->use_jump == lie)
1685 md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1688 /* Install the long jump. */
1689 /* This is a long jump from table_ptr+0 to the final target. */
1690 from_addr = table_addr;
1691 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1692 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1693 lie->add);
1694 table_ptr += md_long_jump_size;
1695 table_addr += md_long_jump_size;
1699 #endif /* not WORKING_DOT_WORD */
1701 /* Resolve symbol values. This needs to be done before processing
1702 the relocations. */
1703 if (symbol_rootP)
1705 symbolS *symp;
1707 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1708 resolve_symbol_value (symp);
1710 resolve_local_symbol_values ();
1711 resolve_reloc_expr_symbols ();
1713 PROGRESS (1);
1715 #ifdef tc_frob_file_before_adjust
1716 tc_frob_file_before_adjust ();
1717 #endif
1718 #ifdef obj_frob_file_before_adjust
1719 obj_frob_file_before_adjust ();
1720 #endif
1722 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1724 #ifdef tc_frob_file_before_fix
1725 tc_frob_file_before_fix ();
1726 #endif
1727 #ifdef obj_frob_file_before_fix
1728 obj_frob_file_before_fix ();
1729 #endif
1731 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1733 /* Set up symbol table, and write it out. */
1734 if (symbol_rootP)
1736 symbolS *symp;
1737 bfd_boolean skip_next_symbol = FALSE;
1739 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1741 int punt = 0;
1742 const char *name;
1744 if (skip_next_symbol)
1746 /* Don't do anything besides moving the value of the
1747 symbol from the GAS value-field to the BFD value-field. */
1748 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1749 skip_next_symbol = FALSE;
1750 continue;
1753 if (symbol_mri_common_p (symp))
1755 if (S_IS_EXTERNAL (symp))
1756 as_bad (_("%s: global symbols not supported in common sections"),
1757 S_GET_NAME (symp));
1758 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1759 continue;
1762 name = S_GET_NAME (symp);
1763 if (name)
1765 const char *name2 =
1766 decode_local_label_name ((char *) S_GET_NAME (symp));
1767 /* They only differ if `name' is a fb or dollar local
1768 label name. */
1769 if (name2 != name && ! S_IS_DEFINED (symp))
1770 as_bad (_("local label `%s' is not defined"), name2);
1773 /* Do it again, because adjust_reloc_syms might introduce
1774 more symbols. They'll probably only be section symbols,
1775 but they'll still need to have the values computed. */
1776 resolve_symbol_value (symp);
1778 /* Skip symbols which were equated to undefined or common
1779 symbols. */
1780 if (symbol_equated_reloc_p (symp)
1781 || S_IS_WEAKREFR (symp))
1783 const char *name = S_GET_NAME (symp);
1784 if (S_IS_COMMON (symp)
1785 && !TC_FAKE_LABEL (name)
1786 && !S_IS_WEAKREFR (symp)
1787 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
1789 expressionS *e = symbol_get_value_expression (symp);
1790 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
1791 name, S_GET_NAME (e->X_add_symbol));
1793 if (S_GET_SEGMENT (symp) == reg_section)
1795 /* Report error only if we know the symbol name. */
1796 if (S_GET_NAME (symp) != reg_section->name)
1797 as_bad (_("can't make global register symbol `%s'"),
1798 name);
1800 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1801 continue;
1804 #ifdef obj_frob_symbol
1805 obj_frob_symbol (symp, punt);
1806 #endif
1807 #ifdef tc_frob_symbol
1808 if (! punt || symbol_used_in_reloc_p (symp))
1809 tc_frob_symbol (symp, punt);
1810 #endif
1812 /* If we don't want to keep this symbol, splice it out of
1813 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
1814 want section symbols. Otherwise, we skip local symbols
1815 and symbols that the frob_symbol macros told us to punt,
1816 but we keep such symbols if they are used in relocs. */
1817 if (symp == abs_section_sym
1818 || (! EMIT_SECTION_SYMBOLS
1819 && symbol_section_p (symp))
1820 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
1821 opposites. Sometimes the former checks flags and the
1822 latter examines the name... */
1823 || (!S_IS_EXTERNAL (symp)
1824 && (punt || S_IS_LOCAL (symp) ||
1825 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
1826 && ! symbol_used_in_reloc_p (symp)))
1828 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1830 /* After symbol_remove, symbol_next(symp) still returns
1831 the one that came after it in the chain. So we don't
1832 need to do any extra cleanup work here. */
1833 continue;
1836 /* Make sure we really got a value for the symbol. */
1837 if (! symbol_resolved_p (symp))
1839 as_bad (_("can't resolve value for symbol `%s'"),
1840 S_GET_NAME (symp));
1841 symbol_mark_resolved (symp);
1844 /* Set the value into the BFD symbol. Up til now the value
1845 has only been kept in the gas symbolS struct. */
1846 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
1848 /* A warning construct is a warning symbol followed by the
1849 symbol warned about. Don't let anything object-format or
1850 target-specific muck with it; it's ready for output. */
1851 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
1852 skip_next_symbol = TRUE;
1856 PROGRESS (1);
1858 /* Now do any format-specific adjustments to the symbol table, such
1859 as adding file symbols. */
1860 #ifdef tc_adjust_symtab
1861 tc_adjust_symtab ();
1862 #endif
1863 #ifdef obj_adjust_symtab
1864 obj_adjust_symtab ();
1865 #endif
1867 /* Stop if there is an error. */
1868 if (had_errors ())
1869 return;
1871 /* Now that all the sizes are known, and contents correct, we can
1872 start writing to the file. */
1873 set_symtab ();
1875 /* If *_frob_file changes the symbol value at this point, it is
1876 responsible for moving the changed value into symp->bsym->value
1877 as well. Hopefully all symbol value changing can be done in
1878 *_frob_symbol. */
1879 #ifdef tc_frob_file
1880 tc_frob_file ();
1881 #endif
1882 #ifdef obj_frob_file
1883 obj_frob_file ();
1884 #endif
1886 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
1888 #ifdef tc_frob_file_after_relocs
1889 tc_frob_file_after_relocs ();
1890 #endif
1891 #ifdef obj_frob_file_after_relocs
1892 obj_frob_file_after_relocs ();
1893 #endif
1895 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
1898 #ifdef TC_GENERIC_RELAX_TABLE
1899 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
1901 long
1902 relax_frag (segT segment, fragS *fragP, long stretch)
1904 const relax_typeS *this_type;
1905 const relax_typeS *start_type;
1906 relax_substateT next_state;
1907 relax_substateT this_state;
1908 offsetT growth;
1909 offsetT aim;
1910 addressT target;
1911 addressT address;
1912 symbolS *symbolP;
1913 const relax_typeS *table;
1915 target = fragP->fr_offset;
1916 address = fragP->fr_address;
1917 table = TC_GENERIC_RELAX_TABLE;
1918 this_state = fragP->fr_subtype;
1919 start_type = this_type = table + this_state;
1920 symbolP = fragP->fr_symbol;
1922 if (symbolP)
1924 fragS *sym_frag;
1926 sym_frag = symbol_get_frag (symbolP);
1928 #ifndef DIFF_EXPR_OK
1929 know (sym_frag != NULL);
1930 #endif
1931 know (S_GET_SEGMENT (symbolP) != absolute_section
1932 || sym_frag == &zero_address_frag);
1933 target += S_GET_VALUE (symbolP);
1935 /* If frag has yet to be reached on this pass,
1936 assume it will move by STRETCH just as we did.
1937 If this is not so, it will be because some frag
1938 between grows, and that will force another pass. */
1940 if (stretch != 0
1941 && sym_frag->relax_marker != fragP->relax_marker
1942 && S_GET_SEGMENT (symbolP) == segment)
1944 target += stretch;
1948 aim = target - address - fragP->fr_fix;
1949 #ifdef TC_PCREL_ADJUST
1950 /* Currently only the ns32k family needs this. */
1951 aim += TC_PCREL_ADJUST (fragP);
1952 #endif
1954 #ifdef md_prepare_relax_scan
1955 /* Formerly called M68K_AIM_KLUDGE. */
1956 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
1957 #endif
1959 if (aim < 0)
1961 /* Look backwards. */
1962 for (next_state = this_type->rlx_more; next_state;)
1963 if (aim >= this_type->rlx_backward)
1964 next_state = 0;
1965 else
1967 /* Grow to next state. */
1968 this_state = next_state;
1969 this_type = table + this_state;
1970 next_state = this_type->rlx_more;
1973 else
1975 /* Look forwards. */
1976 for (next_state = this_type->rlx_more; next_state;)
1977 if (aim <= this_type->rlx_forward)
1978 next_state = 0;
1979 else
1981 /* Grow to next state. */
1982 this_state = next_state;
1983 this_type = table + this_state;
1984 next_state = this_type->rlx_more;
1988 growth = this_type->rlx_length - start_type->rlx_length;
1989 if (growth != 0)
1990 fragP->fr_subtype = this_state;
1991 return growth;
1994 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
1996 /* Relax_align. Advance location counter to next address that has 'alignment'
1997 lowest order bits all 0s, return size of adjustment made. */
1998 static relax_addressT
1999 relax_align (register relax_addressT address, /* Address now. */
2000 register int alignment /* Alignment (binary). */)
2002 relax_addressT mask;
2003 relax_addressT new_address;
2005 mask = ~((~0) << alignment);
2006 new_address = (address + mask) & (~mask);
2007 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2008 if (linkrelax)
2009 /* We must provide lots of padding, so the linker can discard it
2010 when needed. The linker will not add extra space, ever. */
2011 new_address += (1 << alignment);
2012 #endif
2013 return (new_address - address);
2016 /* Now we have a segment, not a crowd of sub-segments, we can make
2017 fr_address values.
2019 Relax the frags.
2021 After this, all frags in this segment have addresses that are correct
2022 within the segment. Since segments live in different file addresses,
2023 these frag addresses may not be the same as final object-file
2024 addresses. */
2027 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2029 unsigned long frag_count;
2030 struct frag *fragP;
2031 relax_addressT address;
2032 int ret;
2034 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2035 subseg_change (segment, 0);
2037 /* For each frag in segment: count and store (a 1st guess of)
2038 fr_address. */
2039 address = 0;
2040 for (frag_count = 0, fragP = segment_frag_root;
2041 fragP;
2042 fragP = fragP->fr_next, frag_count ++)
2044 fragP->relax_marker = 0;
2045 fragP->fr_address = address;
2046 address += fragP->fr_fix;
2048 switch (fragP->fr_type)
2050 case rs_fill:
2051 address += fragP->fr_offset * fragP->fr_var;
2052 break;
2054 case rs_align:
2055 case rs_align_code:
2056 case rs_align_test:
2058 addressT offset = relax_align (address, (int) fragP->fr_offset);
2060 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2061 offset = 0;
2063 if (offset % fragP->fr_var != 0)
2065 as_bad_where (fragP->fr_file, fragP->fr_line,
2066 _("alignment padding (%lu bytes) not a multiple of %ld"),
2067 (unsigned long) offset, (long) fragP->fr_var);
2068 offset -= (offset % fragP->fr_var);
2071 address += offset;
2073 break;
2075 case rs_org:
2076 case rs_space:
2077 /* Assume .org is nugatory. It will grow with 1st relax. */
2078 break;
2080 case rs_machine_dependent:
2081 /* If fr_symbol is an expression, this call to
2082 resolve_symbol_value sets up the correct segment, which will
2083 likely be needed in md_estimate_size_before_relax. */
2084 if (fragP->fr_symbol)
2085 resolve_symbol_value (fragP->fr_symbol);
2087 address += md_estimate_size_before_relax (fragP, segment);
2088 break;
2090 #ifndef WORKING_DOT_WORD
2091 /* Broken words don't concern us yet. */
2092 case rs_broken_word:
2093 break;
2094 #endif
2096 case rs_leb128:
2097 /* Initial guess is always 1; doing otherwise can result in
2098 stable solutions that are larger than the minimum. */
2099 address += fragP->fr_offset = 1;
2100 break;
2102 case rs_cfa:
2103 address += eh_frame_estimate_size_before_relax (fragP);
2104 break;
2106 case rs_dwarf2dbg:
2107 address += dwarf2dbg_estimate_size_before_relax (fragP);
2108 break;
2110 default:
2111 BAD_CASE (fragP->fr_type);
2112 break;
2116 /* Do relax(). */
2118 unsigned long max_iterations;
2120 /* Cumulative address adjustment. */
2121 offsetT stretch;
2123 /* Have we made any adjustment this pass? We can't just test
2124 stretch because one piece of code may have grown and another
2125 shrank. */
2126 int stretched;
2128 /* Most horrible, but gcc may give us some exception data that
2129 is impossible to assemble, of the form
2131 .align 4
2132 .byte 0, 0
2133 .uleb128 end - start
2134 start:
2135 .space 128*128 - 1
2136 .align 4
2137 end:
2139 If the leb128 is two bytes in size, then end-start is 128*128,
2140 which requires a three byte leb128. If the leb128 is three
2141 bytes in size, then end-start is 128*128-1, which requires a
2142 two byte leb128. We work around this dilemma by inserting
2143 an extra 4 bytes of alignment just after the .align. This
2144 works because the data after the align is accessed relative to
2145 the end label.
2147 This counter is used in a tiny state machine to detect
2148 whether a leb128 followed by an align is impossible to
2149 relax. */
2150 int rs_leb128_fudge = 0;
2152 /* We want to prevent going into an infinite loop where one frag grows
2153 depending upon the location of a symbol which is in turn moved by
2154 the growing frag. eg:
2156 foo = .
2157 .org foo+16
2158 foo = .
2160 So we dictate that this algorithm can be at most O2. */
2161 max_iterations = frag_count * frag_count;
2162 /* Check for overflow. */
2163 if (max_iterations < frag_count)
2164 max_iterations = frag_count;
2166 ret = 0;
2169 stretch = 0;
2170 stretched = 0;
2172 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2174 offsetT growth = 0;
2175 addressT was_address;
2176 offsetT offset;
2177 symbolS *symbolP;
2179 fragP->relax_marker ^= 1;
2180 was_address = fragP->fr_address;
2181 address = fragP->fr_address += stretch;
2182 symbolP = fragP->fr_symbol;
2183 offset = fragP->fr_offset;
2185 switch (fragP->fr_type)
2187 case rs_fill: /* .fill never relaxes. */
2188 growth = 0;
2189 break;
2191 #ifndef WORKING_DOT_WORD
2192 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2193 for it I do not want to write it. I do not want to have
2194 anything to do with it. This is not the proper way to
2195 implement this misfeature. */
2196 case rs_broken_word:
2198 struct broken_word *lie;
2199 struct broken_word *untruth;
2201 /* Yes this is ugly (storing the broken_word pointer
2202 in the symbol slot). Still, this whole chunk of
2203 code is ugly, and I don't feel like doing anything
2204 about it. Think of it as stubbornness in action. */
2205 growth = 0;
2206 for (lie = (struct broken_word *) (fragP->fr_symbol);
2207 lie && lie->dispfrag == fragP;
2208 lie = lie->next_broken_word)
2211 if (lie->added)
2212 continue;
2214 offset = (S_GET_VALUE (lie->add)
2215 + lie->addnum
2216 - S_GET_VALUE (lie->sub));
2217 if (offset <= -32768 || offset >= 32767)
2219 if (flag_warn_displacement)
2221 char buf[50];
2222 sprint_value (buf, (addressT) lie->addnum);
2223 as_warn_where (fragP->fr_file, fragP->fr_line,
2224 _(".word %s-%s+%s didn't fit"),
2225 S_GET_NAME (lie->add),
2226 S_GET_NAME (lie->sub),
2227 buf);
2229 lie->added = 1;
2230 if (fragP->fr_subtype == 0)
2232 fragP->fr_subtype++;
2233 growth += md_short_jump_size;
2235 for (untruth = lie->next_broken_word;
2236 untruth && untruth->dispfrag == lie->dispfrag;
2237 untruth = untruth->next_broken_word)
2238 if ((symbol_get_frag (untruth->add)
2239 == symbol_get_frag (lie->add))
2240 && (S_GET_VALUE (untruth->add)
2241 == S_GET_VALUE (lie->add)))
2243 untruth->added = 2;
2244 untruth->use_jump = lie;
2246 growth += md_long_jump_size;
2250 break;
2251 } /* case rs_broken_word */
2252 #endif
2253 case rs_align:
2254 case rs_align_code:
2255 case rs_align_test:
2257 addressT oldoff, newoff;
2259 oldoff = relax_align (was_address + fragP->fr_fix,
2260 (int) offset);
2261 newoff = relax_align (address + fragP->fr_fix,
2262 (int) offset);
2264 if (fragP->fr_subtype != 0)
2266 if (oldoff > fragP->fr_subtype)
2267 oldoff = 0;
2268 if (newoff > fragP->fr_subtype)
2269 newoff = 0;
2272 growth = newoff - oldoff;
2274 /* If this align happens to follow a leb128 and
2275 we have determined that the leb128 is bouncing
2276 in size, then break the cycle by inserting an
2277 extra alignment. */
2278 if (growth < 0
2279 && (rs_leb128_fudge & 16) != 0
2280 && (rs_leb128_fudge & 15) >= 2)
2282 segment_info_type *seginfo = seg_info (segment);
2283 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2284 struct frag *newf;
2286 newf = frag_alloc (ob);
2287 obstack_blank_fast (ob, fragP->fr_var);
2288 obstack_finish (ob);
2289 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2290 memcpy (newf->fr_literal,
2291 fragP->fr_literal + fragP->fr_fix,
2292 fragP->fr_var);
2293 newf->fr_type = rs_fill;
2294 newf->fr_fix = 0;
2295 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2296 / fragP->fr_var);
2297 if (newf->fr_offset * newf->fr_var
2298 != (offsetT) 1 << fragP->fr_offset)
2300 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2301 newf->fr_var = 1;
2303 /* Include growth of new frag, because rs_fill
2304 frags don't normally grow. */
2305 growth += newf->fr_offset * newf->fr_var;
2306 /* The new frag address is newoff. Adjust this
2307 for the amount we'll add when we process the
2308 new frag. */
2309 newf->fr_address = newoff - stretch - growth;
2310 newf->relax_marker ^= 1;
2311 fragP->fr_next = newf;
2312 #ifdef DEBUG
2313 as_warn (_("padding added"));
2314 #endif
2317 break;
2319 case rs_org:
2321 addressT target = offset;
2322 addressT after;
2324 if (symbolP)
2326 /* Convert from an actual address to an octet offset
2327 into the section. Here it is assumed that the
2328 section's VMA is zero, and can omit subtracting it
2329 from the symbol's value to get the address offset. */
2330 know (S_GET_SEGMENT (symbolP)->vma == 0);
2331 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2334 know (fragP->fr_next);
2335 after = fragP->fr_next->fr_address + stretch;
2336 growth = target - after;
2337 if (growth < 0)
2339 growth = 0;
2341 /* Don't error on first few frag relax passes.
2342 The symbol might be an expression involving
2343 symbol values from other sections. If those
2344 sections have not yet been processed their
2345 frags will all have zero addresses, so we
2346 will calculate incorrect values for them. The
2347 number of passes we allow before giving an
2348 error is somewhat arbitrary. It should be at
2349 least one, with larger values requiring
2350 increasingly contrived dependencies between
2351 frags to trigger a false error. */
2352 if (pass < 2)
2354 /* Force another pass. */
2355 ret = 1;
2356 break;
2359 /* Growth may be negative, but variable part of frag
2360 cannot have fewer than 0 chars. That is, we can't
2361 .org backwards. */
2362 as_bad_where (fragP->fr_file, fragP->fr_line,
2363 _("attempt to move .org backwards"));
2365 /* We've issued an error message. Change the
2366 frag to avoid cascading errors. */
2367 fragP->fr_type = rs_align;
2368 fragP->fr_subtype = 0;
2369 fragP->fr_offset = 0;
2370 fragP->fr_fix = after - address;
2373 break;
2375 case rs_space:
2376 growth = 0;
2377 if (symbolP)
2379 offsetT amount;
2381 amount = S_GET_VALUE (symbolP);
2382 if (S_GET_SEGMENT (symbolP) != absolute_section
2383 || S_IS_COMMON (symbolP)
2384 || ! S_IS_DEFINED (symbolP))
2386 as_bad_where (fragP->fr_file, fragP->fr_line,
2387 _(".space specifies non-absolute value"));
2388 /* Prevent repeat of this error message. */
2389 fragP->fr_symbol = 0;
2391 else if (amount < 0)
2393 /* Don't error on first few frag relax passes.
2394 See rs_org comment for a longer explanation. */
2395 if (pass < 2)
2397 ret = 1;
2398 break;
2401 as_warn_where (fragP->fr_file, fragP->fr_line,
2402 _(".space or .fill with negative value, ignored"));
2403 fragP->fr_symbol = 0;
2405 else
2406 growth = (was_address + fragP->fr_fix + amount
2407 - fragP->fr_next->fr_address);
2409 break;
2411 case rs_machine_dependent:
2412 #ifdef md_relax_frag
2413 growth = md_relax_frag (segment, fragP, stretch);
2414 #else
2415 #ifdef TC_GENERIC_RELAX_TABLE
2416 /* The default way to relax a frag is to look through
2417 TC_GENERIC_RELAX_TABLE. */
2418 growth = relax_frag (segment, fragP, stretch);
2419 #endif /* TC_GENERIC_RELAX_TABLE */
2420 #endif
2421 break;
2423 case rs_leb128:
2425 valueT value;
2426 offsetT size;
2428 value = resolve_symbol_value (fragP->fr_symbol);
2429 size = sizeof_leb128 (value, fragP->fr_subtype);
2430 growth = size - fragP->fr_offset;
2431 fragP->fr_offset = size;
2433 break;
2435 case rs_cfa:
2436 growth = eh_frame_relax_frag (fragP);
2437 break;
2439 case rs_dwarf2dbg:
2440 growth = dwarf2dbg_relax_frag (fragP);
2441 break;
2443 default:
2444 BAD_CASE (fragP->fr_type);
2445 break;
2447 if (growth)
2449 stretch += growth;
2450 stretched = 1;
2451 if (fragP->fr_type == rs_leb128)
2452 rs_leb128_fudge += 16;
2453 else if (fragP->fr_type == rs_align
2454 && (rs_leb128_fudge & 16) != 0
2455 && stretch == 0)
2456 rs_leb128_fudge += 16;
2457 else
2458 rs_leb128_fudge = 0;
2462 if (stretch == 0
2463 && (rs_leb128_fudge & 16) == 0
2464 && (rs_leb128_fudge & -16) != 0)
2465 rs_leb128_fudge += 1;
2466 else
2467 rs_leb128_fudge = 0;
2469 /* Until nothing further to relax. */
2470 while (stretched && -- max_iterations);
2472 if (stretched)
2473 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2474 segment_name (segment));
2477 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2478 if (fragP->last_fr_address != fragP->fr_address)
2480 fragP->last_fr_address = fragP->fr_address;
2481 ret = 1;
2483 return ret;
2486 void
2487 number_to_chars_bigendian (char *buf, valueT val, int n)
2489 if (n <= 0)
2490 abort ();
2491 while (n--)
2493 buf[n] = val & 0xff;
2494 val >>= 8;
2498 void
2499 number_to_chars_littleendian (char *buf, valueT val, int n)
2501 if (n <= 0)
2502 abort ();
2503 while (n--)
2505 *buf++ = val & 0xff;
2506 val >>= 8;
2510 void
2511 write_print_statistics (FILE *file)
2513 fprintf (file, "fixups: %d\n", n_fixups);
2516 /* For debugging. */
2517 extern int indent_level;
2519 void
2520 print_fixup (fixS *fixp)
2522 indent_level = 1;
2523 fprintf (stderr, "fix ");
2524 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2525 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2526 if (fixp->fx_pcrel)
2527 fprintf (stderr, " pcrel");
2528 if (fixp->fx_pcrel_adjust)
2529 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2530 if (fixp->fx_im_disp)
2532 #ifdef TC_NS32K
2533 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2534 #else
2535 fprintf (stderr, " im_disp");
2536 #endif
2538 if (fixp->fx_tcbit)
2539 fprintf (stderr, " tcbit");
2540 if (fixp->fx_done)
2541 fprintf (stderr, " done");
2542 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2543 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2544 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2545 (long) fixp->fx_where,
2546 (unsigned long) fixp->fx_offset,
2547 (unsigned long) fixp->fx_addnumber);
2548 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2549 fixp->fx_r_type);
2550 if (fixp->fx_addsy)
2552 fprintf (stderr, "\n +<");
2553 print_symbol_value_1 (stderr, fixp->fx_addsy);
2554 fprintf (stderr, ">");
2556 if (fixp->fx_subsy)
2558 fprintf (stderr, "\n -<");
2559 print_symbol_value_1 (stderr, fixp->fx_subsy);
2560 fprintf (stderr, ">");
2562 fprintf (stderr, "\n");
2563 #ifdef TC_FIX_DATA_PRINT
2564 TC_FIX_DATA_PRINT (stderr, fixp);
2565 #endif