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, 2009,
4
2010, 2011, 2012 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)
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
23
/* This thing should be set up to do byteordering correctly. But... */
28
#include "output-file.h"
29
#include "dwarf2dbg.h"
31
#include "compress-debug.h"
33
#ifndef TC_FORCE_RELOCATION
34
#define TC_FORCE_RELOCATION(FIX) \
35
(generic_force_reloc (FIX))
38
#ifndef TC_FORCE_RELOCATION_ABS
39
#define TC_FORCE_RELOCATION_ABS(FIX) \
40
(TC_FORCE_RELOCATION (FIX))
43
#ifndef TC_FORCE_RELOCATION_LOCAL
44
#define TC_FORCE_RELOCATION_LOCAL(FIX) \
46
|| TC_FORCE_RELOCATION (FIX))
49
#ifndef TC_FORCE_RELOCATION_SUB_SAME
50
#define TC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
54
#ifndef md_register_arithmetic
55
# define md_register_arithmetic 1
58
#ifndef TC_FORCE_RELOCATION_SUB_ABS
59
#define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
60
(!md_register_arithmetic && (SEG) == reg_section)
63
#ifndef TC_FORCE_RELOCATION_SUB_LOCAL
65
#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
66
(!md_register_arithmetic && (SEG) == reg_section)
68
#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
72
#ifndef TC_VALIDATE_FIX_SUB
73
#ifdef UNDEFINED_DIFFERENCE_OK
74
/* The PA needs this for PIC code generation. */
75
#define TC_VALIDATE_FIX_SUB(FIX, SEG) \
76
(md_register_arithmetic || (SEG) != reg_section)
78
#define TC_VALIDATE_FIX_SUB(FIX, SEG) \
79
((md_register_arithmetic || (SEG) != reg_section) \
80
&& ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \
81
|| (FIX)->fx_r_type == BFD_RELOC_GPREL16))
85
#ifndef TC_LINKRELAX_FIXUP
86
#define TC_LINKRELAX_FIXUP(SEG) 1
89
#ifndef MD_APPLY_SYM_VALUE
90
#define MD_APPLY_SYM_VALUE(FIX) 1
93
#ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
94
#define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
97
#ifndef MD_PCREL_FROM_SECTION
98
#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
101
#ifndef TC_FAKE_LABEL
102
#define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
105
/* Positive values of TC_FX_SIZE_SLACK allow a target to define
106
fixups that far past the end of a frag. Having such fixups
107
is of course most most likely a bug in setting fx_size correctly.
108
A negative value disables the fixup check entirely, which is
109
appropriate for something like the Renesas / SuperH SH_COUNT
111
#ifndef TC_FX_SIZE_SLACK
112
#define TC_FX_SIZE_SLACK(FIX) 0
115
/* Used to control final evaluation of expressions. */
116
int finalize_syms = 0;
118
int symbol_table_frozen;
120
symbolS *abs_section_sym;
122
/* Remember the value of dot when parsing expressions. */
125
/* The frag that dot_value is based from. */
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;
141
#define RELOC_ENUM enum bfd_reloc_code_real
143
/* Create a fixS in obstack 'notes'. */
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 /* Relocation type. */,
154
int at_beginning) /* Add to the start of the list? */
160
fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS));
162
fixP->fx_frag = frag;
163
fixP->fx_where = where;
164
fixP->fx_size = size;
165
/* We've made fx_size a narrow field; check that it's wide enough. */
166
if (fixP->fx_size != size)
168
as_bad (_("field fx_size too small to hold %d"), size);
171
fixP->fx_addsy = add_symbol;
172
fixP->fx_subsy = sub_symbol;
173
fixP->fx_offset = offset;
174
fixP->fx_dot_value = dot_value;
175
fixP->fx_dot_frag = dot_frag;
176
fixP->fx_pcrel = pcrel;
177
fixP->fx_r_type = r_type;
178
fixP->fx_im_disp = 0;
179
fixP->fx_pcrel_adjust = 0;
180
fixP->fx_bit_fixP = 0;
181
fixP->fx_addnumber = 0;
185
fixP->fx_no_overflow = 0;
189
fixP->fx_cgen.insn = NULL;
190
fixP->fx_cgen.opinfo = 0;
194
TC_INIT_FIX_DATA (fixP);
197
as_where (&fixP->fx_file, &fixP->fx_line);
201
fixS **seg_fix_rootP = (frags_chained
202
? &seg_info (now_seg)->fix_root
203
: &frchain_now->fix_root);
204
fixS **seg_fix_tailP = (frags_chained
205
? &seg_info (now_seg)->fix_tail
206
: &frchain_now->fix_tail);
210
fixP->fx_next = *seg_fix_rootP;
211
*seg_fix_rootP = fixP;
212
if (fixP->fx_next == NULL)
213
*seg_fix_tailP = fixP;
217
fixP->fx_next = NULL;
219
(*seg_fix_tailP)->fx_next = fixP;
221
*seg_fix_rootP = fixP;
222
*seg_fix_tailP = fixP;
229
/* Create a fixup relative to a symbol (plus a constant). */
232
fix_new (fragS *frag, /* Which frag? */
233
int where, /* Where in that frag? */
234
int size, /* 1, 2, or 4 usually. */
235
symbolS *add_symbol, /* X_add_symbol. */
236
offsetT offset, /* X_add_number. */
237
int pcrel, /* TRUE if PC-relative relocation. */
238
RELOC_ENUM r_type /* Relocation type. */)
240
return fix_new_internal (frag, where, size, add_symbol,
241
(symbolS *) NULL, offset, pcrel, r_type, FALSE);
244
/* Create a fixup for an expression. Currently we only support fixups
245
for difference expressions. That is itself more than most object
246
file formats support anyhow. */
249
fix_new_exp (fragS *frag, /* Which frag? */
250
int where, /* Where in that frag? */
251
int size, /* 1, 2, or 4 usually. */
252
expressionS *exp, /* Expression. */
253
int pcrel, /* TRUE if PC-relative relocation. */
254
RELOC_ENUM r_type /* Relocation type. */)
266
as_bad (_("register value used as expression"));
270
/* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
271
the difference expression cannot immediately be reduced. */
273
symbolS *stmp = make_expr_symbol (exp);
275
exp->X_op = O_symbol;
276
exp->X_op_symbol = 0;
277
exp->X_add_symbol = stmp;
278
exp->X_add_number = 0;
280
return fix_new_exp (frag, where, size, exp, pcrel, r_type);
284
add = exp->X_add_symbol;
285
off = exp->X_add_number;
286
r_type = BFD_RELOC_RVA;
290
sub = exp->X_add_symbol;
291
off = exp->X_add_number;
295
sub = exp->X_op_symbol;
298
add = exp->X_add_symbol;
301
off = exp->X_add_number;
305
add = make_expr_symbol (exp);
309
return fix_new_internal (frag, where, size, add, sub, off, pcrel,
313
/* Create a fixup at the beginning of FRAG. The arguments are the same
314
as for fix_new, except that WHERE is implicitly 0. */
317
fix_at_start (fragS *frag, int size, symbolS *add_symbol,
318
offsetT offset, int pcrel, RELOC_ENUM r_type)
320
return fix_new_internal (frag, 0, size, add_symbol,
321
(symbolS *) NULL, offset, pcrel, r_type, TRUE);
324
/* Generic function to determine whether a fixup requires a relocation. */
326
generic_force_reloc (fixS *fix)
328
if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
329
|| fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
332
if (fix->fx_addsy == NULL)
335
return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
338
/* Append a string onto another string, bumping the pointer along. */
340
append (char **charPP, char *fromP, unsigned long length)
342
/* Don't trust memcpy() of 0 chars. */
346
memcpy (*charPP, fromP, length);
350
/* This routine records the largest alignment seen for each segment.
351
If the beginning of the segment is aligned on the worst-case
352
boundary, all of the other alignments within it will work. At
353
least one object format really uses this info. */
356
record_alignment (/* Segment to which alignment pertains. */
358
/* Alignment, as a power of 2 (e.g., 1 => 2-byte
359
boundary, 2 => 4-byte boundary, etc.) */
362
if (seg == absolute_section)
365
if ((unsigned int) align > bfd_get_section_alignment (stdoutput, seg))
366
bfd_set_section_alignment (stdoutput, seg, align);
370
get_recorded_alignment (segT seg)
372
if (seg == absolute_section)
375
return bfd_get_section_alignment (stdoutput, seg);
378
/* Reset the section indices after removing the gas created sections. */
381
renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
383
int *countp = (int *) countparg;
385
sec->index = *countp;
390
chain_frchains_together_1 (segT section, struct frchain *frchp)
392
fragS dummy, *prev_frag = &dummy;
393
fixS fix_dummy, *prev_fix = &fix_dummy;
395
for (; frchp; frchp = frchp->frch_next)
397
prev_frag->fr_next = frchp->frch_root;
398
prev_frag = frchp->frch_last;
399
gas_assert (prev_frag->fr_type != 0);
400
if (frchp->fix_root != (fixS *) NULL)
402
if (seg_info (section)->fix_root == (fixS *) NULL)
403
seg_info (section)->fix_root = frchp->fix_root;
404
prev_fix->fx_next = frchp->fix_root;
405
seg_info (section)->fix_tail = frchp->fix_tail;
406
prev_fix = frchp->fix_tail;
409
gas_assert (prev_frag != &dummy
410
&& prev_frag->fr_type != 0);
411
prev_frag->fr_next = 0;
416
chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
418
void *xxx ATTRIBUTE_UNUSED)
420
segment_info_type *info;
422
/* BFD may have introduced its own sections without using
423
subseg_new, so it is possible that seg_info is NULL. */
424
info = seg_info (section);
425
if (info != (segment_info_type *) NULL)
426
info->frchainP->frch_last
427
= chain_frchains_together_1 (section, info->frchainP);
429
/* Now that we've chained the frags together, we must add new fixups
430
to the segment, not to the frag chain. */
435
cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
437
switch (fragP->fr_type)
445
HANDLE_ALIGN (fragP);
447
know (fragP->fr_next != NULL);
448
fragP->fr_offset = (fragP->fr_next->fr_address
450
- fragP->fr_fix) / fragP->fr_var;
451
if (fragP->fr_offset < 0)
453
as_bad_where (fragP->fr_file, fragP->fr_line,
454
_("attempt to .org/.space backwards? (%ld)"),
455
(long) fragP->fr_offset);
456
fragP->fr_offset = 0;
458
fragP->fr_type = rs_fill;
466
valueT value = S_GET_VALUE (fragP->fr_symbol);
469
size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
472
fragP->fr_fix += size;
473
fragP->fr_type = rs_fill;
475
fragP->fr_offset = 0;
476
fragP->fr_symbol = NULL;
481
eh_frame_convert_frag (fragP);
485
dwarf2dbg_convert_frag (fragP);
488
case rs_machine_dependent:
489
md_convert_frag (stdoutput, sec, fragP);
491
gas_assert (fragP->fr_next == NULL
492
|| ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
495
/* After md_convert_frag, we make the frag into a ".space 0".
496
md_convert_frag() should set up any fixSs and constants
501
#ifndef WORKING_DOT_WORD
504
struct broken_word *lie;
506
if (fragP->fr_subtype)
508
fragP->fr_fix += md_short_jump_size;
509
for (lie = (struct broken_word *) (fragP->fr_symbol);
510
lie && lie->dispfrag == fragP;
511
lie = lie->next_broken_word)
513
fragP->fr_fix += md_long_jump_size;
521
BAD_CASE (fragP->fr_type);
525
md_frag_check (fragP);
529
struct relax_seg_info
536
relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
538
segment_info_type *seginfo = seg_info (sec);
539
struct relax_seg_info *info = (struct relax_seg_info *) xxx;
541
if (seginfo && seginfo->frchainP
542
&& relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
547
size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
551
segment_info_type *seginfo;
553
valueT size, newsize;
555
subseg_change (sec, 0);
557
seginfo = seg_info (sec);
558
if (seginfo && seginfo->frchainP)
560
for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
561
cvt_frag_to_fill (sec, fragp);
562
for (fragp = seginfo->frchainP->frch_root;
564
fragp = fragp->fr_next)
565
/* Walk to last elt. */
567
size = fragp->fr_address + fragp->fr_fix;
572
flags = bfd_get_section_flags (abfd, sec);
573
if (size == 0 && bfd_get_section_size (sec) != 0 &&
574
(flags & SEC_HAS_CONTENTS) != 0)
577
if (size > 0 && ! seginfo->bss)
578
flags |= SEC_HAS_CONTENTS;
581
x = bfd_set_section_flags (abfd, sec, flags);
584
newsize = md_section_align (sec, size);
585
x = bfd_set_section_size (abfd, sec, newsize);
588
/* If the size had to be rounded up, add some padding in the last
590
gas_assert (newsize >= size);
593
fragS *last = seginfo->frchainP->frch_last;
594
fragp = seginfo->frchainP->frch_root;
595
while (fragp->fr_next != last)
596
fragp = fragp->fr_next;
597
last->fr_address = size;
598
if ((newsize - size) % fragp->fr_var == 0)
599
fragp->fr_offset += (newsize - size) / fragp->fr_var;
601
/* If we hit this abort, it's likely due to subsegs_finish not
602
providing sufficient alignment on the last frag, and the
603
machine dependent code using alignment frags with fr_var
608
#ifdef tc_frob_section
609
tc_frob_section (sec);
611
#ifdef obj_frob_section
612
obj_frob_section (sec);
618
dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
620
segment_info_type *seginfo = seg_info (sec);
621
fixS *fixp = seginfo->fix_root;
626
fprintf (stream, "sec %s relocs:\n", sec->name);
629
symbolS *s = fixp->fx_addsy;
631
fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
632
(int) fixp->fx_r_type);
634
fprintf (stream, "no sym\n");
637
print_symbol_value_1 (stream, s);
638
fprintf (stream, "\n");
640
fixp = fixp->fx_next;
644
#define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
647
#ifndef EMIT_SECTION_SYMBOLS
648
#define EMIT_SECTION_SYMBOLS 1
651
/* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
652
and check for validity. Convert RELOC_LIST from using U.A fields
655
resolve_reloc_expr_symbols (void)
657
bfd_vma addr_mask = 1;
658
struct reloc_list *r;
660
/* Avoid a shift by the width of type. */
661
addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
665
for (r = reloc_list; r; r = r->next)
667
reloc_howto_type *howto = r->u.a.howto;
670
bfd_vma offset, addend;
673
resolve_symbol_value (r->u.a.offset_sym);
674
symval = symbol_get_value_expression (r->u.a.offset_sym);
678
if (symval->X_op == O_constant)
679
sym = r->u.a.offset_sym;
680
else if (symval->X_op == O_symbol)
682
sym = symval->X_add_symbol;
683
offset = symval->X_add_number;
684
symval = symbol_get_value_expression (symval->X_add_symbol);
687
|| symval->X_op != O_constant
688
|| (sec = S_GET_SEGMENT (sym)) == NULL
689
|| !SEG_NORMAL (sec))
691
as_bad_where (r->file, r->line, _("invalid offset expression"));
695
offset += S_GET_VALUE (sym);
698
addend = r->u.a.addend;
699
if (r->u.a.sym != NULL)
701
resolve_symbol_value (r->u.a.sym);
702
symval = symbol_get_value_expression (r->u.a.sym);
703
if (symval->X_op == O_constant)
705
else if (symval->X_op == O_symbol)
707
sym = symval->X_add_symbol;
708
addend += symval->X_add_number;
709
symval = symbol_get_value_expression (symval->X_add_symbol);
711
if (symval->X_op != O_constant)
713
as_bad_where (r->file, r->line, _("invalid reloc expression"));
716
else if (sym != NULL)
718
/* Convert relocs against local symbols to refer to the
719
corresponding section symbol plus offset instead. Keep
720
PC-relative relocs of the REL variety intact though to
721
prevent the offset from overflowing the relocated field,
722
unless it has enough bits to cover the whole address
724
if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
726
|| (howto->partial_inplace
727
&& (!howto->pc_relative
728
|| howto->src_mask == addr_mask))))
730
asection *symsec = S_GET_SEGMENT (sym);
731
if (!(((symsec->flags & SEC_MERGE) != 0
733
|| (symsec->flags & SEC_THREAD_LOCAL) != 0))
735
addend += S_GET_VALUE (sym);
736
sym = section_symbol (symsec);
739
symbol_mark_used_in_reloc (sym);
744
if (abs_section_sym == NULL)
745
abs_section_sym = section_symbol (absolute_section);
746
sym = abs_section_sym;
750
r->u.b.s = symbol_get_bfdsym (sym);
751
r->u.b.r.sym_ptr_ptr = &r->u.b.s;
752
r->u.b.r.address = offset;
753
r->u.b.r.addend = addend;
754
r->u.b.r.howto = howto;
758
/* This pass over fixups decides whether symbols can be replaced with
762
adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
764
void *xxx ATTRIBUTE_UNUSED)
766
segment_info_type *seginfo = seg_info (sec);
772
dump_section_relocs (abfd, sec, stderr);
774
for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
778
else if (fixp->fx_addsy)
784
fprintf (stderr, "\n\nadjusting fixup:\n");
788
sym = fixp->fx_addsy;
790
/* All symbols should have already been resolved at this
791
point. It is possible to see unresolved expression
792
symbols, though, since they are not in the regular symbol
794
resolve_symbol_value (sym);
796
if (fixp->fx_subsy != NULL)
797
resolve_symbol_value (fixp->fx_subsy);
799
/* If this symbol is equated to an undefined or common symbol,
800
convert the fixup to being against that symbol. */
801
while (symbol_equated_reloc_p (sym)
802
|| S_IS_WEAKREFR (sym))
804
symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
807
fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
808
fixp->fx_addsy = newsym;
812
if (symbol_mri_common_p (sym))
814
fixp->fx_offset += S_GET_VALUE (sym);
815
fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
819
/* If the symbol is undefined, common, weak, or global (ELF
820
shared libs), we can't replace it with the section symbol. */
821
if (S_FORCE_RELOC (fixp->fx_addsy, 1))
824
/* Is there some other (target cpu dependent) reason we can't adjust
825
this one? (E.g. relocations involving function addresses on
827
#ifdef tc_fix_adjustable
828
if (! tc_fix_adjustable (fixp))
832
/* Since we're reducing to section symbols, don't attempt to reduce
833
anything that's already using one. */
834
if (symbol_section_p (sym))
837
symsec = S_GET_SEGMENT (sym);
841
if (bfd_is_abs_section (symsec))
843
/* The fixup_segment routine normally will not use this
844
symbol in a relocation. */
848
/* Don't try to reduce relocs which refer to non-local symbols
849
in .linkonce sections. It can lead to confusion when a
850
debugging section refers to a .linkonce section. I hope
851
this will always be correct. */
852
if (symsec != sec && ! S_IS_LOCAL (sym))
854
if ((symsec->flags & SEC_LINK_ONCE) != 0
856
/* The GNU toolchain uses an extension for ELF: a
857
section beginning with the magic string
858
.gnu.linkonce is a linkonce section. */
859
&& strncmp (segment_name (symsec), ".gnu.linkonce",
860
sizeof ".gnu.linkonce" - 1) == 0))
864
/* Never adjust a reloc against local symbol in a merge section
865
with non-zero addend. */
866
if ((symsec->flags & SEC_MERGE) != 0
867
&& (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
870
/* Never adjust a reloc against TLS local symbol. */
871
if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
874
/* We refetch the segment when calling section_symbol, rather
875
than using symsec, because S_GET_VALUE may wind up changing
876
the section when it calls resolve_symbol_value. */
877
fixp->fx_offset += S_GET_VALUE (sym);
878
fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
880
fprintf (stderr, "\nadjusted fixup:\n");
885
dump_section_relocs (abfd, sec, stderr);
890
Go through all the fixS's in a segment and see which ones can be
891
handled now. (These consist of fixS where we have since discovered
892
the value of a symbol, or the address of the frag involved.)
893
For each one, call md_apply_fix to put the fix into the frag data.
894
Ones that we couldn't completely handle here will be output later
895
by emit_relocations. */
898
fixup_segment (fixS *fixP, segT this_segment)
902
segT add_symbol_segment = absolute_section;
904
if (fixP != NULL && abs_section_sym == NULL)
905
abs_section_sym = section_symbol (absolute_section);
907
/* If the linker is doing the relaxing, we must not do any fixups.
909
Well, strictly speaking that's not true -- we could do any that
910
are PC-relative and don't cross regions that could change size.
911
And for the i960 we might be able to turn callx/callj into bal
912
anyways in cases where we know the maximum displacement. */
913
if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
915
for (; fixP; fixP = fixP->fx_next)
918
if (fixP->fx_addsy == NULL)
920
/* There was no symbol required by this relocation.
921
However, BFD doesn't really handle relocations
922
without symbols well. So fake up a local symbol in
923
the absolute section. */
924
fixP->fx_addsy = abs_section_sym;
926
symbol_mark_used_in_reloc (fixP->fx_addsy);
927
if (fixP->fx_subsy != NULL)
928
symbol_mark_used_in_reloc (fixP->fx_subsy);
933
for (; fixP; fixP = fixP->fx_next)
936
fprintf (stderr, "\nprocessing fixup:\n");
940
fragP = fixP->fx_frag;
942
#ifdef TC_VALIDATE_FIX
943
TC_VALIDATE_FIX (fixP, this_segment, skip);
945
add_number = fixP->fx_offset;
947
if (fixP->fx_addsy != NULL)
948
add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
950
if (fixP->fx_subsy != NULL)
952
segT sub_symbol_segment;
953
resolve_symbol_value (fixP->fx_subsy);
954
sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
955
if (fixP->fx_addsy != NULL
956
&& sub_symbol_segment == add_symbol_segment
957
&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
958
&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
959
&& !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
961
add_number += S_GET_VALUE (fixP->fx_addsy);
962
add_number -= S_GET_VALUE (fixP->fx_subsy);
963
fixP->fx_offset = add_number;
964
fixP->fx_addsy = NULL;
965
fixP->fx_subsy = NULL;
967
/* See the comment below about 68k weirdness. */
971
else if (sub_symbol_segment == absolute_section
972
&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
973
&& !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
975
add_number -= S_GET_VALUE (fixP->fx_subsy);
976
fixP->fx_offset = add_number;
977
fixP->fx_subsy = NULL;
979
else if (sub_symbol_segment == this_segment
980
&& !S_FORCE_RELOC (fixP->fx_subsy, 0)
981
&& !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
983
add_number -= S_GET_VALUE (fixP->fx_subsy);
984
fixP->fx_offset = (add_number + fixP->fx_dot_value
985
+ fixP->fx_dot_frag->fr_address);
987
/* Make it pc-relative. If the back-end code has not
988
selected a pc-relative reloc, cancel the adjustment
989
we do later on all pc-relative relocs. */
992
/* Do this for m68k even if it's already described
993
as pc-relative. On the m68k, an operand of
994
"pc@(foo-.-2)" should address "foo" in a
999
add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1000
fixP->fx_subsy = NULL;
1003
else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1005
if (!md_register_arithmetic
1006
&& (add_symbol_segment == reg_section
1007
|| sub_symbol_segment == reg_section))
1008
as_bad_where (fixP->fx_file, fixP->fx_line,
1009
_("register value used as expression"));
1011
as_bad_where (fixP->fx_file, fixP->fx_line,
1012
_("can't resolve `%s' {%s section} - `%s' {%s section}"),
1013
fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1014
segment_name (add_symbol_segment),
1015
S_GET_NAME (fixP->fx_subsy),
1016
segment_name (sub_symbol_segment));
1018
else if (sub_symbol_segment != undefined_section
1019
&& ! bfd_is_com_section (sub_symbol_segment)
1020
&& MD_APPLY_SYM_VALUE (fixP))
1021
add_number -= S_GET_VALUE (fixP->fx_subsy);
1026
if (add_symbol_segment == this_segment
1027
&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
1028
&& !TC_FORCE_RELOCATION_LOCAL (fixP))
1030
/* This fixup was made when the symbol's segment was
1031
SEG_UNKNOWN, but it is now in the local segment.
1032
So we know how to do the address without relocation. */
1033
add_number += S_GET_VALUE (fixP->fx_addsy);
1034
fixP->fx_offset = add_number;
1036
add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1037
fixP->fx_addsy = NULL;
1040
else if (add_symbol_segment == absolute_section
1041
&& !S_FORCE_RELOC (fixP->fx_addsy, 0)
1042
&& !TC_FORCE_RELOCATION_ABS (fixP))
1044
add_number += S_GET_VALUE (fixP->fx_addsy);
1045
fixP->fx_offset = add_number;
1046
fixP->fx_addsy = NULL;
1048
else if (add_symbol_segment != undefined_section
1049
&& ! bfd_is_com_section (add_symbol_segment)
1050
&& MD_APPLY_SYM_VALUE (fixP))
1051
add_number += S_GET_VALUE (fixP->fx_addsy);
1056
add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1057
if (!fixP->fx_done && fixP->fx_addsy == NULL)
1059
/* There was no symbol required by this relocation.
1060
However, BFD doesn't really handle relocations
1061
without symbols well. So fake up a local symbol in
1062
the absolute section. */
1063
fixP->fx_addsy = abs_section_sym;
1068
md_apply_fix (fixP, &add_number, this_segment);
1072
if (fixP->fx_addsy == NULL)
1073
fixP->fx_addsy = abs_section_sym;
1074
symbol_mark_used_in_reloc (fixP->fx_addsy);
1075
if (fixP->fx_subsy != NULL)
1076
symbol_mark_used_in_reloc (fixP->fx_subsy);
1079
if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1081
if (fixP->fx_size < sizeof (valueT))
1086
mask--; /* Set all bits to one. */
1087
mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1088
if ((add_number & mask) != 0 && (add_number & mask) != mask)
1090
char buf[50], buf2[50];
1091
sprint_value (buf, fragP->fr_address + fixP->fx_where);
1092
if (add_number > 1000)
1093
sprint_value (buf2, add_number);
1095
sprintf (buf2, "%ld", (long) add_number);
1096
as_bad_where (fixP->fx_file, fixP->fx_line,
1097
_("value of %s too large for field of %d bytes at %s"),
1098
buf2, fixP->fx_size, buf);
1099
} /* Generic error checking. */
1101
#ifdef WARN_SIGNED_OVERFLOW_WORD
1102
/* Warn if a .word value is too large when treated as a signed
1103
number. We already know it is not too negative. This is to
1104
catch over-large switches generated by gcc on the 68k. */
1105
if (!flag_signed_overflow_ok
1106
&& fixP->fx_size == 2
1107
&& add_number > 0x7fff)
1108
as_bad_where (fixP->fx_file, fixP->fx_line,
1109
_("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1111
(long) (fragP->fr_address + fixP->fx_where));
1113
} /* Not a bit fix. */
1115
#ifdef TC_VALIDATE_FIX
1116
skip: ATTRIBUTE_UNUSED_LABEL
1120
fprintf (stderr, "result:\n");
1123
} /* For each fixS in this segment. */
1127
fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1129
void *xxx ATTRIBUTE_UNUSED)
1131
segment_info_type *seginfo = seg_info (sec);
1133
fixup_segment (seginfo->fix_root, sec);
1137
install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1138
char *file, unsigned int line)
1141
bfd_reloc_status_type s;
1144
if (reloc->sym_ptr_ptr != NULL
1145
&& (sym = *reloc->sym_ptr_ptr) != NULL
1146
&& (sym->flags & BSF_KEEP) == 0
1147
&& ((sym->flags & BSF_SECTION_SYM) == 0
1148
|| (EMIT_SECTION_SYMBOLS
1149
&& !bfd_is_abs_section (sym->section))))
1150
as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1152
s = bfd_install_relocation (stdoutput, reloc,
1153
fragp->fr_literal, fragp->fr_address,
1159
case bfd_reloc_overflow:
1160
as_bad_where (file, line, _("relocation overflow"));
1162
case bfd_reloc_outofrange:
1163
as_bad_where (file, line, _("relocation out of range"));
1166
as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1172
get_frag_for_reloc (fragS *last_frag,
1173
const segment_info_type *seginfo,
1174
const struct reloc_list *r)
1178
for (f = last_frag; f != NULL; f = f->fr_next)
1179
if (f->fr_address <= r->u.b.r.address
1180
&& r->u.b.r.address < f->fr_address + f->fr_fix)
1183
for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1184
if (f->fr_address <= r->u.b.r.address
1185
&& r->u.b.r.address < f->fr_address + f->fr_fix)
1188
as_bad_where (r->file, r->line,
1189
_("reloc not within (fixed part of) section"));
1194
write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1196
segment_info_type *seginfo = seg_info (sec);
1198
struct reloc_list *my_reloc_list, **rp, *r;
1203
/* If seginfo is NULL, we did not create this section; don't do
1204
anything with it. */
1205
if (seginfo == NULL)
1209
for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1213
#ifdef RELOC_EXPANSION_POSSIBLE
1214
n *= MAX_RELOC_EXPANSION;
1217
/* Extract relocs for this section from reloc_list. */
1219
my_reloc_list = NULL;
1220
while ((r = *rp) != NULL)
1222
if (r->u.b.sec == sec)
1225
r->next = my_reloc_list;
1233
relocs = (arelent **) xcalloc (n, sizeof (arelent *));
1238
for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1243
#ifndef RELOC_EXPANSION_POSSIBLE
1252
fx_size = fixp->fx_size;
1253
slack = TC_FX_SIZE_SLACK (fixp);
1255
fx_size = fx_size > slack ? fx_size - slack : 0;
1256
loc = fixp->fx_where + fx_size;
1257
if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1258
as_bad_where (fixp->fx_file, fixp->fx_line,
1259
_("internal error: fixup not contained within frag"));
1261
#ifndef RELOC_EXPANSION_POSSIBLE
1262
*reloc = tc_gen_reloc (sec, fixp);
1264
reloc = tc_gen_reloc (sec, fixp);
1269
while (r != NULL && r->u.b.r.address < (*reloc)->address)
1271
fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1275
relocs[n++] = &r->u.b.r;
1276
install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1280
relocs[n++] = *reloc;
1281
install_reloc (sec, *reloc, fixp->fx_frag,
1282
fixp->fx_file, fixp->fx_line);
1283
#ifndef RELOC_EXPANSION_POSSIBLE
1293
fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1297
relocs[n++] = &r->u.b.r;
1298
install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1305
unsigned int k, j, nsyms;
1307
sympp = bfd_get_outsymbols (stdoutput);
1308
nsyms = bfd_get_symcount (stdoutput);
1309
for (k = 0; k < n; k++)
1310
if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1312
for (j = 0; j < nsyms; j++)
1313
if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1323
flagword flags = bfd_get_section_flags (abfd, sec);
1325
bfd_set_section_flags (abfd, sec, flags);
1326
bfd_set_reloc (stdoutput, sec, relocs, n);
1329
#ifdef SET_SECTION_RELOCS
1330
SET_SECTION_RELOCS (sec, relocs, n);
1337
fprintf (stderr, "relocs for sec %s\n", sec->name);
1338
for (k = 0; k < n; k++)
1340
arelent *rel = relocs[k];
1341
asymbol *s = *rel->sym_ptr_ptr;
1342
fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1343
k, rel, (unsigned long)rel->address, s->name,
1344
(unsigned long)rel->addend);
1351
compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1352
fragS **last_newf, struct obstack *ob)
1355
int total_out_size = 0;
1356
fragS *f = *last_newf;
1360
/* Call the compression routine repeatedly until it has finished
1361
processing the frag. */
1364
/* Reserve all the space available in the current chunk.
1365
If none is available, start a new frag. */
1366
avail_out = obstack_room (ob);
1369
obstack_finish (ob);
1370
f = frag_alloc (ob);
1371
f->fr_type = rs_fill;
1372
(*last_newf)->fr_next = f;
1374
avail_out = obstack_room (ob);
1377
as_fatal (_("can't extend frag"));
1378
next_out = obstack_next_free (ob);
1379
obstack_blank_fast (ob, avail_out);
1380
out_size = compress_data (strm, &contents, &in_size,
1381
&next_out, &avail_out);
1385
f->fr_fix += out_size;
1386
total_out_size += out_size;
1388
/* Return unused space. */
1390
obstack_blank_fast (ob, -avail_out);
1393
return total_out_size;
1397
compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1399
segment_info_type *seginfo = seg_info (sec);
1403
struct obstack *ob = &seginfo->frchainP->frch_obstack;
1404
bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1405
bfd_size_type compressed_size;
1406
const char *section_name;
1407
char *compressed_name;
1409
struct z_stream_s *strm;
1411
flagword flags = bfd_get_section_flags (abfd, sec);
1415
|| (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1418
section_name = bfd_get_section_name (stdoutput, sec);
1419
if (strncmp (section_name, ".debug_", 7) != 0)
1422
strm = compress_init ();
1426
/* Create a new frag to contain the "ZLIB" header. */
1427
first_newf = frag_alloc (ob);
1428
if (obstack_room (ob) < 12)
1429
first_newf = frag_alloc (ob);
1430
if (obstack_room (ob) < 12)
1431
as_fatal (_("can't extend frag %u chars"), 12);
1432
last_newf = first_newf;
1433
obstack_blank_fast (ob, 12);
1434
last_newf->fr_type = rs_fill;
1435
last_newf->fr_fix = 12;
1436
header = last_newf->fr_literal;
1437
memcpy (header, "ZLIB", 4);
1438
header[11] = uncompressed_size; uncompressed_size >>= 8;
1439
header[10] = uncompressed_size; uncompressed_size >>= 8;
1440
header[9] = uncompressed_size; uncompressed_size >>= 8;
1441
header[8] = uncompressed_size; uncompressed_size >>= 8;
1442
header[7] = uncompressed_size; uncompressed_size >>= 8;
1443
header[6] = uncompressed_size; uncompressed_size >>= 8;
1444
header[5] = uncompressed_size; uncompressed_size >>= 8;
1445
header[4] = uncompressed_size;
1446
compressed_size = 12;
1448
/* Stream the frags through the compression engine, adding new frags
1449
as necessary to accomodate the compressed output. */
1450
for (f = seginfo->frchainP->frch_root;
1459
gas_assert (f->fr_type == rs_fill);
1462
out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1466
compressed_size += out_size;
1468
fill_literal = f->fr_literal + f->fr_fix;
1469
fill_size = f->fr_var;
1470
count = f->fr_offset;
1471
gas_assert (count >= 0);
1472
if (fill_size && count)
1476
out_size = compress_frag (strm, fill_literal, (int) fill_size,
1480
compressed_size += out_size;
1485
/* Flush the compression state. */
1492
/* Reserve all the space available in the current chunk.
1493
If none is available, start a new frag. */
1494
avail_out = obstack_room (ob);
1499
obstack_finish (ob);
1500
newf = frag_alloc (ob);
1501
newf->fr_type = rs_fill;
1502
last_newf->fr_next = newf;
1504
avail_out = obstack_room (ob);
1507
as_fatal (_("can't extend frag"));
1508
next_out = obstack_next_free (ob);
1509
obstack_blank_fast (ob, avail_out);
1510
x = compress_finish (strm, &next_out, &avail_out, &out_size);
1514
last_newf->fr_fix += out_size;
1515
compressed_size += out_size;
1517
/* Return unused space. */
1519
obstack_blank_fast (ob, -avail_out);
1525
/* Replace the uncompressed frag list with the compressed frag list. */
1526
seginfo->frchainP->frch_root = first_newf;
1527
seginfo->frchainP->frch_last = last_newf;
1529
/* Update the section size and its name. */
1530
x = bfd_set_section_size (abfd, sec, compressed_size);
1532
compressed_name = (char *) xmalloc (strlen (section_name) + 2);
1533
compressed_name[0] = '.';
1534
compressed_name[1] = 'z';
1535
strcpy (compressed_name + 2, section_name + 1);
1536
bfd_section_name (stdoutput, sec) = compressed_name;
1540
write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1542
void *xxx ATTRIBUTE_UNUSED)
1544
segment_info_type *seginfo = seg_info (sec);
1545
addressT offset = 0;
1548
/* Write out the frags. */
1550
|| !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1553
for (f = seginfo->frchainP->frch_root;
1562
gas_assert (f->fr_type == rs_fill);
1565
x = bfd_set_section_contents (stdoutput, sec,
1566
f->fr_literal, (file_ptr) offset,
1567
(bfd_size_type) f->fr_fix);
1569
as_fatal (_("can't write %s: %s"), stdoutput->filename,
1570
bfd_errmsg (bfd_get_error ()));
1571
offset += f->fr_fix;
1573
fill_literal = f->fr_literal + f->fr_fix;
1574
fill_size = f->fr_var;
1575
count = f->fr_offset;
1576
gas_assert (count >= 0);
1577
if (fill_size && count)
1580
if (fill_size > sizeof (buf))
1582
/* Do it the old way. Can this ever happen? */
1585
x = bfd_set_section_contents (stdoutput, sec,
1588
(bfd_size_type) fill_size);
1590
as_fatal (_("can't write %s: %s"), stdoutput->filename,
1591
bfd_errmsg (bfd_get_error ()));
1592
offset += fill_size;
1597
/* Build a buffer full of fill objects and output it as
1598
often as necessary. This saves on the overhead of
1599
potentially lots of bfd_set_section_contents calls. */
1603
n_per_buf = sizeof (buf);
1604
memset (buf, *fill_literal, n_per_buf);
1609
n_per_buf = sizeof (buf) / fill_size;
1610
for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1611
memcpy (bufp, fill_literal, fill_size);
1613
for (; count > 0; count -= n_per_buf)
1615
n_per_buf = n_per_buf > count ? count : n_per_buf;
1616
x = bfd_set_section_contents
1617
(stdoutput, sec, buf, (file_ptr) offset,
1618
(bfd_size_type) n_per_buf * fill_size);
1620
as_fatal (_("cannot write to output file '%s': %s"),
1621
stdoutput->filename,
1622
bfd_errmsg (bfd_get_error ()));
1623
offset += n_per_buf * fill_size;
1631
merge_data_into_text (void)
1633
seg_info (text_section)->frchainP->frch_last->fr_next =
1634
seg_info (data_section)->frchainP->frch_root;
1635
seg_info (text_section)->frchainP->frch_last =
1636
seg_info (data_section)->frchainP->frch_last;
1637
seg_info (data_section)->frchainP = 0;
1648
/* Count symbols. We can't rely on a count made by the loop in
1649
write_object_file, because *_frob_file may add a new symbol or
1652
for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1658
bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1660
asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1661
symp = symbol_rootP;
1662
for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1664
asympp[i] = symbol_get_bfdsym (symp);
1665
if (asympp[i]->flags != BSF_SECTION_SYM
1666
|| !(bfd_is_const_section (asympp[i]->section)
1667
&& asympp[i]->section->symbol == asympp[i]))
1668
asympp[i]->flags |= BSF_KEEP;
1669
symbol_mark_written (symp);
1674
result = bfd_set_symtab (stdoutput, asympp, nsyms);
1675
gas_assert (result);
1676
symbol_table_frozen = 1;
1679
/* Finish the subsegments. After every sub-segment, we fake an
1680
".align ...". This conforms to BSD4.2 brane-damage. We then fake
1681
".fill 0" because that is the kind of frag that requires least
1682
thought. ".align" frags like to have a following frag since that
1683
makes calculating their intended length trivial. */
1685
#ifndef SUB_SEGMENT_ALIGN
1687
/* The last subsegment gets an alignment corresponding to the alignment
1688
of the section. This allows proper nop-filling at the end of
1689
code-bearing sections. */
1690
#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
1691
(!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1693
#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1698
subsegs_finish (void)
1700
struct frchain *frchainP;
1703
for (s = stdoutput->sections; s; s = s->next)
1705
segment_info_type *seginfo = seg_info (s);
1709
for (frchainP = seginfo->frchainP;
1711
frchainP = frchainP->frch_next)
1715
subseg_set (s, frchainP->frch_subseg);
1717
/* This now gets called even if we had errors. In that case,
1718
any alignment is meaningless, and, moreover, will look weird
1719
if we are generating a listing. */
1722
alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1723
if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1724
&& now_seg->entsize)
1726
unsigned int entsize = now_seg->entsize;
1729
while ((entsize & 1) == 0)
1734
if (entalign > alignment)
1735
alignment = entalign;
1739
if (subseg_text_p (now_seg))
1740
frag_align_code (alignment, 0);
1742
frag_align (alignment, 0, 0);
1744
/* frag_align will have left a new frag.
1745
Use this last frag for an empty ".fill".
1747
For this segment ...
1748
Create a last frag. Do not leave a "being filled in frag". */
1749
frag_wane (frag_now);
1750
frag_now->fr_fix = 0;
1751
know (frag_now->fr_next == NULL);
1756
/* Write the object file. */
1759
write_object_file (void)
1761
struct relax_seg_info rsi;
1762
#ifndef WORKING_DOT_WORD
1763
fragS *fragP; /* Track along all frags. */
1766
#ifdef md_pre_output_hook
1770
/* Do we really want to write it? */
1772
int n_warns, n_errs;
1773
n_warns = had_warnings ();
1774
n_errs = had_errors ();
1775
/* The -Z flag indicates that an object file should be generated,
1776
regardless of warnings and errors. */
1777
if (flag_always_generate_output)
1779
if (n_warns || n_errs)
1780
as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1781
n_errs, n_errs == 1 ? "" : "s",
1782
n_warns, n_warns == 1 ? "" : "s");
1787
as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1788
n_errs, n_errs == 1 ? "" : "s",
1789
n_warns, n_warns == 1 ? "" : "s");
1793
#ifdef md_pre_relax_hook
1797
/* From now on, we don't care about sub-segments. Build one frag chain
1798
for each segment. Linked thru fr_next. */
1800
/* Remove the sections created by gas for its own purposes. */
1804
bfd_section_list_remove (stdoutput, reg_section);
1805
bfd_section_list_remove (stdoutput, expr_section);
1806
stdoutput->section_count -= 2;
1808
bfd_map_over_sections (stdoutput, renumber_sections, &i);
1811
bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1813
/* We have two segments. If user gave -R flag, then we must put the
1814
data frags into the text segment. Do this before relaxing so
1815
we know to take advantage of -R and make shorter addresses. */
1816
if (flag_readonly_data_in_text)
1818
merge_data_into_text ();
1824
#ifndef WORKING_DOT_WORD
1825
/* We need to reset the markers in the broken word list and
1826
associated frags between calls to relax_segment (via
1827
relax_seg). Since the broken word list is global, we do it
1828
once per round, rather than locally in relax_segment for each
1830
struct broken_word *brokp;
1832
for (brokp = broken_words;
1833
brokp != (struct broken_word *) NULL;
1834
brokp = brokp->next_broken_word)
1838
if (brokp->dispfrag != (fragS *) NULL
1839
&& brokp->dispfrag->fr_type == rs_broken_word)
1840
brokp->dispfrag->fr_subtype = 0;
1845
bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1851
/* Note - Most ports will use the default value of
1852
TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
1853
local symbols to be resolved, removing their frag information.
1854
Some ports however, will not have finished relaxing all of
1855
their frags and will still need the local symbol frag
1856
information. These ports can set
1857
TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
1858
finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1860
bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1862
/* Relaxation has completed. Freeze all syms. */
1865
#ifdef md_post_relax_hook
1869
#ifndef WORKING_DOT_WORD
1871
struct broken_word *lie;
1872
struct broken_word **prevP;
1874
prevP = &broken_words;
1875
for (lie = broken_words; lie; lie = lie->next_broken_word)
1880
subseg_change (lie->seg, lie->subseg);
1881
exp.X_op = O_subtract;
1882
exp.X_add_symbol = lie->add;
1883
exp.X_op_symbol = lie->sub;
1884
exp.X_add_number = lie->addnum;
1885
#ifdef TC_CONS_FIX_NEW
1886
TC_CONS_FIX_NEW (lie->frag,
1887
lie->word_goes_here - lie->frag->fr_literal,
1890
fix_new_exp (lie->frag,
1891
lie->word_goes_here - lie->frag->fr_literal,
1892
2, &exp, 0, BFD_RELOC_16);
1894
*prevP = lie->next_broken_word;
1897
prevP = &(lie->next_broken_word);
1899
for (lie = broken_words; lie;)
1901
struct broken_word *untruth;
1903
addressT table_addr;
1904
addressT from_addr, to_addr;
1907
subseg_change (lie->seg, lie->subseg);
1908
fragP = lie->dispfrag;
1910
/* Find out how many broken_words go here. */
1913
untruth && untruth->dispfrag == fragP;
1914
untruth = untruth->next_broken_word)
1915
if (untruth->added == 1)
1918
table_ptr = lie->dispfrag->fr_opcode;
1919
table_addr = (lie->dispfrag->fr_address
1920
+ (table_ptr - lie->dispfrag->fr_literal));
1921
/* Create the jump around the long jumps. This is a short
1922
jump from table_ptr+0 to table_ptr+n*long_jump_size. */
1923
from_addr = table_addr;
1924
to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1925
md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1927
table_ptr += md_short_jump_size;
1928
table_addr += md_short_jump_size;
1931
lie && lie->dispfrag == fragP;
1932
m++, lie = lie->next_broken_word)
1934
if (lie->added == 2)
1936
/* Patch the jump table. */
1937
for (untruth = (struct broken_word *) (fragP->fr_symbol);
1938
untruth && untruth->dispfrag == fragP;
1939
untruth = untruth->next_broken_word)
1941
if (untruth->use_jump == lie)
1943
/* This is the offset from ??? to table_ptr+0.
1944
The target is the same for all users of this
1945
md_long_jump, but the "sub" bases (and hence the
1946
offsets) may be different. */
1947
addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1948
#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1949
TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1951
md_number_to_chars (untruth->word_goes_here, to_word, 2);
1955
/* Install the long jump. */
1956
/* This is a long jump from table_ptr+0 to the final target. */
1957
from_addr = table_addr;
1958
to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1959
md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1961
table_ptr += md_long_jump_size;
1962
table_addr += md_long_jump_size;
1966
#endif /* not WORKING_DOT_WORD */
1968
/* Resolve symbol values. This needs to be done before processing
1974
for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1975
resolve_symbol_value (symp);
1977
resolve_local_symbol_values ();
1978
resolve_reloc_expr_symbols ();
1982
#ifdef tc_frob_file_before_adjust
1983
tc_frob_file_before_adjust ();
1985
#ifdef obj_frob_file_before_adjust
1986
obj_frob_file_before_adjust ();
1989
bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1991
#ifdef tc_frob_file_before_fix
1992
tc_frob_file_before_fix ();
1994
#ifdef obj_frob_file_before_fix
1995
obj_frob_file_before_fix ();
1998
bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2000
/* Set up symbol table, and write it out. */
2004
bfd_boolean skip_next_symbol = FALSE;
2006
for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2011
if (skip_next_symbol)
2013
/* Don't do anything besides moving the value of the
2014
symbol from the GAS value-field to the BFD value-field. */
2015
symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2016
skip_next_symbol = FALSE;
2020
if (symbol_mri_common_p (symp))
2022
if (S_IS_EXTERNAL (symp))
2023
as_bad (_("%s: global symbols not supported in common sections"),
2025
symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2029
name = S_GET_NAME (symp);
2033
decode_local_label_name ((char *) S_GET_NAME (symp));
2034
/* They only differ if `name' is a fb or dollar local
2036
if (name2 != name && ! S_IS_DEFINED (symp))
2037
as_bad (_("local label `%s' is not defined"), name2);
2040
/* Do it again, because adjust_reloc_syms might introduce
2041
more symbols. They'll probably only be section symbols,
2042
but they'll still need to have the values computed. */
2043
resolve_symbol_value (symp);
2045
/* Skip symbols which were equated to undefined or common
2047
if (symbol_equated_reloc_p (symp)
2048
|| S_IS_WEAKREFR (symp))
2050
const char *sname = S_GET_NAME (symp);
2052
if (S_IS_COMMON (symp)
2053
&& !TC_FAKE_LABEL (sname)
2054
&& !S_IS_WEAKREFR (symp)
2055
&& (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2057
expressionS *e = symbol_get_value_expression (symp);
2059
as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2060
sname, S_GET_NAME (e->X_add_symbol));
2062
if (S_GET_SEGMENT (symp) == reg_section)
2064
/* Report error only if we know the symbol name. */
2065
if (S_GET_NAME (symp) != reg_section->name)
2066
as_bad (_("can't make global register symbol `%s'"),
2069
symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2073
#ifdef obj_frob_symbol
2074
obj_frob_symbol (symp, punt);
2076
#ifdef tc_frob_symbol
2077
if (! punt || symbol_used_in_reloc_p (symp))
2078
tc_frob_symbol (symp, punt);
2081
/* If we don't want to keep this symbol, splice it out of
2082
the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2083
want section symbols. Otherwise, we skip local symbols
2084
and symbols that the frob_symbol macros told us to punt,
2085
but we keep such symbols if they are used in relocs. */
2086
if (symp == abs_section_sym
2087
|| (! EMIT_SECTION_SYMBOLS
2088
&& symbol_section_p (symp))
2089
/* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2090
opposites. Sometimes the former checks flags and the
2091
latter examines the name... */
2092
|| (!S_IS_EXTERNAL (symp)
2093
&& (punt || S_IS_LOCAL (symp) ||
2094
(S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2095
&& ! symbol_used_in_reloc_p (symp)))
2097
symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2099
/* After symbol_remove, symbol_next(symp) still returns
2100
the one that came after it in the chain. So we don't
2101
need to do any extra cleanup work here. */
2105
/* Make sure we really got a value for the symbol. */
2106
if (! symbol_resolved_p (symp))
2108
as_bad (_("can't resolve value for symbol `%s'"),
2110
symbol_mark_resolved (symp);
2113
/* Set the value into the BFD symbol. Up til now the value
2114
has only been kept in the gas symbolS struct. */
2115
symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2117
/* A warning construct is a warning symbol followed by the
2118
symbol warned about. Don't let anything object-format or
2119
target-specific muck with it; it's ready for output. */
2120
if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2121
skip_next_symbol = TRUE;
2127
/* Now do any format-specific adjustments to the symbol table, such
2128
as adding file symbols. */
2129
#ifdef tc_adjust_symtab
2130
tc_adjust_symtab ();
2132
#ifdef obj_adjust_symtab
2133
obj_adjust_symtab ();
2136
/* Stop if there is an error. */
2140
/* Now that all the sizes are known, and contents correct, we can
2141
start writing to the file. */
2144
/* If *_frob_file changes the symbol value at this point, it is
2145
responsible for moving the changed value into symp->bsym->value
2146
as well. Hopefully all symbol value changing can be done in
2151
#ifdef obj_frob_file
2154
#ifdef obj_coff_generate_pdata
2155
obj_coff_generate_pdata ();
2157
bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2159
#ifdef tc_frob_file_after_relocs
2160
tc_frob_file_after_relocs ();
2162
#ifdef obj_frob_file_after_relocs
2163
obj_frob_file_after_relocs ();
2166
/* Once all relocations have been written, we can compress the
2167
contents of the debug sections. This needs to be done before
2168
we start writing any sections, because it will affect the file
2169
layout, which is fixed once we start writing contents. */
2170
if (flag_compress_debug)
2171
bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2173
bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2176
#ifdef TC_GENERIC_RELAX_TABLE
2177
/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2180
relax_frag (segT segment, fragS *fragP, long stretch)
2182
const relax_typeS *this_type;
2183
const relax_typeS *start_type;
2184
relax_substateT next_state;
2185
relax_substateT this_state;
2191
const relax_typeS *table;
2193
target = fragP->fr_offset;
2194
address = fragP->fr_address;
2195
table = TC_GENERIC_RELAX_TABLE;
2196
this_state = fragP->fr_subtype;
2197
start_type = this_type = table + this_state;
2198
symbolP = fragP->fr_symbol;
2204
sym_frag = symbol_get_frag (symbolP);
2206
#ifndef DIFF_EXPR_OK
2207
know (sym_frag != NULL);
2209
know (S_GET_SEGMENT (symbolP) != absolute_section
2210
|| sym_frag == &zero_address_frag);
2211
target += S_GET_VALUE (symbolP);
2213
/* If SYM_FRAG has yet to be reached on this pass, assume it
2214
will move by STRETCH just as we did, unless there is an
2215
alignment frag between here and SYM_FRAG. An alignment may
2216
well absorb any STRETCH, and we don't want to choose a larger
2217
branch insn by overestimating the needed reach of this
2218
branch. It isn't critical to calculate TARGET exactly; We
2219
know we'll be doing another pass if STRETCH is non-zero. */
2222
&& sym_frag->relax_marker != fragP->relax_marker
2223
&& S_GET_SEGMENT (symbolP) == segment)
2226
|| sym_frag->region == fragP->region)
2228
/* If we get here we know we have a forward branch. This
2229
relax pass may have stretched previous instructions so
2230
far that omitting STRETCH would make the branch
2231
negative. Don't allow this in case the negative reach is
2232
large enough to require a larger branch instruction. */
2233
else if (target < address)
2234
target = fragP->fr_next->fr_address + stretch;
2238
aim = target - address - fragP->fr_fix;
2239
#ifdef TC_PCREL_ADJUST
2240
/* Currently only the ns32k family needs this. */
2241
aim += TC_PCREL_ADJUST (fragP);
2244
#ifdef md_prepare_relax_scan
2245
/* Formerly called M68K_AIM_KLUDGE. */
2246
md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2251
/* Look backwards. */
2252
for (next_state = this_type->rlx_more; next_state;)
2253
if (aim >= this_type->rlx_backward)
2257
/* Grow to next state. */
2258
this_state = next_state;
2259
this_type = table + this_state;
2260
next_state = this_type->rlx_more;
2265
/* Look forwards. */
2266
for (next_state = this_type->rlx_more; next_state;)
2267
if (aim <= this_type->rlx_forward)
2271
/* Grow to next state. */
2272
this_state = next_state;
2273
this_type = table + this_state;
2274
next_state = this_type->rlx_more;
2278
growth = this_type->rlx_length - start_type->rlx_length;
2280
fragP->fr_subtype = this_state;
2284
#endif /* defined (TC_GENERIC_RELAX_TABLE) */
2286
/* Relax_align. Advance location counter to next address that has 'alignment'
2287
lowest order bits all 0s, return size of adjustment made. */
2288
static relax_addressT
2289
relax_align (register relax_addressT address, /* Address now. */
2290
register int alignment /* Alignment (binary). */)
2292
relax_addressT mask;
2293
relax_addressT new_address;
2295
mask = ~((~0) << alignment);
2296
new_address = (address + mask) & (~mask);
2297
#ifdef LINKER_RELAXING_SHRINKS_ONLY
2299
/* We must provide lots of padding, so the linker can discard it
2300
when needed. The linker will not add extra space, ever. */
2301
new_address += (1 << alignment);
2303
return (new_address - address);
2306
/* Now we have a segment, not a crowd of sub-segments, we can make
2311
After this, all frags in this segment have addresses that are correct
2312
within the segment. Since segments live in different file addresses,
2313
these frag addresses may not be the same as final object-file
2317
relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2319
unsigned long frag_count;
2321
relax_addressT address;
2325
/* In case md_estimate_size_before_relax() wants to make fixSs. */
2326
subseg_change (segment, 0);
2328
/* For each frag in segment: count and store (a 1st guess of)
2332
for (frag_count = 0, fragP = segment_frag_root;
2334
fragP = fragP->fr_next, frag_count ++)
2336
fragP->region = region;
2337
fragP->relax_marker = 0;
2338
fragP->fr_address = address;
2339
address += fragP->fr_fix;
2341
switch (fragP->fr_type)
2344
address += fragP->fr_offset * fragP->fr_var;
2351
addressT offset = relax_align (address, (int) fragP->fr_offset);
2353
if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2356
if (offset % fragP->fr_var != 0)
2358
as_bad_where (fragP->fr_file, fragP->fr_line,
2359
_("alignment padding (%lu bytes) not a multiple of %ld"),
2360
(unsigned long) offset, (long) fragP->fr_var);
2361
offset -= (offset % fragP->fr_var);
2370
/* Assume .org is nugatory. It will grow with 1st relax. */
2377
case rs_machine_dependent:
2378
/* If fr_symbol is an expression, this call to
2379
resolve_symbol_value sets up the correct segment, which will
2380
likely be needed in md_estimate_size_before_relax. */
2381
if (fragP->fr_symbol)
2382
resolve_symbol_value (fragP->fr_symbol);
2384
address += md_estimate_size_before_relax (fragP, segment);
2387
#ifndef WORKING_DOT_WORD
2388
/* Broken words don't concern us yet. */
2389
case rs_broken_word:
2394
/* Initial guess is always 1; doing otherwise can result in
2395
stable solutions that are larger than the minimum. */
2396
address += fragP->fr_offset = 1;
2400
address += eh_frame_estimate_size_before_relax (fragP);
2404
address += dwarf2dbg_estimate_size_before_relax (fragP);
2408
BAD_CASE (fragP->fr_type);
2415
unsigned long max_iterations;
2417
/* Cumulative address adjustment. */
2420
/* Have we made any adjustment this pass? We can't just test
2421
stretch because one piece of code may have grown and another
2425
/* Most horrible, but gcc may give us some exception data that
2426
is impossible to assemble, of the form
2430
.uleb128 end - start
2436
If the leb128 is two bytes in size, then end-start is 128*128,
2437
which requires a three byte leb128. If the leb128 is three
2438
bytes in size, then end-start is 128*128-1, which requires a
2439
two byte leb128. We work around this dilemma by inserting
2440
an extra 4 bytes of alignment just after the .align. This
2441
works because the data after the align is accessed relative to
2444
This counter is used in a tiny state machine to detect
2445
whether a leb128 followed by an align is impossible to
2447
int rs_leb128_fudge = 0;
2449
/* We want to prevent going into an infinite loop where one frag grows
2450
depending upon the location of a symbol which is in turn moved by
2451
the growing frag. eg:
2457
So we dictate that this algorithm can be at most O2. */
2458
max_iterations = frag_count * frag_count;
2459
/* Check for overflow. */
2460
if (max_iterations < frag_count)
2461
max_iterations = frag_count;
2469
for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2472
addressT was_address;
2476
fragP->relax_marker ^= 1;
2477
was_address = fragP->fr_address;
2478
address = fragP->fr_address += stretch;
2479
symbolP = fragP->fr_symbol;
2480
offset = fragP->fr_offset;
2482
switch (fragP->fr_type)
2484
case rs_fill: /* .fill never relaxes. */
2488
#ifndef WORKING_DOT_WORD
2489
/* JF: This is RMS's idea. I do *NOT* want to be blamed
2490
for it I do not want to write it. I do not want to have
2491
anything to do with it. This is not the proper way to
2492
implement this misfeature. */
2493
case rs_broken_word:
2495
struct broken_word *lie;
2496
struct broken_word *untruth;
2498
/* Yes this is ugly (storing the broken_word pointer
2499
in the symbol slot). Still, this whole chunk of
2500
code is ugly, and I don't feel like doing anything
2501
about it. Think of it as stubbornness in action. */
2503
for (lie = (struct broken_word *) (fragP->fr_symbol);
2504
lie && lie->dispfrag == fragP;
2505
lie = lie->next_broken_word)
2511
offset = (S_GET_VALUE (lie->add)
2513
- S_GET_VALUE (lie->sub));
2514
if (offset <= -32768 || offset >= 32767)
2516
if (flag_warn_displacement)
2519
sprint_value (buf, (addressT) lie->addnum);
2520
as_warn_where (fragP->fr_file, fragP->fr_line,
2521
_(".word %s-%s+%s didn't fit"),
2522
S_GET_NAME (lie->add),
2523
S_GET_NAME (lie->sub),
2526
if (fragP->fr_subtype == 0)
2528
fragP->fr_subtype++;
2529
growth += md_short_jump_size;
2532
/* Redirect *all* words of this table with the same
2533
target, lest we have to handle the case where the
2534
same target but with a offset that fits on this
2535
round overflows at the next relaxation round. */
2536
for (untruth = (struct broken_word *) (fragP->fr_symbol);
2537
untruth && untruth->dispfrag == lie->dispfrag;
2538
untruth = untruth->next_broken_word)
2539
if ((symbol_get_frag (untruth->add)
2540
== symbol_get_frag (lie->add))
2541
&& (S_GET_VALUE (untruth->add)
2542
== S_GET_VALUE (lie->add)))
2545
untruth->use_jump = lie;
2549
growth += md_long_jump_size;
2554
} /* case rs_broken_word */
2560
addressT oldoff, newoff;
2562
oldoff = relax_align (was_address + fragP->fr_fix,
2564
newoff = relax_align (address + fragP->fr_fix,
2567
if (fragP->fr_subtype != 0)
2569
if (oldoff > fragP->fr_subtype)
2571
if (newoff > fragP->fr_subtype)
2575
growth = newoff - oldoff;
2577
/* If this align happens to follow a leb128 and
2578
we have determined that the leb128 is bouncing
2579
in size, then break the cycle by inserting an
2582
&& (rs_leb128_fudge & 16) != 0
2583
&& (rs_leb128_fudge & 15) >= 2)
2585
segment_info_type *seginfo = seg_info (segment);
2586
struct obstack *ob = &seginfo->frchainP->frch_obstack;
2589
newf = frag_alloc (ob);
2590
obstack_blank_fast (ob, fragP->fr_var);
2591
obstack_finish (ob);
2592
memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2593
memcpy (newf->fr_literal,
2594
fragP->fr_literal + fragP->fr_fix,
2596
newf->fr_type = rs_fill;
2597
newf->fr_address = address + fragP->fr_fix + newoff;
2599
newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2601
if (newf->fr_offset * newf->fr_var
2602
!= (offsetT) 1 << fragP->fr_offset)
2604
newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2607
/* Include size of new frag in GROWTH. */
2608
growth += newf->fr_offset * newf->fr_var;
2609
/* Adjust the new frag address for the amount
2610
we'll add when we process the new frag. */
2611
newf->fr_address -= stretch + growth;
2612
newf->relax_marker ^= 1;
2613
fragP->fr_next = newf;
2615
as_warn (_("padding added"));
2623
addressT target = offset;
2628
/* Convert from an actual address to an octet offset
2629
into the section. Here it is assumed that the
2630
section's VMA is zero, and can omit subtracting it
2631
from the symbol's value to get the address offset. */
2632
know (S_GET_SEGMENT (symbolP)->vma == 0);
2633
target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2636
know (fragP->fr_next);
2637
after = fragP->fr_next->fr_address + stretch;
2638
growth = target - after;
2643
/* Don't error on first few frag relax passes.
2644
The symbol might be an expression involving
2645
symbol values from other sections. If those
2646
sections have not yet been processed their
2647
frags will all have zero addresses, so we
2648
will calculate incorrect values for them. The
2649
number of passes we allow before giving an
2650
error is somewhat arbitrary. It should be at
2651
least one, with larger values requiring
2652
increasingly contrived dependencies between
2653
frags to trigger a false error. */
2656
/* Force another pass. */
2661
/* Growth may be negative, but variable part of frag
2662
cannot have fewer than 0 chars. That is, we can't
2664
as_bad_where (fragP->fr_file, fragP->fr_line,
2665
_("attempt to move .org backwards"));
2667
/* We've issued an error message. Change the
2668
frag to avoid cascading errors. */
2669
fragP->fr_type = rs_align;
2670
fragP->fr_subtype = 0;
2671
fragP->fr_offset = 0;
2672
fragP->fr_fix = after - address;
2683
amount = S_GET_VALUE (symbolP);
2684
if (S_GET_SEGMENT (symbolP) != absolute_section
2685
|| S_IS_COMMON (symbolP)
2686
|| ! S_IS_DEFINED (symbolP))
2688
as_bad_where (fragP->fr_file, fragP->fr_line,
2689
_(".space specifies non-absolute value"));
2690
/* Prevent repeat of this error message. */
2691
fragP->fr_symbol = 0;
2693
else if (amount < 0)
2695
/* Don't error on first few frag relax passes.
2696
See rs_org comment for a longer explanation. */
2703
as_warn_where (fragP->fr_file, fragP->fr_line,
2704
_(".space or .fill with negative value, ignored"));
2705
fragP->fr_symbol = 0;
2708
growth = (was_address + fragP->fr_fix + amount
2709
- fragP->fr_next->fr_address);
2713
case rs_machine_dependent:
2714
#ifdef md_relax_frag
2715
growth = md_relax_frag (segment, fragP, stretch);
2717
#ifdef TC_GENERIC_RELAX_TABLE
2718
/* The default way to relax a frag is to look through
2719
TC_GENERIC_RELAX_TABLE. */
2720
growth = relax_frag (segment, fragP, stretch);
2721
#endif /* TC_GENERIC_RELAX_TABLE */
2730
value = resolve_symbol_value (fragP->fr_symbol);
2731
size = sizeof_leb128 (value, fragP->fr_subtype);
2732
growth = size - fragP->fr_offset;
2733
fragP->fr_offset = size;
2738
growth = eh_frame_relax_frag (fragP);
2742
growth = dwarf2dbg_relax_frag (fragP);
2746
BAD_CASE (fragP->fr_type);
2753
if (fragP->fr_type == rs_leb128)
2754
rs_leb128_fudge += 16;
2755
else if (fragP->fr_type == rs_align
2756
&& (rs_leb128_fudge & 16) != 0
2758
rs_leb128_fudge += 16;
2760
rs_leb128_fudge = 0;
2765
&& (rs_leb128_fudge & 16) == 0
2766
&& (rs_leb128_fudge & -16) != 0)
2767
rs_leb128_fudge += 1;
2769
rs_leb128_fudge = 0;
2771
/* Until nothing further to relax. */
2772
while (stretched && -- max_iterations);
2775
as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2776
segment_name (segment));
2779
for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2780
if (fragP->last_fr_address != fragP->fr_address)
2782
fragP->last_fr_address = fragP->fr_address;
2789
number_to_chars_bigendian (char *buf, valueT val, int n)
2795
buf[n] = val & 0xff;
2801
number_to_chars_littleendian (char *buf, valueT val, int n)
2807
*buf++ = val & 0xff;
2813
write_print_statistics (FILE *file)
2815
fprintf (file, "fixups: %d\n", n_fixups);
2818
/* For debugging. */
2819
extern int indent_level;
2822
print_fixup (fixS *fixp)
2825
fprintf (stderr, "fix ");
2826
fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2827
fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2829
fprintf (stderr, " pcrel");
2830
if (fixp->fx_pcrel_adjust)
2831
fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2832
if (fixp->fx_im_disp)
2835
fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2837
fprintf (stderr, " im_disp");
2841
fprintf (stderr, " tcbit");
2843
fprintf (stderr, " done");
2844
fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
2845
fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2846
fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2847
(long) fixp->fx_where,
2848
(unsigned long) fixp->fx_offset,
2849
(unsigned long) fixp->fx_addnumber);
2850
fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2854
fprintf (stderr, "\n +<");
2855
print_symbol_value_1 (stderr, fixp->fx_addsy);
2856
fprintf (stderr, ">");
2860
fprintf (stderr, "\n -<");
2861
print_symbol_value_1 (stderr, fixp->fx_subsy);
2862
fprintf (stderr, ">");
2864
fprintf (stderr, "\n");
2865
#ifdef TC_FIX_DATA_PRINT
2866
TC_FIX_DATA_PRINT (stderr, fixp);
added
removed
binutils-2.23.52.20130611/gas/write.c
