projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reverts patches providing octet support in dwarf
[deliverable/binutils-gdb.git] / gas / write.c
CommitLineData
252b5132 1/* write.c - emit .o file
82704155 2 Copyright (C) 1986-2019 Free Software Foundation, Inc.
252b5132
RH		 3
4 This file is part of GAS, the GNU Assembler.
5
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
ec2655a6 8 the Free Software Foundation; either version 3, or (at your option)
252b5132
RH		 9 any later version.
10
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.
15
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
4b4da160
NC		 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
252b5132 20
33eaf5de 21/* This thing should be set up to do byte ordering correctly. But... */
252b5132
RH		 22
23#include "as.h"
24#include "subsegs.h"
25#include "obstack.h"
26#include "output-file.h"
220e750f 27#include "dwarf2dbg.h"
0acf065b 28#include "compress-debug.h"
252b5132 29
252b5132 30#ifndef TC_FORCE_RELOCATION
a161fe53 31#define TC_FORCE_RELOCATION(FIX) \
ae6063d4 32 (generic_force_reloc (FIX))
252b5132
RH		 33#endif
34
a161fe53
AM		 35#ifndef TC_FORCE_RELOCATION_ABS
36#define TC_FORCE_RELOCATION_ABS(FIX) \
37 (TC_FORCE_RELOCATION (FIX))
38#endif
39
91cb9803 40#define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \
a161fe53 41 (!(FIX)->fx_pcrel \
a161fe53 42 || TC_FORCE_RELOCATION (FIX))
91cb9803
AM		 43#ifndef TC_FORCE_RELOCATION_LOCAL
44#define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL
a161fe53
AM		 45#endif
46
91cb9803
AM		 47#define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \
48 (!SEG_NORMAL (SEG))
a161fe53 49#ifndef TC_FORCE_RELOCATION_SUB_SAME
91cb9803 50#define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME
a161fe53
AM		 51#endif
52
9a97a5d7
AM		 53#ifndef md_register_arithmetic
54# define md_register_arithmetic 1
55#endif
56
a161fe53 57#ifndef TC_FORCE_RELOCATION_SUB_ABS
9a97a5d7
AM		 58#define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \
59 (!md_register_arithmetic && (SEG) == reg_section)
a161fe53
AM		 60#endif
61
62#ifndef TC_FORCE_RELOCATION_SUB_LOCAL
63#ifdef DIFF_EXPR_OK
5db484ff
AM		 64#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \
65 (!md_register_arithmetic && (SEG) == reg_section)
a161fe53 66#else
5db484ff 67#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1
a161fe53
AM		 68#endif
69#endif
70
71#ifndef TC_VALIDATE_FIX_SUB
72#ifdef UNDEFINED_DIFFERENCE_OK
73/* The PA needs this for PIC code generation. */
5db484ff
AM		 74#define TC_VALIDATE_FIX_SUB(FIX, SEG) \
75 (md_register_arithmetic || (SEG) != reg_section)
a161fe53 76#else
5db484ff
AM		 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))
a161fe53 81#endif
252b5132
RH		 82#endif
83
58a77e41
EC		 84#ifndef TC_LINKRELAX_FIXUP
85#define TC_LINKRELAX_FIXUP(SEG) 1
86#endif
87
a161fe53
AM		 88#ifndef MD_APPLY_SYM_VALUE
89#define MD_APPLY_SYM_VALUE(FIX) 1
8f36cd18 90#endif
ef99799a 91
87548816
NC		 92#ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG
93#define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1
94#endif
95
252b5132 96#ifndef MD_PCREL_FROM_SECTION
df44284e 97#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX)
252b5132
RH		 98#endif
99
c9cd7160
L		 100#ifndef TC_FAKE_LABEL
101#define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0)
102#endif
103
d31f0f6d
AM		 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
113
6386f3a7
AM		 114/* Used to control final evaluation of expressions. */
115int finalize_syms = 0;
e46d99eb 116
252b5132 117int symbol_table_frozen;
a161fe53
AM		 118
119symbolS *abs_section_sym;
120
26346241
AM		 121/* Remember the value of dot when parsing expressions. */
122addressT dot_value;
123
8e723a10
CLT		 124/* The frag that dot_value is based from. */
125fragS *dot_frag;
126
05e9452c
AM		 127/* Relocs generated by ".reloc" pseudo. */
128struct reloc_list* reloc_list;
129
d7342424 130void print_fixup (fixS *);
252b5132 131
252b5132
RH		 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. */
136static int frags_chained = 0;
252b5132
RH		 137
138static int n_fixups;
139
df44284e 140#define RELOC_ENUM enum bfd_reloc_code_real
df44284e 141
efaf0ba4
NC		 142/* Create a fixS in obstack 'notes'. */
143
252b5132 144static fixS *
d7342424 145fix_new_internal (fragS *frag, /* Which frag? */
90bd3c90
AM		 146 unsigned long where, /* Where in that frag? */
147 unsigned long size, /* 1, 2, or 4 usually. */
d7342424
KH		 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. */
032fbb7a 152 RELOC_ENUM r_type /* Relocation type. */,
c865e45b 153 int at_beginning) /* Add to the start of the list? */
252b5132
RH		 154{
155 fixS *fixP;
156
157 n_fixups++;
158
1e9cc1c2 159 fixP = (fixS *) obstack_alloc (&notes, sizeof (fixS));
252b5132
RH		 160
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)
166 {
90bd3c90 167 as_bad (_("field fx_size too small to hold %lu"), size);
252b5132
RH		 168 abort ();
169 }
170 fixP->fx_addsy = add_symbol;
171 fixP->fx_subsy = sub_symbol;
172 fixP->fx_offset = offset;
26346241 173 fixP->fx_dot_value = dot_value;
8e723a10 174 fixP->fx_dot_frag = dot_frag;
252b5132 175 fixP->fx_pcrel = pcrel;
252b5132 176 fixP->fx_r_type = r_type;
252b5132 177 fixP->fx_pcrel_adjust = 0;
252b5132
RH		 178 fixP->fx_addnumber = 0;
179 fixP->fx_tcbit = 0;
20ee54e8 180 fixP->fx_tcbit2 = 0;
252b5132
RH		 181 fixP->fx_done = 0;
182 fixP->fx_no_overflow = 0;
183 fixP->fx_signed = 0;
184
185#ifdef USING_CGEN
186 fixP->fx_cgen.insn = NULL;
187 fixP->fx_cgen.opinfo = 0;
188#endif
189
190#ifdef TC_FIX_TYPE
efaf0ba4 191 TC_INIT_FIX_DATA (fixP);
252b5132
RH		 192#endif
193
3b4dbbbf 194 fixP->fx_file = as_where (&fixP->fx_line);
252b5132 195
252b5132
RH		 196 {
197
252b5132
RH		 198 fixS **seg_fix_rootP = (frags_chained
199 ? &seg_info (now_seg)->fix_root
200 : &frchain_now->fix_root);
201 fixS **seg_fix_tailP = (frags_chained
202 ? &seg_info (now_seg)->fix_tail
203 : &frchain_now->fix_tail);
252b5132 204
c865e45b
RS		 205 if (at_beginning)
206 {
207 fixP->fx_next = *seg_fix_rootP;
208 *seg_fix_rootP = fixP;
209 if (fixP->fx_next == NULL)
210 *seg_fix_tailP = fixP;
211 }
252b5132 212 else
c865e45b
RS		 213 {
214 fixP->fx_next = NULL;
215 if (*seg_fix_tailP)
216 (*seg_fix_tailP)->fx_next = fixP;
217 else
218 *seg_fix_rootP = fixP;
219 *seg_fix_tailP = fixP;
220 }
252b5132
RH		 221 }
222
223 return fixP;
224}
225
226/* Create a fixup relative to a symbol (plus a constant). */
227
228fixS *
90bd3c90
AM		 229fix_new (fragS *frag, /* Which frag? */
230 unsigned long where, /* Where in that frag? */
231 unsigned long size, /* 1, 2, or 4 usually. */
232 symbolS *add_symbol, /* X_add_symbol. */
d7342424
KH		 233 offsetT offset, /* X_add_number. */
234 int pcrel, /* TRUE if PC-relative relocation. */
235 RELOC_ENUM r_type /* Relocation type. */)
252b5132
RH		 236{
237 return fix_new_internal (frag, where, size, add_symbol,
c865e45b 238 (symbolS *) NULL, offset, pcrel, r_type, FALSE);
252b5132
RH		 239}
240
241/* Create a fixup for an expression. Currently we only support fixups
242 for difference expressions. That is itself more than most object
243 file formats support anyhow. */
244
245fixS *
d7342424 246fix_new_exp (fragS *frag, /* Which frag? */
90bd3c90
AM		 247 unsigned long where, /* Where in that frag? */
248 unsigned long size, /* 1, 2, or 4 usually. */
d7342424
KH		 249 expressionS *exp, /* Expression. */
250 int pcrel, /* TRUE if PC-relative relocation. */
251 RELOC_ENUM r_type /* Relocation type. */)
252b5132
RH		 252{
253 symbolS *add = NULL;
254 symbolS *sub = NULL;
255 offsetT off = 0;
256
257 switch (exp->X_op)
258 {
259 case O_absent:
260 break;
261
37006e43
NC		 262 case O_register:
263 as_bad (_("register value used as expression"));
264 break;
265
252b5132
RH		 266 case O_add:
267 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
268 the difference expression cannot immediately be reduced. */
269 {
270 symbolS *stmp = make_expr_symbol (exp);
58a77e41 271
252b5132
RH		 272 exp->X_op = O_symbol;
273 exp->X_op_symbol = 0;
274 exp->X_add_symbol = stmp;
275 exp->X_add_number = 0;
58a77e41 276
252b5132
RH		 277 return fix_new_exp (frag, where, size, exp, pcrel, r_type);
278 }
279
280 case O_symbol_rva:
281 add = exp->X_add_symbol;
282 off = exp->X_add_number;
252b5132 283 r_type = BFD_RELOC_RVA;
252b5132
RH		 284 break;
285
286 case O_uminus:
287 sub = exp->X_add_symbol;
288 off = exp->X_add_number;
289 break;
290
291 case O_subtract:
292 sub = exp->X_op_symbol;
293 /* Fall through. */
294 case O_symbol:
295 add = exp->X_add_symbol;
efaf0ba4 296 /* Fall through. */
252b5132
RH		 297 case O_constant:
298 off = exp->X_add_number;
299 break;
300
301 default:
302 add = make_expr_symbol (exp);
303 break;
304 }
305
c865e45b
RS		 306 return fix_new_internal (frag, where, size, add, sub, off, pcrel,
307 r_type, FALSE);
308}
309
310/* Create a fixup at the beginning of FRAG. The arguments are the same
311 as for fix_new, except that WHERE is implicitly 0. */
312
313fixS *
90bd3c90 314fix_at_start (fragS *frag, unsigned long size, symbolS *add_symbol,
c865e45b
RS		 315 offsetT offset, int pcrel, RELOC_ENUM r_type)
316{
317 return fix_new_internal (frag, 0, size, add_symbol,
318 (symbolS *) NULL, offset, pcrel, r_type, TRUE);
252b5132
RH		 319}
320
ae6063d4
AM		 321/* Generic function to determine whether a fixup requires a relocation. */
322int
d7342424 323generic_force_reloc (fixS *fix)
ae6063d4 324{
ae6063d4
AM		 325 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
326 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
327 return 1;
7be1c489 328
61e192bf
NC		 329 if (fix->fx_addsy == NULL)
330 return 0;
331
ae6063d4
AM		 332 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
333}
334
252b5132
RH		 335/* Append a string onto another string, bumping the pointer along. */
336void
d7342424 337append (char **charPP, char *fromP, unsigned long length)
252b5132 338{
efaf0ba4 339 /* Don't trust memcpy() of 0 chars. */
252b5132
RH		 340 if (length == 0)
341 return;
342
343 memcpy (*charPP, fromP, length);
344 *charPP += length;
345}
346
efaf0ba4
NC		 347/* This routine records the largest alignment seen for each segment.
348 If the beginning of the segment is aligned on the worst-case
349 boundary, all of the other alignments within it will work. At
350 least one object format really uses this info. */
351
252b5132 352void
d7342424
KH		 353record_alignment (/* Segment to which alignment pertains. */
354 segT seg,
355 /* Alignment, as a power of 2 (e.g., 1 => 2-byte
356 boundary, 2 => 4-byte boundary, etc.) */
9136aa49 357 unsigned int align)
252b5132
RH		 358{
359 if (seg == absolute_section)
360 return;
7be1c489 361
fd361982
AM		 362 if (align > bfd_section_alignment (seg))
363 bfd_set_section_alignment (seg, align);
252b5132
RH		 364}
365
0a9ef439 366int
d7342424 367get_recorded_alignment (segT seg)
0a9ef439
RH		 368{
369 if (seg == absolute_section)
370 return 0;
7be1c489 371
fd361982 372 return bfd_section_alignment (seg);
0a9ef439
RH		 373}
374
252b5132
RH		 375/* Reset the section indices after removing the gas created sections. */
376
377static void
e7ff5c73 378renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
252b5132
RH		 379{
380 int *countp = (int *) countparg;
381
382 sec->index = *countp;
383 ++*countp;
384}
385
252b5132 386static fragS *
d7342424 387chain_frchains_together_1 (segT section, struct frchain *frchp)
252b5132
RH		 388{
389 fragS dummy, *prev_frag = &dummy;
252b5132 390 fixS fix_dummy, *prev_fix = &fix_dummy;
252b5132 391
c9049d30 392 for (; frchp; frchp = frchp->frch_next)
252b5132
RH		 393 {
394 prev_frag->fr_next = frchp->frch_root;
395 prev_frag = frchp->frch_last;
9c2799c2 396 gas_assert (prev_frag->fr_type != 0);
252b5132
RH		 397 if (frchp->fix_root != (fixS *) NULL)
398 {
399 if (seg_info (section)->fix_root == (fixS *) NULL)
400 seg_info (section)->fix_root = frchp->fix_root;
401 prev_fix->fx_next = frchp->fix_root;
402 seg_info (section)->fix_tail = frchp->fix_tail;
403 prev_fix = frchp->fix_tail;
404 }
252b5132 405 }
4fc0b46e
AM		 406 gas_assert (prev_frag != &dummy
407 && prev_frag->fr_type != 0);
252b5132
RH		 408 prev_frag->fr_next = 0;
409 return prev_frag;
410}
411
252b5132 412static void
d7342424
KH		 413chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
414 segT section,
e7ff5c73 415 void *xxx ATTRIBUTE_UNUSED)
252b5132
RH		 416{
417 segment_info_type *info;
418
419 /* BFD may have introduced its own sections without using
420 subseg_new, so it is possible that seg_info is NULL. */
421 info = seg_info (section);
422 if (info != (segment_info_type *) NULL)
efaf0ba4
NC		 423 info->frchainP->frch_last
424 = chain_frchains_together_1 (section, info->frchainP);
252b5132
RH		 425
426 /* Now that we've chained the frags together, we must add new fixups
427 to the segment, not to the frag chain. */
428 frags_chained = 1;
429}
430
252b5132 431static void
d7342424 432cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
252b5132
RH		 433{
434 switch (fragP->fr_type)
435 {
62a02d25
L		 436 case rs_space_nop:
437 goto skip_align;
252b5132
RH		 438 case rs_align:
439 case rs_align_code:
0a9ef439 440 case rs_align_test:
252b5132
RH		 441 case rs_org:
442 case rs_space:
443#ifdef HANDLE_ALIGN
444 HANDLE_ALIGN (fragP);
445#endif
62a02d25 446skip_align:
252b5132
RH		 447 know (fragP->fr_next != NULL);
448 fragP->fr_offset = (fragP->fr_next->fr_address
449 - fragP->fr_address
450 - fragP->fr_fix) / fragP->fr_var;
451 if (fragP->fr_offset < 0)
452 {
14ad458a 453 as_bad_where (fragP->fr_file, fragP->fr_line,
8f065d3b 454 _("attempt to .org/.space/.nops backwards? (%ld)"),
14ad458a 455 (long) fragP->fr_offset);
3f3cdb03 456 fragP->fr_offset = 0;
252b5132 457 }
62a02d25
L		 458 if (fragP->fr_type == rs_space_nop)
459 fragP->fr_type = rs_fill_nop;
460 else
461 fragP->fr_type = rs_fill;
252b5132
RH		 462 break;
463
464 case rs_fill:
62a02d25 465 case rs_fill_nop:
252b5132
RH		 466 break;
467
468 case rs_leb128:
469 {
470 valueT value = S_GET_VALUE (fragP->fr_symbol);
471 int size;
472
ba8826a8
AO		 473 if (!S_IS_DEFINED (fragP->fr_symbol))
474 {
475 as_bad_where (fragP->fr_file, fragP->fr_line,
476 _("leb128 operand is an undefined symbol: %s"),
477 S_GET_NAME (fragP->fr_symbol));
478 }
479
252b5132
RH		 480 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
481 fragP->fr_subtype);
482
483 fragP->fr_fix += size;
484 fragP->fr_type = rs_fill;
485 fragP->fr_var = 0;
486 fragP->fr_offset = 0;
487 fragP->fr_symbol = NULL;
488 }
489 break;
490
491 case rs_cfa:
492 eh_frame_convert_frag (fragP);
493 break;
494
220e750f
RH		 495 case rs_dwarf2dbg:
496 dwarf2dbg_convert_frag (fragP);
497 break;
498
252b5132 499 case rs_machine_dependent:
252b5132 500 md_convert_frag (stdoutput, sec, fragP);
252b5132 501
9c2799c2 502 gas_assert (fragP->fr_next == NULL
871a6bd2
AM		 503 || (fragP->fr_next->fr_address - fragP->fr_address
504 == fragP->fr_fix));
252b5132 505
efaf0ba4
NC		 506 /* After md_convert_frag, we make the frag into a ".space 0".
507 md_convert_frag() should set up any fixSs and constants
508 required. */
252b5132
RH		 509 frag_wane (fragP);
510 break;
511
512#ifndef WORKING_DOT_WORD
513 case rs_broken_word:
514 {
515 struct broken_word *lie;
516
517 if (fragP->fr_subtype)
518 {
519 fragP->fr_fix += md_short_jump_size;
520 for (lie = (struct broken_word *) (fragP->fr_symbol);
521 lie && lie->dispfrag == fragP;
522 lie = lie->next_broken_word)
523 if (lie->added == 1)
524 fragP->fr_fix += md_long_jump_size;
525 }
526 frag_wane (fragP);
527 }
528 break;
529#endif
530
531 default:
532 BAD_CASE (fragP->fr_type);
533 break;
534 }
09b935ac
AM		 535#ifdef md_frag_check
536 md_frag_check (fragP);
537#endif
252b5132
RH		 538}
539
32638454
AM		 540struct relax_seg_info
541{
542 int pass;
543 int changed;
544};
d7342424 545
252b5132 546static void
32638454 547relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
e46d99eb
AM		 548{
549 segment_info_type *seginfo = seg_info (sec);
32638454 550 struct relax_seg_info *info = (struct relax_seg_info *) xxx;
e46d99eb
AM		 551
552 if (seginfo && seginfo->frchainP
32638454
AM		 553 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
554 info->changed = 1;
e46d99eb
AM		 555}
556
e46d99eb 557static void
fd361982 558size_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx ATTRIBUTE_UNUSED)
252b5132
RH		 559{
560 flagword flags;
561 fragS *fragp;
562 segment_info_type *seginfo;
563 int x;
564 valueT size, newsize;
565
566 subseg_change (sec, 0);
567
252b5132
RH		 568 seginfo = seg_info (sec);
569 if (seginfo && seginfo->frchainP)
570 {
252b5132
RH		 571 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
572 cvt_frag_to_fill (sec, fragp);
573 for (fragp = seginfo->frchainP->frch_root;
574 fragp->fr_next;
575 fragp = fragp->fr_next)
efaf0ba4
NC		 576 /* Walk to last elt. */
577 ;
252b5132
RH		 578 size = fragp->fr_address + fragp->fr_fix;
579 }
580 else
581 size = 0;
582
fd361982
AM		 583 flags = bfd_section_flags (sec);
584 if (size == 0 && bfd_section_size (sec) != 0 &&
f3d2b04b
KT		 585 (flags & SEC_HAS_CONTENTS) != 0)
586 return;
e46d99eb 587
252b5132
RH		 588 if (size > 0 && ! seginfo->bss)
589 flags |= SEC_HAS_CONTENTS;
590
e5435dec 591 flags &= ~SEC_RELOC;
fd361982 592 x = bfd_set_section_flags (sec, flags);
9c2799c2 593 gas_assert (x);
252b5132 594
2edb36e7
NC		 595 /* If permitted, allow the backend to pad out the section
596 to some alignment boundary. */
597 if (do_not_pad_sections_to_alignment)
598 newsize = size;
599 else
600 newsize = md_section_align (sec, size);
fd361982 601 x = bfd_set_section_size (sec, newsize);
9c2799c2 602 gas_assert (x);
252b5132
RH		 603
604 /* If the size had to be rounded up, add some padding in the last
605 non-empty frag. */
9c2799c2 606 gas_assert (newsize >= size);
252b5132
RH		 607 if (size != newsize)
608 {
609 fragS *last = seginfo->frchainP->frch_last;
610 fragp = seginfo->frchainP->frch_root;
611 while (fragp->fr_next != last)
612 fragp = fragp->fr_next;
613 last->fr_address = size;
18e1d487
AM		 614 if ((newsize - size) % fragp->fr_var == 0)
615 fragp->fr_offset += (newsize - size) / fragp->fr_var;
616 else
617 /* If we hit this abort, it's likely due to subsegs_finish not
618 providing sufficient alignment on the last frag, and the
619 machine dependent code using alignment frags with fr_var
620 greater than 1. */
621 abort ();
252b5132
RH		 622 }
623
624#ifdef tc_frob_section
625 tc_frob_section (sec);
626#endif
627#ifdef obj_frob_section
628 obj_frob_section (sec);
629#endif
630}
631
632#ifdef DEBUG2
633static void
988392e2 634dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
252b5132 635{
252b5132
RH		 636 segment_info_type *seginfo = seg_info (sec);
637 fixS *fixp = seginfo->fix_root;
638
639 if (!fixp)
640 return;
641
642 fprintf (stream, "sec %s relocs:\n", sec->name);
643 while (fixp)
644 {
645 symbolS *s = fixp->fx_addsy;
e723ef7c
ILT		 646
647 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp,
648 (int) fixp->fx_r_type);
649 if (s == NULL)
650 fprintf (stream, "no sym\n");
651 else
252b5132 652 {
e723ef7c
ILT		 653 print_symbol_value_1 (stream, s);
654 fprintf (stream, "\n");
252b5132 655 }
252b5132
RH		 656 fixp = fixp->fx_next;
657 }
658}
659#else
660#define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0)
661#endif
662
663#ifndef EMIT_SECTION_SYMBOLS
664#define EMIT_SECTION_SYMBOLS 1
665#endif
666
05e9452c
AM		 667/* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
668 and check for validity. Convert RELOC_LIST from using U.A fields
669 to U.B fields. */
670static void
671resolve_reloc_expr_symbols (void)
672{
080f9e4f 673 bfd_vma addr_mask = 1;
05e9452c
AM		 674 struct reloc_list *r;
675
080f9e4f
MR		 676 /* Avoid a shift by the width of type. */
677 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
678 addr_mask <<= 1;
679 addr_mask -= 1;
680
05e9452c
AM		 681 for (r = reloc_list; r; r = r->next)
682 {
080f9e4f 683 reloc_howto_type *howto = r->u.a.howto;
05e9452c
AM		 684 expressionS *symval;
685 symbolS *sym;
686 bfd_vma offset, addend;
687 asection *sec;
05e9452c
AM		 688
689 resolve_symbol_value (r->u.a.offset_sym);
690 symval = symbol_get_value_expression (r->u.a.offset_sym);
691
692 offset = 0;
693 sym = NULL;
694 if (symval->X_op == O_constant)
695 sym = r->u.a.offset_sym;
696 else if (symval->X_op == O_symbol)
697 {
698 sym = symval->X_add_symbol;
699 offset = symval->X_add_number;
700 symval = symbol_get_value_expression (symval->X_add_symbol);
701 }
702 if (sym == NULL
703 || symval->X_op != O_constant
704 || (sec = S_GET_SEGMENT (sym)) == NULL
705 || !SEG_NORMAL (sec))
706 {
707 as_bad_where (r->file, r->line, _("invalid offset expression"));
708 sec = NULL;
709 }
710 else
711 offset += S_GET_VALUE (sym);
712
713 sym = NULL;
714 addend = r->u.a.addend;
715 if (r->u.a.sym != NULL)
716 {
717 resolve_symbol_value (r->u.a.sym);
718 symval = symbol_get_value_expression (r->u.a.sym);
719 if (symval->X_op == O_constant)
720 sym = r->u.a.sym;
721 else if (symval->X_op == O_symbol)
722 {
723 sym = symval->X_add_symbol;
724 addend += symval->X_add_number;
725 symval = symbol_get_value_expression (symval->X_add_symbol);
726 }
727 if (symval->X_op != O_constant)
728 {
729 as_bad_where (r->file, r->line, _("invalid reloc expression"));
730 sec = NULL;
731 }
2578f2f3 732 else if (sym != NULL && sec != NULL)
7230378d 733 {
080f9e4f
MR		 734 /* Convert relocs against local symbols to refer to the
735 corresponding section symbol plus offset instead. Keep
736 PC-relative relocs of the REL variety intact though to
737 prevent the offset from overflowing the relocated field,
738 unless it has enough bits to cover the whole address
739 space. */
740 if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
d6101ac2
MR		 741 && (sec->use_rela_p
742 || (howto->partial_inplace
743 && (!howto->pc_relative
744 || howto->src_mask == addr_mask))))
7230378d
AM		 745 {
746 asection *symsec = S_GET_SEGMENT (sym);
747 if (!(((symsec->flags & SEC_MERGE) != 0
748 && addend != 0)
749 || (symsec->flags & SEC_THREAD_LOCAL) != 0))
750 {
751 addend += S_GET_VALUE (sym);
752 sym = section_symbol (symsec);
753 }
754 }
755 symbol_mark_used_in_reloc (sym);
756 }
05e9452c
AM		 757 }
758 if (sym == NULL)
759 {
760 if (abs_section_sym == NULL)
761 abs_section_sym = section_symbol (absolute_section);
762 sym = abs_section_sym;
763 }
764
05e9452c
AM		 765 r->u.b.sec = sec;
766 r->u.b.s = symbol_get_bfdsym (sym);
767 r->u.b.r.sym_ptr_ptr = &r->u.b.s;
768 r->u.b.r.address = offset;
769 r->u.b.r.addend = addend;
770 r->u.b.r.howto = howto;
771 }
772}
773
df44284e
AM		 774/* This pass over fixups decides whether symbols can be replaced with
775 section symbols. */
776
252b5132 777static void
d7342424
KH		 778adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
779 asection *sec,
e7ff5c73 780 void *xxx ATTRIBUTE_UNUSED)
252b5132
RH		 781{
782 segment_info_type *seginfo = seg_info (sec);
783 fixS *fixp;
784
785 if (seginfo == NULL)
786 return;
787
788 dump_section_relocs (abfd, sec, stderr);
789
790 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
791 if (fixp->fx_done)
efaf0ba4
NC		 792 /* Ignore it. */
793 ;
252b5132
RH		 794 else if (fixp->fx_addsy)
795 {
796 symbolS *sym;
797 asection *symsec;
798
799#ifdef DEBUG5
800 fprintf (stderr, "\n\nadjusting fixup:\n");
801 print_fixup (fixp);
802#endif
803
804 sym = fixp->fx_addsy;
805
806 /* All symbols should have already been resolved at this
807 point. It is possible to see unresolved expression
808 symbols, though, since they are not in the regular symbol
809 table. */
df44284e 810 resolve_symbol_value (sym);
efaf0ba4 811
49309057 812 if (fixp->fx_subsy != NULL)
6386f3a7 813 resolve_symbol_value (fixp->fx_subsy);
252b5132 814
60938e80
L		 815 /* If this symbol is equated to an undefined or common symbol,
816 convert the fixup to being against that symbol. */
b4b24b79
AM		 817 while (symbol_equated_reloc_p (sym)
818 || S_IS_WEAKREFR (sym))
252b5132 819 {
b4b24b79
AM		 820 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
821 if (sym == newsym)
822 break;
49309057 823 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
b4b24b79
AM		 824 fixp->fx_addsy = newsym;
825 sym = newsym;
252b5132
RH		 826 }
827
df44284e 828 if (symbol_mri_common_p (sym))
252b5132 829 {
b4b24b79
AM		 830 fixp->fx_offset += S_GET_VALUE (sym);
831 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
df44284e 832 continue;
252b5132
RH		 833 }
834
a161fe53
AM		 835 /* If the symbol is undefined, common, weak, or global (ELF
836 shared libs), we can't replace it with the section symbol. */
ae6063d4 837 if (S_FORCE_RELOC (fixp->fx_addsy, 1))
a161fe53
AM		 838 continue;
839
840 /* Is there some other (target cpu dependent) reason we can't adjust
841 this one? (E.g. relocations involving function addresses on
842 the PA. */
843#ifdef tc_fix_adjustable
844 if (! tc_fix_adjustable (fixp))
845 continue;
846#endif
847
848 /* Since we're reducing to section symbols, don't attempt to reduce
849 anything that's already using one. */
850 if (symbol_section_p (sym))
851 continue;
852
252b5132 853 symsec = S_GET_SEGMENT (sym);
252b5132
RH		 854 if (symsec == NULL)
855 abort ();
efaf0ba4 856
a841bdf5
AM		 857 if (bfd_is_abs_section (symsec)
858 || symsec == reg_section)
252b5132 859 {
a161fe53 860 /* The fixup_segment routine normally will not use this
b4b24b79 861 symbol in a relocation. */
df44284e 862 continue;
252b5132
RH		 863 }
864
7565ed77 865 /* Don't try to reduce relocs which refer to non-local symbols
b4b24b79
AM		 866 in .linkonce sections. It can lead to confusion when a
867 debugging section refers to a .linkonce section. I hope
868 this will always be correct. */
7565ed77 869 if (symsec != sec && ! S_IS_LOCAL (sym))
252b5132 870 {
a161fe53
AM		 871 if ((symsec->flags & SEC_LINK_ONCE) != 0
872 || (IS_ELF
873 /* The GNU toolchain uses an extension for ELF: a
874 section beginning with the magic string
875 .gnu.linkonce is a linkonce section. */
876 && strncmp (segment_name (symsec), ".gnu.linkonce",
877 sizeof ".gnu.linkonce" - 1) == 0))
878 continue;
252b5132 879 }
f7460f5f
JJ		 880
881 /* Never adjust a reloc against local symbol in a merge section
882 with non-zero addend. */
5045ec7a
AM		 883 if ((symsec->flags & SEC_MERGE) != 0
884 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
a161fe53 885 continue;
13ae64f3
JJ		 886
887 /* Never adjust a reloc against TLS local symbol. */
df44284e 888 if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
a161fe53 889 continue;
252b5132 890
a161fe53 891 /* We refetch the segment when calling section_symbol, rather
252b5132 892 than using symsec, because S_GET_VALUE may wind up changing
efaf0ba4 893 the section when it calls resolve_symbol_value. */
252b5132
RH		 894 fixp->fx_offset += S_GET_VALUE (sym);
895 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
e723ef7c
ILT		 896#ifdef DEBUG5
897 fprintf (stderr, "\nadjusted fixup:\n");
898 print_fixup (fixp);
899#endif
252b5132 900 }
252b5132
RH		 901
902 dump_section_relocs (abfd, sec, stderr);
903}
904
e7ff5c73
AM		 905/* fixup_segment()
906
907 Go through all the fixS's in a segment and see which ones can be
908 handled now. (These consist of fixS where we have since discovered
909 the value of a symbol, or the address of the frag involved.)
910 For each one, call md_apply_fix to put the fix into the frag data.
89d67ed9
AM		 911 Ones that we couldn't completely handle here will be output later
912 by emit_relocations. */
e7ff5c73 913
89d67ed9 914static void
e7ff5c73
AM		 915fixup_segment (fixS *fixP, segT this_segment)
916{
e7ff5c73
AM		 917 valueT add_number;
918 fragS *fragP;
919 segT add_symbol_segment = absolute_section;
920
921 if (fixP != NULL && abs_section_sym == NULL)
922 abs_section_sym = section_symbol (absolute_section);
923
924 /* If the linker is doing the relaxing, we must not do any fixups.
925
926 Well, strictly speaking that's not true -- we could do any that
a8eb42a8 927 are PC-relative and don't cross regions that could change size. */
e7ff5c73
AM		 928 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
929 {
930 for (; fixP; fixP = fixP->fx_next)
931 if (!fixP->fx_done)
932 {
933 if (fixP->fx_addsy == NULL)
934 {
935 /* There was no symbol required by this relocation.
936 However, BFD doesn't really handle relocations
937 without symbols well. So fake up a local symbol in
938 the absolute section. */
939 fixP->fx_addsy = abs_section_sym;
940 }
941 symbol_mark_used_in_reloc (fixP->fx_addsy);
942 if (fixP->fx_subsy != NULL)
943 symbol_mark_used_in_reloc (fixP->fx_subsy);
e7ff5c73 944 }
89d67ed9 945 return;
e7ff5c73
AM		 946 }
947
948 for (; fixP; fixP = fixP->fx_next)
949 {
950#ifdef DEBUG5
951 fprintf (stderr, "\nprocessing fixup:\n");
952 print_fixup (fixP);
953#endif
954
955 fragP = fixP->fx_frag;
956 know (fragP);
957#ifdef TC_VALIDATE_FIX
958 TC_VALIDATE_FIX (fixP, this_segment, skip);
959#endif
960 add_number = fixP->fx_offset;
961
e7ff5c73
AM		 962 if (fixP->fx_addsy != NULL)
963 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
964
965 if (fixP->fx_subsy != NULL)
966 {
967 segT sub_symbol_segment;
968 resolve_symbol_value (fixP->fx_subsy);
969 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
970 if (fixP->fx_addsy != NULL
971 && sub_symbol_segment == add_symbol_segment
c969da64
RS		 972 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
973 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
e7ff5c73
AM		 974 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
975 {
976 add_number += S_GET_VALUE (fixP->fx_addsy);
977 add_number -= S_GET_VALUE (fixP->fx_subsy);
978 fixP->fx_offset = add_number;
979 fixP->fx_addsy = NULL;
980 fixP->fx_subsy = NULL;
981#ifdef TC_M68K
982 /* See the comment below about 68k weirdness. */
983 fixP->fx_pcrel = 0;
984#endif
985 }
986 else if (sub_symbol_segment == absolute_section
c969da64 987 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
9a97a5d7 988 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
e7ff5c73
AM		 989 {
990 add_number -= S_GET_VALUE (fixP->fx_subsy);
991 fixP->fx_offset = add_number;
992 fixP->fx_subsy = NULL;
993 }
994 else if (sub_symbol_segment == this_segment
c969da64 995 && !S_FORCE_RELOC (fixP->fx_subsy, 0)
5db484ff 996 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
e7ff5c73
AM		 997 {
998 add_number -= S_GET_VALUE (fixP->fx_subsy);
999 fixP->fx_offset = (add_number + fixP->fx_dot_value
8e723a10 1000 + fixP->fx_dot_frag->fr_address);
e7ff5c73
AM		 1001
1002 /* Make it pc-relative. If the back-end code has not
1003 selected a pc-relative reloc, cancel the adjustment
1004 we do later on all pc-relative relocs. */
1005 if (0
1006#ifdef TC_M68K
1007 /* Do this for m68k even if it's already described
1008 as pc-relative. On the m68k, an operand of
1009 "pc@(foo-.-2)" should address "foo" in a
1010 pc-relative mode. */
1011 || 1
1012#endif
1013 || !fixP->fx_pcrel)
1014 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1015 fixP->fx_subsy = NULL;
1016 fixP->fx_pcrel = 1;
1017 }
586ec8c1 1018 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
e7ff5c73 1019 {
9a97a5d7
AM		 1020 if (!md_register_arithmetic
1021 && (add_symbol_segment == reg_section
1022 || sub_symbol_segment == reg_section))
1023 as_bad_where (fixP->fx_file, fixP->fx_line,
1024 _("register value used as expression"));
1025 else
1026 as_bad_where (fixP->fx_file, fixP->fx_line,
1027 _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1028 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1029 segment_name (add_symbol_segment),
1030 S_GET_NAME (fixP->fx_subsy),
1031 segment_name (sub_symbol_segment));
e7ff5c73 1032 }
586ec8c1
NC		 1033 else if (sub_symbol_segment != undefined_section
1034 && ! bfd_is_com_section (sub_symbol_segment)
1035 && MD_APPLY_SYM_VALUE (fixP))
1036 add_number -= S_GET_VALUE (fixP->fx_subsy);
e7ff5c73
AM		 1037 }
1038
1039 if (fixP->fx_addsy)
1040 {
1fc5d88e 1041 if (add_symbol_segment == this_segment
c969da64 1042 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
e7ff5c73
AM		 1043 && !TC_FORCE_RELOCATION_LOCAL (fixP))
1044 {
1045 /* This fixup was made when the symbol's segment was
1046 SEG_UNKNOWN, but it is now in the local segment.
1047 So we know how to do the address without relocation. */
1048 add_number += S_GET_VALUE (fixP->fx_addsy);
1049 fixP->fx_offset = add_number;
1050 if (fixP->fx_pcrel)
1051 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1052 fixP->fx_addsy = NULL;
1053 fixP->fx_pcrel = 0;
1054 }
1055 else if (add_symbol_segment == absolute_section
c969da64 1056 && !S_FORCE_RELOC (fixP->fx_addsy, 0)
e7ff5c73
AM		 1057 && !TC_FORCE_RELOCATION_ABS (fixP))
1058 {
1059 add_number += S_GET_VALUE (fixP->fx_addsy);
1060 fixP->fx_offset = add_number;
1061 fixP->fx_addsy = NULL;
1062 }
1063 else if (add_symbol_segment != undefined_section
1064 && ! bfd_is_com_section (add_symbol_segment)
1065 && MD_APPLY_SYM_VALUE (fixP))
1066 add_number += S_GET_VALUE (fixP->fx_addsy);
1067 }
1068
1069 if (fixP->fx_pcrel)
1070 {
1071 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1072 if (!fixP->fx_done && fixP->fx_addsy == NULL)
1073 {
1074 /* There was no symbol required by this relocation.
1075 However, BFD doesn't really handle relocations
1076 without symbols well. So fake up a local symbol in
1077 the absolute section. */
1078 fixP->fx_addsy = abs_section_sym;
1079 }
1080 }
1081
1082 if (!fixP->fx_done)
1083 md_apply_fix (fixP, &add_number, this_segment);
1084
1085 if (!fixP->fx_done)
1086 {
e7ff5c73
AM		 1087 if (fixP->fx_addsy == NULL)
1088 fixP->fx_addsy = abs_section_sym;
1089 symbol_mark_used_in_reloc (fixP->fx_addsy);
1090 if (fixP->fx_subsy != NULL)
1091 symbol_mark_used_in_reloc (fixP->fx_subsy);
1092 }
1093
5bc11336 1094 if (!fixP->fx_no_overflow && fixP->fx_size != 0)
e7ff5c73
AM		 1095 {
1096 if (fixP->fx_size < sizeof (valueT))
1097 {
1098 valueT mask;
1099
1100 mask = 0;
1101 mask--; /* Set all bits to one. */
1102 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1103 if ((add_number & mask) != 0 && (add_number & mask) != mask)
1104 {
1105 char buf[50], buf2[50];
1106 sprint_value (buf, fragP->fr_address + fixP->fx_where);
1107 if (add_number > 1000)
1108 sprint_value (buf2, add_number);
1109 else
1110 sprintf (buf2, "%ld", (long) add_number);
1111 as_bad_where (fixP->fx_file, fixP->fx_line,
992a06ee
AM		 1112 ngettext ("value of %s too large for field "
1113 "of %d byte at %s",
1114 "value of %s too large for field "
1115 "of %d bytes at %s",
1116 fixP->fx_size),
e7ff5c73
AM		 1117 buf2, fixP->fx_size, buf);
1118 } /* Generic error checking. */
1119 }
1120#ifdef WARN_SIGNED_OVERFLOW_WORD
1121 /* Warn if a .word value is too large when treated as a signed
1122 number. We already know it is not too negative. This is to
1123 catch over-large switches generated by gcc on the 68k. */
1124 if (!flag_signed_overflow_ok
1125 && fixP->fx_size == 2
1126 && add_number > 0x7fff)
1127 as_bad_where (fixP->fx_file, fixP->fx_line,
1128 _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1129 (long) add_number,
1130 (long) (fragP->fr_address + fixP->fx_where));
1131#endif
5bc11336 1132 }
e7ff5c73
AM		 1133
1134#ifdef TC_VALIDATE_FIX
1135 skip: ATTRIBUTE_UNUSED_LABEL
1136 ;
1137#endif
1138#ifdef DEBUG5
1139 fprintf (stderr, "result:\n");
1140 print_fixup (fixP);
1141#endif
1142 } /* For each fixS in this segment. */
e7ff5c73
AM		 1143}
1144
a161fe53 1145static void
d7342424
KH		 1146fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1147 asection *sec,
e7ff5c73 1148 void *xxx ATTRIBUTE_UNUSED)
a161fe53
AM		 1149{
1150 segment_info_type *seginfo = seg_info (sec);
1151
1152 fixup_segment (seginfo->fix_root, sec);
1153}
1154
e5435dec
AM		 1155static void
1156install_reloc (asection *sec, arelent *reloc, fragS *fragp,
3b4dbbbf 1157 const char *file, unsigned int line)
e5435dec
AM		 1158{
1159 char *err;
1160 bfd_reloc_status_type s;
76d12939
AM		 1161 asymbol *sym;
1162
1163 if (reloc->sym_ptr_ptr != NULL
1164 && (sym = *reloc->sym_ptr_ptr) != NULL
1165 && (sym->flags & BSF_KEEP) == 0
1166 && ((sym->flags & BSF_SECTION_SYM) == 0
55f8b826
AM		 1167 || (EMIT_SECTION_SYMBOLS
1168 && !bfd_is_abs_section (sym->section))))
76d12939 1169 as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
e5435dec
AM		 1170
1171 s = bfd_install_relocation (stdoutput, reloc,
1172 fragp->fr_literal, fragp->fr_address,
1173 sec, &err);
1174 switch (s)
1175 {
1176 case bfd_reloc_ok:
1177 break;
1178 case bfd_reloc_overflow:
1179 as_bad_where (file, line, _("relocation overflow"));
1180 break;
1181 case bfd_reloc_outofrange:
1182 as_bad_where (file, line, _("relocation out of range"));
1183 break;
1184 default:
1185 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1186 file, line, s);
1187 }
1188}
1189
7230378d
AM		 1190static fragS *
1191get_frag_for_reloc (fragS *last_frag,
1192 const segment_info_type *seginfo,
1193 const struct reloc_list *r)
1194{
1195 fragS *f;
34bca508 1196
7230378d
AM		 1197 for (f = last_frag; f != NULL; f = f->fr_next)
1198 if (f->fr_address <= r->u.b.r.address
1199 && r->u.b.r.address < f->fr_address + f->fr_fix)
1200 return f;
1201
1202 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1203 if (f->fr_address <= r->u.b.r.address
1204 && r->u.b.r.address < f->fr_address + f->fr_fix)
1205 return f;
1206
740bdc67
AM		 1207 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1208 if (f->fr_address <= r->u.b.r.address
1209 && r->u.b.r.address <= f->fr_address + f->fr_fix)
1210 return f;
1211
7230378d
AM		 1212 as_bad_where (r->file, r->line,
1213 _("reloc not within (fixed part of) section"));
1214 return NULL;
1215}
1216
252b5132 1217static void
fd361982
AM		 1218write_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
1219 void *xxx ATTRIBUTE_UNUSED)
252b5132
RH		 1220{
1221 segment_info_type *seginfo = seg_info (sec);
252b5132 1222 unsigned int n;
05e9452c 1223 struct reloc_list *my_reloc_list, **rp, *r;
252b5132
RH		 1224 arelent **relocs;
1225 fixS *fixp;
7230378d 1226 fragS *last_frag;
252b5132
RH		 1227
1228 /* If seginfo is NULL, we did not create this section; don't do
1229 anything with it. */
1230 if (seginfo == NULL)
1231 return;
1232
252b5132
RH		 1233 n = 0;
1234 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
e5435dec
AM		 1235 if (!fixp->fx_done)
1236 n++;
1237
1238#ifdef RELOC_EXPANSION_POSSIBLE
1239 n *= MAX_RELOC_EXPANSION;
1240#endif
252b5132 1241
05e9452c
AM		 1242 /* Extract relocs for this section from reloc_list. */
1243 rp = &reloc_list;
269b4ded 1244
05e9452c
AM		 1245 my_reloc_list = NULL;
1246 while ((r = *rp) != NULL)
1247 {
1248 if (r->u.b.sec == sec)
1249 {
1250 *rp = r->next;
1251 r->next = my_reloc_list;
1252 my_reloc_list = r;
1253 n++;
1254 }
1255 else
1256 rp = &r->next;
1257 }
1258
add39d23 1259 relocs = XCNEWVEC (arelent *, n);
252b5132 1260
7230378d
AM		 1261 n = 0;
1262 r = my_reloc_list;
1263 last_frag = NULL;
252b5132
RH		 1264 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1265 {
d31f0f6d 1266 int fx_size, slack;
871a6bd2 1267 valueT loc;
7230378d
AM		 1268 arelent **reloc;
1269#ifndef RELOC_EXPANSION_POSSIBLE
1270 arelent *rel;
1271
1272 reloc = &rel;
1273#endif
252b5132
RH		 1274
1275 if (fixp->fx_done)
e5435dec 1276 continue;
252b5132 1277
d31f0f6d
AM		 1278 fx_size = fixp->fx_size;
1279 slack = TC_FX_SIZE_SLACK (fixp);
1280 if (slack > 0)
1281 fx_size = fx_size > slack ? fx_size - slack : 0;
1282 loc = fixp->fx_where + fx_size;
e5435dec 1283 if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
d31f0f6d
AM		 1284 as_bad_where (fixp->fx_file, fixp->fx_line,
1285 _("internal error: fixup not contained within frag"));
252b5132 1286
e5435dec 1287#ifndef RELOC_EXPANSION_POSSIBLE
7230378d 1288 *reloc = tc_gen_reloc (sec, fixp);
e5435dec 1289#else
7230378d
AM		 1290 reloc = tc_gen_reloc (sec, fixp);
1291#endif
252b5132 1292
7230378d
AM		 1293 while (*reloc)
1294 {
1295 while (r != NULL && r->u.b.r.address < (*reloc)->address)
1296 {
1297 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1298 if (f != NULL)
1299 {
1300 last_frag = f;
1301 relocs[n++] = &r->u.b.r;
1302 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1303 }
1304 r = r->next;
1305 }
1306 relocs[n++] = *reloc;
1307 install_reloc (sec, *reloc, fixp->fx_frag,
1308 fixp->fx_file, fixp->fx_line);
1309#ifndef RELOC_EXPANSION_POSSIBLE
1310 break;
1311#else
1312 reloc++;
e5435dec 1313#endif
7230378d
AM		 1314 }
1315 }
d31f0f6d 1316
7230378d
AM		 1317 while (r != NULL)
1318 {
1319 fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1320 if (f != NULL)
1321 {
1322 last_frag = f;
1323 relocs[n++] = &r->u.b.r;
1324 install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1325 }
1326 r = r->next;
252b5132 1327 }
252b5132
RH		 1328
1329#ifdef DEBUG4
1330 {
1596988d 1331 unsigned int k, j, nsyms;
252b5132
RH		 1332 asymbol **sympp;
1333 sympp = bfd_get_outsymbols (stdoutput);
1334 nsyms = bfd_get_symcount (stdoutput);
1596988d
TG		 1335 for (k = 0; k < n; k++)
1336 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
252b5132
RH		 1337 {
1338 for (j = 0; j < nsyms; j++)
1596988d 1339 if (sympp[j] == *relocs[k]->sym_ptr_ptr)
252b5132
RH		 1340 break;
1341 if (j == nsyms)
1342 abort ();
1343 }
1344 }
1345#endif
1346
1347 if (n)
e5435dec 1348 {
fd361982 1349 flagword flags = bfd_section_flags (sec);
e5435dec 1350 flags |= SEC_RELOC;
fd361982 1351 bfd_set_section_flags (sec, flags);
e5435dec
AM		 1352 bfd_set_reloc (stdoutput, sec, relocs, n);
1353 }
252b5132 1354
945a1a6b
ILT		 1355#ifdef SET_SECTION_RELOCS
1356 SET_SECTION_RELOCS (sec, relocs, n);
1357#endif
1358
252b5132
RH		 1359#ifdef DEBUG3
1360 {
1596988d
TG		 1361 unsigned int k;
1362
252b5132 1363 fprintf (stderr, "relocs for sec %s\n", sec->name);
1596988d 1364 for (k = 0; k < n; k++)
252b5132 1365 {
1596988d
TG		 1366 arelent *rel = relocs[k];
1367 asymbol *s = *rel->sym_ptr_ptr;
988392e2 1368 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1596988d
TG		 1369 k, rel, (unsigned long)rel->address, s->name,
1370 (unsigned long)rel->addend);
252b5132
RH		 1371 }
1372 }
1373#endif
1374}
1375
0acf065b
CC		 1376static int
1377compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1378 fragS **last_newf, struct obstack *ob)
1379{
1380 int out_size;
1381 int total_out_size = 0;
1382 fragS *f = *last_newf;
1383 char *next_out;
1384 int avail_out;
1385
1386 /* Call the compression routine repeatedly until it has finished
1387 processing the frag. */
1388 while (in_size > 0)
1389 {
1390 /* Reserve all the space available in the current chunk.
1391 If none is available, start a new frag. */
1392 avail_out = obstack_room (ob);
1393 if (avail_out <= 0)
1394 {
1395 obstack_finish (ob);
1396 f = frag_alloc (ob);
1397 f->fr_type = rs_fill;
1398 (*last_newf)->fr_next = f;
1399 *last_newf = f;
1400 avail_out = obstack_room (ob);
1401 }
1402 if (avail_out <= 0)
1403 as_fatal (_("can't extend frag"));
1404 next_out = obstack_next_free (ob);
1405 obstack_blank_fast (ob, avail_out);
1406 out_size = compress_data (strm, &contents, &in_size,
1407 &next_out, &avail_out);
1408 if (out_size < 0)
1409 return -1;
1410
1411 f->fr_fix += out_size;
1412 total_out_size += out_size;
1413
1414 /* Return unused space. */
1415 if (avail_out > 0)
1416 obstack_blank_fast (ob, -avail_out);
1417 }
1418
1419 return total_out_size;
1420}
1421
1422static void
1423compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1424{
1425 segment_info_type *seginfo = seg_info (sec);
1426 fragS *f;
1427 fragS *first_newf;
1428 fragS *last_newf;
1429 struct obstack *ob = &seginfo->frchainP->frch_obstack;
1430 bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1431 bfd_size_type compressed_size;
1432 const char *section_name;
1433 char *compressed_name;
1434 char *header;
1435 struct z_stream_s *strm;
1436 int x;
fd361982 1437 flagword flags = bfd_section_flags (sec);
151411f8 1438 unsigned int header_size, compression_header_size;
0acf065b
CC		 1439
1440 if (seginfo == NULL
6ac88ef3 1441 || sec->size < 32
4a114e3e 1442 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
0acf065b
CC		 1443 return;
1444
fd361982 1445 section_name = bfd_section_name (sec);
0acf065b
CC		 1446 if (strncmp (section_name, ".debug_", 7) != 0)
1447 return;
1448
1449 strm = compress_init ();
1450 if (strm == NULL)
1451 return;
1452
151411f8 1453 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
dab394de 1454 {
dab394de
L		 1455 compression_header_size
1456 = bfd_get_compression_header_size (stdoutput, NULL);
1457 header_size = compression_header_size;
1458 }
151411f8 1459 else
dab394de 1460 {
dab394de
L		 1461 compression_header_size = 0;
1462 header_size = 12;
1463 }
151411f8 1464
dab394de 1465 /* Create a new frag to contain the compression header. */
0acf065b 1466 first_newf = frag_alloc (ob);
151411f8 1467 if (obstack_room (ob) < header_size)
0acf065b 1468 first_newf = frag_alloc (ob);
151411f8 1469 if (obstack_room (ob) < header_size)
992a06ee
AM		 1470 as_fatal (ngettext ("can't extend frag %lu char",
1471 "can't extend frag %lu chars",
1472 (unsigned long) header_size),
1473 (unsigned long) header_size);
0acf065b 1474 last_newf = first_newf;
151411f8 1475 obstack_blank_fast (ob, header_size);
0acf065b 1476 last_newf->fr_type = rs_fill;
151411f8 1477 last_newf->fr_fix = header_size;
0acf065b 1478 header = last_newf->fr_literal;
151411f8 1479 compressed_size = header_size;
0acf065b
CC		 1480
1481 /* Stream the frags through the compression engine, adding new frags
2b0f3761 1482 as necessary to accommodate the compressed output. */
0acf065b
CC		 1483 for (f = seginfo->frchainP->frch_root;
1484 f;
1485 f = f->fr_next)
1486 {
1487 offsetT fill_size;
1488 char *fill_literal;
1489 offsetT count;
1490 int out_size;
1491
1492 gas_assert (f->fr_type == rs_fill);
1493 if (f->fr_fix)
1494 {
1495 out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1496 &last_newf, ob);
1497 if (out_size < 0)
1498 return;
1499 compressed_size += out_size;
1500 }
1501 fill_literal = f->fr_literal + f->fr_fix;
1502 fill_size = f->fr_var;
1503 count = f->fr_offset;
1504 gas_assert (count >= 0);
1505 if (fill_size && count)
1506 {
1507 while (count--)
1508 {
1509 out_size = compress_frag (strm, fill_literal, (int) fill_size,
1510 &last_newf, ob);
1511 if (out_size < 0)
1512 return;
1513 compressed_size += out_size;
1514 }
1515 }
1516 }
1517
1518 /* Flush the compression state. */
1519 for (;;)
1520 {
1521 int avail_out;
1522 char *next_out;
1523 int out_size;
1524
1525 /* Reserve all the space available in the current chunk.
1526 If none is available, start a new frag. */
1527 avail_out = obstack_room (ob);
1528 if (avail_out <= 0)
1529 {
1530 fragS *newf;
1531
1532 obstack_finish (ob);
1533 newf = frag_alloc (ob);
1534 newf->fr_type = rs_fill;
1535 last_newf->fr_next = newf;
1536 last_newf = newf;
1537 avail_out = obstack_room (ob);
1538 }
1539 if (avail_out <= 0)
1540 as_fatal (_("can't extend frag"));
1541 next_out = obstack_next_free (ob);
1542 obstack_blank_fast (ob, avail_out);
1543 x = compress_finish (strm, &next_out, &avail_out, &out_size);
1544 if (x < 0)
1545 return;
1546
1547 last_newf->fr_fix += out_size;
1548 compressed_size += out_size;
1549
1550 /* Return unused space. */
1551 if (avail_out > 0)
1552 obstack_blank_fast (ob, -avail_out);
1553
1554 if (x == 0)
1555 break;
1556 }
1557
b422eb49
L		 1558 /* PR binutils/18087: If compression didn't make the section smaller,
1559 just keep it uncompressed. */
317974f6 1560 if (compressed_size >= uncompressed_size)
273a4985 1561 return;
d94077e2 1562
0acf065b
CC		 1563 /* Replace the uncompressed frag list with the compressed frag list. */
1564 seginfo->frchainP->frch_root = first_newf;
1565 seginfo->frchainP->frch_last = last_newf;
1566
1567 /* Update the section size and its name. */
151411f8 1568 bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
fd361982 1569 x = bfd_set_section_size (sec, compressed_size);
0acf065b 1570 gas_assert (x);
151411f8
L		 1571 if (!compression_header_size)
1572 {
29a2809e 1573 compressed_name = concat (".z", section_name + 1, (char *) NULL);
fd361982 1574 bfd_rename_section (sec, compressed_name);
151411f8 1575 }
0acf065b
CC		 1576}
1577
62a02d25
L		 1578#ifndef md_generate_nops
1579/* Genenerate COUNT bytes of no-op instructions to WHERE. A target
1580 backend must override this with proper no-op instructions. */
1581
1582static void
1583md_generate_nops (fragS *f ATTRIBUTE_UNUSED,
1584 char *where ATTRIBUTE_UNUSED,
1585 offsetT count ATTRIBUTE_UNUSED,
1586 int control ATTRIBUTE_UNUSED)
1587{
8f065d3b 1588 as_bad (_("unimplemented .nops directive"));
62a02d25
L		 1589}
1590#endif
1591
252b5132 1592static void
d7342424
KH		 1593write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1594 asection *sec,
e7ff5c73 1595 void *xxx ATTRIBUTE_UNUSED)
252b5132
RH		 1596{
1597 segment_info_type *seginfo = seg_info (sec);
685736be 1598 addressT offset = 0;
252b5132
RH		 1599 fragS *f;
1600
1601 /* Write out the frags. */
1602 if (seginfo == NULL
fd361982 1603 || !(bfd_section_flags (sec) & SEC_HAS_CONTENTS))
252b5132
RH		 1604 return;
1605
1606 for (f = seginfo->frchainP->frch_root;
1607 f;
1608 f = f->fr_next)
1609 {
1610 int x;
685736be 1611 addressT fill_size;
252b5132 1612 char *fill_literal;
685736be 1613 offsetT count;
252b5132 1614
62a02d25 1615 gas_assert (f->fr_type == rs_fill || f->fr_type == rs_fill_nop);
252b5132
RH		 1616 if (f->fr_fix)
1617 {
1618 x = bfd_set_section_contents (stdoutput, sec,
1619 f->fr_literal, (file_ptr) offset,
1620 (bfd_size_type) f->fr_fix);
b34976b6 1621 if (!x)
992a06ee
AM		 1622 as_fatal (ngettext ("can't write %ld byte "
1623 "to section %s of %s: '%s'",
1624 "can't write %ld bytes "
1625 "to section %s of %s: '%s'",
1626 (long) f->fr_fix),
1627 (long) f->fr_fix,
1628 sec->name, stdoutput->filename,
885afe7b 1629 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1630 offset += f->fr_fix;
1631 }
62a02d25 1632
252b5132
RH		 1633 fill_size = f->fr_var;
1634 count = f->fr_offset;
62a02d25
L		 1635 fill_literal = f->fr_literal + f->fr_fix;
1636
1637 if (f->fr_type == rs_fill_nop)
1638 {
1639 gas_assert (count >= 0 && fill_size == 1);
1640 if (count > 0)
1641 {
1642 char *buf = xmalloc (count);
1643 md_generate_nops (f, buf, count, *fill_literal);
1644 x = bfd_set_section_contents
1645 (stdoutput, sec, buf, (file_ptr) offset,
1646 (bfd_size_type) count);
1647 if (!x)
1648 as_fatal (ngettext ("can't fill %ld byte "
1649 "in section %s of %s: '%s'",
1650 "can't fill %ld bytes "
1651 "in section %s of %s: '%s'",
1652 (long) count), (long) count,
1653 sec->name, stdoutput->filename,
1654 bfd_errmsg (bfd_get_error ()));
1655 offset += count;
1656 free (buf);
1657 }
1658 continue;
1659 }
1660
9c2799c2 1661 gas_assert (count >= 0);
252b5132
RH		 1662 if (fill_size && count)
1663 {
1664 char buf[256];
efaf0ba4 1665 if (fill_size > sizeof (buf))
252b5132 1666 {
efaf0ba4 1667 /* Do it the old way. Can this ever happen? */
252b5132
RH		 1668 while (count--)
1669 {
1670 x = bfd_set_section_contents (stdoutput, sec,
1671 fill_literal,
1672 (file_ptr) offset,
1673 (bfd_size_type) fill_size);
b34976b6 1674 if (!x)
992a06ee
AM		 1675 as_fatal (ngettext ("can't fill %ld byte "
1676 "in section %s of %s: '%s'",
1677 "can't fill %ld bytes "
1678 "in section %s of %s: '%s'",
1679 (long) fill_size),
1680 (long) fill_size,
1681 sec->name, stdoutput->filename,
885afe7b 1682 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1683 offset += fill_size;
1684 }
1685 }
1686 else
1687 {
1688 /* Build a buffer full of fill objects and output it as
1689 often as necessary. This saves on the overhead of
1690 potentially lots of bfd_set_section_contents calls. */
1691 int n_per_buf, i;
1692 if (fill_size == 1)
1693 {
1694 n_per_buf = sizeof (buf);
1695 memset (buf, *fill_literal, n_per_buf);
1696 }
1697 else
1698 {
1699 char *bufp;
efaf0ba4 1700 n_per_buf = sizeof (buf) / fill_size;
252b5132 1701 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
efaf0ba4 1702 memcpy (bufp, fill_literal, fill_size);
252b5132
RH		 1703 }
1704 for (; count > 0; count -= n_per_buf)
1705 {
1706 n_per_buf = n_per_buf > count ? count : n_per_buf;
efaf0ba4
NC		 1707 x = bfd_set_section_contents
1708 (stdoutput, sec, buf, (file_ptr) offset,
1709 (bfd_size_type) n_per_buf * fill_size);
b34976b6 1710 if (!x)
992a06ee
AM		 1711 as_fatal (ngettext ("can't fill %ld byte "
1712 "in section %s of %s: '%s'",
1713 "can't fill %ld bytes "
1714 "in section %s of %s: '%s'",
1715 (long) (n_per_buf * fill_size)),
1716 (long) (n_per_buf * fill_size),
1717 sec->name, stdoutput->filename,
a22429b9 1718 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1719 offset += n_per_buf * fill_size;
1720 }
1721 }
1722 }
1723 }
1724}
252b5132 1725
252b5132 1726static void
d7342424 1727merge_data_into_text (void)
252b5132 1728{
252b5132
RH		 1729 seg_info (text_section)->frchainP->frch_last->fr_next =
1730 seg_info (data_section)->frchainP->frch_root;
1731 seg_info (text_section)->frchainP->frch_last =
1732 seg_info (data_section)->frchainP->frch_last;
1733 seg_info (data_section)->frchainP = 0;
252b5132 1734}
252b5132 1735
252b5132 1736static void
d7342424 1737set_symtab (void)
252b5132
RH		 1738{
1739 int nsyms;
1740 asymbol **asympp;
1741 symbolS *symp;
b34976b6 1742 bfd_boolean result;
252b5132
RH		 1743
1744 /* Count symbols. We can't rely on a count made by the loop in
1745 write_object_file, because *_frob_file may add a new symbol or
1746 two. */
1747 nsyms = 0;
1748 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1749 nsyms++;
1750
1751 if (nsyms)
1752 {
1753 int i;
0e1a166b 1754 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
252b5132 1755
1e9cc1c2 1756 asympp = (asymbol **) bfd_alloc (stdoutput, amt);
252b5132
RH		 1757 symp = symbol_rootP;
1758 for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1759 {
49309057 1760 asympp[i] = symbol_get_bfdsym (symp);
76d12939
AM		 1761 if (asympp[i]->flags != BSF_SECTION_SYM
1762 || !(bfd_is_const_section (asympp[i]->section)
1763 && asympp[i]->section->symbol == asympp[i]))
1764 asympp[i]->flags |= BSF_KEEP;
49309057 1765 symbol_mark_written (symp);
252b5132
RH		 1766 }
1767 }
1768 else
1769 asympp = 0;
1770 result = bfd_set_symtab (stdoutput, asympp, nsyms);
9c2799c2 1771 gas_assert (result);
252b5132
RH		 1772 symbol_table_frozen = 1;
1773}
252b5132
RH		 1774
1775/* Finish the subsegments. After every sub-segment, we fake an
2edb36e7 1776 ".align ...". This conforms to BSD4.2 brain-damage. We then fake
252b5132
RH		 1777 ".fill 0" because that is the kind of frag that requires least
1778 thought. ".align" frags like to have a following frag since that
1779 makes calculating their intended length trivial. */
1780
1781#ifndef SUB_SEGMENT_ALIGN
18e1d487 1782#ifdef HANDLE_ALIGN
436d9e46 1783/* The last subsegment gets an alignment corresponding to the alignment
18e1d487
AM		 1784 of the section. This allows proper nop-filling at the end of
1785 code-bearing sections. */
1786#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
9028d943 1787 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \
2edb36e7 1788 && !do_not_pad_sections_to_alignment \
9028d943
AM		 1789 ? get_recorded_alignment (SEG) \
1790 : 0)
18e1d487 1791#else
18e1d487 1792#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
252b5132
RH		 1793#endif
1794#endif
1795
85024cd8 1796static void
d98b0e2b 1797subsegs_finish_section (asection *s)
252b5132
RH		 1798{
1799 struct frchain *frchainP;
d98b0e2b
TG		 1800 segment_info_type *seginfo = seg_info (s);
1801 if (!seginfo)
1802 return;
252b5132 1803
d98b0e2b
TG		 1804 for (frchainP = seginfo->frchainP;
1805 frchainP != NULL;
1806 frchainP = frchainP->frch_next)
252b5132 1807 {
93a24ba7 1808 int alignment;
0a9ef439 1809
d98b0e2b 1810 subseg_set (s, frchainP->frch_subseg);
381a1ab3 1811
d98b0e2b
TG		 1812 /* This now gets called even if we had errors. In that case,
1813 any alignment is meaningless, and, moreover, will look weird
1814 if we are generating a listing. */
93a24ba7
MR		 1815 if (had_errors ())
1816 do_not_pad_sections_to_alignment = 1;
c9049d30 1817
93a24ba7 1818 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
fd361982 1819 if ((bfd_section_flags (now_seg) & SEC_MERGE)
93a24ba7
MR		 1820 && now_seg->entsize)
1821 {
1822 unsigned int entsize = now_seg->entsize;
1823 int entalign = 0;
d98b0e2b 1824
93a24ba7
MR		 1825 while ((entsize & 1) == 0)
1826 {
1827 ++entalign;
1828 entsize >>= 1;
381a1ab3 1829 }
93a24ba7
MR		 1830
1831 if (entalign > alignment)
1832 alignment = entalign;
d98b0e2b 1833 }
0a9ef439 1834
d98b0e2b
TG		 1835 if (subseg_text_p (now_seg))
1836 frag_align_code (alignment, 0);
1837 else
1838 frag_align (alignment, 0, 0);
252b5132 1839
d98b0e2b
TG		 1840 /* frag_align will have left a new frag.
1841 Use this last frag for an empty ".fill".
252b5132 1842
d98b0e2b
TG		 1843 For this segment ...
1844 Create a last frag. Do not leave a "being filled in frag". */
1845 frag_wane (frag_now);
1846 frag_now->fr_fix = 0;
1847 know (frag_now->fr_next == NULL);
252b5132
RH		 1848 }
1849}
1850
d98b0e2b
TG		 1851static void
1852subsegs_finish (void)
1853{
1854 asection *s;
1855
1856 for (s = stdoutput->sections; s; s = s->next)
1857 subsegs_finish_section (s);
1858}
1859
1860#ifdef OBJ_ELF
1861static void
1862create_obj_attrs_section (void)
1863{
1864 segT s;
1865 char *p;
1866 offsetT size;
1867 const char *name;
1868
1869 size = bfd_elf_obj_attr_size (stdoutput);
0df8ad28
NC		 1870 if (size == 0)
1871 return;
1872
1873 name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1874 if (!name)
1875 name = ".gnu.attributes";
1876 s = subseg_new (name, 0);
1877 elf_section_type (s)
1878 = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
fd361982 1879 bfd_set_section_flags (s, SEC_READONLY | SEC_DATA);
0df8ad28
NC		 1880 frag_now_fix ();
1881 p = frag_more (size);
1882 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1883
1884 subsegs_finish_section (s);
1885 relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1886 size_seg (stdoutput, s, NULL);
1887}
1888
0df8ad28
NC		 1889/* Create a relocation against an entry in a GNU Build attribute section. */
1890
1891static void
1892create_note_reloc (segT sec,
1893 symbolS * sym,
269b4ded
NC		 1894 bfd_size_type note_offset,
1895 bfd_size_type desc2_offset,
0df8ad28
NC		 1896 int reloc_type,
1897 bfd_vma addend,
1898 char * note)
1899{
1900 struct reloc_list * reloc;
1901
1902 reloc = XNEW (struct reloc_list);
1903
1904 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */
269b4ded
NC		 1905 reloc->u.b.sec = sec;
1906 reloc->u.b.s = symbol_get_bfdsym (sym);
0df8ad28 1907 reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s;
269b4ded 1908 reloc->u.b.r.address = note_offset + desc2_offset;
0df8ad28
NC		 1909 reloc->u.b.r.addend = addend;
1910 reloc->u.b.r.howto = bfd_reloc_type_lookup (stdoutput, reloc_type);
1911
1912 if (reloc->u.b.r.howto == NULL)
d98b0e2b 1913 {
0df8ad28
NC		 1914 as_bad (_("unable to create reloc for build note"));
1915 return;
1916 }
1917
1918 reloc->file = N_("<gnu build note>");
1919 reloc->line = 0;
1920
1921 reloc->next = reloc_list;
1922 reloc_list = reloc;
1923
1924 /* For REL relocs, store the addend in the section. */
1925 if (! sec->use_rela_p
1926 /* The SH target is a special case that uses RELA relocs
1927 but still stores the addend in the word being relocated. */
1928 || strstr (bfd_get_target (stdoutput), "-sh") != NULL)
1929 {
1930 if (target_big_endian)
1931 {
1932 if (bfd_arch_bits_per_address (stdoutput) <= 32)
269b4ded 1933 note[desc2_offset + 3] = addend;
0df8ad28 1934 else
269b4ded 1935 note[desc2_offset + 7] = addend;
0df8ad28
NC		 1936 }
1937 else
269b4ded 1938 note[desc2_offset] = addend;
d98b0e2b
TG		 1939 }
1940}
0df8ad28
NC		 1941
1942static void
1943maybe_generate_build_notes (void)
1944{
1945 segT sec;
1946 char * note;
1947 offsetT note_size;
864bb26c 1948 offsetT total_size;
0df8ad28
NC		 1949 offsetT desc_size;
1950 offsetT desc2_offset;
1951 int desc_reloc;
1952 symbolS * sym;
8d1015a8 1953 asymbol * bsym;
0df8ad28
NC		 1954
1955 if (! flag_generate_build_notes
1956 || bfd_get_section_by_name (stdoutput,
1957 GNU_BUILD_ATTRS_SECTION_NAME) != NULL)
1958 return;
1959
1960 /* Create a GNU Build Attribute section. */
1961 sec = subseg_new (GNU_BUILD_ATTRS_SECTION_NAME, FALSE);
1962 elf_section_type (sec) = SHT_NOTE;
fd361982
AM		 1963 bfd_set_section_flags (sec, SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA);
1964 bfd_set_section_alignment (sec, 2);
0df8ad28 1965
864bb26c
NC		 1966 /* Work out the size of the notes that we will create,
1967 and the relocation we should use. */
0df8ad28
NC		 1968 if (bfd_arch_bits_per_address (stdoutput) <= 32)
1969 {
1970 note_size = 28;
1971 desc_size = 8; /* Two 4-byte offsets. */
1972 desc2_offset = 24;
1973
1974 /* FIXME: The BFD backend for the CRX target does not support the
1975 BFD_RELOC_32, even though it really should. Likewise for the
1976 CR16 target. So we have special case code here... */
1977 if (strstr (bfd_get_target (stdoutput), "-crx") != NULL)
1978 desc_reloc = BFD_RELOC_CRX_NUM32;
1979 else if (strstr (bfd_get_target (stdoutput), "-cr16") != NULL)
1980 desc_reloc = BFD_RELOC_CR16_NUM32;
1981 else
1982 desc_reloc = BFD_RELOC_32;
1983 }
1984 else
1985 {
1986 note_size = 36;
1987 desc_size = 16; /* Two 8-byte offsets. */
1988 desc2_offset = 28;
1989 /* FIXME: The BFD backend for the IA64 target does not support the
1990 BFD_RELOC_64, even though it really should. The HPPA backend
1991 has a similar issue, although it does not support BFD_RELOCs at
1992 all! So we have special case code to handle these targets. */
1993 if (strstr (bfd_get_target (stdoutput), "-ia64") != NULL)
1994 desc_reloc = target_big_endian ? BFD_RELOC_IA64_DIR32MSB : BFD_RELOC_IA64_DIR32LSB;
1995 else if (strstr (bfd_get_target (stdoutput), "-hppa") != NULL)
1996 desc_reloc = 80; /* R_PARISC_DIR64. */
1997 else
1998 desc_reloc = BFD_RELOC_64;
1999 }
2000
864bb26c
NC		 2001 /* We have to create a note for *each* code section.
2002 Linker garbage collection might discard some. */
2003 total_size = 0;
2004 note = NULL;
0df8ad28 2005
8d1015a8
AM		 2006 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
2007 if ((bsym = symbol_get_bfdsym (sym)) != NULL
2008 && bsym->flags & BSF_SECTION_SYM
2009 && bsym->section != NULL
2e48456f 2010 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */
8d1015a8 2011 && (bsym->section->flags & (SEC_CODE | SEC_LINK_ONCE)) == SEC_CODE
864bb26c
NC		 2012 /* Not all linkonce sections are flagged... */
2013 && strncmp (S_GET_NAME (sym), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0)
0df8ad28 2014 {
864bb26c
NC		 2015 /* Create a version note. */
2016 frag_now_fix ();
2017 note = frag_more (note_size);
2018 memset (note, 0, note_size);
0df8ad28 2019
864bb26c 2020 if (target_big_endian)
0df8ad28 2021 {
864bb26c
NC		 2022 note[3] = 8; /* strlen (name) + 1. */
2023 note[7] = desc_size; /* Two 8-byte offsets. */
2024 note[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
2025 note[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2026 }
2027 else
2028 {
2029 note[0] = 8; /* strlen (name) + 1. */
2030 note[4] = desc_size; /* Two 8-byte offsets. */
2031 note[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2032 note[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
0df8ad28 2033 }
0df8ad28 2034
864bb26c
NC		 2035 /* The a1 version number indicates that this note was
2036 generated by the assembler and not the gcc annobin plugin. */
2037 memcpy (note + 12, "GA$\ 13a1", 8);
2038
2039 /* Create a relocation to install the start address of the note... */
269b4ded 2040 create_note_reloc (sec, sym, total_size, 20, desc_reloc, 0, note);
864bb26c
NC		 2041
2042 /* ...and another one to install the end address. */
269b4ded 2043 create_note_reloc (sec, sym, total_size, desc2_offset, desc_reloc,
fd361982 2044 bfd_section_size (bsym->section),
864bb26c
NC		 2045 note);
2046
2047 total_size += note_size;
2048 /* FIXME: Maybe add a note recording the assembler command line and version ? */
2049 }
0df8ad28
NC		 2050
2051 /* Install the note(s) into the section. */
864bb26c
NC		 2052 if (total_size)
2053 bfd_set_section_contents (stdoutput, sec, (bfd_byte *) note, 0, total_size);
0df8ad28
NC		 2054 subsegs_finish_section (sec);
2055 relax_segment (seg_info (sec)->frchainP->frch_root, sec, 0);
2056 size_seg (stdoutput, sec, NULL);
2057}
2058#endif /* OBJ_ELF */
d98b0e2b 2059
252b5132
RH		 2060/* Write the object file. */
2061
2062void
d7342424 2063write_object_file (void)
252b5132 2064{
32638454 2065 struct relax_seg_info rsi;
7be1c489 2066#ifndef WORKING_DOT_WORD
efaf0ba4 2067 fragS *fragP; /* Track along all frags. */
252b5132
RH		 2068#endif
2069
85024cd8
AM		 2070 subsegs_finish ();
2071
16a87420
IS		 2072#ifdef md_pre_output_hook
2073 md_pre_output_hook;
2074#endif
2075
cdaa5616
IS		 2076#ifdef md_pre_relax_hook
2077 md_pre_relax_hook;
2078#endif
2079
252b5132 2080 /* From now on, we don't care about sub-segments. Build one frag chain
2b0f3761 2081 for each segment. Linked through fr_next. */
252b5132 2082
252b5132
RH		 2083 /* Remove the sections created by gas for its own purposes. */
2084 {
252b5132
RH		 2085 int i;
2086
5daa8fe7
L		 2087 bfd_section_list_remove (stdoutput, reg_section);
2088 bfd_section_list_remove (stdoutput, expr_section);
2089 stdoutput->section_count -= 2;
252b5132
RH		 2090 i = 0;
2091 bfd_map_over_sections (stdoutput, renumber_sections, &i);
2092 }
2093
2094 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
252b5132
RH		 2095
2096 /* We have two segments. If user gave -R flag, then we must put the
2097 data frags into the text segment. Do this before relaxing so
2098 we know to take advantage of -R and make shorter addresses. */
252b5132
RH		 2099 if (flag_readonly_data_in_text)
2100 {
2101 merge_data_into_text ();
2102 }
252b5132 2103
32638454 2104 rsi.pass = 0;
e46d99eb
AM		 2105 while (1)
2106 {
aacb5251
HPN		 2107#ifndef WORKING_DOT_WORD
2108 /* We need to reset the markers in the broken word list and
2109 associated frags between calls to relax_segment (via
2110 relax_seg). Since the broken word list is global, we do it
2111 once per round, rather than locally in relax_segment for each
2112 segment. */
2113 struct broken_word *brokp;
2114
2115 for (brokp = broken_words;
2116 brokp != (struct broken_word *) NULL;
2117 brokp = brokp->next_broken_word)
2118 {
2119 brokp->added = 0;
2120
2121 if (brokp->dispfrag != (fragS *) NULL
2122 && brokp->dispfrag->fr_type == rs_broken_word)
2123 brokp->dispfrag->fr_subtype = 0;
2124 }
2125#endif
2126
32638454
AM		 2127 rsi.changed = 0;
2128 bfd_map_over_sections (stdoutput, relax_seg, &rsi);
2129 rsi.pass++;
2130 if (!rsi.changed)
e46d99eb
AM		 2131 break;
2132 }
e027f3e8 2133
87548816
NC		 2134 /* Note - Most ports will use the default value of
2135 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force
2136 local symbols to be resolved, removing their frag information.
2137 Some ports however, will not have finished relaxing all of
2138 their frags and will still need the local symbol frag
2139 information. These ports can set
2140 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */
2141 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
2142
e46d99eb 2143 bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
e46d99eb 2144
38b87a1b
NC		 2145 /* Relaxation has completed. Freeze all syms. */
2146 finalize_syms = 1;
2147
ba8826a8
AO		 2148 dwarf2dbg_final_check ();
2149
e0001a05
NC		 2150#ifdef md_post_relax_hook
2151 md_post_relax_hook;
2152#endif
2153
d98b0e2b
TG		 2154#ifdef OBJ_ELF
2155 if (IS_ELF)
2156 create_obj_attrs_section ();
2157#endif
2158
252b5132
RH		 2159#ifndef WORKING_DOT_WORD
2160 {
2161 struct broken_word *lie;
2162 struct broken_word **prevP;
2163
2164 prevP = &broken_words;
2165 for (lie = broken_words; lie; lie = lie->next_broken_word)
2166 if (!lie->added)
2167 {
2168 expressionS exp;
2169
2170 subseg_change (lie->seg, lie->subseg);
2171 exp.X_op = O_subtract;
2172 exp.X_add_symbol = lie->add;
2173 exp.X_op_symbol = lie->sub;
2174 exp.X_add_number = lie->addnum;
252b5132
RH		 2175#ifdef TC_CONS_FIX_NEW
2176 TC_CONS_FIX_NEW (lie->frag,
efaf0ba4 2177 lie->word_goes_here - lie->frag->fr_literal,
62ebcb5c 2178 2, &exp, TC_PARSE_CONS_RETURN_NONE);
252b5132
RH		 2179#else
2180 fix_new_exp (lie->frag,
2181 lie->word_goes_here - lie->frag->fr_literal,
2182 2, &exp, 0, BFD_RELOC_16);
2183#endif
252b5132
RH		 2184 *prevP = lie->next_broken_word;
2185 }
2186 else
2187 prevP = &(lie->next_broken_word);
2188
2189 for (lie = broken_words; lie;)
2190 {
2191 struct broken_word *untruth;
2192 char *table_ptr;
2193 addressT table_addr;
2194 addressT from_addr, to_addr;
2195 int n, m;
2196
2197 subseg_change (lie->seg, lie->subseg);
2198 fragP = lie->dispfrag;
2199
2200 /* Find out how many broken_words go here. */
2201 n = 0;
efaf0ba4
NC		 2202 for (untruth = lie;
2203 untruth && untruth->dispfrag == fragP;
2204 untruth = untruth->next_broken_word)
252b5132
RH		 2205 if (untruth->added == 1)
2206 n++;
2207
2208 table_ptr = lie->dispfrag->fr_opcode;
efaf0ba4
NC		 2209 table_addr = (lie->dispfrag->fr_address
2210 + (table_ptr - lie->dispfrag->fr_literal));
252b5132
RH		 2211 /* Create the jump around the long jumps. This is a short
2212 jump from table_ptr+0 to table_ptr+n*long_jump_size. */
2213 from_addr = table_addr;
2214 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
efaf0ba4
NC		 2215 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2216 lie->add);
252b5132
RH		 2217 table_ptr += md_short_jump_size;
2218 table_addr += md_short_jump_size;
2219
efaf0ba4
NC		 2220 for (m = 0;
2221 lie && lie->dispfrag == fragP;
2222 m++, lie = lie->next_broken_word)
252b5132
RH		 2223 {
2224 if (lie->added == 2)
2225 continue;
efaf0ba4 2226 /* Patch the jump table. */
187af7df 2227 for (untruth = (struct broken_word *) (fragP->fr_symbol);
efaf0ba4
NC		 2228 untruth && untruth->dispfrag == fragP;
2229 untruth = untruth->next_broken_word)
252b5132
RH		 2230 {
2231 if (untruth->use_jump == lie)
187af7df
HPN		 2232 {
2233 /* This is the offset from ??? to table_ptr+0.
2234 The target is the same for all users of this
2235 md_long_jump, but the "sub" bases (and hence the
2236 offsets) may be different. */
2237 addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
2238#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2239 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
2240#endif
2241 md_number_to_chars (untruth->word_goes_here, to_word, 2);
2242 }
252b5132
RH		 2243 }
2244
efaf0ba4
NC		 2245 /* Install the long jump. */
2246 /* This is a long jump from table_ptr+0 to the final target. */
252b5132
RH		 2247 from_addr = table_addr;
2248 to_addr = S_GET_VALUE (lie->add) + lie->addnum;
efaf0ba4
NC		 2249 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2250 lie->add);
252b5132
RH		 2251 table_ptr += md_long_jump_size;
2252 table_addr += md_long_jump_size;
2253 }
2254 }
2255 }
efaf0ba4 2256#endif /* not WORKING_DOT_WORD */
252b5132 2257
252b5132
RH		 2258 /* Resolve symbol values. This needs to be done before processing
2259 the relocations. */
2260 if (symbol_rootP)
2261 {
2262 symbolS *symp;
2263
2264 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
6386f3a7 2265 resolve_symbol_value (symp);
252b5132 2266 }
49309057 2267 resolve_local_symbol_values ();
05e9452c 2268 resolve_reloc_expr_symbols ();
252b5132 2269
0df8ad28
NC		 2270#ifdef OBJ_ELF
2271 if (IS_ELF)
2272 maybe_generate_build_notes ();
2273#endif
269b4ded 2274
252b5132
RH		 2275 PROGRESS (1);
2276
2277#ifdef tc_frob_file_before_adjust
2278 tc_frob_file_before_adjust ();
2279#endif
2280#ifdef obj_frob_file_before_adjust
2281 obj_frob_file_before_adjust ();
2282#endif
2283
efaf0ba4 2284 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
252b5132 2285
a161fe53
AM		 2286#ifdef tc_frob_file_before_fix
2287 tc_frob_file_before_fix ();
2288#endif
2289#ifdef obj_frob_file_before_fix
2290 obj_frob_file_before_fix ();
2291#endif
2292
2293 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2294
252b5132
RH		 2295 /* Set up symbol table, and write it out. */
2296 if (symbol_rootP)
2297 {
2298 symbolS *symp;
aaac53f5 2299 bfd_boolean skip_next_symbol = FALSE;
252b5132
RH		 2300
2301 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2302 {
2303 int punt = 0;
2304 const char *name;
2305
aaac53f5
HPN		 2306 if (skip_next_symbol)
2307 {
2308 /* Don't do anything besides moving the value of the
2309 symbol from the GAS value-field to the BFD value-field. */
2310 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2311 skip_next_symbol = FALSE;
2312 continue;
2313 }
2314
49309057 2315 if (symbol_mri_common_p (symp))
252b5132
RH		 2316 {
2317 if (S_IS_EXTERNAL (symp))
2318 as_bad (_("%s: global symbols not supported in common sections"),
2319 S_GET_NAME (symp));
2320 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2321 continue;
2322 }
2323
2324 name = S_GET_NAME (symp);
2325 if (name)
2326 {
efaf0ba4
NC		 2327 const char *name2 =
2328 decode_local_label_name ((char *) S_GET_NAME (symp));
252b5132
RH		 2329 /* They only differ if `name' is a fb or dollar local
2330 label name. */
2331 if (name2 != name && ! S_IS_DEFINED (symp))
0e389e77 2332 as_bad (_("local label `%s' is not defined"), name2);
252b5132
RH		 2333 }
2334
2335 /* Do it again, because adjust_reloc_syms might introduce
2336 more symbols. They'll probably only be section symbols,
2337 but they'll still need to have the values computed. */
6386f3a7 2338 resolve_symbol_value (symp);
252b5132
RH		 2339
2340 /* Skip symbols which were equated to undefined or common
b4b24b79 2341 symbols. */
06e77878
AO		 2342 if (symbol_equated_reloc_p (symp)
2343 || S_IS_WEAKREFR (symp))
252b5132 2344 {
91d6fa6a
NC		 2345 const char *sname = S_GET_NAME (symp);
2346
60938e80 2347 if (S_IS_COMMON (symp)
91d6fa6a 2348 && !TC_FAKE_LABEL (sname)
76db0a2e 2349 && !S_IS_WEAKREFR (symp))
60938e80
L		 2350 {
2351 expressionS *e = symbol_get_value_expression (symp);
91d6fa6a 2352
76db0a2e 2353 as_bad (_("`%s' can't be equated to common symbol `%s'"),
91d6fa6a 2354 sname, S_GET_NAME (e->X_add_symbol));
60938e80 2355 }
d0548f34
L		 2356 if (S_GET_SEGMENT (symp) == reg_section)
2357 {
2358 /* Report error only if we know the symbol name. */
2359 if (S_GET_NAME (symp) != reg_section->name)
2360 as_bad (_("can't make global register symbol `%s'"),
91d6fa6a 2361 sname);
d0548f34 2362 }
252b5132
RH		 2363 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2364 continue;
2365 }
2366
252b5132
RH		 2367#ifdef obj_frob_symbol
2368 obj_frob_symbol (symp, punt);
2369#endif
2370#ifdef tc_frob_symbol
49309057 2371 if (! punt || symbol_used_in_reloc_p (symp))
252b5132
RH		 2372 tc_frob_symbol (symp, punt);
2373#endif
2374
2375 /* If we don't want to keep this symbol, splice it out of
2376 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never
2377 want section symbols. Otherwise, we skip local symbols
2378 and symbols that the frob_symbol macros told us to punt,
2379 but we keep such symbols if they are used in relocs. */
a161fe53
AM		 2380 if (symp == abs_section_sym
2381 || (! EMIT_SECTION_SYMBOLS
2382 && symbol_section_p (symp))
e97b3f28 2383 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
252b5132
RH		 2384 opposites. Sometimes the former checks flags and the
2385 latter examines the name... */
e97b3f28 2386 || (!S_IS_EXTERNAL (symp)
461b725f
AO		 2387 && (punt || S_IS_LOCAL (symp) ||
2388 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
49309057 2389 && ! symbol_used_in_reloc_p (symp)))
252b5132
RH		 2390 {
2391 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
efaf0ba4 2392
252b5132
RH		 2393 /* After symbol_remove, symbol_next(symp) still returns
2394 the one that came after it in the chain. So we don't
2395 need to do any extra cleanup work here. */
252b5132
RH		 2396 continue;
2397 }
2398
2399 /* Make sure we really got a value for the symbol. */
49309057 2400 if (! symbol_resolved_p (symp))
252b5132 2401 {
0e389e77 2402 as_bad (_("can't resolve value for symbol `%s'"),
252b5132 2403 S_GET_NAME (symp));
49309057 2404 symbol_mark_resolved (symp);
252b5132
RH		 2405 }
2406
2407 /* Set the value into the BFD symbol. Up til now the value
2408 has only been kept in the gas symbolS struct. */
49309057 2409 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
aaac53f5
HPN		 2410
2411 /* A warning construct is a warning symbol followed by the
2412 symbol warned about. Don't let anything object-format or
2413 target-specific muck with it; it's ready for output. */
2414 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2415 skip_next_symbol = TRUE;
252b5132
RH		 2416 }
2417 }
2418
2419 PROGRESS (1);
2420
2421 /* Now do any format-specific adjustments to the symbol table, such
2422 as adding file symbols. */
2423#ifdef tc_adjust_symtab
2424 tc_adjust_symtab ();
2425#endif
2426#ifdef obj_adjust_symtab
2427 obj_adjust_symtab ();
2428#endif
2429
d0548f34
L		 2430 /* Stop if there is an error. */
2431 if (had_errors ())
2432 return;
2433
252b5132
RH		 2434 /* Now that all the sizes are known, and contents correct, we can
2435 start writing to the file. */
2ae08483 2436 set_symtab ();
252b5132
RH		 2437
2438 /* If *_frob_file changes the symbol value at this point, it is
2439 responsible for moving the changed value into symp->bsym->value
2440 as well. Hopefully all symbol value changing can be done in
2441 *_frob_symbol. */
2442#ifdef tc_frob_file
2443 tc_frob_file ();
2444#endif
2445#ifdef obj_frob_file
2446 obj_frob_file ();
2447#endif
f3d2b04b
KT		 2448#ifdef obj_coff_generate_pdata
2449 obj_coff_generate_pdata ();
2450#endif
0df8ad28 2451
252b5132
RH		 2452 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2453
f1c2d4af 2454#ifdef tc_frob_file_after_relocs
252b5132
RH		 2455 tc_frob_file_after_relocs ();
2456#endif
2457#ifdef obj_frob_file_after_relocs
2458 obj_frob_file_after_relocs ();
2459#endif
f1c2d4af 2460
b8871f35
L		 2461#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2462 if (IS_ELF && flag_use_elf_stt_common)
2463 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
2464#endif
2465
0acf065b
CC		 2466 /* Once all relocations have been written, we can compress the
2467 contents of the debug sections. This needs to be done before
2468 we start writing any sections, because it will affect the file
2469 layout, which is fixed once we start writing contents. */
2470 if (flag_compress_debug)
8ecb73dd
L		 2471 {
2472 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
2473 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
2474 else
2475 stdoutput->flags |= BFD_COMPRESS;
2476 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2477 }
0acf065b 2478
252b5132 2479 bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
252b5132 2480}
252b5132
RH		 2481
2482#ifdef TC_GENERIC_RELAX_TABLE
252b5132
RH		 2483/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */
2484
2485long
d7342424 2486relax_frag (segT segment, fragS *fragP, long stretch)
252b5132
RH		 2487{
2488 const relax_typeS *this_type;
2489 const relax_typeS *start_type;
2490 relax_substateT next_state;
2491 relax_substateT this_state;
685736be 2492 offsetT growth;
38686296
AM		 2493 offsetT aim;
2494 addressT target;
2495 addressT address;
2496 symbolS *symbolP;
2497 const relax_typeS *table;
2498
2499 target = fragP->fr_offset;
37a58883 2500 address = fragP->fr_address + fragP->fr_fix;
38686296 2501 table = TC_GENERIC_RELAX_TABLE;
252b5132
RH		 2502 this_state = fragP->fr_subtype;
2503 start_type = this_type = table + this_state;
38686296 2504 symbolP = fragP->fr_symbol;
252b5132
RH		 2505
2506 if (symbolP)
2507 {
c842b53a
ILT		 2508 fragS *sym_frag;
2509
2510 sym_frag = symbol_get_frag (symbolP);
2511
252b5132 2512#ifndef DIFF_EXPR_OK
c842b53a 2513 know (sym_frag != NULL);
252b5132 2514#endif
a161fe53 2515 know (S_GET_SEGMENT (symbolP) != absolute_section
c842b53a 2516 || sym_frag == &zero_address_frag);
ac62c346 2517 target += S_GET_VALUE (symbolP);
252b5132 2518
e35a414d
AM		 2519 /* If SYM_FRAG has yet to be reached on this pass, assume it
2520 will move by STRETCH just as we did, unless there is an
2521 alignment frag between here and SYM_FRAG. An alignment may
2522 well absorb any STRETCH, and we don't want to choose a larger
2523 branch insn by overestimating the needed reach of this
2524 branch. It isn't critical to calculate TARGET exactly; We
2525 know we'll be doing another pass if STRETCH is non-zero. */
252b5132 2526
c842b53a 2527 if (stretch != 0
38686296
AM		 2528 && sym_frag->relax_marker != fragP->relax_marker
2529 && S_GET_SEGMENT (symbolP) == segment)
252b5132 2530 {
e35a414d
AM		 2531 if (stretch < 0
2532 || sym_frag->region == fragP->region)
2533 target += stretch;
e5940dff
AM		 2534 /* If we get here we know we have a forward branch. This
2535 relax pass may have stretched previous instructions so
2536 far that omitting STRETCH would make the branch
2537 negative. Don't allow this in case the negative reach is
2538 large enough to require a larger branch instruction. */
2539 else if (target < address)
37a58883 2540 return 0;
252b5132
RH		 2541 }
2542 }
2543
37a58883 2544 aim = target - address;
252b5132 2545#ifdef TC_PCREL_ADJUST
37a58883 2546 /* Currently only the ns32k and arc needs this. */
efaf0ba4 2547 aim += TC_PCREL_ADJUST (fragP);
efaf0ba4 2548#endif
59c871b4
BE		 2549
2550#ifdef md_prepare_relax_scan
2551 /* Formerly called M68K_AIM_KLUDGE. */
252b5132
RH		 2552 md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2553#endif
2554
2555 if (aim < 0)
2556 {
efaf0ba4 2557 /* Look backwards. */
252b5132
RH		 2558 for (next_state = this_type->rlx_more; next_state;)
2559 if (aim >= this_type->rlx_backward)
2560 next_state = 0;
2561 else
2562 {
efaf0ba4 2563 /* Grow to next state. */
252b5132
RH		 2564 this_state = next_state;
2565 this_type = table + this_state;
2566 next_state = this_type->rlx_more;
2567 }
2568 }
2569 else
2570 {
efaf0ba4 2571 /* Look forwards. */
252b5132
RH		 2572 for (next_state = this_type->rlx_more; next_state;)
2573 if (aim <= this_type->rlx_forward)
2574 next_state = 0;
2575 else
2576 {
efaf0ba4 2577 /* Grow to next state. */
252b5132
RH		 2578 this_state = next_state;
2579 this_type = table + this_state;
2580 next_state = this_type->rlx_more;
2581 }
2582 }
2583
2584 growth = this_type->rlx_length - start_type->rlx_length;
2585 if (growth != 0)
2586 fragP->fr_subtype = this_state;
2587 return growth;
2588}
2589
efaf0ba4 2590#endif /* defined (TC_GENERIC_RELAX_TABLE) */
252b5132
RH		 2591
2592/* Relax_align. Advance location counter to next address that has 'alignment'
2593 lowest order bits all 0s, return size of adjustment made. */
2594static relax_addressT
ed9e98c2
AM		 2595relax_align (relax_addressT address, /* Address now. */
2596 int alignment /* Alignment (binary). */)
252b5132
RH		 2597{
2598 relax_addressT mask;
2599 relax_addressT new_address;
2600
65879393 2601 mask = ~((relax_addressT) ~0 << alignment);
252b5132
RH		 2602 new_address = (address + mask) & (~mask);
2603#ifdef LINKER_RELAXING_SHRINKS_ONLY
2604 if (linkrelax)
2605 /* We must provide lots of padding, so the linker can discard it
2606 when needed. The linker will not add extra space, ever. */
2607 new_address += (1 << alignment);
2608#endif
2609 return (new_address - address);
2610}
2611
efaf0ba4
NC		 2612/* Now we have a segment, not a crowd of sub-segments, we can make
2613 fr_address values.
58a77e41 2614
efaf0ba4 2615 Relax the frags.
58a77e41 2616
efaf0ba4
NC		 2617 After this, all frags in this segment have addresses that are correct
2618 within the segment. Since segments live in different file addresses,
2619 these frag addresses may not be the same as final object-file
2620 addresses. */
2621
e46d99eb 2622int
32638454 2623relax_segment (struct frag *segment_frag_root, segT segment, int pass)
252b5132 2624{
4111faa5
NC		 2625 unsigned long frag_count;
2626 struct frag *fragP;
2627 relax_addressT address;
e35a414d 2628 int region;
e46d99eb
AM		 2629 int ret;
2630
efaf0ba4 2631 /* In case md_estimate_size_before_relax() wants to make fixSs. */
252b5132
RH		 2632 subseg_change (segment, 0);
2633
2634 /* For each frag in segment: count and store (a 1st guess of)
2635 fr_address. */
2636 address = 0;
e35a414d 2637 region = 0;
4111faa5
NC		 2638 for (frag_count = 0, fragP = segment_frag_root;
2639 fragP;
2640 fragP = fragP->fr_next, frag_count ++)
252b5132 2641 {
e35a414d 2642 fragP->region = region;
38686296 2643 fragP->relax_marker = 0;
252b5132
RH		 2644 fragP->fr_address = address;
2645 address += fragP->fr_fix;
2646
2647 switch (fragP->fr_type)
2648 {
2649 case rs_fill:
2650 address += fragP->fr_offset * fragP->fr_var;
2651 break;
2652
2653 case rs_align:
2654 case rs_align_code:
0a9ef439 2655 case rs_align_test:
252b5132
RH		 2656 {
2657 addressT offset = relax_align (address, (int) fragP->fr_offset);
2658
2659 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2660 offset = 0;
2661
2662 if (offset % fragP->fr_var != 0)
2663 {
54d3cad9 2664 as_bad_where (fragP->fr_file, fragP->fr_line,
992a06ee
AM		 2665 ngettext ("alignment padding (%lu byte) "
2666 "not a multiple of %ld",
2667 "alignment padding (%lu bytes) "
2668 "not a multiple of %ld",
2669 (unsigned long) offset),
54d3cad9 2670 (unsigned long) offset, (long) fragP->fr_var);
252b5132
RH		 2671 offset -= (offset % fragP->fr_var);
2672 }
2673
2674 address += offset;
e35a414d 2675 region += 1;
252b5132
RH		 2676 }
2677 break;
2678
2679 case rs_org:
252b5132 2680 /* Assume .org is nugatory. It will grow with 1st relax. */
e35a414d
AM		 2681 region += 1;
2682 break;
2683
2684 case rs_space:
62a02d25 2685 case rs_space_nop:
252b5132
RH		 2686 break;
2687
2688 case rs_machine_dependent:
e0890092
AM		 2689 /* If fr_symbol is an expression, this call to
2690 resolve_symbol_value sets up the correct segment, which will
2691 likely be needed in md_estimate_size_before_relax. */
2692 if (fragP->fr_symbol)
2693 resolve_symbol_value (fragP->fr_symbol);
2694
252b5132
RH		 2695 address += md_estimate_size_before_relax (fragP, segment);
2696 break;
2697
2698#ifndef WORKING_DOT_WORD
efaf0ba4 2699 /* Broken words don't concern us yet. */
252b5132
RH		 2700 case rs_broken_word:
2701 break;
2702#endif
2703
2704 case rs_leb128:
efaf0ba4 2705 /* Initial guess is always 1; doing otherwise can result in
252b5132
RH		 2706 stable solutions that are larger than the minimum. */
2707 address += fragP->fr_offset = 1;
2708 break;
2709
2710 case rs_cfa:
2711 address += eh_frame_estimate_size_before_relax (fragP);
2712 break;
2713
220e750f
RH		 2714 case rs_dwarf2dbg:
2715 address += dwarf2dbg_estimate_size_before_relax (fragP);
2716 break;
2717
252b5132
RH		 2718 default:
2719 BAD_CASE (fragP->fr_type);
2720 break;
efaf0ba4
NC		 2721 }
2722 }
252b5132
RH		 2723
2724 /* Do relax(). */
2725 {
4111faa5 2726 unsigned long max_iterations;
d1c5f158
AM		 2727
2728 /* Cumulative address adjustment. */
2729 offsetT stretch;
2730
2731 /* Have we made any adjustment this pass? We can't just test
2732 stretch because one piece of code may have grown and another
2733 shrank. */
2734 int stretched;
2735
2736 /* Most horrible, but gcc may give us some exception data that
2737 is impossible to assemble, of the form
2738
2739 .align 4
2740 .byte 0, 0
2741 .uleb128 end - start
2742 start:
2743 .space 128*128 - 1
2744 .align 4
2745 end:
2746
2747 If the leb128 is two bytes in size, then end-start is 128*128,
2748 which requires a three byte leb128. If the leb128 is three
2749 bytes in size, then end-start is 128*128-1, which requires a
2750 two byte leb128. We work around this dilemma by inserting
2751 an extra 4 bytes of alignment just after the .align. This
2752 works because the data after the align is accessed relative to
2753 the end label.
2754
2755 This counter is used in a tiny state machine to detect
2756 whether a leb128 followed by an align is impossible to
2757 relax. */
2758 int rs_leb128_fudge = 0;
252b5132 2759
4111faa5
NC		 2760 /* We want to prevent going into an infinite loop where one frag grows
2761 depending upon the location of a symbol which is in turn moved by
2762 the growing frag. eg:
2763
b4b24b79
AM		 2764 foo = .
2765 .org foo+16
2766 foo = .
4111faa5 2767
b4b24b79 2768 So we dictate that this algorithm can be at most O2. */
4111faa5
NC		 2769 max_iterations = frag_count * frag_count;
2770 /* Check for overflow. */
2771 if (max_iterations < frag_count)
2772 max_iterations = frag_count;
2773
32638454 2774 ret = 0;
252b5132
RH		 2775 do
2776 {
e46d99eb
AM		 2777 stretch = 0;
2778 stretched = 0;
58a77e41 2779
252b5132
RH		 2780 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2781 {
685736be 2782 offsetT growth = 0;
252b5132
RH		 2783 addressT was_address;
2784 offsetT offset;
2785 symbolS *symbolP;
2786
38686296 2787 fragP->relax_marker ^= 1;
252b5132
RH		 2788 was_address = fragP->fr_address;
2789 address = fragP->fr_address += stretch;
2790 symbolP = fragP->fr_symbol;
2791 offset = fragP->fr_offset;
2792
2793 switch (fragP->fr_type)
2794 {
efaf0ba4 2795 case rs_fill: /* .fill never relaxes. */
252b5132
RH		 2796 growth = 0;
2797 break;
2798
2799#ifndef WORKING_DOT_WORD
2800 /* JF: This is RMS's idea. I do *NOT* want to be blamed
2801 for it I do not want to write it. I do not want to have
2802 anything to do with it. This is not the proper way to
2803 implement this misfeature. */
2804 case rs_broken_word:
2805 {
2806 struct broken_word *lie;
2807 struct broken_word *untruth;
2808
2809 /* Yes this is ugly (storing the broken_word pointer
2810 in the symbol slot). Still, this whole chunk of
2811 code is ugly, and I don't feel like doing anything
2812 about it. Think of it as stubbornness in action. */
2813 growth = 0;
2814 for (lie = (struct broken_word *) (fragP->fr_symbol);
2815 lie && lie->dispfrag == fragP;
2816 lie = lie->next_broken_word)
2817 {
2818
2819 if (lie->added)
2820 continue;
2821
ac62c346 2822 offset = (S_GET_VALUE (lie->add)
252b5132 2823 + lie->addnum
ac62c346 2824 - S_GET_VALUE (lie->sub));
252b5132
RH		 2825 if (offset <= -32768 || offset >= 32767)
2826 {
2827 if (flag_warn_displacement)
2828 {
2829 char buf[50];
2830 sprint_value (buf, (addressT) lie->addnum);
54d3cad9
AM		 2831 as_warn_where (fragP->fr_file, fragP->fr_line,
2832 _(".word %s-%s+%s didn't fit"),
2833 S_GET_NAME (lie->add),
2834 S_GET_NAME (lie->sub),
2835 buf);
252b5132 2836 }
252b5132
RH		 2837 if (fragP->fr_subtype == 0)
2838 {
2839 fragP->fr_subtype++;
2840 growth += md_short_jump_size;
2841 }
187af7df
HPN		 2842
2843 /* Redirect *all* words of this table with the same
2844 target, lest we have to handle the case where the
2845 same target but with a offset that fits on this
2846 round overflows at the next relaxation round. */
2847 for (untruth = (struct broken_word *) (fragP->fr_symbol);
252b5132
RH		 2848 untruth && untruth->dispfrag == lie->dispfrag;
2849 untruth = untruth->next_broken_word)
49309057
ILT		 2850 if ((symbol_get_frag (untruth->add)
2851 == symbol_get_frag (lie->add))
2852 && (S_GET_VALUE (untruth->add)
2853 == S_GET_VALUE (lie->add)))
252b5132
RH		 2854 {
2855 untruth->added = 2;
2856 untruth->use_jump = lie;
2857 }
187af7df
HPN		 2858
2859 lie->added = 1;
252b5132
RH		 2860 growth += md_long_jump_size;
2861 }
2862 }
2863
2864 break;
efaf0ba4 2865 } /* case rs_broken_word */
252b5132
RH		 2866#endif
2867 case rs_align:
2868 case rs_align_code:
0a9ef439 2869 case rs_align_test:
252b5132
RH		 2870 {
2871 addressT oldoff, newoff;
2872
2873 oldoff = relax_align (was_address + fragP->fr_fix,
2874 (int) offset);
2875 newoff = relax_align (address + fragP->fr_fix,
2876 (int) offset);
2877
2878 if (fragP->fr_subtype != 0)
2879 {
2880 if (oldoff > fragP->fr_subtype)
2881 oldoff = 0;
2882 if (newoff > fragP->fr_subtype)
2883 newoff = 0;
2884 }
2885
2886 growth = newoff - oldoff;
d1c5f158
AM		 2887
2888 /* If this align happens to follow a leb128 and
2889 we have determined that the leb128 is bouncing
2890 in size, then break the cycle by inserting an
2891 extra alignment. */
2892 if (growth < 0
2893 && (rs_leb128_fudge & 16) != 0
2894 && (rs_leb128_fudge & 15) >= 2)
2895 {
2896 segment_info_type *seginfo = seg_info (segment);
2897 struct obstack *ob = &seginfo->frchainP->frch_obstack;
2898 struct frag *newf;
2899
2900 newf = frag_alloc (ob);
2901 obstack_blank_fast (ob, fragP->fr_var);
2902 obstack_finish (ob);
2903 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2904 memcpy (newf->fr_literal,
2905 fragP->fr_literal + fragP->fr_fix,
2906 fragP->fr_var);
2907 newf->fr_type = rs_fill;
20f5cfbd 2908 newf->fr_address = address + fragP->fr_fix + newoff;
d1c5f158
AM		 2909 newf->fr_fix = 0;
2910 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2911 / fragP->fr_var);
2912 if (newf->fr_offset * newf->fr_var
2913 != (offsetT) 1 << fragP->fr_offset)
2914 {
2915 newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2916 newf->fr_var = 1;
2917 }
20f5cfbd 2918 /* Include size of new frag in GROWTH. */
d1c5f158 2919 growth += newf->fr_offset * newf->fr_var;
20f5cfbd
AM		 2920 /* Adjust the new frag address for the amount
2921 we'll add when we process the new frag. */
2922 newf->fr_address -= stretch + growth;
d1c5f158
AM		 2923 newf->relax_marker ^= 1;
2924 fragP->fr_next = newf;
2925#ifdef DEBUG
2926 as_warn (_("padding added"));
2927#endif
2928 }
252b5132
RH		 2929 }
2930 break;
2931
2932 case rs_org:
2933 {
e46d99eb
AM		 2934 addressT target = offset;
2935 addressT after;
252b5132
RH		 2936
2937 if (symbolP)
2938 {
b4b24b79
AM		 2939 /* Convert from an actual address to an octet offset
2940 into the section. Here it is assumed that the
2941 section's VMA is zero, and can omit subtracting it
2942 from the symbol's value to get the address offset. */
2943 know (S_GET_SEGMENT (symbolP)->vma == 0);
6e917903 2944 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
ac62c346 2945 }
252b5132
RH		 2946
2947 know (fragP->fr_next);
6afe8e98 2948 after = fragP->fr_next->fr_address + stretch;
252b5132 2949 growth = target - after;
9875b365
MR		 2950
2951 /* Growth may be negative, but variable part of frag
2952 cannot have fewer than 0 chars. That is, we can't
2953 .org backwards. */
2954 if (address + fragP->fr_fix > target)
252b5132 2955 {
32638454
AM		 2956 growth = 0;
2957
2958 /* Don't error on first few frag relax passes.
2959 The symbol might be an expression involving
2960 symbol values from other sections. If those
2961 sections have not yet been processed their
2962 frags will all have zero addresses, so we
2963 will calculate incorrect values for them. The
2964 number of passes we allow before giving an
2965 error is somewhat arbitrary. It should be at
2966 least one, with larger values requiring
2967 increasingly contrived dependencies between
2968 frags to trigger a false error. */
2969 if (pass < 2)
2970 {
2971 /* Force another pass. */
2972 ret = 1;
2973 break;
2974 }
2975
14ad458a 2976 as_bad_where (fragP->fr_file, fragP->fr_line,
685736be 2977 _("attempt to move .org backwards"));
14ad458a
ILT		 2978
2979 /* We've issued an error message. Change the
b4b24b79 2980 frag to avoid cascading errors. */
14ad458a
ILT		 2981 fragP->fr_type = rs_align;
2982 fragP->fr_subtype = 0;
2983 fragP->fr_offset = 0;
6afe8e98 2984 fragP->fr_fix = after - address;
252b5132 2985 }
252b5132 2986 }
6afe8e98 2987 break;
252b5132
RH		 2988
2989 case rs_space:
62a02d25 2990 case rs_space_nop:
54d3cad9 2991 growth = 0;
252b5132
RH		 2992 if (symbolP)
2993 {
766c03c9
AM		 2994 offsetT amount;
2995
2996 amount = S_GET_VALUE (symbolP);
9e40345d 2997 if (S_GET_SEGMENT (symbolP) != absolute_section
252b5132
RH		 2998 || S_IS_COMMON (symbolP)
2999 || ! S_IS_DEFINED (symbolP))
252b5132 3000 {
54d3cad9
AM		 3001 as_bad_where (fragP->fr_file, fragP->fr_line,
3002 _(".space specifies non-absolute value"));
3003 /* Prevent repeat of this error message. */
3004 fragP->fr_symbol = 0;
3005 }
3006 else if (amount < 0)
3007 {
32638454
AM		 3008 /* Don't error on first few frag relax passes.
3009 See rs_org comment for a longer explanation. */
3010 if (pass < 2)
3011 {
3012 ret = 1;
3013 break;
3014 }
3015
54d3cad9 3016 as_warn_where (fragP->fr_file, fragP->fr_line,
8f065d3b 3017 _(".space, .nops or .fill with negative value, ignored"));
766c03c9 3018 fragP->fr_symbol = 0;
252b5132 3019 }
54d3cad9 3020 else
050be34e 3021 growth = (was_address + fragP->fr_fix + amount
54d3cad9 3022 - fragP->fr_next->fr_address);
252b5132 3023 }
252b5132
RH		 3024 break;
3025
3026 case rs_machine_dependent:
3027#ifdef md_relax_frag
c842b53a 3028 growth = md_relax_frag (segment, fragP, stretch);
252b5132
RH		 3029#else
3030#ifdef TC_GENERIC_RELAX_TABLE
3031 /* The default way to relax a frag is to look through
3032 TC_GENERIC_RELAX_TABLE. */
c842b53a 3033 growth = relax_frag (segment, fragP, stretch);
efaf0ba4 3034#endif /* TC_GENERIC_RELAX_TABLE */
252b5132
RH		 3035#endif
3036 break;
3037
3038 case rs_leb128:
3039 {
3040 valueT value;
685736be 3041 offsetT size;
252b5132 3042
6386f3a7 3043 value = resolve_symbol_value (fragP->fr_symbol);
252b5132
RH		 3044 size = sizeof_leb128 (value, fragP->fr_subtype);
3045 growth = size - fragP->fr_offset;
3046 fragP->fr_offset = size;
3047 }
3048 break;
3049
3050 case rs_cfa:
3051 growth = eh_frame_relax_frag (fragP);
3052 break;
3053
220e750f
RH		 3054 case rs_dwarf2dbg:
3055 growth = dwarf2dbg_relax_frag (fragP);
3056 break;
3057
252b5132
RH		 3058 default:
3059 BAD_CASE (fragP->fr_type);
3060 break;
3061 }
3062 if (growth)
3063 {
3064 stretch += growth;
e46d99eb 3065 stretched = 1;
d1c5f158
AM		 3066 if (fragP->fr_type == rs_leb128)
3067 rs_leb128_fudge += 16;
3068 else if (fragP->fr_type == rs_align
3069 && (rs_leb128_fudge & 16) != 0
3070 && stretch == 0)
3071 rs_leb128_fudge += 16;
3072 else
3073 rs_leb128_fudge = 0;
252b5132 3074 }
4111faa5 3075 }
d1c5f158
AM		 3076
3077 if (stretch == 0
3078 && (rs_leb128_fudge & 16) == 0
3079 && (rs_leb128_fudge & -16) != 0)
3080 rs_leb128_fudge += 1;
3081 else
3082 rs_leb128_fudge = 0;
252b5132 3083 }
4111faa5
NC		 3084 /* Until nothing further to relax. */
3085 while (stretched && -- max_iterations);
3086
3087 if (stretched)
3088 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3089 segment_name (segment));
3090 }
252b5132 3091
e46d99eb
AM		 3092 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
3093 if (fragP->last_fr_address != fragP->fr_address)
3094 {
3095 fragP->last_fr_address = fragP->fr_address;
3096 ret = 1;
3097 }
3098 return ret;
efaf0ba4 3099}
252b5132 3100
252b5132 3101void
d7342424 3102number_to_chars_bigendian (char *buf, valueT val, int n)
252b5132 3103{
937149dd 3104 if (n <= 0)
252b5132
RH		 3105 abort ();
3106 while (n--)
3107 {
3108 buf[n] = val & 0xff;
3109 val >>= 8;
3110 }
3111}
3112
3113void
d7342424 3114number_to_chars_littleendian (char *buf, valueT val, int n)
252b5132 3115{
937149dd 3116 if (n <= 0)
252b5132
RH		 3117 abort ();
3118 while (n--)
3119 {
3120 *buf++ = val & 0xff;
3121 val >>= 8;
3122 }
3123}
3124
3125void
d7342424 3126write_print_statistics (FILE *file)
252b5132 3127{
6d4d30bb 3128 fprintf (file, "fixups: %d\n", n_fixups);
252b5132
RH		 3129}
3130
efaf0ba4 3131/* For debugging. */
252b5132
RH		 3132extern int indent_level;
3133
3134void
d7342424 3135print_fixup (fixS *fixp)
252b5132
RH		 3136{
3137 indent_level = 1;
d2df793a
NC		 3138 fprintf (stderr, "fix ");
3139 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
3140 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
252b5132
RH		 3141 if (fixp->fx_pcrel)
3142 fprintf (stderr, " pcrel");
3143 if (fixp->fx_pcrel_adjust)
3144 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
252b5132
RH		 3145 if (fixp->fx_tcbit)
3146 fprintf (stderr, " tcbit");
3147 if (fixp->fx_done)
3148 fprintf (stderr, " done");
d2df793a
NC		 3149 fprintf (stderr, "\n size=%d frag=", fixp->fx_size);
3150 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
3151 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
3152 (long) fixp->fx_where,
0af1713e
AM		 3153 (unsigned long) fixp->fx_offset,
3154 (unsigned long) fixp->fx_addnumber);
252b5132
RH		 3155 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3156 fixp->fx_r_type);
252b5132
RH		 3157 if (fixp->fx_addsy)
3158 {
3159 fprintf (stderr, "\n +<");
3160 print_symbol_value_1 (stderr, fixp->fx_addsy);
3161 fprintf (stderr, ">");
3162 }
3163 if (fixp->fx_subsy)
3164 {
3165 fprintf (stderr, "\n -<");
3166 print_symbol_value_1 (stderr, fixp->fx_subsy);
3167 fprintf (stderr, ">");
3168 }
3169 fprintf (stderr, "\n");
3170#ifdef TC_FIX_DATA_PRINT
3171 TC_FIX_DATA_PRINT (stderr, fixp);
3172#endif
3173}
GDB Binutils - Deliverables
This page took 1.074403 seconds and 4 git commands to generate.