1/* write.c - emit .o file 2 Copyright (C) 1986-2020 Free Software Foundation, Inc. 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 8 the Free Software Foundation; either version 3, or (at your option) 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 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21/* This thing should be set up to do byte ordering correctly. But... */ 22 23#include "as.h" 24#include "subsegs.h" 25#include "obstack.h" 26#include "output-file.h" 27#include "dwarf2dbg.h" 28#include "compress-debug.h" 29 30#ifndef TC_FORCE_RELOCATION 31#define TC_FORCE_RELOCATION(FIX) \ 32 (generic_force_reloc (FIX)) 33#endif 34 35#ifndef TC_FORCE_RELOCATION_ABS 36#define TC_FORCE_RELOCATION_ABS(FIX) \ 37 (TC_FORCE_RELOCATION (FIX)) 38#endif 39 40#define GENERIC_FORCE_RELOCATION_LOCAL(FIX) \ 41 (!(FIX)->fx_pcrel \ 42 || TC_FORCE_RELOCATION (FIX)) 43#ifndef TC_FORCE_RELOCATION_LOCAL 44#define TC_FORCE_RELOCATION_LOCAL GENERIC_FORCE_RELOCATION_LOCAL 45#endif 46 47#define GENERIC_FORCE_RELOCATION_SUB_SAME(FIX, SEG) \ 48 (!SEG_NORMAL (SEG)) 49#ifndef TC_FORCE_RELOCATION_SUB_SAME 50#define TC_FORCE_RELOCATION_SUB_SAME GENERIC_FORCE_RELOCATION_SUB_SAME 51#endif 52 53#ifndef md_register_arithmetic 54# define md_register_arithmetic 1 55#endif 56 57#ifndef TC_FORCE_RELOCATION_SUB_ABS 58#define TC_FORCE_RELOCATION_SUB_ABS(FIX, SEG) \ 59 (!md_register_arithmetic && (SEG) == reg_section) 60#endif 61 62#ifndef TC_FORCE_RELOCATION_SUB_LOCAL 63#ifdef DIFF_EXPR_OK 64#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) \ 65 (!md_register_arithmetic && (SEG) == reg_section) 66#else 67#define TC_FORCE_RELOCATION_SUB_LOCAL(FIX, SEG) 1 68#endif 69#endif 70 71#ifndef TC_VALIDATE_FIX_SUB 72#ifdef UNDEFINED_DIFFERENCE_OK 73/* The PA needs this for PIC code generation. */ 74#define TC_VALIDATE_FIX_SUB(FIX, SEG) \ 75 (md_register_arithmetic || (SEG) != reg_section) 76#else 77#define TC_VALIDATE_FIX_SUB(FIX, SEG) \ 78 ((md_register_arithmetic || (SEG) != reg_section) \ 79 && ((FIX)->fx_r_type == BFD_RELOC_GPREL32 \ 80 || (FIX)->fx_r_type == BFD_RELOC_GPREL16)) 81#endif 82#endif 83 84#ifndef TC_LINKRELAX_FIXUP 85#define TC_LINKRELAX_FIXUP(SEG) 1 86#endif 87 88#ifndef MD_APPLY_SYM_VALUE 89#define MD_APPLY_SYM_VALUE(FIX) 1 90#endif 91 92#ifndef TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 93#define TC_FINALIZE_SYMS_BEFORE_SIZE_SEG 1 94#endif 95 96#ifndef MD_PCREL_FROM_SECTION 97#define MD_PCREL_FROM_SECTION(FIX, SEC) md_pcrel_from (FIX) 98#endif 99 100#ifndef TC_FAKE_LABEL 101#define TC_FAKE_LABEL(NAME) (strcmp ((NAME), FAKE_LABEL_NAME) == 0) 102#endif 103 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 114/* Used to control final evaluation of expressions. */ 115int finalize_syms = 0; 116 117int symbol_table_frozen; 118 119symbolS *abs_section_sym; 120 121/* Remember the value of dot when parsing expressions. */ 122addressT dot_value; 123 124/* The frag that dot_value is based from. */ 125fragS *dot_frag; 126 127/* Relocs generated by ".reloc" pseudo. */ 128struct reloc_list* reloc_list; 129 130void print_fixup (fixS *); 131 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; 137 138static int n_fixups; 139 140#define RELOC_ENUM enum bfd_reloc_code_real 141 142/* Create a fixS in obstack 'notes'. */ 143 144static fixS * 145fix_new_internal (fragS *frag, /* Which frag? */ 146 unsigned long where, /* Where in that frag? */ 147 unsigned long size, /* 1, 2, or 4 usually. */ 148 symbolS *add_symbol, /* X_add_symbol. */ 149 symbolS *sub_symbol, /* X_op_symbol. */ 150 offsetT offset, /* X_add_number. */ 151 int pcrel, /* TRUE if PC-relative relocation. */ 152 RELOC_ENUM r_type /* Relocation type. */, 153 int at_beginning) /* Add to the start of the list? */ 154{ 155 fixS *fixP; 156 157 n_fixups++; 158 159 fixP = (fixS *) obstack_alloc (¬es, sizeof (fixS)); 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 { 167 as_bad (_("field fx_size too small to hold %lu"), size); 168 abort (); 169 } 170 fixP->fx_addsy = add_symbol; 171 fixP->fx_subsy = sub_symbol; 172 fixP->fx_offset = offset; 173 fixP->fx_dot_value = dot_value; 174 fixP->fx_dot_frag = dot_frag; 175 fixP->fx_pcrel = pcrel; 176 fixP->fx_r_type = r_type; 177 fixP->fx_pcrel_adjust = 0; 178 fixP->fx_addnumber = 0; 179 fixP->fx_tcbit = 0; 180 fixP->fx_tcbit2 = 0; 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 191 TC_INIT_FIX_DATA (fixP); 192#endif 193 194 fixP->fx_file = as_where (&fixP->fx_line); 195 196 { 197 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); 204 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 } 212 else 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 } 221 } 222 223 return fixP; 224} 225 226/* Create a fixup relative to a symbol (plus a constant). */ 227 228fixS * 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. */ 233 offsetT offset, /* X_add_number. */ 234 int pcrel, /* TRUE if PC-relative relocation. */ 235 RELOC_ENUM r_type /* Relocation type. */) 236{ 237 return fix_new_internal (frag, where, size, add_symbol, 238 (symbolS *) NULL, offset, pcrel, r_type, FALSE); 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 * 246fix_new_exp (fragS *frag, /* Which frag? */ 247 unsigned long where, /* Where in that frag? */ 248 unsigned long size, /* 1, 2, or 4 usually. */ 249 expressionS *exp, /* Expression. */ 250 int pcrel, /* TRUE if PC-relative relocation. */ 251 RELOC_ENUM r_type /* Relocation type. */) 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 262 case O_register: 263 as_bad (_("register value used as expression")); 264 break; 265 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); 271 272 exp->X_op = O_symbol; 273 exp->X_op_symbol = 0; 274 exp->X_add_symbol = stmp; 275 exp->X_add_number = 0; 276 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; 283 r_type = BFD_RELOC_RVA; 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; 296 /* Fall through. */ 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 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 * 314fix_at_start (fragS *frag, unsigned long size, symbolS *add_symbol, 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); 319} 320 321/* Generic function to determine whether a fixup requires a relocation. */ 322int 323generic_force_reloc (fixS *fix) 324{ 325 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT 326 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 327 return 1; 328 329 if (fix->fx_addsy == NULL) 330 return 0; 331 332 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL); 333} 334 335/* Append a string onto another string, bumping the pointer along. */ 336void 337append (char **charPP, char *fromP, unsigned long length) 338{ 339 /* Don't trust memcpy() of 0 chars. */ 340 if (length == 0) 341 return; 342 343 memcpy (*charPP, fromP, length); 344 *charPP += length; 345} 346 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 352void 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.) */ 357 unsigned int align) 358{ 359 if (seg == absolute_section) 360 return; 361 362 if (align > bfd_section_alignment (seg)) 363 bfd_set_section_alignment (seg, align); 364} 365 366int 367get_recorded_alignment (segT seg) 368{ 369 if (seg == absolute_section) 370 return 0; 371 372 return bfd_section_alignment (seg); 373} 374 375/* Reset the section indices after removing the gas created sections. */ 376 377static void 378renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg) 379{ 380 int *countp = (int *) countparg; 381 382 sec->index = *countp; 383 ++*countp; 384} 385 386static fragS * 387chain_frchains_together_1 (segT section, struct frchain *frchp) 388{ 389 fragS dummy, *prev_frag = &dummy; 390 fixS fix_dummy, *prev_fix = &fix_dummy; 391 392 for (; frchp; frchp = frchp->frch_next) 393 { 394 prev_frag->fr_next = frchp->frch_root; 395 prev_frag = frchp->frch_last; 396 gas_assert (prev_frag->fr_type != 0); 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 } 405 } 406 gas_assert (prev_frag != &dummy 407 && prev_frag->fr_type != 0); 408 prev_frag->fr_next = 0; 409 return prev_frag; 410} 411 412static void 413chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED, 414 segT section, 415 void *xxx ATTRIBUTE_UNUSED) 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) 423 info->frchainP->frch_last 424 = chain_frchains_together_1 (section, info->frchainP); 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 431static void 432cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP) 433{ 434 switch (fragP->fr_type) 435 { 436 case rs_space_nop: 437 goto skip_align; 438 case rs_align: 439 case rs_align_code: 440 case rs_align_test: 441 case rs_org: 442 case rs_space: 443#ifdef HANDLE_ALIGN 444 HANDLE_ALIGN (fragP); 445#endif 446 skip_align: 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 { 453 as_bad_where (fragP->fr_file, fragP->fr_line, 454 _("attempt to .org/.space/.nops backwards? (%ld)"), 455 (long) fragP->fr_offset); 456 fragP->fr_offset = 0; 457 } 458 if (fragP->fr_type == rs_space_nop) 459 fragP->fr_type = rs_fill_nop; 460 else 461 fragP->fr_type = rs_fill; 462 break; 463 464 case rs_fill: 465 case rs_fill_nop: 466 break; 467 468 case rs_leb128: 469 { 470 valueT value = S_GET_VALUE (fragP->fr_symbol); 471 int size; 472 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 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 495 case rs_dwarf2dbg: 496 dwarf2dbg_convert_frag (fragP); 497 break; 498 499 case rs_machine_dependent: 500 md_convert_frag (stdoutput, sec, fragP); 501 502 gas_assert (fragP->fr_next == NULL 503 || (fragP->fr_next->fr_address - fragP->fr_address 504 == fragP->fr_fix)); 505 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. */ 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 } 535#ifdef md_frag_check 536 md_frag_check (fragP); 537#endif 538} 539 540struct relax_seg_info 541{ 542 int pass; 543 int changed; 544}; 545 546static void 547relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx) 548{ 549 segment_info_type *seginfo = seg_info (sec); 550 struct relax_seg_info *info = (struct relax_seg_info *) xxx; 551 552 if (seginfo && seginfo->frchainP 553 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass)) 554 info->changed = 1; 555} 556 557static void 558size_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx ATTRIBUTE_UNUSED) 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 568 seginfo = seg_info (sec); 569 if (seginfo && seginfo->frchainP) 570 { 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) 576 /* Walk to last elt. */ 577 ; 578 size = fragp->fr_address + fragp->fr_fix; 579 } 580 else 581 size = 0; 582 583 flags = bfd_section_flags (sec); 584 if (size == 0 && bfd_section_size (sec) != 0 && 585 (flags & SEC_HAS_CONTENTS) != 0) 586 return; 587 588 if (size > 0 && ! seginfo->bss) 589 flags |= SEC_HAS_CONTENTS; 590 591 flags &= ~SEC_RELOC; 592 x = bfd_set_section_flags (sec, flags); 593 gas_assert (x); 594 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); 601 x = bfd_set_section_size (sec, newsize); 602 gas_assert (x); 603 604 /* If the size had to be rounded up, add some padding in the last 605 non-empty frag. */ 606 gas_assert (newsize >= size); 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; 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 (); 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 634dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream) 635{ 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; 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 652 { 653 print_symbol_value_1 (stream, s); 654 fprintf (stream, "\n"); 655 } 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 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{ 673 bfd_vma addr_mask = 1; 674 struct reloc_list *r; 675 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 681 for (r = reloc_list; r; r = r->next) 682 { 683 reloc_howto_type *howto = r->u.a.howto; 684 expressionS *symval; 685 symbolS *sym; 686 bfd_vma offset, addend; 687 asection *sec; 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 } 732 else if (sym != NULL && sec != NULL) 733 { 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) 741 && (sec->use_rela_p 742 || (howto->partial_inplace 743 && (!howto->pc_relative 744 || howto->src_mask == addr_mask)))) 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 } 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 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 774/* This pass over fixups decides whether symbols can be replaced with 775 section symbols. */ 776 777static void 778adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED, 779 asection *sec, 780 void *xxx ATTRIBUTE_UNUSED) 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) 792 /* Ignore it. */ 793 ; 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. */ 810 resolve_symbol_value (sym); 811 812 if (fixp->fx_subsy != NULL) 813 resolve_symbol_value (fixp->fx_subsy); 814 815 /* If this symbol is equated to an undefined or common symbol, 816 convert the fixup to being against that symbol. */ 817 while (symbol_equated_reloc_p (sym) 818 || S_IS_WEAKREFR (sym)) 819 { 820 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol; 821 if (sym == newsym) 822 break; 823 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; 824 fixp->fx_addsy = newsym; 825 sym = newsym; 826 } 827 828 if (symbol_mri_common_p (sym)) 829 { 830 fixp->fx_offset += S_GET_VALUE (sym); 831 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol; 832 continue; 833 } 834 835 /* If the symbol is undefined, common, weak, or global (ELF 836 shared libs), we can't replace it with the section symbol. */ 837 if (S_FORCE_RELOC (fixp->fx_addsy, 1)) 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 853 symsec = S_GET_SEGMENT (sym); 854 if (symsec == NULL) 855 abort (); 856 857 if (bfd_is_abs_section (symsec) 858 || symsec == reg_section) 859 { 860 /* The fixup_segment routine normally will not use this 861 symbol in a relocation. */ 862 continue; 863 } 864 865 /* Don't try to reduce relocs which refer to non-local symbols 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. */ 869 if (symsec != sec && ! S_IS_LOCAL (sym)) 870 { 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; 879 } 880 881 /* Never adjust a reloc against local symbol in a merge section 882 with non-zero addend. */ 883 if ((symsec->flags & SEC_MERGE) != 0 884 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL)) 885 continue; 886 887 /* Never adjust a reloc against TLS local symbol. */ 888 if ((symsec->flags & SEC_THREAD_LOCAL) != 0) 889 continue; 890 891 /* We refetch the segment when calling section_symbol, rather 892 than using symsec, because S_GET_VALUE may wind up changing 893 the section when it calls resolve_symbol_value. */ 894 fixp->fx_offset += S_GET_VALUE (sym); 895 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym)); 896#ifdef DEBUG5 897 fprintf (stderr, "\nadjusted fixup:\n"); 898 print_fixup (fixp); 899#endif 900 } 901 902 dump_section_relocs (abfd, sec, stderr); 903} 904 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. 911 Ones that we couldn't completely handle here will be output later 912 by emit_relocations. */ 913 914static void 915fixup_segment (fixS *fixP, segT this_segment) 916{ 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 927 are PC-relative and don't cross regions that could change size. */ 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); 944 } 945 return; 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 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 972 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 973 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 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 987 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 988 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment)) 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 995 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 996 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment)) 997 { 998 add_number -= S_GET_VALUE (fixP->fx_subsy); 999 fixP->fx_offset = (add_number + fixP->fx_dot_value 1000 + fixP->fx_dot_frag->fr_address); 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 } 1018 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment)) 1019 { 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)); 1032 } 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); 1037 } 1038 1039 if (fixP->fx_addsy) 1040 { 1041 if (add_symbol_segment == this_segment 1042 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 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 1056 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 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 { 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 1094 if (!fixP->fx_no_overflow && fixP->fx_size != 0) 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, 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), 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 1132 } 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. */ 1143} 1144 1145static void 1146fix_segment (bfd *abfd ATTRIBUTE_UNUSED, 1147 asection *sec, 1148 void *xxx ATTRIBUTE_UNUSED) 1149{ 1150 segment_info_type *seginfo = seg_info (sec); 1151 1152 fixup_segment (seginfo->fix_root, sec); 1153} 1154 1155static void 1156install_reloc (asection *sec, arelent *reloc, fragS *fragp, 1157 const char *file, unsigned int line) 1158{ 1159 char *err; 1160 bfd_reloc_status_type s; 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 1167 || (EMIT_SECTION_SYMBOLS 1168 && !bfd_is_abs_section (sym->section)))) 1169 as_bad_where (file, line, _("redefined symbol cannot be used on reloc")); 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 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; 1196 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 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 1212 as_bad_where (r->file, r->line, 1213 _("reloc not within (fixed part of) section")); 1214 return NULL; 1215} 1216 1217static void 1218write_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, 1219 void *xxx ATTRIBUTE_UNUSED) 1220{ 1221 segment_info_type *seginfo = seg_info (sec); 1222 unsigned int n; 1223 struct reloc_list *my_reloc_list, **rp, *r; 1224 arelent **relocs; 1225 fixS *fixp; 1226 fragS *last_frag; 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 1233 n = 0; 1234 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 1235 if (!fixp->fx_done) 1236 n++; 1237 1238#ifdef RELOC_EXPANSION_POSSIBLE 1239 n *= MAX_RELOC_EXPANSION; 1240#endif 1241 1242 /* Extract relocs for this section from reloc_list. */ 1243 rp = &reloc_list; 1244 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 1259 relocs = XCNEWVEC (arelent *, n); 1260 1261 n = 0; 1262 r = my_reloc_list; 1263 last_frag = NULL; 1264 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) 1265 { 1266 int fx_size, slack; 1267 valueT loc; 1268 arelent **reloc; 1269#ifndef RELOC_EXPANSION_POSSIBLE 1270 arelent *rel; 1271 1272 reloc = &rel; 1273#endif 1274 1275 if (fixp->fx_done) 1276 continue; 1277 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; 1283 if (slack >= 0 && loc > fixp->fx_frag->fr_fix) 1284 as_bad_where (fixp->fx_file, fixp->fx_line, 1285 _("internal error: fixup not contained within frag")); 1286 1287#ifndef RELOC_EXPANSION_POSSIBLE 1288 *reloc = tc_gen_reloc (sec, fixp); 1289#else 1290 reloc = tc_gen_reloc (sec, fixp); 1291#endif 1292 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++; 1313#endif 1314 } 1315 } 1316 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; 1327 } 1328 1329#ifdef DEBUG4 1330 { 1331 unsigned int k, j, nsyms; 1332 asymbol **sympp; 1333 sympp = bfd_get_outsymbols (stdoutput); 1334 nsyms = bfd_get_symcount (stdoutput); 1335 for (k = 0; k < n; k++) 1336 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0) 1337 { 1338 for (j = 0; j < nsyms; j++) 1339 if (sympp[j] == *relocs[k]->sym_ptr_ptr) 1340 break; 1341 if (j == nsyms) 1342 abort (); 1343 } 1344 } 1345#endif 1346 1347 if (n) 1348 { 1349 flagword flags = bfd_section_flags (sec); 1350 flags |= SEC_RELOC; 1351 bfd_set_section_flags (sec, flags); 1352 bfd_set_reloc (stdoutput, sec, relocs, n); 1353 } 1354 1355#ifdef SET_SECTION_RELOCS 1356 SET_SECTION_RELOCS (sec, relocs, n); 1357#endif 1358 1359#ifdef DEBUG3 1360 { 1361 unsigned int k; 1362 1363 fprintf (stderr, "relocs for sec %s\n", sec->name); 1364 for (k = 0; k < n; k++) 1365 { 1366 arelent *rel = relocs[k]; 1367 asymbol *s = *rel->sym_ptr_ptr; 1368 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n", 1369 k, rel, (unsigned long)rel->address, s->name, 1370 (unsigned long)rel->addend); 1371 } 1372 } 1373#endif 1374} 1375 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; 1437 flagword flags = bfd_section_flags (sec); 1438 unsigned int header_size, compression_header_size; 1439 1440 if (seginfo == NULL 1441 || sec->size < 32 1442 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC) 1443 return; 1444 1445 section_name = bfd_section_name (sec); 1446 if (strncmp (section_name, ".debug_", 7) != 0) 1447 return; 1448 1449 strm = compress_init (); 1450 if (strm == NULL) 1451 return; 1452 1453 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB) 1454 { 1455 compression_header_size 1456 = bfd_get_compression_header_size (stdoutput, NULL); 1457 header_size = compression_header_size; 1458 } 1459 else 1460 { 1461 compression_header_size = 0; 1462 header_size = 12; 1463 } 1464 1465 /* Create a new frag to contain the compression header. */ 1466 first_newf = frag_alloc (ob); 1467 if (obstack_room (ob) < header_size) 1468 first_newf = frag_alloc (ob); 1469 if (obstack_room (ob) < header_size) 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); 1474 last_newf = first_newf; 1475 obstack_blank_fast (ob, header_size); 1476 last_newf->fr_type = rs_fill; 1477 last_newf->fr_fix = header_size; 1478 header = last_newf->fr_literal; 1479 compressed_size = header_size; 1480 1481 /* Stream the frags through the compression engine, adding new frags 1482 as necessary to accommodate the compressed output. */ 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 1558 /* PR binutils/18087: If compression didn't make the section smaller, 1559 just keep it uncompressed. */ 1560 if (compressed_size >= uncompressed_size) 1561 return; 1562 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. */ 1568 bfd_update_compression_header (abfd, (bfd_byte *) header, sec); 1569 x = bfd_set_section_size (sec, compressed_size); 1570 gas_assert (x); 1571 if (!compression_header_size) 1572 { 1573 compressed_name = concat (".z", section_name + 1, (char *) NULL); 1574 bfd_rename_section (sec, compressed_name); 1575 } 1576} 1577 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{ 1588 as_bad (_("unimplemented .nops directive")); 1589} 1590#endif 1591 1592static void 1593write_contents (bfd *abfd ATTRIBUTE_UNUSED, 1594 asection *sec, 1595 void *xxx ATTRIBUTE_UNUSED) 1596{ 1597 segment_info_type *seginfo = seg_info (sec); 1598 addressT offset = 0; 1599 fragS *f; 1600 1601 /* Write out the frags. */ 1602 if (seginfo == NULL 1603 || !(bfd_section_flags (sec) & SEC_HAS_CONTENTS)) 1604 return; 1605 1606 for (f = seginfo->frchainP->frch_root; 1607 f; 1608 f = f->fr_next) 1609 { 1610 int x; 1611 addressT fill_size; 1612 char *fill_literal; 1613 offsetT count; 1614 1615 gas_assert (f->fr_type == rs_fill || f->fr_type == rs_fill_nop); 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); 1621 if (!x) 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 bfd_section_name (sec), bfd_get_filename (stdoutput), 1629 bfd_errmsg (bfd_get_error ())); 1630 offset += f->fr_fix; 1631 } 1632 1633 fill_size = f->fr_var; 1634 count = f->fr_offset; 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), 1653 (long) count, 1654 bfd_section_name (sec), 1655 bfd_get_filename (stdoutput), 1656 bfd_errmsg (bfd_get_error ())); 1657 offset += count; 1658 free (buf); 1659 } 1660 continue; 1661 } 1662 1663 gas_assert (count >= 0); 1664 if (fill_size && count) 1665 { 1666 char buf[256]; 1667 if (fill_size > sizeof (buf)) 1668 { 1669 /* Do it the old way. Can this ever happen? */ 1670 while (count--) 1671 { 1672 x = bfd_set_section_contents (stdoutput, sec, 1673 fill_literal, 1674 (file_ptr) offset, 1675 (bfd_size_type) fill_size); 1676 if (!x) 1677 as_fatal (ngettext ("can't fill %ld byte " 1678 "in section %s of %s: '%s'", 1679 "can't fill %ld bytes " 1680 "in section %s of %s: '%s'", 1681 (long) fill_size), 1682 (long) fill_size, 1683 bfd_section_name (sec), 1684 bfd_get_filename (stdoutput), 1685 bfd_errmsg (bfd_get_error ())); 1686 offset += fill_size; 1687 } 1688 } 1689 else 1690 { 1691 /* Build a buffer full of fill objects and output it as 1692 often as necessary. This saves on the overhead of 1693 potentially lots of bfd_set_section_contents calls. */ 1694 int n_per_buf, i; 1695 if (fill_size == 1) 1696 { 1697 n_per_buf = sizeof (buf); 1698 memset (buf, *fill_literal, n_per_buf); 1699 } 1700 else 1701 { 1702 char *bufp; 1703 n_per_buf = sizeof (buf) / fill_size; 1704 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size) 1705 memcpy (bufp, fill_literal, fill_size); 1706 } 1707 for (; count > 0; count -= n_per_buf) 1708 { 1709 n_per_buf = n_per_buf > count ? count : n_per_buf; 1710 x = bfd_set_section_contents 1711 (stdoutput, sec, buf, (file_ptr) offset, 1712 (bfd_size_type) n_per_buf * fill_size); 1713 if (!x) 1714 as_fatal (ngettext ("can't fill %ld byte " 1715 "in section %s of %s: '%s'", 1716 "can't fill %ld bytes " 1717 "in section %s of %s: '%s'", 1718 (long) (n_per_buf * fill_size)), 1719 (long) (n_per_buf * fill_size), 1720 bfd_section_name (sec), 1721 bfd_get_filename (stdoutput), 1722 bfd_errmsg (bfd_get_error ())); 1723 offset += n_per_buf * fill_size; 1724 } 1725 } 1726 } 1727 } 1728} 1729 1730static void 1731merge_data_into_text (void) 1732{ 1733 seg_info (text_section)->frchainP->frch_last->fr_next = 1734 seg_info (data_section)->frchainP->frch_root; 1735 seg_info (text_section)->frchainP->frch_last = 1736 seg_info (data_section)->frchainP->frch_last; 1737 seg_info (data_section)->frchainP = 0; 1738} 1739 1740static void 1741set_symtab (void) 1742{ 1743 int nsyms; 1744 asymbol **asympp; 1745 symbolS *symp; 1746 bfd_boolean result; 1747 1748 /* Count symbols. We can't rely on a count made by the loop in 1749 write_object_file, because *_frob_file may add a new symbol or 1750 two. */ 1751 nsyms = 0; 1752 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1753 nsyms++; 1754 1755 if (nsyms) 1756 { 1757 int i; 1758 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *); 1759 1760 asympp = (asymbol **) bfd_alloc (stdoutput, amt); 1761 symp = symbol_rootP; 1762 for (i = 0; i < nsyms; i++, symp = symbol_next (symp)) 1763 { 1764 asympp[i] = symbol_get_bfdsym (symp); 1765 if (asympp[i]->flags != BSF_SECTION_SYM 1766 || !(bfd_is_const_section (asympp[i]->section) 1767 && asympp[i]->section->symbol == asympp[i])) 1768 asympp[i]->flags |= BSF_KEEP; 1769 symbol_mark_written (symp); 1770 } 1771 } 1772 else 1773 asympp = 0; 1774 result = bfd_set_symtab (stdoutput, asympp, nsyms); 1775 gas_assert (result); 1776 symbol_table_frozen = 1; 1777} 1778 1779/* Finish the subsegments. After every sub-segment, we fake an 1780 ".align ...". This conforms to BSD4.2 brain-damage. We then fake 1781 ".fill 0" because that is the kind of frag that requires least 1782 thought. ".align" frags like to have a following frag since that 1783 makes calculating their intended length trivial. */ 1784 1785#ifndef SUB_SEGMENT_ALIGN 1786#ifdef HANDLE_ALIGN 1787/* The last subsegment gets an alignment corresponding to the alignment 1788 of the section. This allows proper nop-filling at the end of 1789 code-bearing sections. */ 1790#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \ 1791 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \ 1792 && !do_not_pad_sections_to_alignment \ 1793 ? get_recorded_alignment (SEG) \ 1794 : 0) 1795#else 1796#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 1797#endif 1798#endif 1799 1800static void 1801subsegs_finish_section (asection *s) 1802{ 1803 struct frchain *frchainP; 1804 segment_info_type *seginfo = seg_info (s); 1805 if (!seginfo) 1806 return; 1807 1808 for (frchainP = seginfo->frchainP; 1809 frchainP != NULL; 1810 frchainP = frchainP->frch_next) 1811 { 1812 int alignment; 1813 1814 subseg_set (s, frchainP->frch_subseg); 1815 1816 /* This now gets called even if we had errors. In that case, 1817 any alignment is meaningless, and, moreover, will look weird 1818 if we are generating a listing. */ 1819 if (had_errors ()) 1820 do_not_pad_sections_to_alignment = 1; 1821 1822 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP); 1823 if ((bfd_section_flags (now_seg) & SEC_MERGE) 1824 && now_seg->entsize) 1825 { 1826 unsigned int entsize = now_seg->entsize; 1827 int entalign = 0; 1828 1829 while ((entsize & 1) == 0) 1830 { 1831 ++entalign; 1832 entsize >>= 1; 1833 } 1834 1835 if (entalign > alignment) 1836 alignment = entalign; 1837 } 1838 1839 if (subseg_text_p (now_seg)) 1840 frag_align_code (alignment, 0); 1841 else 1842 frag_align (alignment, 0, 0); 1843 1844 /* frag_align will have left a new frag. 1845 Use this last frag for an empty ".fill". 1846 1847 For this segment ... 1848 Create a last frag. Do not leave a "being filled in frag". */ 1849 frag_wane (frag_now); 1850 frag_now->fr_fix = 0; 1851 know (frag_now->fr_next == NULL); 1852 } 1853} 1854 1855static void 1856subsegs_finish (void) 1857{ 1858 asection *s; 1859 1860 for (s = stdoutput->sections; s; s = s->next) 1861 subsegs_finish_section (s); 1862} 1863 1864#ifdef OBJ_ELF 1865static void 1866create_obj_attrs_section (void) 1867{ 1868 segT s; 1869 char *p; 1870 offsetT size; 1871 const char *name; 1872 1873 size = bfd_elf_obj_attr_size (stdoutput); 1874 if (size == 0) 1875 return; 1876 1877 name = get_elf_backend_data (stdoutput)->obj_attrs_section; 1878 if (!name) 1879 name = ".gnu.attributes"; 1880 s = subseg_new (name, 0); 1881 elf_section_type (s) 1882 = get_elf_backend_data (stdoutput)->obj_attrs_section_type; 1883 bfd_set_section_flags (s, SEC_READONLY | SEC_DATA); 1884 frag_now_fix (); 1885 p = frag_more (size); 1886 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size); 1887 1888 subsegs_finish_section (s); 1889 relax_segment (seg_info (s)->frchainP->frch_root, s, 0); 1890 size_seg (stdoutput, s, NULL); 1891} 1892 1893/* Create a relocation against an entry in a GNU Build attribute section. */ 1894 1895static void 1896create_note_reloc (segT sec, 1897 symbolS * sym, 1898 bfd_size_type note_offset, 1899 bfd_size_type desc2_offset, 1900 offsetT desc2_size, 1901 int reloc_type, 1902 bfd_vma addend, 1903 char * note) 1904{ 1905 struct reloc_list * reloc; 1906 1907 reloc = XNEW (struct reloc_list); 1908 1909 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */ 1910 reloc->u.b.sec = sec; 1911 reloc->u.b.s = symbol_get_bfdsym (sym); 1912 reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s; 1913 reloc->u.b.r.address = note_offset + desc2_offset; 1914 reloc->u.b.r.addend = addend; 1915 reloc->u.b.r.howto = bfd_reloc_type_lookup (stdoutput, reloc_type); 1916 1917 if (reloc->u.b.r.howto == NULL) 1918 { 1919 as_bad (_("unable to create reloc for build note")); 1920 return; 1921 } 1922 1923 reloc->file = N_("<gnu build note>"); 1924 reloc->line = 0; 1925 1926 reloc->next = reloc_list; 1927 reloc_list = reloc; 1928 1929 /* For REL relocs, store the addend in the section. */ 1930 if (! sec->use_rela_p 1931 /* The SH target is a special case that uses RELA relocs 1932 but still stores the addend in the word being relocated. */ 1933 || strstr (bfd_get_target (stdoutput), "-sh") != NULL) 1934 { 1935 offsetT i; 1936 1937 /* Zero out the addend, since it is now stored in the note. */ 1938 reloc->u.b.r.addend = 0; 1939 1940 if (target_big_endian) 1941 { 1942 for (i = desc2_size; addend != 0 && i > 0; addend >>= 8, i--) 1943 note[desc2_offset + i - 1] = (addend & 0xff); 1944 } 1945 else 1946 { 1947 for (i = 0; addend != 0 && i < desc2_size; addend >>= 8, i++) 1948 note[desc2_offset + i] = (addend & 0xff); 1949 } 1950 } 1951} 1952 1953static void 1954maybe_generate_build_notes (void) 1955{ 1956 segT sec; 1957 char * note; 1958 offsetT note_size; 1959 offsetT total_size; 1960 offsetT desc_size; 1961 offsetT desc2_offset; 1962 int desc_reloc; 1963 symbolS * sym; 1964 asymbol * bsym; 1965 1966 if (! flag_generate_build_notes 1967 || bfd_get_section_by_name (stdoutput, 1968 GNU_BUILD_ATTRS_SECTION_NAME) != NULL) 1969 return; 1970 1971 /* Create a GNU Build Attribute section. */ 1972 sec = subseg_new (GNU_BUILD_ATTRS_SECTION_NAME, FALSE); 1973 elf_section_type (sec) = SHT_NOTE; 1974 bfd_set_section_flags (sec, (SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA 1975 | SEC_OCTETS)); 1976 bfd_set_section_alignment (sec, 2); 1977 1978 /* Work out the size of the notes that we will create, 1979 and the relocation we should use. */ 1980 if (bfd_arch_bits_per_address (stdoutput) <= 32) 1981 { 1982 note_size = 28; 1983 desc_size = 8; /* Two 4-byte offsets. */ 1984 desc2_offset = 24; 1985 1986 /* FIXME: The BFD backend for the CRX target does not support the 1987 BFD_RELOC_32, even though it really should. Likewise for the 1988 CR16 target. So we have special case code here... */ 1989 if (strstr (bfd_get_target (stdoutput), "-crx") != NULL) 1990 desc_reloc = BFD_RELOC_CRX_NUM32; 1991 else if (strstr (bfd_get_target (stdoutput), "-cr16") != NULL) 1992 desc_reloc = BFD_RELOC_CR16_NUM32; 1993 else 1994 desc_reloc = BFD_RELOC_32; 1995 } 1996 else 1997 { 1998 note_size = 36; 1999 desc_size = 16; /* Two 8-byte offsets. */ 2000 desc2_offset = 28; 2001 /* FIXME: The BFD backend for the IA64 target does not support the 2002 BFD_RELOC_64, even though it really should. The HPPA backend 2003 has a similar issue, although it does not support BFD_RELOCs at 2004 all! So we have special case code to handle these targets. */ 2005 if (strstr (bfd_get_target (stdoutput), "-ia64") != NULL) 2006 desc_reloc = target_big_endian ? BFD_RELOC_IA64_DIR32MSB : BFD_RELOC_IA64_DIR32LSB; 2007 else if (strstr (bfd_get_target (stdoutput), "-hppa") != NULL) 2008 desc_reloc = 80; /* R_PARISC_DIR64. */ 2009 else 2010 desc_reloc = BFD_RELOC_64; 2011 } 2012 2013 /* We have to create a note for *each* code section. 2014 Linker garbage collection might discard some. */ 2015 total_size = 0; 2016 note = NULL; 2017 2018 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym)) 2019 if ((bsym = symbol_get_bfdsym (sym)) != NULL 2020 && bsym->flags & BSF_SECTION_SYM 2021 && bsym->section != NULL 2022 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */ 2023 && (bsym->section->flags & (SEC_CODE | SEC_LINK_ONCE)) == SEC_CODE 2024 /* Not all linkonce sections are flagged... */ 2025 && strncmp (S_GET_NAME (sym), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0) 2026 { 2027 /* Create a version note. */ 2028 frag_now_fix (); 2029 note = frag_more (note_size); 2030 memset (note, 0, note_size); 2031 2032 if (target_big_endian) 2033 { 2034 note[3] = 8; /* strlen (name) + 1. */ 2035 note[7] = desc_size; /* Two N-byte offsets. */ 2036 note[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8; 2037 note[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff; 2038 } 2039 else 2040 { 2041 note[0] = 8; /* strlen (name) + 1. */ 2042 note[4] = desc_size; /* Two N-byte offsets. */ 2043 note[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff; 2044 note[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8; 2045 } 2046 2047 /* The a1 version number indicates that this note was 2048 generated by the assembler and not the gcc annobin plugin. */ 2049 memcpy (note + 12, "GA$3a1", 8); 2050 2051 /* Create a relocation to install the start address of the note... */ 2052 create_note_reloc (sec, sym, total_size, 20, desc_size / 2, desc_reloc, 0, note); 2053 2054 /* ...and another one to install the end address. */ 2055 create_note_reloc (sec, sym, total_size, desc2_offset, 2056 desc_size / 2, 2057 desc_reloc, 2058 bfd_section_size (bsym->section), 2059 note); 2060 2061 total_size += note_size; 2062 /* FIXME: Maybe add a note recording the assembler command line and version ? */ 2063 } 2064 2065 /* Install the note(s) into the section. */ 2066 if (total_size) 2067 bfd_set_section_contents (stdoutput, sec, (bfd_byte *) note, 0, total_size); 2068 subsegs_finish_section (sec); 2069 relax_segment (seg_info (sec)->frchainP->frch_root, sec, 0); 2070 size_seg (stdoutput, sec, NULL); 2071} 2072#endif /* OBJ_ELF */ 2073 2074/* Write the object file. */ 2075 2076void 2077write_object_file (void) 2078{ 2079 struct relax_seg_info rsi; 2080#ifndef WORKING_DOT_WORD 2081 fragS *fragP; /* Track along all frags. */ 2082#endif 2083 2084 subsegs_finish (); 2085 2086#ifdef md_pre_output_hook 2087 md_pre_output_hook; 2088#endif 2089 2090#ifdef md_pre_relax_hook 2091 md_pre_relax_hook; 2092#endif 2093 2094 /* From now on, we don't care about sub-segments. Build one frag chain 2095 for each segment. Linked through fr_next. */ 2096 2097 /* Remove the sections created by gas for its own purposes. */ 2098 { 2099 int i; 2100 2101 bfd_section_list_remove (stdoutput, reg_section); 2102 bfd_section_list_remove (stdoutput, expr_section); 2103 stdoutput->section_count -= 2; 2104 i = 0; 2105 bfd_map_over_sections (stdoutput, renumber_sections, &i); 2106 } 2107 2108 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0); 2109 2110 /* We have two segments. If user gave -R flag, then we must put the 2111 data frags into the text segment. Do this before relaxing so 2112 we know to take advantage of -R and make shorter addresses. */ 2113 if (flag_readonly_data_in_text) 2114 { 2115 merge_data_into_text (); 2116 } 2117 2118 rsi.pass = 0; 2119 while (1) 2120 { 2121#ifndef WORKING_DOT_WORD 2122 /* We need to reset the markers in the broken word list and 2123 associated frags between calls to relax_segment (via 2124 relax_seg). Since the broken word list is global, we do it 2125 once per round, rather than locally in relax_segment for each 2126 segment. */ 2127 struct broken_word *brokp; 2128 2129 for (brokp = broken_words; 2130 brokp != (struct broken_word *) NULL; 2131 brokp = brokp->next_broken_word) 2132 { 2133 brokp->added = 0; 2134 2135 if (brokp->dispfrag != (fragS *) NULL 2136 && brokp->dispfrag->fr_type == rs_broken_word) 2137 brokp->dispfrag->fr_subtype = 0; 2138 } 2139#endif 2140 2141 rsi.changed = 0; 2142 bfd_map_over_sections (stdoutput, relax_seg, &rsi); 2143 rsi.pass++; 2144 if (!rsi.changed) 2145 break; 2146 } 2147 2148 /* Note - Most ports will use the default value of 2149 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force 2150 local symbols to be resolved, removing their frag information. 2151 Some ports however, will not have finished relaxing all of 2152 their frags and will still need the local symbol frag 2153 information. These ports can set 2154 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */ 2155 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG; 2156 2157 bfd_map_over_sections (stdoutput, size_seg, (char *) 0); 2158 2159 /* Relaxation has completed. Freeze all syms. */ 2160 finalize_syms = 1; 2161 2162 dwarf2dbg_final_check (); 2163 2164#ifdef md_post_relax_hook 2165 md_post_relax_hook; 2166#endif 2167 2168#ifdef OBJ_ELF 2169 if (IS_ELF) 2170 create_obj_attrs_section (); 2171#endif 2172 2173#ifndef WORKING_DOT_WORD 2174 { 2175 struct broken_word *lie; 2176 struct broken_word **prevP; 2177 2178 prevP = &broken_words; 2179 for (lie = broken_words; lie; lie = lie->next_broken_word) 2180 if (!lie->added) 2181 { 2182 expressionS exp; 2183 2184 subseg_change (lie->seg, lie->subseg); 2185 exp.X_op = O_subtract; 2186 exp.X_add_symbol = lie->add; 2187 exp.X_op_symbol = lie->sub; 2188 exp.X_add_number = lie->addnum; 2189#ifdef TC_CONS_FIX_NEW 2190 TC_CONS_FIX_NEW (lie->frag, 2191 lie->word_goes_here - lie->frag->fr_literal, 2192 2, &exp, TC_PARSE_CONS_RETURN_NONE); 2193#else 2194 fix_new_exp (lie->frag, 2195 lie->word_goes_here - lie->frag->fr_literal, 2196 2, &exp, 0, BFD_RELOC_16); 2197#endif 2198 *prevP = lie->next_broken_word; 2199 } 2200 else 2201 prevP = &(lie->next_broken_word); 2202 2203 for (lie = broken_words; lie;) 2204 { 2205 struct broken_word *untruth; 2206 char *table_ptr; 2207 addressT table_addr; 2208 addressT from_addr, to_addr; 2209 int n, m; 2210 2211 subseg_change (lie->seg, lie->subseg); 2212 fragP = lie->dispfrag; 2213 2214 /* Find out how many broken_words go here. */ 2215 n = 0; 2216 for (untruth = lie; 2217 untruth && untruth->dispfrag == fragP; 2218 untruth = untruth->next_broken_word) 2219 if (untruth->added == 1) 2220 n++; 2221 2222 table_ptr = lie->dispfrag->fr_opcode; 2223 table_addr = (lie->dispfrag->fr_address 2224 + (table_ptr - lie->dispfrag->fr_literal)); 2225 /* Create the jump around the long jumps. This is a short 2226 jump from table_ptr+0 to table_ptr+n*long_jump_size. */ 2227 from_addr = table_addr; 2228 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size; 2229 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2230 lie->add); 2231 table_ptr += md_short_jump_size; 2232 table_addr += md_short_jump_size; 2233 2234 for (m = 0; 2235 lie && lie->dispfrag == fragP; 2236 m++, lie = lie->next_broken_word) 2237 { 2238 if (lie->added == 2) 2239 continue; 2240 /* Patch the jump table. */ 2241 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2242 untruth && untruth->dispfrag == fragP; 2243 untruth = untruth->next_broken_word) 2244 { 2245 if (untruth->use_jump == lie) 2246 { 2247 /* This is the offset from ??? to table_ptr+0. 2248 The target is the same for all users of this 2249 md_long_jump, but the "sub" bases (and hence the 2250 offsets) may be different. */ 2251 addressT to_word = table_addr - S_GET_VALUE (untruth->sub); 2252#ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD 2253 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth); 2254#endif 2255 md_number_to_chars (untruth->word_goes_here, to_word, 2); 2256 } 2257 } 2258 2259 /* Install the long jump. */ 2260 /* This is a long jump from table_ptr+0 to the final target. */ 2261 from_addr = table_addr; 2262 to_addr = S_GET_VALUE (lie->add) + lie->addnum; 2263 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2264 lie->add); 2265 table_ptr += md_long_jump_size; 2266 table_addr += md_long_jump_size; 2267 } 2268 } 2269 } 2270#endif /* not WORKING_DOT_WORD */ 2271 2272 /* Resolve symbol values. This needs to be done before processing 2273 the relocations. */ 2274 if (symbol_rootP) 2275 { 2276 symbolS *symp; 2277 2278 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2279 resolve_symbol_value (symp); 2280 } 2281 resolve_local_symbol_values (); 2282 resolve_reloc_expr_symbols (); 2283 2284#ifdef OBJ_ELF 2285 if (IS_ELF) 2286 maybe_generate_build_notes (); 2287#endif 2288 2289 PROGRESS (1); 2290 2291#ifdef tc_frob_file_before_adjust 2292 tc_frob_file_before_adjust (); 2293#endif 2294#ifdef obj_frob_file_before_adjust 2295 obj_frob_file_before_adjust (); 2296#endif 2297 2298 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0); 2299 2300#ifdef tc_frob_file_before_fix 2301 tc_frob_file_before_fix (); 2302#endif 2303#ifdef obj_frob_file_before_fix 2304 obj_frob_file_before_fix (); 2305#endif 2306 2307 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0); 2308 2309 /* Set up symbol table, and write it out. */ 2310 if (symbol_rootP) 2311 { 2312 symbolS *symp; 2313 bfd_boolean skip_next_symbol = FALSE; 2314 2315 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2316 { 2317 int punt = 0; 2318 const char *name; 2319 2320 if (skip_next_symbol) 2321 { 2322 /* Don't do anything besides moving the value of the 2323 symbol from the GAS value-field to the BFD value-field. */ 2324 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2325 skip_next_symbol = FALSE; 2326 continue; 2327 } 2328 2329 if (symbol_mri_common_p (symp)) 2330 { 2331 if (S_IS_EXTERNAL (symp)) 2332 as_bad (_("%s: global symbols not supported in common sections"), 2333 S_GET_NAME (symp)); 2334 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2335 continue; 2336 } 2337 2338 name = S_GET_NAME (symp); 2339 if (name) 2340 { 2341 const char *name2 = 2342 decode_local_label_name ((char *) S_GET_NAME (symp)); 2343 /* They only differ if `name' is a fb or dollar local 2344 label name. */ 2345 if (name2 != name && ! S_IS_DEFINED (symp)) 2346 as_bad (_("local label `%s' is not defined"), name2); 2347 } 2348 2349 /* Do it again, because adjust_reloc_syms might introduce 2350 more symbols. They'll probably only be section symbols, 2351 but they'll still need to have the values computed. */ 2352 resolve_symbol_value (symp); 2353 2354 /* Skip symbols which were equated to undefined or common 2355 symbols. */ 2356 if (symbol_equated_reloc_p (symp) 2357 || S_IS_WEAKREFR (symp)) 2358 { 2359 const char *sname = S_GET_NAME (symp); 2360 2361 if (S_IS_COMMON (symp) 2362 && !TC_FAKE_LABEL (sname) 2363 && !S_IS_WEAKREFR (symp)) 2364 { 2365 expressionS *e = symbol_get_value_expression (symp); 2366 2367 as_bad (_("`%s' can't be equated to common symbol `%s'"), 2368 sname, S_GET_NAME (e->X_add_symbol)); 2369 } 2370 if (S_GET_SEGMENT (symp) == reg_section) 2371 { 2372 /* Report error only if we know the symbol name. */ 2373 if (S_GET_NAME (symp) != reg_section->name) 2374 as_bad (_("can't make global register symbol `%s'"), 2375 sname); 2376 } 2377 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2378 continue; 2379 } 2380 2381#ifdef obj_frob_symbol 2382 obj_frob_symbol (symp, punt); 2383#endif 2384#ifdef tc_frob_symbol 2385 if (! punt || symbol_used_in_reloc_p (symp)) 2386 tc_frob_symbol (symp, punt); 2387#endif 2388 2389 /* If we don't want to keep this symbol, splice it out of 2390 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never 2391 want section symbols. Otherwise, we skip local symbols 2392 and symbols that the frob_symbol macros told us to punt, 2393 but we keep such symbols if they are used in relocs. */ 2394 if (symp == abs_section_sym 2395 || (! EMIT_SECTION_SYMBOLS 2396 && symbol_section_p (symp)) 2397 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always 2398 opposites. Sometimes the former checks flags and the 2399 latter examines the name... */ 2400 || (!S_IS_EXTERNAL (symp) 2401 && (punt || S_IS_LOCAL (symp) || 2402 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp))) 2403 && ! symbol_used_in_reloc_p (symp))) 2404 { 2405 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2406 2407 /* After symbol_remove, symbol_next(symp) still returns 2408 the one that came after it in the chain. So we don't 2409 need to do any extra cleanup work here. */ 2410 continue; 2411 } 2412 2413 /* Make sure we really got a value for the symbol. */ 2414 if (! symbol_resolved_p (symp)) 2415 { 2416 as_bad (_("can't resolve value for symbol `%s'"), 2417 S_GET_NAME (symp)); 2418 symbol_mark_resolved (symp); 2419 } 2420 2421 /* Set the value into the BFD symbol. Up til now the value 2422 has only been kept in the gas symbolS struct. */ 2423 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2424 2425 /* A warning construct is a warning symbol followed by the 2426 symbol warned about. Don't let anything object-format or 2427 target-specific muck with it; it's ready for output. */ 2428 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING) 2429 skip_next_symbol = TRUE; 2430 } 2431 } 2432 2433 PROGRESS (1); 2434 2435 /* Now do any format-specific adjustments to the symbol table, such 2436 as adding file symbols. */ 2437#ifdef tc_adjust_symtab 2438 tc_adjust_symtab (); 2439#endif 2440#ifdef obj_adjust_symtab 2441 obj_adjust_symtab (); 2442#endif 2443 2444 /* Stop if there is an error. */ 2445 if (!flag_always_generate_output && had_errors ()) 2446 return; 2447 2448 /* Now that all the sizes are known, and contents correct, we can 2449 start writing to the file. */ 2450 set_symtab (); 2451 2452 /* If *_frob_file changes the symbol value at this point, it is 2453 responsible for moving the changed value into symp->bsym->value 2454 as well. Hopefully all symbol value changing can be done in 2455 *_frob_symbol. */ 2456#ifdef tc_frob_file 2457 tc_frob_file (); 2458#endif 2459#ifdef obj_frob_file 2460 obj_frob_file (); 2461#endif 2462#ifdef obj_coff_generate_pdata 2463 obj_coff_generate_pdata (); 2464#endif 2465 2466 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0); 2467 2468#ifdef tc_frob_file_after_relocs 2469 tc_frob_file_after_relocs (); 2470#endif 2471#ifdef obj_frob_file_after_relocs 2472 obj_frob_file_after_relocs (); 2473#endif 2474 2475#if defined OBJ_ELF || defined OBJ_MAYBE_ELF 2476 if (IS_ELF && flag_use_elf_stt_common) 2477 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON; 2478#endif 2479 2480 /* Once all relocations have been written, we can compress the 2481 contents of the debug sections. This needs to be done before 2482 we start writing any sections, because it will affect the file 2483 layout, which is fixed once we start writing contents. */ 2484 if (flag_compress_debug) 2485 { 2486 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB) 2487 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI; 2488 else 2489 stdoutput->flags |= BFD_COMPRESS; 2490 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0); 2491 } 2492 2493 bfd_map_over_sections (stdoutput, write_contents, (char *) 0); 2494} 2495 2496#ifdef TC_GENERIC_RELAX_TABLE 2497#ifndef md_generic_table_relax_frag 2498#define md_generic_table_relax_frag relax_frag 2499#endif 2500 2501/* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ 2502 2503long 2504relax_frag (segT segment, fragS *fragP, long stretch) 2505{ 2506 const relax_typeS *this_type; 2507 const relax_typeS *start_type; 2508 relax_substateT next_state; 2509 relax_substateT this_state; 2510 offsetT growth; 2511 offsetT aim; 2512 addressT target; 2513 addressT address; 2514 symbolS *symbolP; 2515 const relax_typeS *table; 2516 2517 target = fragP->fr_offset; 2518 address = fragP->fr_address + fragP->fr_fix; 2519 table = TC_GENERIC_RELAX_TABLE; 2520 this_state = fragP->fr_subtype; 2521 start_type = this_type = table + this_state; 2522 symbolP = fragP->fr_symbol; 2523 2524 if (symbolP) 2525 { 2526 fragS *sym_frag; 2527 2528 sym_frag = symbol_get_frag (symbolP); 2529 2530#ifndef DIFF_EXPR_OK 2531 know (sym_frag != NULL); 2532#endif 2533 know (S_GET_SEGMENT (symbolP) != absolute_section 2534 || sym_frag == &zero_address_frag); 2535 target += S_GET_VALUE (symbolP); 2536 2537 /* If SYM_FRAG has yet to be reached on this pass, assume it 2538 will move by STRETCH just as we did, unless there is an 2539 alignment frag between here and SYM_FRAG. An alignment may 2540 well absorb any STRETCH, and we don't want to choose a larger 2541 branch insn by overestimating the needed reach of this 2542 branch. It isn't critical to calculate TARGET exactly; We 2543 know we'll be doing another pass if STRETCH is non-zero. */ 2544 2545 if (stretch != 0 2546 && sym_frag->relax_marker != fragP->relax_marker 2547 && S_GET_SEGMENT (symbolP) == segment) 2548 { 2549 if (stretch < 0 2550 || sym_frag->region == fragP->region) 2551 target += stretch; 2552 /* If we get here we know we have a forward branch. This 2553 relax pass may have stretched previous instructions so 2554 far that omitting STRETCH would make the branch 2555 negative. Don't allow this in case the negative reach is 2556 large enough to require a larger branch instruction. */ 2557 else if (target < address) 2558 return 0; 2559 } 2560 } 2561 2562 aim = target - address; 2563#ifdef TC_PCREL_ADJUST 2564 /* Currently only the ns32k and arc needs this. */ 2565 aim += TC_PCREL_ADJUST (fragP); 2566#endif 2567 2568#ifdef md_prepare_relax_scan 2569 /* Formerly called M68K_AIM_KLUDGE. */ 2570 md_prepare_relax_scan (fragP, address, aim, this_state, this_type); 2571#endif 2572 2573 if (aim < 0) 2574 { 2575 /* Look backwards. */ 2576 for (next_state = this_type->rlx_more; next_state;) 2577 if (aim >= this_type->rlx_backward) 2578 next_state = 0; 2579 else 2580 { 2581 /* Grow to next state. */ 2582 this_state = next_state; 2583 this_type = table + this_state; 2584 next_state = this_type->rlx_more; 2585 } 2586 } 2587 else 2588 { 2589 /* Look forwards. */ 2590 for (next_state = this_type->rlx_more; next_state;) 2591 if (aim <= this_type->rlx_forward) 2592 next_state = 0; 2593 else 2594 { 2595 /* Grow to next state. */ 2596 this_state = next_state; 2597 this_type = table + this_state; 2598 next_state = this_type->rlx_more; 2599 } 2600 } 2601 2602 growth = this_type->rlx_length - start_type->rlx_length; 2603 if (growth != 0) 2604 fragP->fr_subtype = this_state; 2605 return growth; 2606} 2607 2608#endif /* defined (TC_GENERIC_RELAX_TABLE) */ 2609 2610/* Relax_align. Advance location counter to next address that has 'alignment' 2611 lowest order bits all 0s, return size of adjustment made. */ 2612static relax_addressT 2613relax_align (relax_addressT address, /* Address now. */ 2614 int alignment /* Alignment (binary). */) 2615{ 2616 relax_addressT mask; 2617 relax_addressT new_address; 2618 2619 mask = ~((relax_addressT) ~0 << alignment); 2620 new_address = (address + mask) & (~mask); 2621#ifdef LINKER_RELAXING_SHRINKS_ONLY 2622 if (linkrelax) 2623 /* We must provide lots of padding, so the linker can discard it 2624 when needed. The linker will not add extra space, ever. */ 2625 new_address += (1 << alignment); 2626#endif 2627 return (new_address - address); 2628} 2629 2630/* Now we have a segment, not a crowd of sub-segments, we can make 2631 fr_address values. 2632 2633 Relax the frags. 2634 2635 After this, all frags in this segment have addresses that are correct 2636 within the segment. Since segments live in different file addresses, 2637 these frag addresses may not be the same as final object-file 2638 addresses. */ 2639 2640int 2641relax_segment (struct frag *segment_frag_root, segT segment, int pass) 2642{ 2643 unsigned long frag_count; 2644 struct frag *fragP; 2645 relax_addressT address; 2646 int region; 2647 int ret; 2648 2649 /* In case md_estimate_size_before_relax() wants to make fixSs. */ 2650 subseg_change (segment, 0); 2651 2652 /* For each frag in segment: count and store (a 1st guess of) 2653 fr_address. */ 2654 address = 0; 2655 region = 0; 2656 for (frag_count = 0, fragP = segment_frag_root; 2657 fragP; 2658 fragP = fragP->fr_next, frag_count ++) 2659 { 2660 fragP->region = region; 2661 fragP->relax_marker = 0; 2662 fragP->fr_address = address; 2663 address += fragP->fr_fix; 2664 2665 switch (fragP->fr_type) 2666 { 2667 case rs_fill: 2668 address += fragP->fr_offset * fragP->fr_var; 2669 break; 2670 2671 case rs_align: 2672 case rs_align_code: 2673 case rs_align_test: 2674 { 2675 addressT offset = relax_align (address, (int) fragP->fr_offset); 2676 2677 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) 2678 offset = 0; 2679 2680 if (offset % fragP->fr_var != 0) 2681 { 2682 as_bad_where (fragP->fr_file, fragP->fr_line, 2683 ngettext ("alignment padding (%lu byte) " 2684 "not a multiple of %ld", 2685 "alignment padding (%lu bytes) " 2686 "not a multiple of %ld", 2687 (unsigned long) offset), 2688 (unsigned long) offset, (long) fragP->fr_var); 2689 offset -= (offset % fragP->fr_var); 2690 } 2691 2692 address += offset; 2693 region += 1; 2694 } 2695 break; 2696 2697 case rs_org: 2698 /* Assume .org is nugatory. It will grow with 1st relax. */ 2699 region += 1; 2700 break; 2701 2702 case rs_space: 2703 case rs_space_nop: 2704 break; 2705 2706 case rs_machine_dependent: 2707 /* If fr_symbol is an expression, this call to 2708 resolve_symbol_value sets up the correct segment, which will 2709 likely be needed in md_estimate_size_before_relax. */ 2710 if (fragP->fr_symbol) 2711 resolve_symbol_value (fragP->fr_symbol); 2712 2713 address += md_estimate_size_before_relax (fragP, segment); 2714 break; 2715 2716#ifndef WORKING_DOT_WORD 2717 /* Broken words don't concern us yet. */ 2718 case rs_broken_word: 2719 break; 2720#endif 2721 2722 case rs_leb128: 2723 /* Initial guess is always 1; doing otherwise can result in 2724 stable solutions that are larger than the minimum. */ 2725 address += fragP->fr_offset = 1; 2726 break; 2727 2728 case rs_cfa: 2729 address += eh_frame_estimate_size_before_relax (fragP); 2730 break; 2731 2732 case rs_dwarf2dbg: 2733 address += dwarf2dbg_estimate_size_before_relax (fragP); 2734 break; 2735 2736 default: 2737 BAD_CASE (fragP->fr_type); 2738 break; 2739 } 2740 } 2741 2742 /* Do relax(). */ 2743 { 2744 unsigned long max_iterations; 2745 2746 /* Cumulative address adjustment. */ 2747 offsetT stretch; 2748 2749 /* Have we made any adjustment this pass? We can't just test 2750 stretch because one piece of code may have grown and another 2751 shrank. */ 2752 int stretched; 2753 2754 /* Most horrible, but gcc may give us some exception data that 2755 is impossible to assemble, of the form 2756 2757 .align 4 2758 .byte 0, 0 2759 .uleb128 end - start 2760 start: 2761 .space 128*128 - 1 2762 .align 4 2763 end: 2764 2765 If the leb128 is two bytes in size, then end-start is 128*128, 2766 which requires a three byte leb128. If the leb128 is three 2767 bytes in size, then end-start is 128*128-1, which requires a 2768 two byte leb128. We work around this dilemma by inserting 2769 an extra 4 bytes of alignment just after the .align. This 2770 works because the data after the align is accessed relative to 2771 the end label. 2772 2773 This counter is used in a tiny state machine to detect 2774 whether a leb128 followed by an align is impossible to 2775 relax. */ 2776 int rs_leb128_fudge = 0; 2777 2778 /* We want to prevent going into an infinite loop where one frag grows 2779 depending upon the location of a symbol which is in turn moved by 2780 the growing frag. eg: 2781 2782 foo = . 2783 .org foo+16 2784 foo = . 2785 2786 So we dictate that this algorithm can be at most O2. */ 2787 max_iterations = frag_count * frag_count; 2788 /* Check for overflow. */ 2789 if (max_iterations < frag_count) 2790 max_iterations = frag_count; 2791 2792 ret = 0; 2793 do 2794 { 2795 stretch = 0; 2796 stretched = 0; 2797 2798 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2799 { 2800 offsetT growth = 0; 2801 addressT was_address; 2802 offsetT offset; 2803 symbolS *symbolP; 2804 2805 fragP->relax_marker ^= 1; 2806 was_address = fragP->fr_address; 2807 address = fragP->fr_address += stretch; 2808 symbolP = fragP->fr_symbol; 2809 offset = fragP->fr_offset; 2810 2811 switch (fragP->fr_type) 2812 { 2813 case rs_fill: /* .fill never relaxes. */ 2814 growth = 0; 2815 break; 2816 2817#ifndef WORKING_DOT_WORD 2818 /* JF: This is RMS's idea. I do *NOT* want to be blamed 2819 for it I do not want to write it. I do not want to have 2820 anything to do with it. This is not the proper way to 2821 implement this misfeature. */ 2822 case rs_broken_word: 2823 { 2824 struct broken_word *lie; 2825 struct broken_word *untruth; 2826 2827 /* Yes this is ugly (storing the broken_word pointer 2828 in the symbol slot). Still, this whole chunk of 2829 code is ugly, and I don't feel like doing anything 2830 about it. Think of it as stubbornness in action. */ 2831 growth = 0; 2832 for (lie = (struct broken_word *) (fragP->fr_symbol); 2833 lie && lie->dispfrag == fragP; 2834 lie = lie->next_broken_word) 2835 { 2836 2837 if (lie->added) 2838 continue; 2839 2840 offset = (S_GET_VALUE (lie->add) 2841 + lie->addnum 2842 - S_GET_VALUE (lie->sub)); 2843 if (offset <= -32768 || offset >= 32767) 2844 { 2845 if (flag_warn_displacement) 2846 { 2847 char buf[50]; 2848 sprint_value (buf, (addressT) lie->addnum); 2849 as_warn_where (fragP->fr_file, fragP->fr_line, 2850 _(".word %s-%s+%s didn't fit"), 2851 S_GET_NAME (lie->add), 2852 S_GET_NAME (lie->sub), 2853 buf); 2854 } 2855 if (fragP->fr_subtype == 0) 2856 { 2857 fragP->fr_subtype++; 2858 growth += md_short_jump_size; 2859 } 2860 2861 /* Redirect *all* words of this table with the same 2862 target, lest we have to handle the case where the 2863 same target but with a offset that fits on this 2864 round overflows at the next relaxation round. */ 2865 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2866 untruth && untruth->dispfrag == lie->dispfrag; 2867 untruth = untruth->next_broken_word) 2868 if ((symbol_get_frag (untruth->add) 2869 == symbol_get_frag (lie->add)) 2870 && (S_GET_VALUE (untruth->add) 2871 == S_GET_VALUE (lie->add))) 2872 { 2873 untruth->added = 2; 2874 untruth->use_jump = lie; 2875 } 2876 2877 lie->added = 1; 2878 growth += md_long_jump_size; 2879 } 2880 } 2881 2882 break; 2883 } /* case rs_broken_word */ 2884#endif 2885 case rs_align: 2886 case rs_align_code: 2887 case rs_align_test: 2888 { 2889 addressT oldoff, newoff; 2890 2891 oldoff = relax_align (was_address + fragP->fr_fix, 2892 (int) offset); 2893 newoff = relax_align (address + fragP->fr_fix, 2894 (int) offset); 2895 2896 if (fragP->fr_subtype != 0) 2897 { 2898 if (oldoff > fragP->fr_subtype) 2899 oldoff = 0; 2900 if (newoff > fragP->fr_subtype) 2901 newoff = 0; 2902 } 2903 2904 growth = newoff - oldoff; 2905 2906 /* If this align happens to follow a leb128 and 2907 we have determined that the leb128 is bouncing 2908 in size, then break the cycle by inserting an 2909 extra alignment. */ 2910 if (growth < 0 2911 && (rs_leb128_fudge & 16) != 0 2912 && (rs_leb128_fudge & 15) >= 2) 2913 { 2914 segment_info_type *seginfo = seg_info (segment); 2915 struct obstack *ob = &seginfo->frchainP->frch_obstack; 2916 struct frag *newf; 2917 2918 newf = frag_alloc (ob); 2919 obstack_blank_fast (ob, fragP->fr_var); 2920 obstack_finish (ob); 2921 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG); 2922 memcpy (newf->fr_literal, 2923 fragP->fr_literal + fragP->fr_fix, 2924 fragP->fr_var); 2925 newf->fr_type = rs_fill; 2926 newf->fr_address = address + fragP->fr_fix + newoff; 2927 newf->fr_fix = 0; 2928 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset) 2929 / fragP->fr_var); 2930 if (newf->fr_offset * newf->fr_var 2931 != (offsetT) 1 << fragP->fr_offset) 2932 { 2933 newf->fr_offset = (offsetT) 1 << fragP->fr_offset; 2934 newf->fr_var = 1; 2935 } 2936 /* Include size of new frag in GROWTH. */ 2937 growth += newf->fr_offset * newf->fr_var; 2938 /* Adjust the new frag address for the amount 2939 we'll add when we process the new frag. */ 2940 newf->fr_address -= stretch + growth; 2941 newf->relax_marker ^= 1; 2942 fragP->fr_next = newf; 2943#ifdef DEBUG 2944 as_warn (_("padding added")); 2945#endif 2946 } 2947 } 2948 break; 2949 2950 case rs_org: 2951 { 2952 offsetT target = offset; 2953 addressT after; 2954 2955 if (symbolP) 2956 { 2957 /* Convert from an actual address to an octet offset 2958 into the section. Here it is assumed that the 2959 section's VMA is zero, and can omit subtracting it 2960 from the symbol's value to get the address offset. */ 2961 know (S_GET_SEGMENT (symbolP)->vma == 0); 2962 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE; 2963 } 2964 2965 know (fragP->fr_next); 2966 after = fragP->fr_next->fr_address + stretch; 2967 growth = target - after; 2968 2969 /* Growth may be negative, but variable part of frag 2970 cannot have fewer than 0 chars. That is, we can't 2971 .org backwards. */ 2972 if ((offsetT) (address + fragP->fr_fix) > target) 2973 { 2974 growth = 0; 2975 2976 /* Don't error on first few frag relax passes. 2977 The symbol might be an expression involving 2978 symbol values from other sections. If those 2979 sections have not yet been processed their 2980 frags will all have zero addresses, so we 2981 will calculate incorrect values for them. The 2982 number of passes we allow before giving an 2983 error is somewhat arbitrary. It should be at 2984 least one, with larger values requiring 2985 increasingly contrived dependencies between 2986 frags to trigger a false error. */ 2987 if (pass < 2) 2988 { 2989 /* Force another pass. */ 2990 ret = 1; 2991 break; 2992 } 2993 2994 as_bad_where (fragP->fr_file, fragP->fr_line, 2995 _("attempt to move .org backwards")); 2996 2997 /* We've issued an error message. Change the 2998 frag to avoid cascading errors. */ 2999 fragP->fr_type = rs_align; 3000 fragP->fr_subtype = 0; 3001 fragP->fr_offset = 0; 3002 fragP->fr_fix = after - address; 3003 } 3004 } 3005 break; 3006 3007 case rs_space: 3008 case rs_space_nop: 3009 growth = 0; 3010 if (symbolP) 3011 { 3012 offsetT amount; 3013 3014 amount = S_GET_VALUE (symbolP); 3015 if (S_GET_SEGMENT (symbolP) != absolute_section 3016 || S_IS_COMMON (symbolP) 3017 || ! S_IS_DEFINED (symbolP)) 3018 { 3019 as_bad_where (fragP->fr_file, fragP->fr_line, 3020 _(".space specifies non-absolute value")); 3021 /* Prevent repeat of this error message. */ 3022 fragP->fr_symbol = 0; 3023 } 3024 else if (amount < 0) 3025 { 3026 /* Don't error on first few frag relax passes. 3027 See rs_org comment for a longer explanation. */ 3028 if (pass < 2) 3029 { 3030 ret = 1; 3031 break; 3032 } 3033 3034 as_warn_where (fragP->fr_file, fragP->fr_line, 3035 _(".space, .nops or .fill with negative value, ignored")); 3036 fragP->fr_symbol = 0; 3037 } 3038 else 3039 growth = (was_address + fragP->fr_fix + amount 3040 - fragP->fr_next->fr_address); 3041 } 3042 break; 3043 3044 case rs_machine_dependent: 3045#ifdef md_relax_frag 3046 growth = md_relax_frag (segment, fragP, stretch); 3047#else 3048#ifdef TC_GENERIC_RELAX_TABLE 3049 /* The default way to relax a frag is to look through 3050 TC_GENERIC_RELAX_TABLE. */ 3051 growth = md_generic_table_relax_frag (segment, fragP, 3052 stretch); 3053#endif /* TC_GENERIC_RELAX_TABLE */ 3054#endif 3055 break; 3056 3057 case rs_leb128: 3058 { 3059 valueT value; 3060 offsetT size; 3061 3062 value = resolve_symbol_value (fragP->fr_symbol); 3063 size = sizeof_leb128 (value, fragP->fr_subtype); 3064 growth = size - fragP->fr_offset; 3065 fragP->fr_offset = size; 3066 } 3067 break; 3068 3069 case rs_cfa: 3070 growth = eh_frame_relax_frag (fragP); 3071 break; 3072 3073 case rs_dwarf2dbg: 3074 growth = dwarf2dbg_relax_frag (fragP); 3075 break; 3076 3077 default: 3078 BAD_CASE (fragP->fr_type); 3079 break; 3080 } 3081 if (growth) 3082 { 3083 stretch += growth; 3084 stretched = 1; 3085 if (fragP->fr_type == rs_leb128) 3086 rs_leb128_fudge += 16; 3087 else if (fragP->fr_type == rs_align 3088 && (rs_leb128_fudge & 16) != 0 3089 && stretch == 0) 3090 rs_leb128_fudge += 16; 3091 else 3092 rs_leb128_fudge = 0; 3093 } 3094 } 3095 3096 if (stretch == 0 3097 && (rs_leb128_fudge & 16) == 0 3098 && (rs_leb128_fudge & -16) != 0) 3099 rs_leb128_fudge += 1; 3100 else 3101 rs_leb128_fudge = 0; 3102 } 3103 /* Until nothing further to relax. */ 3104 while (stretched && -- max_iterations); 3105 3106 if (stretched) 3107 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"), 3108 segment_name (segment)); 3109 } 3110 3111 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 3112 if (fragP->last_fr_address != fragP->fr_address) 3113 { 3114 fragP->last_fr_address = fragP->fr_address; 3115 ret = 1; 3116 } 3117 return ret; 3118} 3119 3120void 3121number_to_chars_bigendian (char *buf, valueT val, int n) 3122{ 3123 if (n <= 0) 3124 abort (); 3125 while (n--) 3126 { 3127 buf[n] = val & 0xff; 3128 val >>= 8; 3129 } 3130} 3131 3132void 3133number_to_chars_littleendian (char *buf, valueT val, int n) 3134{ 3135 if (n <= 0) 3136 abort (); 3137 while (n--) 3138 { 3139 *buf++ = val & 0xff; 3140 val >>= 8; 3141 } 3142} 3143 3144void 3145write_print_statistics (FILE *file) 3146{ 3147 fprintf (file, "fixups: %d\n", n_fixups); 3148} 3149 3150/* For debugging. */ 3151extern int indent_level; 3152 3153void 3154print_fixup (fixS *fixp) 3155{ 3156 indent_level = 1; 3157 fprintf (stderr, "fix "); 3158 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp)); 3159 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line); 3160 if (fixp->fx_pcrel) 3161 fprintf (stderr, " pcrel"); 3162 if (fixp->fx_pcrel_adjust) 3163 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust); 3164 if (fixp->fx_tcbit) 3165 fprintf (stderr, " tcbit"); 3166 if (fixp->fx_done) 3167 fprintf (stderr, " done"); 3168 fprintf (stderr, "\n size=%d frag=", fixp->fx_size); 3169 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag)); 3170 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx", 3171 (long) fixp->fx_where, 3172 (unsigned long) fixp->fx_offset, 3173 (unsigned long) fixp->fx_addnumber); 3174 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), 3175 fixp->fx_r_type); 3176 if (fixp->fx_addsy) 3177 { 3178 fprintf (stderr, "\n +<"); 3179 print_symbol_value_1 (stderr, fixp->fx_addsy); 3180 fprintf (stderr, ">"); 3181 } 3182 if (fixp->fx_subsy) 3183 { 3184 fprintf (stderr, "\n -<"); 3185 print_symbol_value_1 (stderr, fixp->fx_subsy); 3186 fprintf (stderr, ">"); 3187 } 3188 fprintf (stderr, "\n"); 3189#ifdef TC_FIX_DATA_PRINT 3190 TC_FIX_DATA_PRINT (stderr, fixp); 3191#endif 3192} 3193