Automatic date update in version.in
[binutils-gdb.git] / gas / write.c
blobdf88905013b9d12ab82000a5d20b137dd7cc4362
1 /* write.c - emit .o file
2 Copyright (C) 1986-2017 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
21 /* This thing should be set up to do byte ordering correctly. But... */
23 #include "as.h"
24 #include "subsegs.h"
25 #include "obstack.h"
26 #include "output-file.h"
27 #include "dwarf2dbg.h"
28 #include "compress-debug.h"
30 #ifndef TC_FORCE_RELOCATION
31 #define TC_FORCE_RELOCATION(FIX) \
32 (generic_force_reloc (FIX))
33 #endif
35 #ifndef TC_FORCE_RELOCATION_ABS
36 #define TC_FORCE_RELOCATION_ABS(FIX) \
37 (TC_FORCE_RELOCATION (FIX))
38 #endif
40 #define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \
41 (!(FIX)->fx_pcrel \
42 || TC_FORCE_RELOCATION (FIX))
43 #ifndef TC_FORCE_RELOCATION_LOCAL
44 #define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL
45 #endif
47 #define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
48 (!SEG_NORMAL (SEG))
49 #ifndef TC_FORCE_RELOCATION_SUB_SAME
50 #define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME
51 #endif
53 #ifndef md_register_arithmetic
54 # define md_register_arithmetic 1
55 #endif
57 #ifndef TC_FORCE_RELOCATION_SUB_ABS
58 #define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
59 (!md_register_arithmetic && (SEG) == reg_section)
60 #endif
62 #ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63 #ifdef DIFF_EXPR_OK
64 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
65 (!md_register_arithmetic && (SEG) == reg_section)
66 #else
67 #define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 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, SEG) \
75 (md_register_arithmetic || (SEG) != reg_section)
76 #else
77 #define TC_VALIDATE_FIX_SUB(FIX, SEG) \
78 ((md_register_arithmetic || (SEG) != reg_section) \
79 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
80 || (FIX)->fx_r_type == BFD_RELOC_GPREL16))
81 #endif
82 #endif
84 #ifndef TC_LINKRELAX_FIXUP
85 #define TC_LINKRELAX_FIXUP(SEG) 1
86 #endif
88 #ifndef MD_APPLY_SYM_VALUE
89 #define MD_APPLY_SYM_VALUE(FIX) 1
90 #endif
92 #ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
93 #define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
94 #endif
96 #ifndef MD_PCREL_FROM_SECTION
97 #define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
98 #endif
100 #ifndef TC_FAKE_LABEL
101 #define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
102 #endif
104 /* Positive values of TC_FX_SIZE_SLACK allow a target to define
105 fixups that far past the end of a frag. Having such fixups
106 is of course most most likely a bug in setting fx_size correctly.
107 A negative value disables the fixup check entirely, which is
108 appropriate for something like the Renesas / SuperH SH_COUNT
109 reloc. */
110 #ifndef TC_FX_SIZE_SLACK
111 #define TC_FX_SIZE_SLACK(FIX) 0
112 #endif
114 /* Used to control final evaluation of expressions. */
115 int finalize_syms = 0;
117 int symbol_table_frozen;
119 symbolS *abs_section_sym;
121 /* Remember the value of dot when parsing expressions. */
122 addressT dot_value;
124 /* The frag that dot_value is based from. */
125 fragS *dot_frag;
127 /* Relocs generated by ".reloc" pseudo. */
128 struct reloc_list* reloc_list;
130 void print_fixup (fixS *);
132 /* We generally attach relocs to frag chains. However, after we have
133 chained these all together into a segment, any relocs we add after
134 that must be attached to a segment. This will include relocs added
135 in md_estimate_size_for_relax, for example. */
136 static int frags_chained = 0;
138 static int n_fixups;
140 #define RELOC_ENUM enum bfd_reloc_code_real
142 /* Create a fixS in obstack 'notes'. */
144 static fixS *
145 fix_new_internal (fragS *frag, /* Which frag? */
146 int where, /* Where in that frag? */
147 int size, /* 1, 2, or 4 usually. */
148 symbolS *add_symbol, /* X_add_symbol. */
149 symbolS *sub_symbol, /* X_op_symbol. */
150 offsetT offset, /* X_add_number. */
151 int pcrel, /* TRUE if PC-relative relocation. */
152 RELOC_ENUM r_type /* Relocation type. */,
153 int at_beginning) /* Add to the start of the list? */
155 fixS *fixP;
157 n_fixups++;
159 fixP = (fixS *) 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_dot_frag = dot_frag;
175 fixP->fx_pcrel = pcrel;
176 fixP->fx_r_type = r_type;
177 fixP->fx_im_disp = 0;
178 fixP->fx_pcrel_adjust = 0;
179 fixP->fx_bit_fixP = 0;
180 fixP->fx_addnumber = 0;
181 fixP->fx_tcbit = 0;
182 fixP->fx_tcbit2 = 0;
183 fixP->fx_done = 0;
184 fixP->fx_no_overflow = 0;
185 fixP->fx_signed = 0;
187 #ifdef USING_CGEN
188 fixP->fx_cgen.insn = NULL;
189 fixP->fx_cgen.opinfo = 0;
190 #endif
192 #ifdef TC_FIX_TYPE
193 TC_INIT_FIX_DATA (fixP);
194 #endif
196 fixP->fx_file = as_where (&fixP->fx_line);
200 fixS **seg_fix_rootP = (frags_chained
201 ? &seg_info (now_seg)->fix_root
202 : &frchain_now->fix_root);
203 fixS **seg_fix_tailP = (frags_chained
204 ? &seg_info (now_seg)->fix_tail
205 : &frchain_now->fix_tail);
207 if (at_beginning)
209 fixP->fx_next = *seg_fix_rootP;
210 *seg_fix_rootP = fixP;
211 if (fixP->fx_next == NULL)
212 *seg_fix_tailP = fixP;
214 else
216 fixP->fx_next = NULL;
217 if (*seg_fix_tailP)
218 (*seg_fix_tailP)->fx_next = fixP;
219 else
220 *seg_fix_rootP = fixP;
221 *seg_fix_tailP = fixP;
225 return fixP;
228 /* Create a fixup relative to a symbol (plus a constant). */
230 fixS *
231 fix_new (fragS *frag, /* Which frag? */
232 int where, /* Where in that frag? */
233 int size, /* 1, 2, or 4 usually. */
234 symbolS *add_symbol, /* X_add_symbol. */
235 offsetT offset, /* X_add_number. */
236 int pcrel, /* TRUE if PC-relative relocation. */
237 RELOC_ENUM r_type /* Relocation type. */)
239 return fix_new_internal (frag, where, size, add_symbol,
240 (symbolS *) NULL, offset, pcrel, r_type, FALSE);
243 /* Create a fixup for an expression. Currently we only support fixups
244 for difference expressions. That is itself more than most object
245 file formats support anyhow. */
247 fixS *
248 fix_new_exp (fragS *frag, /* Which frag? */
249 int where, /* Where in that frag? */
250 int size, /* 1, 2, or 4 usually. */
251 expressionS *exp, /* Expression. */
252 int pcrel, /* TRUE if PC-relative relocation. */
253 RELOC_ENUM r_type /* Relocation type. */)
255 symbolS *add = NULL;
256 symbolS *sub = NULL;
257 offsetT off = 0;
259 switch (exp->X_op)
261 case O_absent:
262 break;
264 case O_register:
265 as_bad (_("register value used as expression"));
266 break;
268 case O_add:
269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
270 the difference expression cannot immediately be reduced. */
272 symbolS *stmp = make_expr_symbol (exp);
274 exp->X_op = O_symbol;
275 exp->X_op_symbol = 0;
276 exp->X_add_symbol = stmp;
277 exp->X_add_number = 0;
279 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
282 case O_symbol_rva:
283 add = exp->X_add_symbol;
284 off = exp->X_add_number;
285 r_type = BFD_RELOC_RVA;
286 break;
288 case O_uminus:
289 sub = exp->X_add_symbol;
290 off = exp->X_add_number;
291 break;
293 case O_subtract:
294 sub = exp->X_op_symbol;
295 /* Fall through. */
296 case O_symbol:
297 add = exp->X_add_symbol;
298 /* Fall through. */
299 case O_constant:
300 off = exp->X_add_number;
301 break;
303 default:
304 add = make_expr_symbol (exp);
305 break;
308 return fix_new_internal (frag, where, size, add, sub, off, pcrel,
309 r_type, FALSE);
312 /* Create a fixup at the beginning of FRAG. The arguments are the same
313 as for fix_new, except that WHERE is implicitly 0. */
315 fixS *
316 fix_at_start (fragS *frag, int size, symbolS *add_symbol,
317 offsetT offset, int pcrel, RELOC_ENUM r_type)
319 return fix_new_internal (frag, 0, size, add_symbol,
320 (symbolS *) NULL, offset, pcrel, r_type, TRUE);
323 /* Generic function to determine whether a fixup requires a relocation. */
325 generic_force_reloc (fixS *fix)
327 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
328 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
329 return 1;
331 if (fix->fx_addsy == NULL)
332 return 0;
334 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
337 /* Append a string onto another string, bumping the pointer along. */
338 void
339 append (char **charPP, char *fromP, unsigned long length)
341 /* Don't trust memcpy() of 0 chars. */
342 if (length == 0)
343 return;
345 memcpy (*charPP, fromP, length);
346 *charPP += length;
349 /* This routine records the largest alignment seen for each segment.
350 If the beginning of the segment is aligned on the worst-case
351 boundary, all of the other alignments within it will work. At
352 least one object format really uses this info. */
354 void
355 record_alignment (/* Segment to which alignment pertains. */
356 segT seg,
357 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
358 boundary, 2 => 4-byte boundary, etc.) */
359 unsigned int align)
361 if (seg == absolute_section)
362 return;
364 if (align > bfd_get_section_alignment (stdoutput, seg))
365 bfd_set_section_alignment (stdoutput, seg, align);
369 get_recorded_alignment (segT seg)
371 if (seg == absolute_section)
372 return 0;
374 return bfd_get_section_alignment (stdoutput, seg);
377 /* Reset the section indices after removing the gas created sections. */
379 static void
380 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
382 int *countp = (int *) countparg;
384 sec->index = *countp;
385 ++*countp;
388 static fragS *
389 chain_frchains_together_1 (segT section, struct frchain *frchp)
391 fragS dummy, *prev_frag = &dummy;
392 fixS fix_dummy, *prev_fix = &fix_dummy;
394 for (; frchp; frchp = frchp->frch_next)
396 prev_frag->fr_next = frchp->frch_root;
397 prev_frag = frchp->frch_last;
398 gas_assert (prev_frag->fr_type != 0);
399 if (frchp->fix_root != (fixS *) NULL)
401 if (seg_info (section)->fix_root == (fixS *) NULL)
402 seg_info (section)->fix_root = frchp->fix_root;
403 prev_fix->fx_next = frchp->fix_root;
404 seg_info (section)->fix_tail = frchp->fix_tail;
405 prev_fix = frchp->fix_tail;
408 gas_assert (prev_frag != &dummy
409 && prev_frag->fr_type != 0);
410 prev_frag->fr_next = 0;
411 return prev_frag;
414 static void
415 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
416 segT section,
417 void *xxx ATTRIBUTE_UNUSED)
419 segment_info_type *info;
421 /* BFD may have introduced its own sections without using
422 subseg_new, so it is possible that seg_info is NULL. */
423 info = seg_info (section);
424 if (info != (segment_info_type *) NULL)
425 info->frchainP->frch_last
426 = chain_frchains_together_1 (section, info->frchainP);
428 /* Now that we've chained the frags together, we must add new fixups
429 to the segment, not to the frag chain. */
430 frags_chained = 1;
433 static void
434 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
436 switch (fragP->fr_type)
438 case rs_align:
439 case rs_align_code:
440 case rs_align_test:
441 case rs_org:
442 case rs_space:
443 #ifdef HANDLE_ALIGN
444 HANDLE_ALIGN (fragP);
445 #endif
446 know (fragP->fr_next != NULL);
447 fragP->fr_offset = (fragP->fr_next->fr_address
448 - fragP->fr_address
449 - fragP->fr_fix) / fragP->fr_var;
450 if (fragP->fr_offset < 0)
452 as_bad_where (fragP->fr_file, fragP->fr_line,
453 _("attempt to .org/.space backwards? (%ld)"),
454 (long) fragP->fr_offset);
455 fragP->fr_offset = 0;
457 fragP->fr_type = rs_fill;
458 break;
460 case rs_fill:
461 break;
463 case rs_leb128:
465 valueT value = S_GET_VALUE (fragP->fr_symbol);
466 int size;
468 if (!S_IS_DEFINED (fragP->fr_symbol))
470 as_bad_where (fragP->fr_file, fragP->fr_line,
471 _("leb128 operand is an undefined symbol: %s"),
472 S_GET_NAME (fragP->fr_symbol));
475 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
476 fragP->fr_subtype);
478 fragP->fr_fix += size;
479 fragP->fr_type = rs_fill;
480 fragP->fr_var = 0;
481 fragP->fr_offset = 0;
482 fragP->fr_symbol = NULL;
484 break;
486 case rs_cfa:
487 eh_frame_convert_frag (fragP);
488 break;
490 case rs_dwarf2dbg:
491 dwarf2dbg_convert_frag (fragP);
492 break;
494 case rs_machine_dependent:
495 md_convert_frag (stdoutput, sec, fragP);
497 gas_assert (fragP->fr_next == NULL
498 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
499 == fragP->fr_fix));
501 /* After md_convert_frag, we make the frag into a ".space 0".
502 md_convert_frag() should set up any fixSs and constants
503 required. */
504 frag_wane (fragP);
505 break;
507 #ifndef WORKING_DOT_WORD
508 case rs_broken_word:
510 struct broken_word *lie;
512 if (fragP->fr_subtype)
514 fragP->fr_fix += md_short_jump_size;
515 for (lie = (struct broken_word *) (fragP->fr_symbol);
516 lie && lie->dispfrag == fragP;
517 lie = lie->next_broken_word)
518 if (lie->added == 1)
519 fragP->fr_fix += md_long_jump_size;
521 frag_wane (fragP);
523 break;
524 #endif
526 default:
527 BAD_CASE (fragP->fr_type);
528 break;
530 #ifdef md_frag_check
531 md_frag_check (fragP);
532 #endif
535 struct relax_seg_info
537 int pass;
538 int changed;
541 static void
542 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
544 segment_info_type *seginfo = seg_info (sec);
545 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
547 if (seginfo && seginfo->frchainP
548 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
549 info->changed = 1;
552 static void
553 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
555 flagword flags;
556 fragS *fragp;
557 segment_info_type *seginfo;
558 int x;
559 valueT size, newsize;
561 subseg_change (sec, 0);
563 seginfo = seg_info (sec);
564 if (seginfo && seginfo->frchainP)
566 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
567 cvt_frag_to_fill (sec, fragp);
568 for (fragp = seginfo->frchainP->frch_root;
569 fragp->fr_next;
570 fragp = fragp->fr_next)
571 /* Walk to last elt. */
573 size = fragp->fr_address + fragp->fr_fix;
575 else
576 size = 0;
578 flags = bfd_get_section_flags (abfd, sec);
579 if (size == 0 && bfd_get_section_size (sec) != 0 &&
580 (flags & SEC_HAS_CONTENTS) != 0)
581 return;
583 if (size > 0 && ! seginfo->bss)
584 flags |= SEC_HAS_CONTENTS;
586 flags &= ~SEC_RELOC;
587 x = bfd_set_section_flags (abfd, sec, flags);
588 gas_assert (x);
590 /* If permitted, allow the backend to pad out the section
591 to some alignment boundary. */
592 if (do_not_pad_sections_to_alignment)
593 newsize = size;
594 else
595 newsize = md_section_align (sec, size);
596 x = bfd_set_section_size (abfd, sec, newsize);
597 gas_assert (x);
599 /* If the size had to be rounded up, add some padding in the last
600 non-empty frag. */
601 gas_assert (newsize >= size);
602 if (size != newsize)
604 fragS *last = seginfo->frchainP->frch_last;
605 fragp = seginfo->frchainP->frch_root;
606 while (fragp->fr_next != last)
607 fragp = fragp->fr_next;
608 last->fr_address = size;
609 if ((newsize - size) % fragp->fr_var == 0)
610 fragp->fr_offset += (newsize - size) / fragp->fr_var;
611 else
612 /* If we hit this abort, it's likely due to subsegs_finish not
613 providing sufficient alignment on the last frag, and the
614 machine dependent code using alignment frags with fr_var
615 greater than 1. */
616 abort ();
619 #ifdef tc_frob_section
620 tc_frob_section (sec);
621 #endif
622 #ifdef obj_frob_section
623 obj_frob_section (sec);
624 #endif
627 #ifdef DEBUG2
628 static void
629 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
631 segment_info_type *seginfo = seg_info (sec);
632 fixS *fixp = seginfo->fix_root;
634 if (!fixp)
635 return;
637 fprintf (stream, "sec %s relocs:\n", sec->name);
638 while (fixp)
640 symbolS *s = fixp->fx_addsy;
642 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
643 (int) fixp->fx_r_type);
644 if (s == NULL)
645 fprintf (stream, "no sym\n");
646 else
648 print_symbol_value_1 (stream, s);
649 fprintf (stream, "\n");
651 fixp = fixp->fx_next;
654 #else
655 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
656 #endif
658 #ifndef EMIT_SECTION_SYMBOLS
659 #define EMIT_SECTION_SYMBOLS 1
660 #endif
662 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
663 and check for validity. Convert RELOC_LIST from using U.A fields
664 to U.B fields. */
665 static void
666 resolve_reloc_expr_symbols (void)
668 bfd_vma addr_mask = 1;
669 struct reloc_list *r;
671 /* Avoid a shift by the width of type. */
672 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
673 addr_mask <<= 1;
674 addr_mask -= 1;
676 for (r = reloc_list; r; r = r->next)
678 reloc_howto_type *howto = r->u.a.howto;
679 expressionS *symval;
680 symbolS *sym;
681 bfd_vma offset, addend;
682 asection *sec;
684 resolve_symbol_value (r->u.a.offset_sym);
685 symval = symbol_get_value_expression (r->u.a.offset_sym);
687 offset = 0;
688 sym = NULL;
689 if (symval->X_op == O_constant)
690 sym = r->u.a.offset_sym;
691 else if (symval->X_op == O_symbol)
693 sym = symval->X_add_symbol;
694 offset = symval->X_add_number;
695 symval = symbol_get_value_expression (symval->X_add_symbol);
697 if (sym == NULL
698 || symval->X_op != O_constant
699 || (sec = S_GET_SEGMENT (sym)) == NULL
700 || !SEG_NORMAL (sec))
702 as_bad_where (r->file, r->line, _("invalid offset expression"));
703 sec = NULL;
705 else
706 offset += S_GET_VALUE (sym);
708 sym = NULL;
709 addend = r->u.a.addend;
710 if (r->u.a.sym != NULL)
712 resolve_symbol_value (r->u.a.sym);
713 symval = symbol_get_value_expression (r->u.a.sym);
714 if (symval->X_op == O_constant)
715 sym = r->u.a.sym;
716 else if (symval->X_op == O_symbol)
718 sym = symval->X_add_symbol;
719 addend += symval->X_add_number;
720 symval = symbol_get_value_expression (symval->X_add_symbol);
722 if (symval->X_op != O_constant)
724 as_bad_where (r->file, r->line, _("invalid reloc expression"));
725 sec = NULL;
727 else if (sym != NULL && sec != NULL)
729 /* Convert relocs against local symbols to refer to the
730 corresponding section symbol plus offset instead. Keep
731 PC-relative relocs of the REL variety intact though to
732 prevent the offset from overflowing the relocated field,
733 unless it has enough bits to cover the whole address
734 space. */
735 if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
736 && (sec->use_rela_p
737 || (howto->partial_inplace
738 && (!howto->pc_relative
739 || howto->src_mask == addr_mask))))
741 asection *symsec = S_GET_SEGMENT (sym);
742 if (!(((symsec->flags & SEC_MERGE) != 0
743 && addend != 0)
744 || (symsec->flags & SEC_THREAD_LOCAL) != 0))
746 addend += S_GET_VALUE (sym);
747 sym = section_symbol (symsec);
750 symbol_mark_used_in_reloc (sym);
753 if (sym == NULL)
755 if (abs_section_sym == NULL)
756 abs_section_sym = section_symbol (absolute_section);
757 sym = abs_section_sym;
760 r->u.b.sec = sec;
761 r->u.b.s = symbol_get_bfdsym (sym);
762 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
763 r->u.b.r.address = offset;
764 r->u.b.r.addend = addend;
765 r->u.b.r.howto = howto;
769 /* This pass over fixups decides whether symbols can be replaced with
770 section symbols. */
772 static void
773 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
774 asection *sec,
775 void *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 or common symbol,
811 convert the fixup to being against that symbol. */
812 while (symbol_equated_reloc_p (sym)
813 || S_IS_WEAKREFR (sym))
815 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
816 if (sym == newsym)
817 break;
818 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
819 fixp->fx_addsy = newsym;
820 sym = newsym;
823 if (symbol_mri_common_p (sym))
825 fixp->fx_offset += S_GET_VALUE (sym);
826 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
827 continue;
830 /* If the symbol is undefined, common, weak, or global (ELF
831 shared libs), we can't replace it with the section symbol. */
832 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
833 continue;
835 /* Is there some other (target cpu dependent) reason we can't adjust
836 this one? (E.g. relocations involving function addresses on
837 the PA. */
838 #ifdef tc_fix_adjustable
839 if (! tc_fix_adjustable (fixp))
840 continue;
841 #endif
843 /* Since we're reducing to section symbols, don't attempt to reduce
844 anything that's already using one. */
845 if (symbol_section_p (sym))
846 continue;
848 symsec = S_GET_SEGMENT (sym);
849 if (symsec == NULL)
850 abort ();
852 if (bfd_is_abs_section (symsec)
853 || symsec == reg_section)
855 /* The fixup_segment routine normally will not use this
856 symbol in a relocation. */
857 continue;
860 /* Don't try to reduce relocs which refer to non-local symbols
861 in .linkonce sections. It can lead to confusion when a
862 debugging section refers to a .linkonce section. I hope
863 this will always be correct. */
864 if (symsec != sec && ! S_IS_LOCAL (sym))
866 if ((symsec->flags & SEC_LINK_ONCE) != 0
867 || (IS_ELF
868 /* The GNU toolchain uses an extension for ELF: a
869 section beginning with the magic string
870 .gnu.linkonce is a linkonce section. */
871 && strncmp (segment_name (symsec), ".gnu.linkonce",
872 sizeof ".gnu.linkonce" - 1) == 0))
873 continue;
876 /* Never adjust a reloc against local symbol in a merge section
877 with non-zero addend. */
878 if ((symsec->flags & SEC_MERGE) != 0
879 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
880 continue;
882 /* Never adjust a reloc against TLS local symbol. */
883 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
884 continue;
886 /* We refetch the segment when calling section_symbol, rather
887 than using symsec, because S_GET_VALUE may wind up changing
888 the section when it calls resolve_symbol_value. */
889 fixp->fx_offset += S_GET_VALUE (sym);
890 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
891 #ifdef DEBUG5
892 fprintf (stderr, "\nadjusted fixup:\n");
893 print_fixup (fixp);
894 #endif
897 dump_section_relocs (abfd, sec, stderr);
900 /* fixup_segment()
902 Go through all the fixS's in a segment and see which ones can be
903 handled now. (These consist of fixS where we have since discovered
904 the value of a symbol, or the address of the frag involved.)
905 For each one, call md_apply_fix to put the fix into the frag data.
906 Ones that we couldn't completely handle here will be output later
907 by emit_relocations. */
909 static void
910 fixup_segment (fixS *fixP, segT this_segment)
912 valueT add_number;
913 fragS *fragP;
914 segT add_symbol_segment = absolute_section;
916 if (fixP != NULL && abs_section_sym == NULL)
917 abs_section_sym = section_symbol (absolute_section);
919 /* If the linker is doing the relaxing, we must not do any fixups.
921 Well, strictly speaking that's not true -- we could do any that
922 are PC-relative and don't cross regions that could change size.
923 And for the i960 we might be able to turn callx/callj into bal
924 anyways in cases where we know the maximum displacement. */
925 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
927 for (; fixP; fixP = fixP->fx_next)
928 if (!fixP->fx_done)
930 if (fixP->fx_addsy == NULL)
932 /* There was no symbol required by this relocation.
933 However, BFD doesn't really handle relocations
934 without symbols well. So fake up a local symbol in
935 the absolute section. */
936 fixP->fx_addsy = abs_section_sym;
938 symbol_mark_used_in_reloc (fixP->fx_addsy);
939 if (fixP->fx_subsy != NULL)
940 symbol_mark_used_in_reloc (fixP->fx_subsy);
942 return;
945 for (; fixP; fixP = fixP->fx_next)
947 #ifdef DEBUG5
948 fprintf (stderr, "\nprocessing fixup:\n");
949 print_fixup (fixP);
950 #endif
952 fragP = fixP->fx_frag;
953 know (fragP);
954 #ifdef TC_VALIDATE_FIX
955 TC_VALIDATE_FIX (fixP, this_segment, skip);
956 #endif
957 add_number = fixP->fx_offset;
959 if (fixP->fx_addsy != NULL)
960 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
962 if (fixP->fx_subsy != NULL)
964 segT sub_symbol_segment;
965 resolve_symbol_value (fixP->fx_subsy);
966 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
967 if (fixP->fx_addsy != NULL
968 && sub_symbol_segment == add_symbol_segment
969 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
970 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
971 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
973 add_number += S_GET_VALUE (fixP->fx_addsy);
974 add_number -= S_GET_VALUE (fixP->fx_subsy);
975 fixP->fx_offset = add_number;
976 fixP->fx_addsy = NULL;
977 fixP->fx_subsy = NULL;
978 #ifdef TC_M68K
979 /* See the comment below about 68k weirdness. */
980 fixP->fx_pcrel = 0;
981 #endif
983 else if (sub_symbol_segment == absolute_section
984 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
985 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
987 add_number -= S_GET_VALUE (fixP->fx_subsy);
988 fixP->fx_offset = add_number;
989 fixP->fx_subsy = NULL;
991 else if (sub_symbol_segment == this_segment
992 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
993 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
995 add_number -= S_GET_VALUE (fixP->fx_subsy);
996 fixP->fx_offset = (add_number + fixP->fx_dot_value
997 + fixP->fx_dot_frag->fr_address);
999 /* Make it pc-relative. If the back-end code has not
1000 selected a pc-relative reloc, cancel the adjustment
1001 we do later on all pc-relative relocs. */
1002 if (0
1003 #ifdef TC_M68K
1004 /* Do this for m68k even if it's already described
1005 as pc-relative. On the m68k, an operand of
1006 "pc@(foo-.-2)" should address "foo" in a
1007 pc-relative mode. */
1008 || 1
1009 #endif
1010 || !fixP->fx_pcrel)
1011 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1012 fixP->fx_subsy = NULL;
1013 fixP->fx_pcrel = 1;
1015 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1017 if (!md_register_arithmetic
1018 && (add_symbol_segment == reg_section
1019 || sub_symbol_segment == reg_section))
1020 as_bad_where (fixP->fx_file, fixP->fx_line,
1021 _("register value used as expression"));
1022 else
1023 as_bad_where (fixP->fx_file, fixP->fx_line,
1024 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1025 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1026 segment_name (add_symbol_segment),
1027 S_GET_NAME (fixP->fx_subsy),
1028 segment_name (sub_symbol_segment));
1030 else if (sub_symbol_segment != undefined_section
1031 && ! bfd_is_com_section (sub_symbol_segment)
1032 && MD_APPLY_SYM_VALUE (fixP))
1033 add_number -= S_GET_VALUE (fixP->fx_subsy);
1036 if (fixP->fx_addsy)
1038 if (add_symbol_segment == this_segment
1039 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1040 && !TC_FORCE_RELOCATION_LOCAL (fixP))
1042 /* This fixup was made when the symbol's segment was
1043 SEG_UNKNOWN, but it is now in the local segment.
1044 So we know how to do the address without relocation. */
1045 add_number += S_GET_VALUE (fixP->fx_addsy);
1046 fixP->fx_offset = add_number;
1047 if (fixP->fx_pcrel)
1048 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1049 fixP->fx_addsy = NULL;
1050 fixP->fx_pcrel = 0;
1052 else if (add_symbol_segment == absolute_section
1053 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1054 && !TC_FORCE_RELOCATION_ABS (fixP))
1056 add_number += S_GET_VALUE (fixP->fx_addsy);
1057 fixP->fx_offset = add_number;
1058 fixP->fx_addsy = NULL;
1060 else if (add_symbol_segment != undefined_section
1061 && ! bfd_is_com_section (add_symbol_segment)
1062 && MD_APPLY_SYM_VALUE (fixP))
1063 add_number += S_GET_VALUE (fixP->fx_addsy);
1066 if (fixP->fx_pcrel)
1068 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1069 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1071 /* There was no symbol required by this relocation.
1072 However, BFD doesn't really handle relocations
1073 without symbols well. So fake up a local symbol in
1074 the absolute section. */
1075 fixP->fx_addsy = abs_section_sym;
1079 if (!fixP->fx_done)
1080 md_apply_fix (fixP, &add_number, this_segment);
1082 if (!fixP->fx_done)
1084 if (fixP->fx_addsy == NULL)
1085 fixP->fx_addsy = abs_section_sym;
1086 symbol_mark_used_in_reloc (fixP->fx_addsy);
1087 if (fixP->fx_subsy != NULL)
1088 symbol_mark_used_in_reloc (fixP->fx_subsy);
1091 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1093 if (fixP->fx_size < sizeof (valueT))
1095 valueT mask;
1097 mask = 0;
1098 mask--; /* Set all bits to one. */
1099 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1100 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1102 char buf[50], buf2[50];
1103 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1104 if (add_number > 1000)
1105 sprint_value (buf2, add_number);
1106 else
1107 sprintf (buf2, "%ld", (long) add_number);
1108 as_bad_where (fixP->fx_file, fixP->fx_line,
1109 _("value of %s too large for field of %d bytes at %s"),
1110 buf2, fixP->fx_size, buf);
1111 } /* Generic error checking. */
1113 #ifdef WARN_SIGNED_OVERFLOW_WORD
1114 /* Warn if a .word value is too large when treated as a signed
1115 number. We already know it is not too negative. This is to
1116 catch over-large switches generated by gcc on the 68k. */
1117 if (!flag_signed_overflow_ok
1118 && fixP->fx_size == 2
1119 && add_number > 0x7fff)
1120 as_bad_where (fixP->fx_file, fixP->fx_line,
1121 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1122 (long) add_number,
1123 (long) (fragP->fr_address + fixP->fx_where));
1124 #endif
1125 } /* Not a bit fix. */
1127 #ifdef TC_VALIDATE_FIX
1128 skip: ATTRIBUTE_UNUSED_LABEL
1130 #endif
1131 #ifdef DEBUG5
1132 fprintf (stderr, "result:\n");
1133 print_fixup (fixP);
1134 #endif
1135 } /* For each fixS in this segment. */
1138 static void
1139 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1140 asection *sec,
1141 void *xxx ATTRIBUTE_UNUSED)
1143 segment_info_type *seginfo = seg_info (sec);
1145 fixup_segment (seginfo->fix_root, sec);
1148 static void
1149 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1150 const char *file, unsigned int line)
1152 char *err;
1153 bfd_reloc_status_type s;
1154 asymbol *sym;
1156 if (reloc->sym_ptr_ptr != NULL
1157 && (sym = *reloc->sym_ptr_ptr) != NULL
1158 && (sym->flags & BSF_KEEP) == 0
1159 && ((sym->flags & BSF_SECTION_SYM) == 0
1160 || (EMIT_SECTION_SYMBOLS
1161 && !bfd_is_abs_section (sym->section))))
1162 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1164 s = bfd_install_relocation (stdoutput, reloc,
1165 fragp->fr_literal, fragp->fr_address,
1166 sec, &err);
1167 switch (s)
1169 case bfd_reloc_ok:
1170 break;
1171 case bfd_reloc_overflow:
1172 as_bad_where (file, line, _("relocation overflow"));
1173 break;
1174 case bfd_reloc_outofrange:
1175 as_bad_where (file, line, _("relocation out of range"));
1176 break;
1177 default:
1178 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1179 file, line, s);
1183 static fragS *
1184 get_frag_for_reloc (fragS *last_frag,
1185 const segment_info_type *seginfo,
1186 const struct reloc_list *r)
1188 fragS *f;
1190 for (f = last_frag; f != NULL; f = f->fr_next)
1191 if (f->fr_address <= r->u.b.r.address
1192 && r->u.b.r.address < f->fr_address + f->fr_fix)
1193 return f;
1195 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1196 if (f->fr_address <= r->u.b.r.address
1197 && r->u.b.r.address < f->fr_address + f->fr_fix)
1198 return f;
1200 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1201 if (f->fr_address <= r->u.b.r.address
1202 && r->u.b.r.address <= f->fr_address + f->fr_fix)
1203 return f;
1205 as_bad_where (r->file, r->line,
1206 _("reloc not within (fixed part of) section"));
1207 return NULL;
1210 static void
1211 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1213 segment_info_type *seginfo = seg_info (sec);
1214 unsigned int n;
1215 struct reloc_list *my_reloc_list, **rp, *r;
1216 arelent **relocs;
1217 fixS *fixp;
1218 fragS *last_frag;
1220 /* If seginfo is NULL, we did not create this section; don't do
1221 anything with it. */
1222 if (seginfo == NULL)
1223 return;
1225 n = 0;
1226 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1227 if (!fixp->fx_done)
1228 n++;
1230 #ifdef RELOC_EXPANSION_POSSIBLE
1231 n *= MAX_RELOC_EXPANSION;
1232 #endif
1234 /* Extract relocs for this section from reloc_list. */
1235 rp = &reloc_list;
1236 my_reloc_list = NULL;
1237 while ((r = *rp) != NULL)
1239 if (r->u.b.sec == sec)
1241 *rp = r->next;
1242 r->next = my_reloc_list;
1243 my_reloc_list = r;
1244 n++;
1246 else
1247 rp = &r->next;
1250 relocs = XCNEWVEC (arelent *, n);
1252 n = 0;
1253 r = my_reloc_list;
1254 last_frag = NULL;
1255 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1257 int fx_size, slack;
1258 offsetT loc;
1259 arelent **reloc;
1260 #ifndef RELOC_EXPANSION_POSSIBLE
1261 arelent *rel;
1263 reloc = &rel;
1264 #endif
1266 if (fixp->fx_done)
1267 continue;
1269 fx_size = fixp->fx_size;
1270 slack = TC_FX_SIZE_SLACK (fixp);
1271 if (slack > 0)
1272 fx_size = fx_size > slack ? fx_size - slack : 0;
1273 loc = fixp->fx_where + fx_size;
1274 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1275 as_bad_where (fixp->fx_file, fixp->fx_line,
1276 _("internal error: fixup not contained within frag"));
1278 #ifndef RELOC_EXPANSION_POSSIBLE
1279 *reloc = tc_gen_reloc (sec, fixp);
1280 #else
1281 reloc = tc_gen_reloc (sec, fixp);
1282 #endif
1284 while (*reloc)
1286 while (r != NULL && r->u.b.r.address < (*reloc)->address)
1288 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1289 if (f != NULL)
1291 last_frag = f;
1292 relocs[n++] = &r->u.b.r;
1293 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1295 r = r->next;
1297 relocs[n++] = *reloc;
1298 install_reloc (sec, *reloc, fixp->fx_frag,
1299 fixp->fx_file, fixp->fx_line);
1300 #ifndef RELOC_EXPANSION_POSSIBLE
1301 break;
1302 #else
1303 reloc++;
1304 #endif
1308 while (r != NULL)
1310 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1311 if (f != NULL)
1313 last_frag = f;
1314 relocs[n++] = &r->u.b.r;
1315 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1317 r = r->next;
1320 #ifdef DEBUG4
1322 unsigned int k, j, nsyms;
1323 asymbol **sympp;
1324 sympp = bfd_get_outsymbols (stdoutput);
1325 nsyms = bfd_get_symcount (stdoutput);
1326 for (k = 0; k < n; k++)
1327 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1329 for (j = 0; j < nsyms; j++)
1330 if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1331 break;
1332 if (j == nsyms)
1333 abort ();
1336 #endif
1338 if (n)
1340 flagword flags = bfd_get_section_flags (abfd, sec);
1341 flags |= SEC_RELOC;
1342 bfd_set_section_flags (abfd, sec, flags);
1343 bfd_set_reloc (stdoutput, sec, relocs, n);
1346 #ifdef SET_SECTION_RELOCS
1347 SET_SECTION_RELOCS (sec, relocs, n);
1348 #endif
1350 #ifdef DEBUG3
1352 unsigned int k;
1354 fprintf (stderr, "relocs for sec %s\n", sec->name);
1355 for (k = 0; k < n; k++)
1357 arelent *rel = relocs[k];
1358 asymbol *s = *rel->sym_ptr_ptr;
1359 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1360 k, rel, (unsigned long)rel->address, s->name,
1361 (unsigned long)rel->addend);
1364 #endif
1367 static int
1368 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1369 fragS **last_newf, struct obstack *ob)
1371 int out_size;
1372 int total_out_size = 0;
1373 fragS *f = *last_newf;
1374 char *next_out;
1375 int avail_out;
1377 /* Call the compression routine repeatedly until it has finished
1378 processing the frag. */
1379 while (in_size > 0)
1381 /* Reserve all the space available in the current chunk.
1382 If none is available, start a new frag. */
1383 avail_out = obstack_room (ob);
1384 if (avail_out <= 0)
1386 obstack_finish (ob);
1387 f = frag_alloc (ob);
1388 f->fr_type = rs_fill;
1389 (*last_newf)->fr_next = f;
1390 *last_newf = f;
1391 avail_out = obstack_room (ob);
1393 if (avail_out <= 0)
1394 as_fatal (_("can't extend frag"));
1395 next_out = obstack_next_free (ob);
1396 obstack_blank_fast (ob, avail_out);
1397 out_size = compress_data (strm, &contents, &in_size,
1398 &next_out, &avail_out);
1399 if (out_size < 0)
1400 return -1;
1402 f->fr_fix += out_size;
1403 total_out_size += out_size;
1405 /* Return unused space. */
1406 if (avail_out > 0)
1407 obstack_blank_fast (ob, -avail_out);
1410 return total_out_size;
1413 static void
1414 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1416 segment_info_type *seginfo = seg_info (sec);
1417 fragS *f;
1418 fragS *first_newf;
1419 fragS *last_newf;
1420 struct obstack *ob = &seginfo->frchainP->frch_obstack;
1421 bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1422 bfd_size_type compressed_size;
1423 const char *section_name;
1424 char *compressed_name;
1425 char *header;
1426 struct z_stream_s *strm;
1427 int x;
1428 flagword flags = bfd_get_section_flags (abfd, sec);
1429 unsigned int header_size, compression_header_size;
1431 if (seginfo == NULL
1432 || sec->size < 32
1433 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1434 return;
1436 section_name = bfd_get_section_name (stdoutput, sec);
1437 if (strncmp (section_name, ".debug_", 7) != 0)
1438 return;
1440 strm = compress_init ();
1441 if (strm == NULL)
1442 return;
1444 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
1446 compression_header_size
1447 = bfd_get_compression_header_size (stdoutput, NULL);
1448 header_size = compression_header_size;
1450 else
1452 compression_header_size = 0;
1453 header_size = 12;
1456 /* Create a new frag to contain the compression header. */
1457 first_newf = frag_alloc (ob);
1458 if (obstack_room (ob) < header_size)
1459 first_newf = frag_alloc (ob);
1460 if (obstack_room (ob) < header_size)
1461 as_fatal (_("can't extend frag %u chars"), header_size);
1462 last_newf = first_newf;
1463 obstack_blank_fast (ob, header_size);
1464 last_newf->fr_type = rs_fill;
1465 last_newf->fr_fix = header_size;
1466 header = last_newf->fr_literal;
1467 compressed_size = header_size;
1469 /* Stream the frags through the compression engine, adding new frags
1470 as necessary to accommodate the compressed output. */
1471 for (f = seginfo->frchainP->frch_root;
1473 f = f->fr_next)
1475 offsetT fill_size;
1476 char *fill_literal;
1477 offsetT count;
1478 int out_size;
1480 gas_assert (f->fr_type == rs_fill);
1481 if (f->fr_fix)
1483 out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1484 &last_newf, ob);
1485 if (out_size < 0)
1486 return;
1487 compressed_size += out_size;
1489 fill_literal = f->fr_literal + f->fr_fix;
1490 fill_size = f->fr_var;
1491 count = f->fr_offset;
1492 gas_assert (count >= 0);
1493 if (fill_size && count)
1495 while (count--)
1497 out_size = compress_frag (strm, fill_literal, (int) fill_size,
1498 &last_newf, ob);
1499 if (out_size < 0)
1500 return;
1501 compressed_size += out_size;
1506 /* Flush the compression state. */
1507 for (;;)
1509 int avail_out;
1510 char *next_out;
1511 int out_size;
1513 /* Reserve all the space available in the current chunk.
1514 If none is available, start a new frag. */
1515 avail_out = obstack_room (ob);
1516 if (avail_out <= 0)
1518 fragS *newf;
1520 obstack_finish (ob);
1521 newf = frag_alloc (ob);
1522 newf->fr_type = rs_fill;
1523 last_newf->fr_next = newf;
1524 last_newf = newf;
1525 avail_out = obstack_room (ob);
1527 if (avail_out <= 0)
1528 as_fatal (_("can't extend frag"));
1529 next_out = obstack_next_free (ob);
1530 obstack_blank_fast (ob, avail_out);
1531 x = compress_finish (strm, &next_out, &avail_out, &out_size);
1532 if (x < 0)
1533 return;
1535 last_newf->fr_fix += out_size;
1536 compressed_size += out_size;
1538 /* Return unused space. */
1539 if (avail_out > 0)
1540 obstack_blank_fast (ob, -avail_out);
1542 if (x == 0)
1543 break;
1546 /* PR binutils/18087: If compression didn't make the section smaller,
1547 just keep it uncompressed. */
1548 if (compressed_size >= uncompressed_size)
1549 return;
1551 /* Replace the uncompressed frag list with the compressed frag list. */
1552 seginfo->frchainP->frch_root = first_newf;
1553 seginfo->frchainP->frch_last = last_newf;
1555 /* Update the section size and its name. */
1556 bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
1557 x = bfd_set_section_size (abfd, sec, compressed_size);
1558 gas_assert (x);
1559 if (!compression_header_size)
1561 compressed_name = concat (".z", section_name + 1, (char *) NULL);
1562 bfd_section_name (stdoutput, sec) = compressed_name;
1566 static void
1567 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1568 asection *sec,
1569 void *xxx ATTRIBUTE_UNUSED)
1571 segment_info_type *seginfo = seg_info (sec);
1572 addressT offset = 0;
1573 fragS *f;
1575 /* Write out the frags. */
1576 if (seginfo == NULL
1577 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1578 return;
1580 for (f = seginfo->frchainP->frch_root;
1582 f = f->fr_next)
1584 int x;
1585 addressT fill_size;
1586 char *fill_literal;
1587 offsetT count;
1589 gas_assert (f->fr_type == rs_fill);
1590 if (f->fr_fix)
1592 x = bfd_set_section_contents (stdoutput, sec,
1593 f->fr_literal, (file_ptr) offset,
1594 (bfd_size_type) f->fr_fix);
1595 if (!x)
1596 as_fatal (_("can't write %ld bytes to section %s of %s because: '%s'"),
1597 (long) f->fr_fix, sec->name,
1598 stdoutput->filename,
1599 bfd_errmsg (bfd_get_error ()));
1600 offset += f->fr_fix;
1602 fill_literal = f->fr_literal + f->fr_fix;
1603 fill_size = f->fr_var;
1604 count = f->fr_offset;
1605 gas_assert (count >= 0);
1606 if (fill_size && count)
1608 char buf[256];
1609 if (fill_size > sizeof (buf))
1611 /* Do it the old way. Can this ever happen? */
1612 while (count--)
1614 x = bfd_set_section_contents (stdoutput, sec,
1615 fill_literal,
1616 (file_ptr) offset,
1617 (bfd_size_type) fill_size);
1618 if (!x)
1619 as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
1620 (long) fill_size, sec->name,
1621 stdoutput->filename,
1622 bfd_errmsg (bfd_get_error ()));
1623 offset += fill_size;
1626 else
1628 /* Build a buffer full of fill objects and output it as
1629 often as necessary. This saves on the overhead of
1630 potentially lots of bfd_set_section_contents calls. */
1631 int n_per_buf, i;
1632 if (fill_size == 1)
1634 n_per_buf = sizeof (buf);
1635 memset (buf, *fill_literal, n_per_buf);
1637 else
1639 char *bufp;
1640 n_per_buf = sizeof (buf) / fill_size;
1641 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1642 memcpy (bufp, fill_literal, fill_size);
1644 for (; count > 0; count -= n_per_buf)
1646 n_per_buf = n_per_buf > count ? count : n_per_buf;
1647 x = bfd_set_section_contents
1648 (stdoutput, sec, buf, (file_ptr) offset,
1649 (bfd_size_type) n_per_buf * fill_size);
1650 if (!x)
1651 as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
1652 (long)(n_per_buf * fill_size), sec->name,
1653 stdoutput->filename,
1654 bfd_errmsg (bfd_get_error ()));
1655 offset += n_per_buf * fill_size;
1662 static void
1663 merge_data_into_text (void)
1665 seg_info (text_section)->frchainP->frch_last->fr_next =
1666 seg_info (data_section)->frchainP->frch_root;
1667 seg_info (text_section)->frchainP->frch_last =
1668 seg_info (data_section)->frchainP->frch_last;
1669 seg_info (data_section)->frchainP = 0;
1672 static void
1673 set_symtab (void)
1675 int nsyms;
1676 asymbol **asympp;
1677 symbolS *symp;
1678 bfd_boolean result;
1680 /* Count symbols. We can't rely on a count made by the loop in
1681 write_object_file, because *_frob_file may add a new symbol or
1682 two. */
1683 nsyms = 0;
1684 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1685 nsyms++;
1687 if (nsyms)
1689 int i;
1690 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1692 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1693 symp = symbol_rootP;
1694 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1696 asympp[i] = symbol_get_bfdsym (symp);
1697 if (asympp[i]->flags != BSF_SECTION_SYM
1698 || !(bfd_is_const_section (asympp[i]->section)
1699 && asympp[i]->section->symbol == asympp[i]))
1700 asympp[i]->flags |= BSF_KEEP;
1701 symbol_mark_written (symp);
1704 else
1705 asympp = 0;
1706 result = bfd_set_symtab (stdoutput, asympp, nsyms);
1707 gas_assert (result);
1708 symbol_table_frozen = 1;
1711 /* Finish the subsegments. After every sub-segment, we fake an
1712 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
1713 ".fill 0" because that is the kind of frag that requires least
1714 thought. ".align" frags like to have a following frag since that
1715 makes calculating their intended length trivial. */
1717 #ifndef SUB_SEGMENT_ALIGN
1718 #ifdef HANDLE_ALIGN
1719 /* The last subsegment gets an alignment corresponding to the alignment
1720 of the section. This allows proper nop-filling at the end of
1721 code-bearing sections. */
1722 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1723 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
1724 && !do_not_pad_sections_to_alignment \
1725 ? get_recorded_alignment (SEG) \
1726 : 0)
1727 #else
1728 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1729 #endif
1730 #endif
1732 static void
1733 subsegs_finish_section (asection *s)
1735 struct frchain *frchainP;
1736 segment_info_type *seginfo = seg_info (s);
1737 if (!seginfo)
1738 return;
1740 for (frchainP = seginfo->frchainP;
1741 frchainP != NULL;
1742 frchainP = frchainP->frch_next)
1744 int alignment;
1746 subseg_set (s, frchainP->frch_subseg);
1748 /* This now gets called even if we had errors. In that case,
1749 any alignment is meaningless, and, moreover, will look weird
1750 if we are generating a listing. */
1751 if (had_errors ())
1752 do_not_pad_sections_to_alignment = 1;
1754 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1755 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1756 && now_seg->entsize)
1758 unsigned int entsize = now_seg->entsize;
1759 int entalign = 0;
1761 while ((entsize & 1) == 0)
1763 ++entalign;
1764 entsize >>= 1;
1767 if (entalign > alignment)
1768 alignment = entalign;
1771 if (subseg_text_p (now_seg))
1772 frag_align_code (alignment, 0);
1773 else
1774 frag_align (alignment, 0, 0);
1776 /* frag_align will have left a new frag.
1777 Use this last frag for an empty ".fill".
1779 For this segment ...
1780 Create a last frag. Do not leave a "being filled in frag". */
1781 frag_wane (frag_now);
1782 frag_now->fr_fix = 0;
1783 know (frag_now->fr_next == NULL);
1787 static void
1788 subsegs_finish (void)
1790 asection *s;
1792 for (s = stdoutput->sections; s; s = s->next)
1793 subsegs_finish_section (s);
1796 #ifdef OBJ_ELF
1797 static void
1798 create_obj_attrs_section (void)
1800 segT s;
1801 char *p;
1802 offsetT size;
1803 const char *name;
1805 size = bfd_elf_obj_attr_size (stdoutput);
1806 if (size)
1808 name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1809 if (!name)
1810 name = ".gnu.attributes";
1811 s = subseg_new (name, 0);
1812 elf_section_type (s)
1813 = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1814 bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1815 frag_now_fix ();
1816 p = frag_more (size);
1817 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1819 subsegs_finish_section (s);
1820 relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1821 size_seg (stdoutput, s, NULL);
1824 #endif
1826 /* Write the object file. */
1828 void
1829 write_object_file (void)
1831 struct relax_seg_info rsi;
1832 #ifndef WORKING_DOT_WORD
1833 fragS *fragP; /* Track along all frags. */
1834 #endif
1836 subsegs_finish ();
1838 #ifdef md_pre_output_hook
1839 md_pre_output_hook;
1840 #endif
1842 #ifdef md_pre_relax_hook
1843 md_pre_relax_hook;
1844 #endif
1846 /* From now on, we don't care about sub-segments. Build one frag chain
1847 for each segment. Linked through fr_next. */
1849 /* Remove the sections created by gas for its own purposes. */
1851 int i;
1853 bfd_section_list_remove (stdoutput, reg_section);
1854 bfd_section_list_remove (stdoutput, expr_section);
1855 stdoutput->section_count -= 2;
1856 i = 0;
1857 bfd_map_over_sections (stdoutput, renumber_sections, &i);
1860 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1862 /* We have two segments. If user gave -R flag, then we must put the
1863 data frags into the text segment. Do this before relaxing so
1864 we know to take advantage of -R and make shorter addresses. */
1865 if (flag_readonly_data_in_text)
1867 merge_data_into_text ();
1870 rsi.pass = 0;
1871 while (1)
1873 #ifndef WORKING_DOT_WORD
1874 /* We need to reset the markers in the broken word list and
1875 associated frags between calls to relax_segment (via
1876 relax_seg). Since the broken word list is global, we do it
1877 once per round, rather than locally in relax_segment for each
1878 segment. */
1879 struct broken_word *brokp;
1881 for (brokp = broken_words;
1882 brokp != (struct broken_word *) NULL;
1883 brokp = brokp->next_broken_word)
1885 brokp->added = 0;
1887 if (brokp->dispfrag != (fragS *) NULL
1888 && brokp->dispfrag->fr_type == rs_broken_word)
1889 brokp->dispfrag->fr_subtype = 0;
1891 #endif
1893 rsi.changed = 0;
1894 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1895 rsi.pass++;
1896 if (!rsi.changed)
1897 break;
1900 /* Note - Most ports will use the default value of
1901 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1902 local symbols to be resolved, removing their frag information.
1903 Some ports however, will not have finished relaxing all of
1904 their frags and will still need the local symbol frag
1905 information. These ports can set
1906 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1907 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1909 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1911 /* Relaxation has completed. Freeze all syms. */
1912 finalize_syms = 1;
1914 dwarf2dbg_final_check ();
1916 #ifdef md_post_relax_hook
1917 md_post_relax_hook;
1918 #endif
1920 #ifdef OBJ_ELF
1921 if (IS_ELF)
1922 create_obj_attrs_section ();
1923 #endif
1925 #ifndef WORKING_DOT_WORD
1927 struct broken_word *lie;
1928 struct broken_word **prevP;
1930 prevP = &broken_words;
1931 for (lie = broken_words; lie; lie = lie->next_broken_word)
1932 if (!lie->added)
1934 expressionS exp;
1936 subseg_change (lie->seg, lie->subseg);
1937 exp.X_op = O_subtract;
1938 exp.X_add_symbol = lie->add;
1939 exp.X_op_symbol = lie->sub;
1940 exp.X_add_number = lie->addnum;
1941 #ifdef TC_CONS_FIX_NEW
1942 TC_CONS_FIX_NEW (lie->frag,
1943 lie->word_goes_here - lie->frag->fr_literal,
1944 2, &exp, TC_PARSE_CONS_RETURN_NONE);
1945 #else
1946 fix_new_exp (lie->frag,
1947 lie->word_goes_here - lie->frag->fr_literal,
1948 2, &exp, 0, BFD_RELOC_16);
1949 #endif
1950 *prevP = lie->next_broken_word;
1952 else
1953 prevP = &(lie->next_broken_word);
1955 for (lie = broken_words; lie;)
1957 struct broken_word *untruth;
1958 char *table_ptr;
1959 addressT table_addr;
1960 addressT from_addr, to_addr;
1961 int n, m;
1963 subseg_change (lie->seg, lie->subseg);
1964 fragP = lie->dispfrag;
1966 /* Find out how many broken_words go here. */
1967 n = 0;
1968 for (untruth = lie;
1969 untruth && untruth->dispfrag == fragP;
1970 untruth = untruth->next_broken_word)
1971 if (untruth->added == 1)
1972 n++;
1974 table_ptr = lie->dispfrag->fr_opcode;
1975 table_addr = (lie->dispfrag->fr_address
1976 + (table_ptr - lie->dispfrag->fr_literal));
1977 /* Create the jump around the long jumps. This is a short
1978 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1979 from_addr = table_addr;
1980 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1981 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1982 lie->add);
1983 table_ptr += md_short_jump_size;
1984 table_addr += md_short_jump_size;
1986 for (m = 0;
1987 lie && lie->dispfrag == fragP;
1988 m++, lie = lie->next_broken_word)
1990 if (lie->added == 2)
1991 continue;
1992 /* Patch the jump table. */
1993 for (untruth = (struct broken_word *) (fragP->fr_symbol);
1994 untruth && untruth->dispfrag == fragP;
1995 untruth = untruth->next_broken_word)
1997 if (untruth->use_jump == lie)
1999 /* This is the offset from ??? to table_ptr+0.
2000 The target is the same for all users of this
2001 md_long_jump, but the "sub" bases (and hence the
2002 offsets) may be different. */
2003 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
2004 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2005 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
2006 #endif
2007 md_number_to_chars (untruth->word_goes_here, to_word, 2);
2011 /* Install the long jump. */
2012 /* This is a long jump from table_ptr+0 to the final target. */
2013 from_addr = table_addr;
2014 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
2015 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2016 lie->add);
2017 table_ptr += md_long_jump_size;
2018 table_addr += md_long_jump_size;
2022 #endif /* not WORKING_DOT_WORD */
2024 /* Resolve symbol values. This needs to be done before processing
2025 the relocations. */
2026 if (symbol_rootP)
2028 symbolS *symp;
2030 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2031 resolve_symbol_value (symp);
2033 resolve_local_symbol_values ();
2034 resolve_reloc_expr_symbols ();
2036 PROGRESS (1);
2038 #ifdef tc_frob_file_before_adjust
2039 tc_frob_file_before_adjust ();
2040 #endif
2041 #ifdef obj_frob_file_before_adjust
2042 obj_frob_file_before_adjust ();
2043 #endif
2045 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2047 #ifdef tc_frob_file_before_fix
2048 tc_frob_file_before_fix ();
2049 #endif
2050 #ifdef obj_frob_file_before_fix
2051 obj_frob_file_before_fix ();
2052 #endif
2054 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2056 /* Set up symbol table, and write it out. */
2057 if (symbol_rootP)
2059 symbolS *symp;
2060 bfd_boolean skip_next_symbol = FALSE;
2062 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2064 int punt = 0;
2065 const char *name;
2067 if (skip_next_symbol)
2069 /* Don't do anything besides moving the value of the
2070 symbol from the GAS value-field to the BFD value-field. */
2071 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2072 skip_next_symbol = FALSE;
2073 continue;
2076 if (symbol_mri_common_p (symp))
2078 if (S_IS_EXTERNAL (symp))
2079 as_bad (_("%s: global symbols not supported in common sections"),
2080 S_GET_NAME (symp));
2081 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2082 continue;
2085 name = S_GET_NAME (symp);
2086 if (name)
2088 const char *name2 =
2089 decode_local_label_name ((char *) S_GET_NAME (symp));
2090 /* They only differ if `name' is a fb or dollar local
2091 label name. */
2092 if (name2 != name && ! S_IS_DEFINED (symp))
2093 as_bad (_("local label `%s' is not defined"), name2);
2096 /* Do it again, because adjust_reloc_syms might introduce
2097 more symbols. They'll probably only be section symbols,
2098 but they'll still need to have the values computed. */
2099 resolve_symbol_value (symp);
2101 /* Skip symbols which were equated to undefined or common
2102 symbols. */
2103 if (symbol_equated_reloc_p (symp)
2104 || S_IS_WEAKREFR (symp))
2106 const char *sname = S_GET_NAME (symp);
2108 if (S_IS_COMMON (symp)
2109 && !TC_FAKE_LABEL (sname)
2110 && !S_IS_WEAKREFR (symp))
2112 expressionS *e = symbol_get_value_expression (symp);
2114 as_bad (_("`%s' can't be equated to common symbol `%s'"),
2115 sname, S_GET_NAME (e->X_add_symbol));
2117 if (S_GET_SEGMENT (symp) == reg_section)
2119 /* Report error only if we know the symbol name. */
2120 if (S_GET_NAME (symp) != reg_section->name)
2121 as_bad (_("can't make global register symbol `%s'"),
2122 sname);
2124 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2125 continue;
2128 #ifdef obj_frob_symbol
2129 obj_frob_symbol (symp, punt);
2130 #endif
2131 #ifdef tc_frob_symbol
2132 if (! punt || symbol_used_in_reloc_p (symp))
2133 tc_frob_symbol (symp, punt);
2134 #endif
2136 /* If we don't want to keep this symbol, splice it out of
2137 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2138 want section symbols. Otherwise, we skip local symbols
2139 and symbols that the frob_symbol macros told us to punt,
2140 but we keep such symbols if they are used in relocs. */
2141 if (symp == abs_section_sym
2142 || (! EMIT_SECTION_SYMBOLS
2143 && symbol_section_p (symp))
2144 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2145 opposites. Sometimes the former checks flags and the
2146 latter examines the name... */
2147 || (!S_IS_EXTERNAL (symp)
2148 && (punt || S_IS_LOCAL (symp) ||
2149 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2150 && ! symbol_used_in_reloc_p (symp)))
2152 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2154 /* After symbol_remove, symbol_next(symp) still returns
2155 the one that came after it in the chain. So we don't
2156 need to do any extra cleanup work here. */
2157 continue;
2160 /* Make sure we really got a value for the symbol. */
2161 if (! symbol_resolved_p (symp))
2163 as_bad (_("can't resolve value for symbol `%s'"),
2164 S_GET_NAME (symp));
2165 symbol_mark_resolved (symp);
2168 /* Set the value into the BFD symbol. Up til now the value
2169 has only been kept in the gas symbolS struct. */
2170 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2172 /* A warning construct is a warning symbol followed by the
2173 symbol warned about. Don't let anything object-format or
2174 target-specific muck with it; it's ready for output. */
2175 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2176 skip_next_symbol = TRUE;
2180 PROGRESS (1);
2182 /* Now do any format-specific adjustments to the symbol table, such
2183 as adding file symbols. */
2184 #ifdef tc_adjust_symtab
2185 tc_adjust_symtab ();
2186 #endif
2187 #ifdef obj_adjust_symtab
2188 obj_adjust_symtab ();
2189 #endif
2191 /* Stop if there is an error. */
2192 if (had_errors ())
2193 return;
2195 /* Now that all the sizes are known, and contents correct, we can
2196 start writing to the file. */
2197 set_symtab ();
2199 /* If *_frob_file changes the symbol value at this point, it is
2200 responsible for moving the changed value into symp->bsym->value
2201 as well. Hopefully all symbol value changing can be done in
2202 *_frob_symbol. */
2203 #ifdef tc_frob_file
2204 tc_frob_file ();
2205 #endif
2206 #ifdef obj_frob_file
2207 obj_frob_file ();
2208 #endif
2209 #ifdef obj_coff_generate_pdata
2210 obj_coff_generate_pdata ();
2211 #endif
2212 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2214 #ifdef tc_frob_file_after_relocs
2215 tc_frob_file_after_relocs ();
2216 #endif
2217 #ifdef obj_frob_file_after_relocs
2218 obj_frob_file_after_relocs ();
2219 #endif
2221 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2222 if (IS_ELF && flag_use_elf_stt_common)
2223 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
2224 #endif
2226 /* Once all relocations have been written, we can compress the
2227 contents of the debug sections. This needs to be done before
2228 we start writing any sections, because it will affect the file
2229 layout, which is fixed once we start writing contents. */
2230 if (flag_compress_debug)
2232 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
2233 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
2234 else
2235 stdoutput->flags |= BFD_COMPRESS;
2236 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2239 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2242 #ifdef TC_GENERIC_RELAX_TABLE
2243 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2245 long
2246 relax_frag (segT segment, fragS *fragP, long stretch)
2248 const relax_typeS *this_type;
2249 const relax_typeS *start_type;
2250 relax_substateT next_state;
2251 relax_substateT this_state;
2252 offsetT growth;
2253 offsetT aim;
2254 addressT target;
2255 addressT address;
2256 symbolS *symbolP;
2257 const relax_typeS *table;
2259 target = fragP->fr_offset;
2260 address = fragP->fr_address;
2261 table = TC_GENERIC_RELAX_TABLE;
2262 this_state = fragP->fr_subtype;
2263 start_type = this_type = table + this_state;
2264 symbolP = fragP->fr_symbol;
2266 if (symbolP)
2268 fragS *sym_frag;
2270 sym_frag = symbol_get_frag (symbolP);
2272 #ifndef DIFF_EXPR_OK
2273 know (sym_frag != NULL);
2274 #endif
2275 know (S_GET_SEGMENT (symbolP) != absolute_section
2276 || sym_frag == &zero_address_frag);
2277 target += S_GET_VALUE (symbolP);
2279 /* If SYM_FRAG has yet to be reached on this pass, assume it
2280 will move by STRETCH just as we did, unless there is an
2281 alignment frag between here and SYM_FRAG. An alignment may
2282 well absorb any STRETCH, and we don't want to choose a larger
2283 branch insn by overestimating the needed reach of this
2284 branch. It isn't critical to calculate TARGET exactly; We
2285 know we'll be doing another pass if STRETCH is non-zero. */
2287 if (stretch != 0
2288 && sym_frag->relax_marker != fragP->relax_marker
2289 && S_GET_SEGMENT (symbolP) == segment)
2291 if (stretch < 0
2292 || sym_frag->region == fragP->region)
2293 target += stretch;
2294 /* If we get here we know we have a forward branch. This
2295 relax pass may have stretched previous instructions so
2296 far that omitting STRETCH would make the branch
2297 negative. Don't allow this in case the negative reach is
2298 large enough to require a larger branch instruction. */
2299 else if (target < address)
2300 target = fragP->fr_next->fr_address + stretch;
2304 aim = target - address - fragP->fr_fix;
2305 #ifdef TC_PCREL_ADJUST
2306 /* Currently only the ns32k family needs this. */
2307 aim += TC_PCREL_ADJUST (fragP);
2308 #endif
2310 #ifdef md_prepare_relax_scan
2311 /* Formerly called M68K_AIM_KLUDGE. */
2312 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2313 #endif
2315 if (aim < 0)
2317 /* Look backwards. */
2318 for (next_state = this_type->rlx_more; next_state;)
2319 if (aim >= this_type->rlx_backward)
2320 next_state = 0;
2321 else
2323 /* Grow to next state. */
2324 this_state = next_state;
2325 this_type = table + this_state;
2326 next_state = this_type->rlx_more;
2329 else
2331 /* Look forwards. */
2332 for (next_state = this_type->rlx_more; next_state;)
2333 if (aim <= this_type->rlx_forward)
2334 next_state = 0;
2335 else
2337 /* Grow to next state. */
2338 this_state = next_state;
2339 this_type = table + this_state;
2340 next_state = this_type->rlx_more;
2344 growth = this_type->rlx_length - start_type->rlx_length;
2345 if (growth != 0)
2346 fragP->fr_subtype = this_state;
2347 return growth;
2350 #endif /* defined (TC_GENERIC_RELAX_TABLE) */
2352 /* Relax_align. Advance location counter to next address that has 'alignment'
2353 lowest order bits all 0s, return size of adjustment made. */
2354 static relax_addressT
2355 relax_align (relax_addressT address, /* Address now. */
2356 int alignment /* Alignment (binary). */)
2358 relax_addressT mask;
2359 relax_addressT new_address;
2361 mask = ~((relax_addressT) ~0 << alignment);
2362 new_address = (address + mask) & (~mask);
2363 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2364 if (linkrelax)
2365 /* We must provide lots of padding, so the linker can discard it
2366 when needed. The linker will not add extra space, ever. */
2367 new_address += (1 << alignment);
2368 #endif
2369 return (new_address - address);
2372 /* Now we have a segment, not a crowd of sub-segments, we can make
2373 fr_address values.
2375 Relax the frags.
2377 After this, all frags in this segment have addresses that are correct
2378 within the segment. Since segments live in different file addresses,
2379 these frag addresses may not be the same as final object-file
2380 addresses. */
2383 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2385 unsigned long frag_count;
2386 struct frag *fragP;
2387 relax_addressT address;
2388 int region;
2389 int ret;
2391 /* In case md_estimate_size_before_relax() wants to make fixSs. */
2392 subseg_change (segment, 0);
2394 /* For each frag in segment: count and store (a 1st guess of)
2395 fr_address. */
2396 address = 0;
2397 region = 0;
2398 for (frag_count = 0, fragP = segment_frag_root;
2399 fragP;
2400 fragP = fragP->fr_next, frag_count ++)
2402 fragP->region = region;
2403 fragP->relax_marker = 0;
2404 fragP->fr_address = address;
2405 address += fragP->fr_fix;
2407 switch (fragP->fr_type)
2409 case rs_fill:
2410 address += fragP->fr_offset * fragP->fr_var;
2411 break;
2413 case rs_align:
2414 case rs_align_code:
2415 case rs_align_test:
2417 addressT offset = relax_align (address, (int) fragP->fr_offset);
2419 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2420 offset = 0;
2422 if (offset % fragP->fr_var != 0)
2424 as_bad_where (fragP->fr_file, fragP->fr_line,
2425 _("alignment padding (%lu bytes) not a multiple of %ld"),
2426 (unsigned long) offset, (long) fragP->fr_var);
2427 offset -= (offset % fragP->fr_var);
2430 address += offset;
2431 region += 1;
2433 break;
2435 case rs_org:
2436 /* Assume .org is nugatory. It will grow with 1st relax. */
2437 region += 1;
2438 break;
2440 case rs_space:
2441 break;
2443 case rs_machine_dependent:
2444 /* If fr_symbol is an expression, this call to
2445 resolve_symbol_value sets up the correct segment, which will
2446 likely be needed in md_estimate_size_before_relax. */
2447 if (fragP->fr_symbol)
2448 resolve_symbol_value (fragP->fr_symbol);
2450 address += md_estimate_size_before_relax (fragP, segment);
2451 break;
2453 #ifndef WORKING_DOT_WORD
2454 /* Broken words don't concern us yet. */
2455 case rs_broken_word:
2456 break;
2457 #endif
2459 case rs_leb128:
2460 /* Initial guess is always 1; doing otherwise can result in
2461 stable solutions that are larger than the minimum. */
2462 address += fragP->fr_offset = 1;
2463 break;
2465 case rs_cfa:
2466 address += eh_frame_estimate_size_before_relax (fragP);
2467 break;
2469 case rs_dwarf2dbg:
2470 address += dwarf2dbg_estimate_size_before_relax (fragP);
2471 break;
2473 default:
2474 BAD_CASE (fragP->fr_type);
2475 break;
2479 /* Do relax(). */
2481 unsigned long max_iterations;
2483 /* Cumulative address adjustment. */
2484 offsetT stretch;
2486 /* Have we made any adjustment this pass? We can't just test
2487 stretch because one piece of code may have grown and another
2488 shrank. */
2489 int stretched;
2491 /* Most horrible, but gcc may give us some exception data that
2492 is impossible to assemble, of the form
2494 .align 4
2495 .byte 0, 0
2496 .uleb128 end - start
2497 start:
2498 .space 128*128 - 1
2499 .align 4
2500 end:
2502 If the leb128 is two bytes in size, then end-start is 128*128,
2503 which requires a three byte leb128. If the leb128 is three
2504 bytes in size, then end-start is 128*128-1, which requires a
2505 two byte leb128. We work around this dilemma by inserting
2506 an extra 4 bytes of alignment just after the .align. This
2507 works because the data after the align is accessed relative to
2508 the end label.
2510 This counter is used in a tiny state machine to detect
2511 whether a leb128 followed by an align is impossible to
2512 relax. */
2513 int rs_leb128_fudge = 0;
2515 /* We want to prevent going into an infinite loop where one frag grows
2516 depending upon the location of a symbol which is in turn moved by
2517 the growing frag. eg:
2519 foo = .
2520 .org foo+16
2521 foo = .
2523 So we dictate that this algorithm can be at most O2. */
2524 max_iterations = frag_count * frag_count;
2525 /* Check for overflow. */
2526 if (max_iterations < frag_count)
2527 max_iterations = frag_count;
2529 ret = 0;
2532 stretch = 0;
2533 stretched = 0;
2535 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2537 offsetT growth = 0;
2538 addressT was_address;
2539 offsetT offset;
2540 symbolS *symbolP;
2542 fragP->relax_marker ^= 1;
2543 was_address = fragP->fr_address;
2544 address = fragP->fr_address += stretch;
2545 symbolP = fragP->fr_symbol;
2546 offset = fragP->fr_offset;
2548 switch (fragP->fr_type)
2550 case rs_fill: /* .fill never relaxes. */
2551 growth = 0;
2552 break;
2554 #ifndef WORKING_DOT_WORD
2555 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2556 for it I do not want to write it. I do not want to have
2557 anything to do with it. This is not the proper way to
2558 implement this misfeature. */
2559 case rs_broken_word:
2561 struct broken_word *lie;
2562 struct broken_word *untruth;
2564 /* Yes this is ugly (storing the broken_word pointer
2565 in the symbol slot). Still, this whole chunk of
2566 code is ugly, and I don't feel like doing anything
2567 about it. Think of it as stubbornness in action. */
2568 growth = 0;
2569 for (lie = (struct broken_word *) (fragP->fr_symbol);
2570 lie && lie->dispfrag == fragP;
2571 lie = lie->next_broken_word)
2574 if (lie->added)
2575 continue;
2577 offset = (S_GET_VALUE (lie->add)
2578 + lie->addnum
2579 - S_GET_VALUE (lie->sub));
2580 if (offset <= -32768 || offset >= 32767)
2582 if (flag_warn_displacement)
2584 char buf[50];
2585 sprint_value (buf, (addressT) lie->addnum);
2586 as_warn_where (fragP->fr_file, fragP->fr_line,
2587 _(".word %s-%s+%s didn't fit"),
2588 S_GET_NAME (lie->add),
2589 S_GET_NAME (lie->sub),
2590 buf);
2592 if (fragP->fr_subtype == 0)
2594 fragP->fr_subtype++;
2595 growth += md_short_jump_size;
2598 /* Redirect *all* words of this table with the same
2599 target, lest we have to handle the case where the
2600 same target but with a offset that fits on this
2601 round overflows at the next relaxation round. */
2602 for (untruth = (struct broken_word *) (fragP->fr_symbol);
2603 untruth && untruth->dispfrag == lie->dispfrag;
2604 untruth = untruth->next_broken_word)
2605 if ((symbol_get_frag (untruth->add)
2606 == symbol_get_frag (lie->add))
2607 && (S_GET_VALUE (untruth->add)
2608 == S_GET_VALUE (lie->add)))
2610 untruth->added = 2;
2611 untruth->use_jump = lie;
2614 lie->added = 1;
2615 growth += md_long_jump_size;
2619 break;
2620 } /* case rs_broken_word */
2621 #endif
2622 case rs_align:
2623 case rs_align_code:
2624 case rs_align_test:
2626 addressT oldoff, newoff;
2628 oldoff = relax_align (was_address + fragP->fr_fix,
2629 (int) offset);
2630 newoff = relax_align (address + fragP->fr_fix,
2631 (int) offset);
2633 if (fragP->fr_subtype != 0)
2635 if (oldoff > fragP->fr_subtype)
2636 oldoff = 0;
2637 if (newoff > fragP->fr_subtype)
2638 newoff = 0;
2641 growth = newoff - oldoff;
2643 /* If this align happens to follow a leb128 and
2644 we have determined that the leb128 is bouncing
2645 in size, then break the cycle by inserting an
2646 extra alignment. */
2647 if (growth < 0
2648 && (rs_leb128_fudge & 16) != 0
2649 && (rs_leb128_fudge & 15) >= 2)
2651 segment_info_type *seginfo = seg_info (segment);
2652 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2653 struct frag *newf;
2655 newf = frag_alloc (ob);
2656 obstack_blank_fast (ob, fragP->fr_var);
2657 obstack_finish (ob);
2658 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2659 memcpy (newf->fr_literal,
2660 fragP->fr_literal + fragP->fr_fix,
2661 fragP->fr_var);
2662 newf->fr_type = rs_fill;
2663 newf->fr_address = address + fragP->fr_fix + newoff;
2664 newf->fr_fix = 0;
2665 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2666 / fragP->fr_var);
2667 if (newf->fr_offset * newf->fr_var
2668 != (offsetT) 1 << fragP->fr_offset)
2670 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2671 newf->fr_var = 1;
2673 /* Include size of new frag in GROWTH. */
2674 growth += newf->fr_offset * newf->fr_var;
2675 /* Adjust the new frag address for the amount
2676 we'll add when we process the new frag. */
2677 newf->fr_address -= stretch + growth;
2678 newf->relax_marker ^= 1;
2679 fragP->fr_next = newf;
2680 #ifdef DEBUG
2681 as_warn (_("padding added"));
2682 #endif
2685 break;
2687 case rs_org:
2689 addressT target = offset;
2690 addressT after;
2692 if (symbolP)
2694 /* Convert from an actual address to an octet offset
2695 into the section. Here it is assumed that the
2696 section's VMA is zero, and can omit subtracting it
2697 from the symbol's value to get the address offset. */
2698 know (S_GET_SEGMENT (symbolP)->vma == 0);
2699 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2702 know (fragP->fr_next);
2703 after = fragP->fr_next->fr_address + stretch;
2704 growth = target - after;
2706 /* Growth may be negative, but variable part of frag
2707 cannot have fewer than 0 chars. That is, we can't
2708 .org backwards. */
2709 if (address + fragP->fr_fix > target)
2711 growth = 0;
2713 /* Don't error on first few frag relax passes.
2714 The symbol might be an expression involving
2715 symbol values from other sections. If those
2716 sections have not yet been processed their
2717 frags will all have zero addresses, so we
2718 will calculate incorrect values for them. The
2719 number of passes we allow before giving an
2720 error is somewhat arbitrary. It should be at
2721 least one, with larger values requiring
2722 increasingly contrived dependencies between
2723 frags to trigger a false error. */
2724 if (pass < 2)
2726 /* Force another pass. */
2727 ret = 1;
2728 break;
2731 as_bad_where (fragP->fr_file, fragP->fr_line,
2732 _("attempt to move .org backwards"));
2734 /* We've issued an error message. Change the
2735 frag to avoid cascading errors. */
2736 fragP->fr_type = rs_align;
2737 fragP->fr_subtype = 0;
2738 fragP->fr_offset = 0;
2739 fragP->fr_fix = after - address;
2742 break;
2744 case rs_space:
2745 growth = 0;
2746 if (symbolP)
2748 offsetT amount;
2750 amount = S_GET_VALUE (symbolP);
2751 if (S_GET_SEGMENT (symbolP) != absolute_section
2752 || S_IS_COMMON (symbolP)
2753 || ! S_IS_DEFINED (symbolP))
2755 as_bad_where (fragP->fr_file, fragP->fr_line,
2756 _(".space specifies non-absolute value"));
2757 /* Prevent repeat of this error message. */
2758 fragP->fr_symbol = 0;
2760 else if (amount < 0)
2762 /* Don't error on first few frag relax passes.
2763 See rs_org comment for a longer explanation. */
2764 if (pass < 2)
2766 ret = 1;
2767 break;
2770 as_warn_where (fragP->fr_file, fragP->fr_line,
2771 _(".space or .fill with negative value, ignored"));
2772 fragP->fr_symbol = 0;
2774 else
2775 growth = (was_address + fragP->fr_fix + amount
2776 - fragP->fr_next->fr_address);
2778 break;
2780 case rs_machine_dependent:
2781 #ifdef md_relax_frag
2782 growth = md_relax_frag (segment, fragP, stretch);
2783 #else
2784 #ifdef TC_GENERIC_RELAX_TABLE
2785 /* The default way to relax a frag is to look through
2786 TC_GENERIC_RELAX_TABLE. */
2787 growth = relax_frag (segment, fragP, stretch);
2788 #endif /* TC_GENERIC_RELAX_TABLE */
2789 #endif
2790 break;
2792 case rs_leb128:
2794 valueT value;
2795 offsetT size;
2797 value = resolve_symbol_value (fragP->fr_symbol);
2798 size = sizeof_leb128 (value, fragP->fr_subtype);
2799 growth = size - fragP->fr_offset;
2800 fragP->fr_offset = size;
2802 break;
2804 case rs_cfa:
2805 growth = eh_frame_relax_frag (fragP);
2806 break;
2808 case rs_dwarf2dbg:
2809 growth = dwarf2dbg_relax_frag (fragP);
2810 break;
2812 default:
2813 BAD_CASE (fragP->fr_type);
2814 break;
2816 if (growth)
2818 stretch += growth;
2819 stretched = 1;
2820 if (fragP->fr_type == rs_leb128)
2821 rs_leb128_fudge += 16;
2822 else if (fragP->fr_type == rs_align
2823 && (rs_leb128_fudge & 16) != 0
2824 && stretch == 0)
2825 rs_leb128_fudge += 16;
2826 else
2827 rs_leb128_fudge = 0;
2831 if (stretch == 0
2832 && (rs_leb128_fudge & 16) == 0
2833 && (rs_leb128_fudge & -16) != 0)
2834 rs_leb128_fudge += 1;
2835 else
2836 rs_leb128_fudge = 0;
2838 /* Until nothing further to relax. */
2839 while (stretched && -- max_iterations);
2841 if (stretched)
2842 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2843 segment_name (segment));
2846 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2847 if (fragP->last_fr_address != fragP->fr_address)
2849 fragP->last_fr_address = fragP->fr_address;
2850 ret = 1;
2852 return ret;
2855 void
2856 number_to_chars_bigendian (char *buf, valueT val, int n)
2858 if (n <= 0)
2859 abort ();
2860 while (n--)
2862 buf[n] = val & 0xff;
2863 val >>= 8;
2867 void
2868 number_to_chars_littleendian (char *buf, valueT val, int n)
2870 if (n <= 0)
2871 abort ();
2872 while (n--)
2874 *buf++ = val & 0xff;
2875 val >>= 8;
2879 void
2880 write_print_statistics (FILE *file)
2882 fprintf (file, "fixups: %d\n", n_fixups);
2885 /* For debugging. */
2886 extern int indent_level;
2888 void
2889 print_fixup (fixS *fixp)
2891 indent_level = 1;
2892 fprintf (stderr, "fix ");
2893 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2894 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2895 if (fixp->fx_pcrel)
2896 fprintf (stderr, " pcrel");
2897 if (fixp->fx_pcrel_adjust)
2898 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2899 if (fixp->fx_im_disp)
2901 #ifdef TC_NS32K
2902 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2903 #else
2904 fprintf (stderr, " im_disp");
2905 #endif
2907 if (fixp->fx_tcbit)
2908 fprintf (stderr, " tcbit");
2909 if (fixp->fx_done)
2910 fprintf (stderr, " done");
2911 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2912 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2913 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2914 (long) fixp->fx_where,
2915 (unsigned long) fixp->fx_offset,
2916 (unsigned long) fixp->fx_addnumber);
2917 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2918 fixp->fx_r_type);
2919 if (fixp->fx_addsy)
2921 fprintf (stderr, "\n +<");
2922 print_symbol_value_1 (stderr, fixp->fx_addsy);
2923 fprintf (stderr, ">");
2925 if (fixp->fx_subsy)
2927 fprintf (stderr, "\n -<");
2928 print_symbol_value_1 (stderr, fixp->fx_subsy);
2929 fprintf (stderr, ">");
2931 fprintf (stderr, "\n");
2932 #ifdef TC_FIX_DATA_PRINT
2933 TC_FIX_DATA_PRINT (stderr, fixp);
2934 #endif