1 /* write.c - emit .o file 2 Copyright (C) 1986-2018 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. */ 115 int finalize_syms = 0; 116 117 int symbol_table_frozen; 118 119 symbolS *abs_section_sym; 120 121 /* Remember the value of dot when parsing expressions. */ 122 addressT dot_value; 123 124 /* The frag that dot_value is based from. */ 125 fragS *dot_frag; 126 127 /* Relocs generated by ".reloc" pseudo. */ 128 struct reloc_list* reloc_list; 129 130 void 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. */ 136 static int frags_chained = 0; 137 138 static int n_fixups; 139 140 #define RELOC_ENUM enum bfd_reloc_code_real 141 142 /* Create a fixS in obstack 'notes'. */ 143 144 static fixS * 145 fix_new_internal (fragS *frag, /* Which frag? */ 146 int where, /* Where in that frag? */ 147 int size, /* 1, 2, or 4 usually. */ 148 symbolS *add_symbol, /* X_add_symbol. */ 149 symbolS *sub_symbol, /* X_op_symbol. */ 150 offsetT offset, /* X_add_number. */ 151 int pcrel, /* TRUE if PC-relative relocation. */ 152 RELOC_ENUM r_type /* Relocation type. */, 153 int at_beginning) /* Add to the start of the list? */ 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 %d"), 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_im_disp = 0; 178 fixP->fx_pcrel_adjust = 0; 179 fixP->fx_bit_fixP = 0; 180 fixP->fx_addnumber = 0; 181 fixP->fx_tcbit = 0; 182 fixP->fx_tcbit2 = 0; 183 fixP->fx_done = 0; 184 fixP->fx_no_overflow = 0; 185 fixP->fx_signed = 0; 186 187 #ifdef USING_CGEN 188 fixP->fx_cgen.insn = NULL; 189 fixP->fx_cgen.opinfo = 0; 190 #endif 191 192 #ifdef TC_FIX_TYPE 193 TC_INIT_FIX_DATA (fixP); 194 #endif 195 196 fixP->fx_file = as_where (&fixP->fx_line); 197 198 { 199 200 fixS **seg_fix_rootP = (frags_chained 201 ? &seg_info (now_seg)->fix_root 202 : &frchain_now->fix_root); 203 fixS **seg_fix_tailP = (frags_chained 204 ? &seg_info (now_seg)->fix_tail 205 : &frchain_now->fix_tail); 206 207 if (at_beginning) 208 { 209 fixP->fx_next = *seg_fix_rootP; 210 *seg_fix_rootP = fixP; 211 if (fixP->fx_next == NULL) 212 *seg_fix_tailP = fixP; 213 } 214 else 215 { 216 fixP->fx_next = NULL; 217 if (*seg_fix_tailP) 218 (*seg_fix_tailP)->fx_next = fixP; 219 else 220 *seg_fix_rootP = fixP; 221 *seg_fix_tailP = fixP; 222 } 223 } 224 225 return fixP; 226 } 227 228 /* Create a fixup relative to a symbol (plus a constant). */ 229 230 fixS * 231 fix_new (fragS *frag, /* Which frag? */ 232 int where, /* Where in that frag? */ 233 int size, /* 1, 2, or 4 usually. */ 234 symbolS *add_symbol, /* X_add_symbol. */ 235 offsetT offset, /* X_add_number. */ 236 int pcrel, /* TRUE if PC-relative relocation. */ 237 RELOC_ENUM r_type /* Relocation type. */) 238 { 239 return fix_new_internal (frag, where, size, add_symbol, 240 (symbolS *) NULL, offset, pcrel, r_type, FALSE); 241 } 242 243 /* Create a fixup for an expression. Currently we only support fixups 244 for difference expressions. That is itself more than most object 245 file formats support anyhow. */ 246 247 fixS * 248 fix_new_exp (fragS *frag, /* Which frag? */ 249 int where, /* Where in that frag? */ 250 int size, /* 1, 2, or 4 usually. */ 251 expressionS *exp, /* Expression. */ 252 int pcrel, /* TRUE if PC-relative relocation. */ 253 RELOC_ENUM r_type /* Relocation type. */) 254 { 255 symbolS *add = NULL; 256 symbolS *sub = NULL; 257 offsetT off = 0; 258 259 switch (exp->X_op) 260 { 261 case O_absent: 262 break; 263 264 case O_register: 265 as_bad (_("register value used as expression")); 266 break; 267 268 case O_add: 269 /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if 270 the difference expression cannot immediately be reduced. */ 271 { 272 symbolS *stmp = make_expr_symbol (exp); 273 274 exp->X_op = O_symbol; 275 exp->X_op_symbol = 0; 276 exp->X_add_symbol = stmp; 277 exp->X_add_number = 0; 278 279 return fix_new_exp (frag, where, size, exp, pcrel, r_type); 280 } 281 282 case O_symbol_rva: 283 add = exp->X_add_symbol; 284 off = exp->X_add_number; 285 r_type = BFD_RELOC_RVA; 286 break; 287 288 case O_uminus: 289 sub = exp->X_add_symbol; 290 off = exp->X_add_number; 291 break; 292 293 case O_subtract: 294 sub = exp->X_op_symbol; 295 /* Fall through. */ 296 case O_symbol: 297 add = exp->X_add_symbol; 298 /* Fall through. */ 299 case O_constant: 300 off = exp->X_add_number; 301 break; 302 303 default: 304 add = make_expr_symbol (exp); 305 break; 306 } 307 308 return fix_new_internal (frag, where, size, add, sub, off, pcrel, 309 r_type, FALSE); 310 } 311 312 /* Create a fixup at the beginning of FRAG. The arguments are the same 313 as for fix_new, except that WHERE is implicitly 0. */ 314 315 fixS * 316 fix_at_start (fragS *frag, int size, symbolS *add_symbol, 317 offsetT offset, int pcrel, RELOC_ENUM r_type) 318 { 319 return fix_new_internal (frag, 0, size, add_symbol, 320 (symbolS *) NULL, offset, pcrel, r_type, TRUE); 321 } 322 323 /* Generic function to determine whether a fixup requires a relocation. */ 324 int 325 generic_force_reloc (fixS *fix) 326 { 327 if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT 328 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 329 return 1; 330 331 if (fix->fx_addsy == NULL) 332 return 0; 333 334 return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL); 335 } 336 337 /* Append a string onto another string, bumping the pointer along. */ 338 void 339 append (char **charPP, char *fromP, unsigned long length) 340 { 341 /* Don't trust memcpy() of 0 chars. */ 342 if (length == 0) 343 return; 344 345 memcpy (*charPP, fromP, length); 346 *charPP += length; 347 } 348 349 /* This routine records the largest alignment seen for each segment. 350 If the beginning of the segment is aligned on the worst-case 351 boundary, all of the other alignments within it will work. At 352 least one object format really uses this info. */ 353 354 void 355 record_alignment (/* Segment to which alignment pertains. */ 356 segT seg, 357 /* Alignment, as a power of 2 (e.g., 1 => 2-byte 358 boundary, 2 => 4-byte boundary, etc.) */ 359 unsigned int align) 360 { 361 if (seg == absolute_section) 362 return; 363 364 if (align > bfd_get_section_alignment (stdoutput, seg)) 365 bfd_set_section_alignment (stdoutput, seg, align); 366 } 367 368 int 369 get_recorded_alignment (segT seg) 370 { 371 if (seg == absolute_section) 372 return 0; 373 374 return bfd_get_section_alignment (stdoutput, seg); 375 } 376 377 /* Reset the section indices after removing the gas created sections. */ 378 379 static void 380 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg) 381 { 382 int *countp = (int *) countparg; 383 384 sec->index = *countp; 385 ++*countp; 386 } 387 388 static fragS * 389 chain_frchains_together_1 (segT section, struct frchain *frchp) 390 { 391 fragS dummy, *prev_frag = &dummy; 392 fixS fix_dummy, *prev_fix = &fix_dummy; 393 394 for (; frchp; frchp = frchp->frch_next) 395 { 396 prev_frag->fr_next = frchp->frch_root; 397 prev_frag = frchp->frch_last; 398 gas_assert (prev_frag->fr_type != 0); 399 if (frchp->fix_root != (fixS *) NULL) 400 { 401 if (seg_info (section)->fix_root == (fixS *) NULL) 402 seg_info (section)->fix_root = frchp->fix_root; 403 prev_fix->fx_next = frchp->fix_root; 404 seg_info (section)->fix_tail = frchp->fix_tail; 405 prev_fix = frchp->fix_tail; 406 } 407 } 408 gas_assert (prev_frag != &dummy 409 && prev_frag->fr_type != 0); 410 prev_frag->fr_next = 0; 411 return prev_frag; 412 } 413 414 static void 415 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED, 416 segT section, 417 void *xxx ATTRIBUTE_UNUSED) 418 { 419 segment_info_type *info; 420 421 /* BFD may have introduced its own sections without using 422 subseg_new, so it is possible that seg_info is NULL. */ 423 info = seg_info (section); 424 if (info != (segment_info_type *) NULL) 425 info->frchainP->frch_last 426 = chain_frchains_together_1 (section, info->frchainP); 427 428 /* Now that we've chained the frags together, we must add new fixups 429 to the segment, not to the frag chain. */ 430 frags_chained = 1; 431 } 432 433 static void 434 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP) 435 { 436 switch (fragP->fr_type) 437 { 438 case rs_space_nop: 439 goto skip_align; 440 case rs_align: 441 case rs_align_code: 442 case rs_align_test: 443 case rs_org: 444 case rs_space: 445 #ifdef HANDLE_ALIGN 446 HANDLE_ALIGN (fragP); 447 #endif 448 skip_align: 449 know (fragP->fr_next != NULL); 450 fragP->fr_offset = (fragP->fr_next->fr_address 451 - fragP->fr_address 452 - fragP->fr_fix) / fragP->fr_var; 453 if (fragP->fr_offset < 0) 454 { 455 as_bad_where (fragP->fr_file, fragP->fr_line, 456 _("attempt to .org/.space/.nops backwards? (%ld)"), 457 (long) fragP->fr_offset); 458 fragP->fr_offset = 0; 459 } 460 if (fragP->fr_type == rs_space_nop) 461 fragP->fr_type = rs_fill_nop; 462 else 463 fragP->fr_type = rs_fill; 464 break; 465 466 case rs_fill: 467 case rs_fill_nop: 468 break; 469 470 case rs_leb128: 471 { 472 valueT value = S_GET_VALUE (fragP->fr_symbol); 473 int size; 474 475 if (!S_IS_DEFINED (fragP->fr_symbol)) 476 { 477 as_bad_where (fragP->fr_file, fragP->fr_line, 478 _("leb128 operand is an undefined symbol: %s"), 479 S_GET_NAME (fragP->fr_symbol)); 480 } 481 482 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value, 483 fragP->fr_subtype); 484 485 fragP->fr_fix += size; 486 fragP->fr_type = rs_fill; 487 fragP->fr_var = 0; 488 fragP->fr_offset = 0; 489 fragP->fr_symbol = NULL; 490 } 491 break; 492 493 case rs_cfa: 494 eh_frame_convert_frag (fragP); 495 break; 496 497 case rs_dwarf2dbg: 498 dwarf2dbg_convert_frag (fragP); 499 break; 500 501 case rs_machine_dependent: 502 md_convert_frag (stdoutput, sec, fragP); 503 504 gas_assert (fragP->fr_next == NULL 505 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address) 506 == fragP->fr_fix)); 507 508 /* After md_convert_frag, we make the frag into a ".space 0". 509 md_convert_frag() should set up any fixSs and constants 510 required. */ 511 frag_wane (fragP); 512 break; 513 514 #ifndef WORKING_DOT_WORD 515 case rs_broken_word: 516 { 517 struct broken_word *lie; 518 519 if (fragP->fr_subtype) 520 { 521 fragP->fr_fix += md_short_jump_size; 522 for (lie = (struct broken_word *) (fragP->fr_symbol); 523 lie && lie->dispfrag == fragP; 524 lie = lie->next_broken_word) 525 if (lie->added == 1) 526 fragP->fr_fix += md_long_jump_size; 527 } 528 frag_wane (fragP); 529 } 530 break; 531 #endif 532 533 default: 534 BAD_CASE (fragP->fr_type); 535 break; 536 } 537 #ifdef md_frag_check 538 md_frag_check (fragP); 539 #endif 540 } 541 542 struct relax_seg_info 543 { 544 int pass; 545 int changed; 546 }; 547 548 static void 549 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx) 550 { 551 segment_info_type *seginfo = seg_info (sec); 552 struct relax_seg_info *info = (struct relax_seg_info *) xxx; 553 554 if (seginfo && seginfo->frchainP 555 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass)) 556 info->changed = 1; 557 } 558 559 static void 560 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 561 { 562 flagword flags; 563 fragS *fragp; 564 segment_info_type *seginfo; 565 int x; 566 valueT size, newsize; 567 568 subseg_change (sec, 0); 569 570 seginfo = seg_info (sec); 571 if (seginfo && seginfo->frchainP) 572 { 573 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next) 574 cvt_frag_to_fill (sec, fragp); 575 for (fragp = seginfo->frchainP->frch_root; 576 fragp->fr_next; 577 fragp = fragp->fr_next) 578 /* Walk to last elt. */ 579 ; 580 size = fragp->fr_address + fragp->fr_fix; 581 } 582 else 583 size = 0; 584 585 flags = bfd_get_section_flags (abfd, sec); 586 if (size == 0 && bfd_get_section_size (sec) != 0 && 587 (flags & SEC_HAS_CONTENTS) != 0) 588 return; 589 590 if (size > 0 && ! seginfo->bss) 591 flags |= SEC_HAS_CONTENTS; 592 593 flags &= ~SEC_RELOC; 594 x = bfd_set_section_flags (abfd, sec, flags); 595 gas_assert (x); 596 597 /* If permitted, allow the backend to pad out the section 598 to some alignment boundary. */ 599 if (do_not_pad_sections_to_alignment) 600 newsize = size; 601 else 602 newsize = md_section_align (sec, size); 603 x = bfd_set_section_size (abfd, sec, newsize); 604 gas_assert (x); 605 606 /* If the size had to be rounded up, add some padding in the last 607 non-empty frag. */ 608 gas_assert (newsize >= size); 609 if (size != newsize) 610 { 611 fragS *last = seginfo->frchainP->frch_last; 612 fragp = seginfo->frchainP->frch_root; 613 while (fragp->fr_next != last) 614 fragp = fragp->fr_next; 615 last->fr_address = size; 616 if ((newsize - size) % fragp->fr_var == 0) 617 fragp->fr_offset += (newsize - size) / fragp->fr_var; 618 else 619 /* If we hit this abort, it's likely due to subsegs_finish not 620 providing sufficient alignment on the last frag, and the 621 machine dependent code using alignment frags with fr_var 622 greater than 1. */ 623 abort (); 624 } 625 626 #ifdef tc_frob_section 627 tc_frob_section (sec); 628 #endif 629 #ifdef obj_frob_section 630 obj_frob_section (sec); 631 #endif 632 } 633 634 #ifdef DEBUG2 635 static void 636 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream) 637 { 638 segment_info_type *seginfo = seg_info (sec); 639 fixS *fixp = seginfo->fix_root; 640 641 if (!fixp) 642 return; 643 644 fprintf (stream, "sec %s relocs:\n", sec->name); 645 while (fixp) 646 { 647 symbolS *s = fixp->fx_addsy; 648 649 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp, 650 (int) fixp->fx_r_type); 651 if (s == NULL) 652 fprintf (stream, "no sym\n"); 653 else 654 { 655 print_symbol_value_1 (stream, s); 656 fprintf (stream, "\n"); 657 } 658 fixp = fixp->fx_next; 659 } 660 } 661 #else 662 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0) 663 #endif 664 665 #ifndef EMIT_SECTION_SYMBOLS 666 #define EMIT_SECTION_SYMBOLS 1 667 #endif 668 669 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries, 670 and check for validity. Convert RELOC_LIST from using U.A fields 671 to U.B fields. */ 672 static void 673 resolve_reloc_expr_symbols (void) 674 { 675 bfd_vma addr_mask = 1; 676 struct reloc_list *r; 677 678 /* Avoid a shift by the width of type. */ 679 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1; 680 addr_mask <<= 1; 681 addr_mask -= 1; 682 683 for (r = reloc_list; r; r = r->next) 684 { 685 reloc_howto_type *howto = r->u.a.howto; 686 expressionS *symval; 687 symbolS *sym; 688 bfd_vma offset, addend; 689 asection *sec; 690 691 resolve_symbol_value (r->u.a.offset_sym); 692 symval = symbol_get_value_expression (r->u.a.offset_sym); 693 694 offset = 0; 695 sym = NULL; 696 if (symval->X_op == O_constant) 697 sym = r->u.a.offset_sym; 698 else if (symval->X_op == O_symbol) 699 { 700 sym = symval->X_add_symbol; 701 offset = symval->X_add_number; 702 symval = symbol_get_value_expression (symval->X_add_symbol); 703 } 704 if (sym == NULL 705 || symval->X_op != O_constant 706 || (sec = S_GET_SEGMENT (sym)) == NULL 707 || !SEG_NORMAL (sec)) 708 { 709 as_bad_where (r->file, r->line, _("invalid offset expression")); 710 sec = NULL; 711 } 712 else 713 offset += S_GET_VALUE (sym); 714 715 sym = NULL; 716 addend = r->u.a.addend; 717 if (r->u.a.sym != NULL) 718 { 719 resolve_symbol_value (r->u.a.sym); 720 symval = symbol_get_value_expression (r->u.a.sym); 721 if (symval->X_op == O_constant) 722 sym = r->u.a.sym; 723 else if (symval->X_op == O_symbol) 724 { 725 sym = symval->X_add_symbol; 726 addend += symval->X_add_number; 727 symval = symbol_get_value_expression (symval->X_add_symbol); 728 } 729 if (symval->X_op != O_constant) 730 { 731 as_bad_where (r->file, r->line, _("invalid reloc expression")); 732 sec = NULL; 733 } 734 else if (sym != NULL && sec != NULL) 735 { 736 /* Convert relocs against local symbols to refer to the 737 corresponding section symbol plus offset instead. Keep 738 PC-relative relocs of the REL variety intact though to 739 prevent the offset from overflowing the relocated field, 740 unless it has enough bits to cover the whole address 741 space. */ 742 if (S_IS_LOCAL (sym) && !symbol_section_p (sym) 743 && (sec->use_rela_p 744 || (howto->partial_inplace 745 && (!howto->pc_relative 746 || howto->src_mask == addr_mask)))) 747 { 748 asection *symsec = S_GET_SEGMENT (sym); 749 if (!(((symsec->flags & SEC_MERGE) != 0 750 && addend != 0) 751 || (symsec->flags & SEC_THREAD_LOCAL) != 0)) 752 { 753 addend += S_GET_VALUE (sym); 754 sym = section_symbol (symsec); 755 } 756 } 757 symbol_mark_used_in_reloc (sym); 758 } 759 } 760 if (sym == NULL) 761 { 762 if (abs_section_sym == NULL) 763 abs_section_sym = section_symbol (absolute_section); 764 sym = abs_section_sym; 765 } 766 767 r->u.b.sec = sec; 768 r->u.b.s = symbol_get_bfdsym (sym); 769 r->u.b.r.sym_ptr_ptr = &r->u.b.s; 770 r->u.b.r.address = offset; 771 r->u.b.r.addend = addend; 772 r->u.b.r.howto = howto; 773 } 774 } 775 776 /* This pass over fixups decides whether symbols can be replaced with 777 section symbols. */ 778 779 static void 780 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED, 781 asection *sec, 782 void *xxx ATTRIBUTE_UNUSED) 783 { 784 segment_info_type *seginfo = seg_info (sec); 785 fixS *fixp; 786 787 if (seginfo == NULL) 788 return; 789 790 dump_section_relocs (abfd, sec, stderr); 791 792 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 793 if (fixp->fx_done) 794 /* Ignore it. */ 795 ; 796 else if (fixp->fx_addsy) 797 { 798 symbolS *sym; 799 asection *symsec; 800 801 #ifdef DEBUG5 802 fprintf (stderr, "\n\nadjusting fixup:\n"); 803 print_fixup (fixp); 804 #endif 805 806 sym = fixp->fx_addsy; 807 808 /* All symbols should have already been resolved at this 809 point. It is possible to see unresolved expression 810 symbols, though, since they are not in the regular symbol 811 table. */ 812 resolve_symbol_value (sym); 813 814 if (fixp->fx_subsy != NULL) 815 resolve_symbol_value (fixp->fx_subsy); 816 817 /* If this symbol is equated to an undefined or common symbol, 818 convert the fixup to being against that symbol. */ 819 while (symbol_equated_reloc_p (sym) 820 || S_IS_WEAKREFR (sym)) 821 { 822 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol; 823 if (sym == newsym) 824 break; 825 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; 826 fixp->fx_addsy = newsym; 827 sym = newsym; 828 } 829 830 if (symbol_mri_common_p (sym)) 831 { 832 fixp->fx_offset += S_GET_VALUE (sym); 833 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol; 834 continue; 835 } 836 837 /* If the symbol is undefined, common, weak, or global (ELF 838 shared libs), we can't replace it with the section symbol. */ 839 if (S_FORCE_RELOC (fixp->fx_addsy, 1)) 840 continue; 841 842 /* Is there some other (target cpu dependent) reason we can't adjust 843 this one? (E.g. relocations involving function addresses on 844 the PA. */ 845 #ifdef tc_fix_adjustable 846 if (! tc_fix_adjustable (fixp)) 847 continue; 848 #endif 849 850 /* Since we're reducing to section symbols, don't attempt to reduce 851 anything that's already using one. */ 852 if (symbol_section_p (sym)) 853 continue; 854 855 symsec = S_GET_SEGMENT (sym); 856 if (symsec == NULL) 857 abort (); 858 859 if (bfd_is_abs_section (symsec) 860 || symsec == reg_section) 861 { 862 /* The fixup_segment routine normally will not use this 863 symbol in a relocation. */ 864 continue; 865 } 866 867 /* Don't try to reduce relocs which refer to non-local symbols 868 in .linkonce sections. It can lead to confusion when a 869 debugging section refers to a .linkonce section. I hope 870 this will always be correct. */ 871 if (symsec != sec && ! S_IS_LOCAL (sym)) 872 { 873 if ((symsec->flags & SEC_LINK_ONCE) != 0 874 || (IS_ELF 875 /* The GNU toolchain uses an extension for ELF: a 876 section beginning with the magic string 877 .gnu.linkonce is a linkonce section. */ 878 && strncmp (segment_name (symsec), ".gnu.linkonce", 879 sizeof ".gnu.linkonce" - 1) == 0)) 880 continue; 881 } 882 883 /* Never adjust a reloc against local symbol in a merge section 884 with non-zero addend. */ 885 if ((symsec->flags & SEC_MERGE) != 0 886 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL)) 887 continue; 888 889 /* Never adjust a reloc against TLS local symbol. */ 890 if ((symsec->flags & SEC_THREAD_LOCAL) != 0) 891 continue; 892 893 /* We refetch the segment when calling section_symbol, rather 894 than using symsec, because S_GET_VALUE may wind up changing 895 the section when it calls resolve_symbol_value. */ 896 fixp->fx_offset += S_GET_VALUE (sym); 897 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym)); 898 #ifdef DEBUG5 899 fprintf (stderr, "\nadjusted fixup:\n"); 900 print_fixup (fixp); 901 #endif 902 } 903 904 dump_section_relocs (abfd, sec, stderr); 905 } 906 907 /* fixup_segment() 908 909 Go through all the fixS's in a segment and see which ones can be 910 handled now. (These consist of fixS where we have since discovered 911 the value of a symbol, or the address of the frag involved.) 912 For each one, call md_apply_fix to put the fix into the frag data. 913 Ones that we couldn't completely handle here will be output later 914 by emit_relocations. */ 915 916 static void 917 fixup_segment (fixS *fixP, segT this_segment) 918 { 919 valueT add_number; 920 fragS *fragP; 921 segT add_symbol_segment = absolute_section; 922 923 if (fixP != NULL && abs_section_sym == NULL) 924 abs_section_sym = section_symbol (absolute_section); 925 926 /* If the linker is doing the relaxing, we must not do any fixups. 927 928 Well, strictly speaking that's not true -- we could do any that 929 are PC-relative and don't cross regions that could change size. */ 930 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment)) 931 { 932 for (; fixP; fixP = fixP->fx_next) 933 if (!fixP->fx_done) 934 { 935 if (fixP->fx_addsy == NULL) 936 { 937 /* There was no symbol required by this relocation. 938 However, BFD doesn't really handle relocations 939 without symbols well. So fake up a local symbol in 940 the absolute section. */ 941 fixP->fx_addsy = abs_section_sym; 942 } 943 symbol_mark_used_in_reloc (fixP->fx_addsy); 944 if (fixP->fx_subsy != NULL) 945 symbol_mark_used_in_reloc (fixP->fx_subsy); 946 } 947 return; 948 } 949 950 for (; fixP; fixP = fixP->fx_next) 951 { 952 #ifdef DEBUG5 953 fprintf (stderr, "\nprocessing fixup:\n"); 954 print_fixup (fixP); 955 #endif 956 957 fragP = fixP->fx_frag; 958 know (fragP); 959 #ifdef TC_VALIDATE_FIX 960 TC_VALIDATE_FIX (fixP, this_segment, skip); 961 #endif 962 add_number = fixP->fx_offset; 963 964 if (fixP->fx_addsy != NULL) 965 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy); 966 967 if (fixP->fx_subsy != NULL) 968 { 969 segT sub_symbol_segment; 970 resolve_symbol_value (fixP->fx_subsy); 971 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy); 972 if (fixP->fx_addsy != NULL 973 && sub_symbol_segment == add_symbol_segment 974 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 975 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 976 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment)) 977 { 978 add_number += S_GET_VALUE (fixP->fx_addsy); 979 add_number -= S_GET_VALUE (fixP->fx_subsy); 980 fixP->fx_offset = add_number; 981 fixP->fx_addsy = NULL; 982 fixP->fx_subsy = NULL; 983 #ifdef TC_M68K 984 /* See the comment below about 68k weirdness. */ 985 fixP->fx_pcrel = 0; 986 #endif 987 } 988 else if (sub_symbol_segment == absolute_section 989 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 990 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment)) 991 { 992 add_number -= S_GET_VALUE (fixP->fx_subsy); 993 fixP->fx_offset = add_number; 994 fixP->fx_subsy = NULL; 995 } 996 else if (sub_symbol_segment == this_segment 997 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 998 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment)) 999 { 1000 add_number -= S_GET_VALUE (fixP->fx_subsy); 1001 fixP->fx_offset = (add_number + fixP->fx_dot_value 1002 + fixP->fx_dot_frag->fr_address); 1003 1004 /* Make it pc-relative. If the back-end code has not 1005 selected a pc-relative reloc, cancel the adjustment 1006 we do later on all pc-relative relocs. */ 1007 if (0 1008 #ifdef TC_M68K 1009 /* Do this for m68k even if it's already described 1010 as pc-relative. On the m68k, an operand of 1011 "pc@(foo-.-2)" should address "foo" in a 1012 pc-relative mode. */ 1013 || 1 1014 #endif 1015 || !fixP->fx_pcrel) 1016 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment); 1017 fixP->fx_subsy = NULL; 1018 fixP->fx_pcrel = 1; 1019 } 1020 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment)) 1021 { 1022 if (!md_register_arithmetic 1023 && (add_symbol_segment == reg_section 1024 || sub_symbol_segment == reg_section)) 1025 as_bad_where (fixP->fx_file, fixP->fx_line, 1026 _("register value used as expression")); 1027 else 1028 as_bad_where (fixP->fx_file, fixP->fx_line, 1029 _("can't resolve `%s' {%s section} - `%s' {%s section}"), 1030 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0", 1031 segment_name (add_symbol_segment), 1032 S_GET_NAME (fixP->fx_subsy), 1033 segment_name (sub_symbol_segment)); 1034 } 1035 else if (sub_symbol_segment != undefined_section 1036 && ! bfd_is_com_section (sub_symbol_segment) 1037 && MD_APPLY_SYM_VALUE (fixP)) 1038 add_number -= S_GET_VALUE (fixP->fx_subsy); 1039 } 1040 1041 if (fixP->fx_addsy) 1042 { 1043 if (add_symbol_segment == this_segment 1044 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 1045 && !TC_FORCE_RELOCATION_LOCAL (fixP)) 1046 { 1047 /* This fixup was made when the symbol's segment was 1048 SEG_UNKNOWN, but it is now in the local segment. 1049 So we know how to do the address without relocation. */ 1050 add_number += S_GET_VALUE (fixP->fx_addsy); 1051 fixP->fx_offset = add_number; 1052 if (fixP->fx_pcrel) 1053 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 1054 fixP->fx_addsy = NULL; 1055 fixP->fx_pcrel = 0; 1056 } 1057 else if (add_symbol_segment == absolute_section 1058 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 1059 && !TC_FORCE_RELOCATION_ABS (fixP)) 1060 { 1061 add_number += S_GET_VALUE (fixP->fx_addsy); 1062 fixP->fx_offset = add_number; 1063 fixP->fx_addsy = NULL; 1064 } 1065 else if (add_symbol_segment != undefined_section 1066 && ! bfd_is_com_section (add_symbol_segment) 1067 && MD_APPLY_SYM_VALUE (fixP)) 1068 add_number += S_GET_VALUE (fixP->fx_addsy); 1069 } 1070 1071 if (fixP->fx_pcrel) 1072 { 1073 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 1074 if (!fixP->fx_done && fixP->fx_addsy == NULL) 1075 { 1076 /* There was no symbol required by this relocation. 1077 However, BFD doesn't really handle relocations 1078 without symbols well. So fake up a local symbol in 1079 the absolute section. */ 1080 fixP->fx_addsy = abs_section_sym; 1081 } 1082 } 1083 1084 if (!fixP->fx_done) 1085 md_apply_fix (fixP, &add_number, this_segment); 1086 1087 if (!fixP->fx_done) 1088 { 1089 if (fixP->fx_addsy == NULL) 1090 fixP->fx_addsy = abs_section_sym; 1091 symbol_mark_used_in_reloc (fixP->fx_addsy); 1092 if (fixP->fx_subsy != NULL) 1093 symbol_mark_used_in_reloc (fixP->fx_subsy); 1094 } 1095 1096 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0) 1097 { 1098 if (fixP->fx_size < sizeof (valueT)) 1099 { 1100 valueT mask; 1101 1102 mask = 0; 1103 mask--; /* Set all bits to one. */ 1104 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0); 1105 if ((add_number & mask) != 0 && (add_number & mask) != mask) 1106 { 1107 char buf[50], buf2[50]; 1108 sprint_value (buf, fragP->fr_address + fixP->fx_where); 1109 if (add_number > 1000) 1110 sprint_value (buf2, add_number); 1111 else 1112 sprintf (buf2, "%ld", (long) add_number); 1113 as_bad_where (fixP->fx_file, fixP->fx_line, 1114 ngettext ("value of %s too large for field " 1115 "of %d byte at %s", 1116 "value of %s too large for field " 1117 "of %d bytes at %s", 1118 fixP->fx_size), 1119 buf2, fixP->fx_size, buf); 1120 } /* Generic error checking. */ 1121 } 1122 #ifdef WARN_SIGNED_OVERFLOW_WORD 1123 /* Warn if a .word value is too large when treated as a signed 1124 number. We already know it is not too negative. This is to 1125 catch over-large switches generated by gcc on the 68k. */ 1126 if (!flag_signed_overflow_ok 1127 && fixP->fx_size == 2 1128 && add_number > 0x7fff) 1129 as_bad_where (fixP->fx_file, fixP->fx_line, 1130 _("signed .word overflow; switch may be too large; %ld at 0x%lx"), 1131 (long) add_number, 1132 (long) (fragP->fr_address + fixP->fx_where)); 1133 #endif 1134 } /* Not a bit fix. */ 1135 1136 #ifdef TC_VALIDATE_FIX 1137 skip: ATTRIBUTE_UNUSED_LABEL 1138 ; 1139 #endif 1140 #ifdef DEBUG5 1141 fprintf (stderr, "result:\n"); 1142 print_fixup (fixP); 1143 #endif 1144 } /* For each fixS in this segment. */ 1145 } 1146 1147 static void 1148 fix_segment (bfd *abfd ATTRIBUTE_UNUSED, 1149 asection *sec, 1150 void *xxx ATTRIBUTE_UNUSED) 1151 { 1152 segment_info_type *seginfo = seg_info (sec); 1153 1154 fixup_segment (seginfo->fix_root, sec); 1155 } 1156 1157 static void 1158 install_reloc (asection *sec, arelent *reloc, fragS *fragp, 1159 const char *file, unsigned int line) 1160 { 1161 char *err; 1162 bfd_reloc_status_type s; 1163 asymbol *sym; 1164 1165 if (reloc->sym_ptr_ptr != NULL 1166 && (sym = *reloc->sym_ptr_ptr) != NULL 1167 && (sym->flags & BSF_KEEP) == 0 1168 && ((sym->flags & BSF_SECTION_SYM) == 0 1169 || (EMIT_SECTION_SYMBOLS 1170 && !bfd_is_abs_section (sym->section)))) 1171 as_bad_where (file, line, _("redefined symbol cannot be used on reloc")); 1172 1173 s = bfd_install_relocation (stdoutput, reloc, 1174 fragp->fr_literal, fragp->fr_address, 1175 sec, &err); 1176 switch (s) 1177 { 1178 case bfd_reloc_ok: 1179 break; 1180 case bfd_reloc_overflow: 1181 as_bad_where (file, line, _("relocation overflow")); 1182 break; 1183 case bfd_reloc_outofrange: 1184 as_bad_where (file, line, _("relocation out of range")); 1185 break; 1186 default: 1187 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"), 1188 file, line, s); 1189 } 1190 } 1191 1192 static fragS * 1193 get_frag_for_reloc (fragS *last_frag, 1194 const segment_info_type *seginfo, 1195 const struct reloc_list *r) 1196 { 1197 fragS *f; 1198 1199 for (f = last_frag; f != NULL; f = f->fr_next) 1200 if (f->fr_address <= r->u.b.r.address 1201 && r->u.b.r.address < f->fr_address + f->fr_fix) 1202 return f; 1203 1204 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next) 1205 if (f->fr_address <= r->u.b.r.address 1206 && r->u.b.r.address < f->fr_address + f->fr_fix) 1207 return f; 1208 1209 for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next) 1210 if (f->fr_address <= r->u.b.r.address 1211 && r->u.b.r.address <= f->fr_address + f->fr_fix) 1212 return f; 1213 1214 as_bad_where (r->file, r->line, 1215 _("reloc not within (fixed part of) section")); 1216 return NULL; 1217 } 1218 1219 static void 1220 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 1221 { 1222 segment_info_type *seginfo = seg_info (sec); 1223 unsigned int n; 1224 struct reloc_list *my_reloc_list, **rp, *r; 1225 arelent **relocs; 1226 fixS *fixp; 1227 fragS *last_frag; 1228 1229 /* If seginfo is NULL, we did not create this section; don't do 1230 anything with it. */ 1231 if (seginfo == NULL) 1232 return; 1233 1234 n = 0; 1235 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 1236 if (!fixp->fx_done) 1237 n++; 1238 1239 #ifdef RELOC_EXPANSION_POSSIBLE 1240 n *= MAX_RELOC_EXPANSION; 1241 #endif 1242 1243 /* Extract relocs for this section from reloc_list. */ 1244 rp = &reloc_list; 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 offsetT 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_get_section_flags (abfd, sec); 1350 flags |= SEC_RELOC; 1351 bfd_set_section_flags (abfd, 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 1376 static int 1377 compress_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 1422 static void 1423 compress_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_get_section_flags (abfd, 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_get_section_name (stdoutput, 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 (abfd, 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_section_name (stdoutput, 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 1582 static void 1583 md_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 1592 static void 1593 write_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_get_section_flags (abfd, 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 sec->name, stdoutput->filename, 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), (long) count, 1653 sec->name, stdoutput->filename, 1654 bfd_errmsg (bfd_get_error ())); 1655 offset += count; 1656 free (buf); 1657 } 1658 continue; 1659 } 1660 1661 gas_assert (count >= 0); 1662 if (fill_size && count) 1663 { 1664 char buf[256]; 1665 if (fill_size > sizeof (buf)) 1666 { 1667 /* Do it the old way. Can this ever happen? */ 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); 1674 if (!x) 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, 1682 bfd_errmsg (bfd_get_error ())); 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; 1700 n_per_buf = sizeof (buf) / fill_size; 1701 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size) 1702 memcpy (bufp, fill_literal, fill_size); 1703 } 1704 for (; count > 0; count -= n_per_buf) 1705 { 1706 n_per_buf = n_per_buf > count ? count : n_per_buf; 1707 x = bfd_set_section_contents 1708 (stdoutput, sec, buf, (file_ptr) offset, 1709 (bfd_size_type) n_per_buf * fill_size); 1710 if (!x) 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, 1718 bfd_errmsg (bfd_get_error ())); 1719 offset += n_per_buf * fill_size; 1720 } 1721 } 1722 } 1723 } 1724 } 1725 1726 static void 1727 merge_data_into_text (void) 1728 { 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; 1734 } 1735 1736 static void 1737 set_symtab (void) 1738 { 1739 int nsyms; 1740 asymbol **asympp; 1741 symbolS *symp; 1742 bfd_boolean result; 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; 1754 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *); 1755 1756 asympp = (asymbol **) bfd_alloc (stdoutput, amt); 1757 symp = symbol_rootP; 1758 for (i = 0; i < nsyms; i++, symp = symbol_next (symp)) 1759 { 1760 asympp[i] = symbol_get_bfdsym (symp); 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; 1765 symbol_mark_written (symp); 1766 } 1767 } 1768 else 1769 asympp = 0; 1770 result = bfd_set_symtab (stdoutput, asympp, nsyms); 1771 gas_assert (result); 1772 symbol_table_frozen = 1; 1773 } 1774 1775 /* Finish the subsegments. After every sub-segment, we fake an 1776 ".align ...". This conforms to BSD4.2 brain-damage. We then fake 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 1782 #ifdef HANDLE_ALIGN 1783 /* The last subsegment gets an alignment corresponding to the alignment 1784 of the section. This allows proper nop-filling at the end of 1785 code-bearing sections. */ 1786 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \ 1787 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \ 1788 && !do_not_pad_sections_to_alignment \ 1789 ? get_recorded_alignment (SEG) \ 1790 : 0) 1791 #else 1792 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 1793 #endif 1794 #endif 1795 1796 static void 1797 subsegs_finish_section (asection *s) 1798 { 1799 struct frchain *frchainP; 1800 segment_info_type *seginfo = seg_info (s); 1801 if (!seginfo) 1802 return; 1803 1804 for (frchainP = seginfo->frchainP; 1805 frchainP != NULL; 1806 frchainP = frchainP->frch_next) 1807 { 1808 int alignment; 1809 1810 subseg_set (s, frchainP->frch_subseg); 1811 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. */ 1815 if (had_errors ()) 1816 do_not_pad_sections_to_alignment = 1; 1817 1818 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP); 1819 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE) 1820 && now_seg->entsize) 1821 { 1822 unsigned int entsize = now_seg->entsize; 1823 int entalign = 0; 1824 1825 while ((entsize & 1) == 0) 1826 { 1827 ++entalign; 1828 entsize >>= 1; 1829 } 1830 1831 if (entalign > alignment) 1832 alignment = entalign; 1833 } 1834 1835 if (subseg_text_p (now_seg)) 1836 frag_align_code (alignment, 0); 1837 else 1838 frag_align (alignment, 0, 0); 1839 1840 /* frag_align will have left a new frag. 1841 Use this last frag for an empty ".fill". 1842 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); 1848 } 1849 } 1850 1851 static void 1852 subsegs_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 1861 static void 1862 create_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); 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; 1879 bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA); 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 1889 #include "struc-symbol.h" 1890 1891 /* Create a relocation against an entry in a GNU Build attribute section. */ 1892 1893 static void 1894 create_note_reloc (segT sec, 1895 symbolS * sym, 1896 bfd_size_type offset, 1897 int reloc_type, 1898 bfd_vma addend, 1899 char * note) 1900 { 1901 struct reloc_list * reloc; 1902 1903 reloc = XNEW (struct reloc_list); 1904 1905 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */ 1906 reloc->u.b.sec = sec; 1907 reloc->u.b.s = sym->bsym; 1908 reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s; 1909 reloc->u.b.r.address = offset; 1910 reloc->u.b.r.addend = addend; 1911 reloc->u.b.r.howto = bfd_reloc_type_lookup (stdoutput, reloc_type); 1912 1913 if (reloc->u.b.r.howto == NULL) 1914 { 1915 as_bad (_("unable to create reloc for build note")); 1916 return; 1917 } 1918 1919 reloc->file = N_("<gnu build note>"); 1920 reloc->line = 0; 1921 1922 reloc->next = reloc_list; 1923 reloc_list = reloc; 1924 1925 /* For REL relocs, store the addend in the section. */ 1926 if (! sec->use_rela_p 1927 /* The SH target is a special case that uses RELA relocs 1928 but still stores the addend in the word being relocated. */ 1929 || strstr (bfd_get_target (stdoutput), "-sh") != NULL) 1930 { 1931 if (target_big_endian) 1932 { 1933 if (bfd_arch_bits_per_address (stdoutput) <= 32) 1934 note[offset + 3] = addend; 1935 else 1936 note[offset + 7] = addend; 1937 } 1938 else 1939 note[offset] = addend; 1940 } 1941 } 1942 1943 static void 1944 maybe_generate_build_notes (void) 1945 { 1946 segT sec; 1947 char * note; 1948 offsetT note_size; 1949 offsetT total_size; 1950 offsetT desc_size; 1951 offsetT desc2_offset; 1952 int desc_reloc; 1953 symbolS * sym; 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; 1963 bfd_set_section_flags (stdoutput, sec, 1964 SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA); 1965 bfd_set_section_alignment (stdoutput, sec, 2); 1966 1967 /* Work out the size of the notes that we will create, 1968 and the relocation we should use. */ 1969 if (bfd_arch_bits_per_address (stdoutput) <= 32) 1970 { 1971 note_size = 28; 1972 desc_size = 8; /* Two 4-byte offsets. */ 1973 desc2_offset = 24; 1974 1975 /* FIXME: The BFD backend for the CRX target does not support the 1976 BFD_RELOC_32, even though it really should. Likewise for the 1977 CR16 target. So we have special case code here... */ 1978 if (strstr (bfd_get_target (stdoutput), "-crx") != NULL) 1979 desc_reloc = BFD_RELOC_CRX_NUM32; 1980 else if (strstr (bfd_get_target (stdoutput), "-cr16") != NULL) 1981 desc_reloc = BFD_RELOC_CR16_NUM32; 1982 else 1983 desc_reloc = BFD_RELOC_32; 1984 } 1985 else 1986 { 1987 note_size = 36; 1988 desc_size = 16; /* Two 8-byte offsets. */ 1989 desc2_offset = 28; 1990 /* FIXME: The BFD backend for the IA64 target does not support the 1991 BFD_RELOC_64, even though it really should. The HPPA backend 1992 has a similar issue, although it does not support BFD_RELOCs at 1993 all! So we have special case code to handle these targets. */ 1994 if (strstr (bfd_get_target (stdoutput), "-ia64") != NULL) 1995 desc_reloc = target_big_endian ? BFD_RELOC_IA64_DIR32MSB : BFD_RELOC_IA64_DIR32LSB; 1996 else if (strstr (bfd_get_target (stdoutput), "-hppa") != NULL) 1997 desc_reloc = 80; /* R_PARISC_DIR64. */ 1998 else 1999 desc_reloc = BFD_RELOC_64; 2000 } 2001 2002 /* We have to create a note for *each* code section. 2003 Linker garbage collection might discard some. */ 2004 total_size = 0; 2005 note = NULL; 2006 2007 for (sym = symbol_rootP; sym != NULL; sym = sym->sy_next) 2008 if (sym->bsym != NULL 2009 && sym->bsym->flags & BSF_SECTION_SYM 2010 && sym->bsym->section != NULL 2011 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */ 2012 && (sym->bsym->section->flags & (SEC_CODE | SEC_LINK_ONCE)) == SEC_CODE 2013 /* Not all linkonce sections are flagged... */ 2014 && strncmp (S_GET_NAME (sym), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0) 2015 { 2016 /* Create a version note. */ 2017 frag_now_fix (); 2018 note = frag_more (note_size); 2019 memset (note, 0, note_size); 2020 2021 if (target_big_endian) 2022 { 2023 note[3] = 8; /* strlen (name) + 1. */ 2024 note[7] = desc_size; /* Two 8-byte offsets. */ 2025 note[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8; 2026 note[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff; 2027 } 2028 else 2029 { 2030 note[0] = 8; /* strlen (name) + 1. */ 2031 note[4] = desc_size; /* Two 8-byte offsets. */ 2032 note[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff; 2033 note[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8; 2034 } 2035 2036 /* The a1 version number indicates that this note was 2037 generated by the assembler and not the gcc annobin plugin. */ 2038 memcpy (note + 12, "GA$3a1", 8); 2039 2040 /* Create a relocation to install the start address of the note... */ 2041 create_note_reloc (sec, sym, total_size + 20, desc_reloc, 0, note); 2042 2043 /* ...and another one to install the end address. */ 2044 create_note_reloc (sec, sym, total_size + desc2_offset, desc_reloc, 2045 bfd_get_section_size (sym->bsym->section), 2046 note); 2047 2048 total_size += note_size; 2049 /* FIXME: Maybe add a note recording the assembler command line and version ? */ 2050 } 2051 2052 /* Install the note(s) into the section. */ 2053 if (total_size) 2054 bfd_set_section_contents (stdoutput, sec, (bfd_byte *) note, 0, total_size); 2055 subsegs_finish_section (sec); 2056 relax_segment (seg_info (sec)->frchainP->frch_root, sec, 0); 2057 size_seg (stdoutput, sec, NULL); 2058 } 2059 #endif /* OBJ_ELF */ 2060 2061 /* Write the object file. */ 2062 2063 void 2064 write_object_file (void) 2065 { 2066 struct relax_seg_info rsi; 2067 #ifndef WORKING_DOT_WORD 2068 fragS *fragP; /* Track along all frags. */ 2069 #endif 2070 2071 subsegs_finish (); 2072 2073 #ifdef md_pre_output_hook 2074 md_pre_output_hook; 2075 #endif 2076 2077 #ifdef md_pre_relax_hook 2078 md_pre_relax_hook; 2079 #endif 2080 2081 /* From now on, we don't care about sub-segments. Build one frag chain 2082 for each segment. Linked through fr_next. */ 2083 2084 /* Remove the sections created by gas for its own purposes. */ 2085 { 2086 int i; 2087 2088 bfd_section_list_remove (stdoutput, reg_section); 2089 bfd_section_list_remove (stdoutput, expr_section); 2090 stdoutput->section_count -= 2; 2091 i = 0; 2092 bfd_map_over_sections (stdoutput, renumber_sections, &i); 2093 } 2094 2095 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0); 2096 2097 /* We have two segments. If user gave -R flag, then we must put the 2098 data frags into the text segment. Do this before relaxing so 2099 we know to take advantage of -R and make shorter addresses. */ 2100 if (flag_readonly_data_in_text) 2101 { 2102 merge_data_into_text (); 2103 } 2104 2105 rsi.pass = 0; 2106 while (1) 2107 { 2108 #ifndef WORKING_DOT_WORD 2109 /* We need to reset the markers in the broken word list and 2110 associated frags between calls to relax_segment (via 2111 relax_seg). Since the broken word list is global, we do it 2112 once per round, rather than locally in relax_segment for each 2113 segment. */ 2114 struct broken_word *brokp; 2115 2116 for (brokp = broken_words; 2117 brokp != (struct broken_word *) NULL; 2118 brokp = brokp->next_broken_word) 2119 { 2120 brokp->added = 0; 2121 2122 if (brokp->dispfrag != (fragS *) NULL 2123 && brokp->dispfrag->fr_type == rs_broken_word) 2124 brokp->dispfrag->fr_subtype = 0; 2125 } 2126 #endif 2127 2128 rsi.changed = 0; 2129 bfd_map_over_sections (stdoutput, relax_seg, &rsi); 2130 rsi.pass++; 2131 if (!rsi.changed) 2132 break; 2133 } 2134 2135 /* Note - Most ports will use the default value of 2136 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force 2137 local symbols to be resolved, removing their frag information. 2138 Some ports however, will not have finished relaxing all of 2139 their frags and will still need the local symbol frag 2140 information. These ports can set 2141 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */ 2142 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG; 2143 2144 bfd_map_over_sections (stdoutput, size_seg, (char *) 0); 2145 2146 /* Relaxation has completed. Freeze all syms. */ 2147 finalize_syms = 1; 2148 2149 dwarf2dbg_final_check (); 2150 2151 #ifdef md_post_relax_hook 2152 md_post_relax_hook; 2153 #endif 2154 2155 #ifdef OBJ_ELF 2156 if (IS_ELF) 2157 create_obj_attrs_section (); 2158 #endif 2159 2160 #ifndef WORKING_DOT_WORD 2161 { 2162 struct broken_word *lie; 2163 struct broken_word **prevP; 2164 2165 prevP = &broken_words; 2166 for (lie = broken_words; lie; lie = lie->next_broken_word) 2167 if (!lie->added) 2168 { 2169 expressionS exp; 2170 2171 subseg_change (lie->seg, lie->subseg); 2172 exp.X_op = O_subtract; 2173 exp.X_add_symbol = lie->add; 2174 exp.X_op_symbol = lie->sub; 2175 exp.X_add_number = lie->addnum; 2176 #ifdef TC_CONS_FIX_NEW 2177 TC_CONS_FIX_NEW (lie->frag, 2178 lie->word_goes_here - lie->frag->fr_literal, 2179 2, &exp, TC_PARSE_CONS_RETURN_NONE); 2180 #else 2181 fix_new_exp (lie->frag, 2182 lie->word_goes_here - lie->frag->fr_literal, 2183 2, &exp, 0, BFD_RELOC_16); 2184 #endif 2185 *prevP = lie->next_broken_word; 2186 } 2187 else 2188 prevP = &(lie->next_broken_word); 2189 2190 for (lie = broken_words; lie;) 2191 { 2192 struct broken_word *untruth; 2193 char *table_ptr; 2194 addressT table_addr; 2195 addressT from_addr, to_addr; 2196 int n, m; 2197 2198 subseg_change (lie->seg, lie->subseg); 2199 fragP = lie->dispfrag; 2200 2201 /* Find out how many broken_words go here. */ 2202 n = 0; 2203 for (untruth = lie; 2204 untruth && untruth->dispfrag == fragP; 2205 untruth = untruth->next_broken_word) 2206 if (untruth->added == 1) 2207 n++; 2208 2209 table_ptr = lie->dispfrag->fr_opcode; 2210 table_addr = (lie->dispfrag->fr_address 2211 + (table_ptr - lie->dispfrag->fr_literal)); 2212 /* Create the jump around the long jumps. This is a short 2213 jump from table_ptr+0 to table_ptr+n*long_jump_size. */ 2214 from_addr = table_addr; 2215 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size; 2216 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2217 lie->add); 2218 table_ptr += md_short_jump_size; 2219 table_addr += md_short_jump_size; 2220 2221 for (m = 0; 2222 lie && lie->dispfrag == fragP; 2223 m++, lie = lie->next_broken_word) 2224 { 2225 if (lie->added == 2) 2226 continue; 2227 /* Patch the jump table. */ 2228 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2229 untruth && untruth->dispfrag == fragP; 2230 untruth = untruth->next_broken_word) 2231 { 2232 if (untruth->use_jump == lie) 2233 { 2234 /* This is the offset from ??? to table_ptr+0. 2235 The target is the same for all users of this 2236 md_long_jump, but the "sub" bases (and hence the 2237 offsets) may be different. */ 2238 addressT to_word = table_addr - S_GET_VALUE (untruth->sub); 2239 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD 2240 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth); 2241 #endif 2242 md_number_to_chars (untruth->word_goes_here, to_word, 2); 2243 } 2244 } 2245 2246 /* Install the long jump. */ 2247 /* This is a long jump from table_ptr+0 to the final target. */ 2248 from_addr = table_addr; 2249 to_addr = S_GET_VALUE (lie->add) + lie->addnum; 2250 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2251 lie->add); 2252 table_ptr += md_long_jump_size; 2253 table_addr += md_long_jump_size; 2254 } 2255 } 2256 } 2257 #endif /* not WORKING_DOT_WORD */ 2258 2259 /* Resolve symbol values. This needs to be done before processing 2260 the relocations. */ 2261 if (symbol_rootP) 2262 { 2263 symbolS *symp; 2264 2265 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2266 resolve_symbol_value (symp); 2267 } 2268 resolve_local_symbol_values (); 2269 resolve_reloc_expr_symbols (); 2270 2271 #ifdef OBJ_ELF 2272 if (IS_ELF) 2273 maybe_generate_build_notes (); 2274 #endif 2275 2276 PROGRESS (1); 2277 2278 #ifdef tc_frob_file_before_adjust 2279 tc_frob_file_before_adjust (); 2280 #endif 2281 #ifdef obj_frob_file_before_adjust 2282 obj_frob_file_before_adjust (); 2283 #endif 2284 2285 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0); 2286 2287 #ifdef tc_frob_file_before_fix 2288 tc_frob_file_before_fix (); 2289 #endif 2290 #ifdef obj_frob_file_before_fix 2291 obj_frob_file_before_fix (); 2292 #endif 2293 2294 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0); 2295 2296 /* Set up symbol table, and write it out. */ 2297 if (symbol_rootP) 2298 { 2299 symbolS *symp; 2300 bfd_boolean skip_next_symbol = FALSE; 2301 2302 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2303 { 2304 int punt = 0; 2305 const char *name; 2306 2307 if (skip_next_symbol) 2308 { 2309 /* Don't do anything besides moving the value of the 2310 symbol from the GAS value-field to the BFD value-field. */ 2311 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2312 skip_next_symbol = FALSE; 2313 continue; 2314 } 2315 2316 if (symbol_mri_common_p (symp)) 2317 { 2318 if (S_IS_EXTERNAL (symp)) 2319 as_bad (_("%s: global symbols not supported in common sections"), 2320 S_GET_NAME (symp)); 2321 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2322 continue; 2323 } 2324 2325 name = S_GET_NAME (symp); 2326 if (name) 2327 { 2328 const char *name2 = 2329 decode_local_label_name ((char *) S_GET_NAME (symp)); 2330 /* They only differ if `name' is a fb or dollar local 2331 label name. */ 2332 if (name2 != name && ! S_IS_DEFINED (symp)) 2333 as_bad (_("local label `%s' is not defined"), name2); 2334 } 2335 2336 /* Do it again, because adjust_reloc_syms might introduce 2337 more symbols. They'll probably only be section symbols, 2338 but they'll still need to have the values computed. */ 2339 resolve_symbol_value (symp); 2340 2341 /* Skip symbols which were equated to undefined or common 2342 symbols. */ 2343 if (symbol_equated_reloc_p (symp) 2344 || S_IS_WEAKREFR (symp)) 2345 { 2346 const char *sname = S_GET_NAME (symp); 2347 2348 if (S_IS_COMMON (symp) 2349 && !TC_FAKE_LABEL (sname) 2350 && !S_IS_WEAKREFR (symp)) 2351 { 2352 expressionS *e = symbol_get_value_expression (symp); 2353 2354 as_bad (_("`%s' can't be equated to common symbol `%s'"), 2355 sname, S_GET_NAME (e->X_add_symbol)); 2356 } 2357 if (S_GET_SEGMENT (symp) == reg_section) 2358 { 2359 /* Report error only if we know the symbol name. */ 2360 if (S_GET_NAME (symp) != reg_section->name) 2361 as_bad (_("can't make global register symbol `%s'"), 2362 sname); 2363 } 2364 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2365 continue; 2366 } 2367 2368 #ifdef obj_frob_symbol 2369 obj_frob_symbol (symp, punt); 2370 #endif 2371 #ifdef tc_frob_symbol 2372 if (! punt || symbol_used_in_reloc_p (symp)) 2373 tc_frob_symbol (symp, punt); 2374 #endif 2375 2376 /* If we don't want to keep this symbol, splice it out of 2377 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never 2378 want section symbols. Otherwise, we skip local symbols 2379 and symbols that the frob_symbol macros told us to punt, 2380 but we keep such symbols if they are used in relocs. */ 2381 if (symp == abs_section_sym 2382 || (! EMIT_SECTION_SYMBOLS 2383 && symbol_section_p (symp)) 2384 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always 2385 opposites. Sometimes the former checks flags and the 2386 latter examines the name... */ 2387 || (!S_IS_EXTERNAL (symp) 2388 && (punt || S_IS_LOCAL (symp) || 2389 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp))) 2390 && ! symbol_used_in_reloc_p (symp))) 2391 { 2392 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2393 2394 /* After symbol_remove, symbol_next(symp) still returns 2395 the one that came after it in the chain. So we don't 2396 need to do any extra cleanup work here. */ 2397 continue; 2398 } 2399 2400 /* Make sure we really got a value for the symbol. */ 2401 if (! symbol_resolved_p (symp)) 2402 { 2403 as_bad (_("can't resolve value for symbol `%s'"), 2404 S_GET_NAME (symp)); 2405 symbol_mark_resolved (symp); 2406 } 2407 2408 /* Set the value into the BFD symbol. Up til now the value 2409 has only been kept in the gas symbolS struct. */ 2410 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2411 2412 /* A warning construct is a warning symbol followed by the 2413 symbol warned about. Don't let anything object-format or 2414 target-specific muck with it; it's ready for output. */ 2415 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING) 2416 skip_next_symbol = TRUE; 2417 } 2418 } 2419 2420 PROGRESS (1); 2421 2422 /* Now do any format-specific adjustments to the symbol table, such 2423 as adding file symbols. */ 2424 #ifdef tc_adjust_symtab 2425 tc_adjust_symtab (); 2426 #endif 2427 #ifdef obj_adjust_symtab 2428 obj_adjust_symtab (); 2429 #endif 2430 2431 /* Stop if there is an error. */ 2432 if (had_errors ()) 2433 return; 2434 2435 /* Now that all the sizes are known, and contents correct, we can 2436 start writing to the file. */ 2437 set_symtab (); 2438 2439 /* If *_frob_file changes the symbol value at this point, it is 2440 responsible for moving the changed value into symp->bsym->value 2441 as well. Hopefully all symbol value changing can be done in 2442 *_frob_symbol. */ 2443 #ifdef tc_frob_file 2444 tc_frob_file (); 2445 #endif 2446 #ifdef obj_frob_file 2447 obj_frob_file (); 2448 #endif 2449 #ifdef obj_coff_generate_pdata 2450 obj_coff_generate_pdata (); 2451 #endif 2452 2453 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0); 2454 2455 #ifdef tc_frob_file_after_relocs 2456 tc_frob_file_after_relocs (); 2457 #endif 2458 #ifdef obj_frob_file_after_relocs 2459 obj_frob_file_after_relocs (); 2460 #endif 2461 2462 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF 2463 if (IS_ELF && flag_use_elf_stt_common) 2464 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON; 2465 #endif 2466 2467 /* Once all relocations have been written, we can compress the 2468 contents of the debug sections. This needs to be done before 2469 we start writing any sections, because it will affect the file 2470 layout, which is fixed once we start writing contents. */ 2471 if (flag_compress_debug) 2472 { 2473 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB) 2474 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI; 2475 else 2476 stdoutput->flags |= BFD_COMPRESS; 2477 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0); 2478 } 2479 2480 bfd_map_over_sections (stdoutput, write_contents, (char *) 0); 2481 } 2482 2483 #ifdef TC_GENERIC_RELAX_TABLE 2484 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ 2485 2486 long 2487 relax_frag (segT segment, fragS *fragP, long stretch) 2488 { 2489 const relax_typeS *this_type; 2490 const relax_typeS *start_type; 2491 relax_substateT next_state; 2492 relax_substateT this_state; 2493 offsetT growth; 2494 offsetT aim; 2495 addressT target; 2496 addressT address; 2497 symbolS *symbolP; 2498 const relax_typeS *table; 2499 2500 target = fragP->fr_offset; 2501 address = fragP->fr_address; 2502 table = TC_GENERIC_RELAX_TABLE; 2503 this_state = fragP->fr_subtype; 2504 start_type = this_type = table + this_state; 2505 symbolP = fragP->fr_symbol; 2506 2507 if (symbolP) 2508 { 2509 fragS *sym_frag; 2510 2511 sym_frag = symbol_get_frag (symbolP); 2512 2513 #ifndef DIFF_EXPR_OK 2514 know (sym_frag != NULL); 2515 #endif 2516 know (S_GET_SEGMENT (symbolP) != absolute_section 2517 || sym_frag == &zero_address_frag); 2518 target += S_GET_VALUE (symbolP); 2519 2520 /* If SYM_FRAG has yet to be reached on this pass, assume it 2521 will move by STRETCH just as we did, unless there is an 2522 alignment frag between here and SYM_FRAG. An alignment may 2523 well absorb any STRETCH, and we don't want to choose a larger 2524 branch insn by overestimating the needed reach of this 2525 branch. It isn't critical to calculate TARGET exactly; We 2526 know we'll be doing another pass if STRETCH is non-zero. */ 2527 2528 if (stretch != 0 2529 && sym_frag->relax_marker != fragP->relax_marker 2530 && S_GET_SEGMENT (symbolP) == segment) 2531 { 2532 if (stretch < 0 2533 || sym_frag->region == fragP->region) 2534 target += stretch; 2535 /* If we get here we know we have a forward branch. This 2536 relax pass may have stretched previous instructions so 2537 far that omitting STRETCH would make the branch 2538 negative. Don't allow this in case the negative reach is 2539 large enough to require a larger branch instruction. */ 2540 else if (target < address) 2541 target = fragP->fr_next->fr_address + stretch; 2542 } 2543 } 2544 2545 aim = target - address - fragP->fr_fix; 2546 #ifdef TC_PCREL_ADJUST 2547 /* Currently only the ns32k family needs this. */ 2548 aim += TC_PCREL_ADJUST (fragP); 2549 #endif 2550 2551 #ifdef md_prepare_relax_scan 2552 /* Formerly called M68K_AIM_KLUDGE. */ 2553 md_prepare_relax_scan (fragP, address, aim, this_state, this_type); 2554 #endif 2555 2556 if (aim < 0) 2557 { 2558 /* Look backwards. */ 2559 for (next_state = this_type->rlx_more; next_state;) 2560 if (aim >= this_type->rlx_backward) 2561 next_state = 0; 2562 else 2563 { 2564 /* Grow to next state. */ 2565 this_state = next_state; 2566 this_type = table + this_state; 2567 next_state = this_type->rlx_more; 2568 } 2569 } 2570 else 2571 { 2572 /* Look forwards. */ 2573 for (next_state = this_type->rlx_more; next_state;) 2574 if (aim <= this_type->rlx_forward) 2575 next_state = 0; 2576 else 2577 { 2578 /* Grow to next state. */ 2579 this_state = next_state; 2580 this_type = table + this_state; 2581 next_state = this_type->rlx_more; 2582 } 2583 } 2584 2585 growth = this_type->rlx_length - start_type->rlx_length; 2586 if (growth != 0) 2587 fragP->fr_subtype = this_state; 2588 return growth; 2589 } 2590 2591 #endif /* defined (TC_GENERIC_RELAX_TABLE) */ 2592 2593 /* Relax_align. Advance location counter to next address that has 'alignment' 2594 lowest order bits all 0s, return size of adjustment made. */ 2595 static relax_addressT 2596 relax_align (relax_addressT address, /* Address now. */ 2597 int alignment /* Alignment (binary). */) 2598 { 2599 relax_addressT mask; 2600 relax_addressT new_address; 2601 2602 mask = ~((relax_addressT) ~0 << alignment); 2603 new_address = (address + mask) & (~mask); 2604 #ifdef LINKER_RELAXING_SHRINKS_ONLY 2605 if (linkrelax) 2606 /* We must provide lots of padding, so the linker can discard it 2607 when needed. The linker will not add extra space, ever. */ 2608 new_address += (1 << alignment); 2609 #endif 2610 return (new_address - address); 2611 } 2612 2613 /* Now we have a segment, not a crowd of sub-segments, we can make 2614 fr_address values. 2615 2616 Relax the frags. 2617 2618 After this, all frags in this segment have addresses that are correct 2619 within the segment. Since segments live in different file addresses, 2620 these frag addresses may not be the same as final object-file 2621 addresses. */ 2622 2623 int 2624 relax_segment (struct frag *segment_frag_root, segT segment, int pass) 2625 { 2626 unsigned long frag_count; 2627 struct frag *fragP; 2628 relax_addressT address; 2629 int region; 2630 int ret; 2631 2632 /* In case md_estimate_size_before_relax() wants to make fixSs. */ 2633 subseg_change (segment, 0); 2634 2635 /* For each frag in segment: count and store (a 1st guess of) 2636 fr_address. */ 2637 address = 0; 2638 region = 0; 2639 for (frag_count = 0, fragP = segment_frag_root; 2640 fragP; 2641 fragP = fragP->fr_next, frag_count ++) 2642 { 2643 fragP->region = region; 2644 fragP->relax_marker = 0; 2645 fragP->fr_address = address; 2646 address += fragP->fr_fix; 2647 2648 switch (fragP->fr_type) 2649 { 2650 case rs_fill: 2651 address += fragP->fr_offset * fragP->fr_var; 2652 break; 2653 2654 case rs_align: 2655 case rs_align_code: 2656 case rs_align_test: 2657 { 2658 addressT offset = relax_align (address, (int) fragP->fr_offset); 2659 2660 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) 2661 offset = 0; 2662 2663 if (offset % fragP->fr_var != 0) 2664 { 2665 as_bad_where (fragP->fr_file, fragP->fr_line, 2666 ngettext ("alignment padding (%lu byte) " 2667 "not a multiple of %ld", 2668 "alignment padding (%lu bytes) " 2669 "not a multiple of %ld", 2670 (unsigned long) offset), 2671 (unsigned long) offset, (long) fragP->fr_var); 2672 offset -= (offset % fragP->fr_var); 2673 } 2674 2675 address += offset; 2676 region += 1; 2677 } 2678 break; 2679 2680 case rs_org: 2681 /* Assume .org is nugatory. It will grow with 1st relax. */ 2682 region += 1; 2683 break; 2684 2685 case rs_space: 2686 case rs_space_nop: 2687 break; 2688 2689 case rs_machine_dependent: 2690 /* If fr_symbol is an expression, this call to 2691 resolve_symbol_value sets up the correct segment, which will 2692 likely be needed in md_estimate_size_before_relax. */ 2693 if (fragP->fr_symbol) 2694 resolve_symbol_value (fragP->fr_symbol); 2695 2696 address += md_estimate_size_before_relax (fragP, segment); 2697 break; 2698 2699 #ifndef WORKING_DOT_WORD 2700 /* Broken words don't concern us yet. */ 2701 case rs_broken_word: 2702 break; 2703 #endif 2704 2705 case rs_leb128: 2706 /* Initial guess is always 1; doing otherwise can result in 2707 stable solutions that are larger than the minimum. */ 2708 address += fragP->fr_offset = 1; 2709 break; 2710 2711 case rs_cfa: 2712 address += eh_frame_estimate_size_before_relax (fragP); 2713 break; 2714 2715 case rs_dwarf2dbg: 2716 address += dwarf2dbg_estimate_size_before_relax (fragP); 2717 break; 2718 2719 default: 2720 BAD_CASE (fragP->fr_type); 2721 break; 2722 } 2723 } 2724 2725 /* Do relax(). */ 2726 { 2727 unsigned long max_iterations; 2728 2729 /* Cumulative address adjustment. */ 2730 offsetT stretch; 2731 2732 /* Have we made any adjustment this pass? We can't just test 2733 stretch because one piece of code may have grown and another 2734 shrank. */ 2735 int stretched; 2736 2737 /* Most horrible, but gcc may give us some exception data that 2738 is impossible to assemble, of the form 2739 2740 .align 4 2741 .byte 0, 0 2742 .uleb128 end - start 2743 start: 2744 .space 128*128 - 1 2745 .align 4 2746 end: 2747 2748 If the leb128 is two bytes in size, then end-start is 128*128, 2749 which requires a three byte leb128. If the leb128 is three 2750 bytes in size, then end-start is 128*128-1, which requires a 2751 two byte leb128. We work around this dilemma by inserting 2752 an extra 4 bytes of alignment just after the .align. This 2753 works because the data after the align is accessed relative to 2754 the end label. 2755 2756 This counter is used in a tiny state machine to detect 2757 whether a leb128 followed by an align is impossible to 2758 relax. */ 2759 int rs_leb128_fudge = 0; 2760 2761 /* We want to prevent going into an infinite loop where one frag grows 2762 depending upon the location of a symbol which is in turn moved by 2763 the growing frag. eg: 2764 2765 foo = . 2766 .org foo+16 2767 foo = . 2768 2769 So we dictate that this algorithm can be at most O2. */ 2770 max_iterations = frag_count * frag_count; 2771 /* Check for overflow. */ 2772 if (max_iterations < frag_count) 2773 max_iterations = frag_count; 2774 2775 ret = 0; 2776 do 2777 { 2778 stretch = 0; 2779 stretched = 0; 2780 2781 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2782 { 2783 offsetT growth = 0; 2784 addressT was_address; 2785 offsetT offset; 2786 symbolS *symbolP; 2787 2788 fragP->relax_marker ^= 1; 2789 was_address = fragP->fr_address; 2790 address = fragP->fr_address += stretch; 2791 symbolP = fragP->fr_symbol; 2792 offset = fragP->fr_offset; 2793 2794 switch (fragP->fr_type) 2795 { 2796 case rs_fill: /* .fill never relaxes. */ 2797 growth = 0; 2798 break; 2799 2800 #ifndef WORKING_DOT_WORD 2801 /* JF: This is RMS's idea. I do *NOT* want to be blamed 2802 for it I do not want to write it. I do not want to have 2803 anything to do with it. This is not the proper way to 2804 implement this misfeature. */ 2805 case rs_broken_word: 2806 { 2807 struct broken_word *lie; 2808 struct broken_word *untruth; 2809 2810 /* Yes this is ugly (storing the broken_word pointer 2811 in the symbol slot). Still, this whole chunk of 2812 code is ugly, and I don't feel like doing anything 2813 about it. Think of it as stubbornness in action. */ 2814 growth = 0; 2815 for (lie = (struct broken_word *) (fragP->fr_symbol); 2816 lie && lie->dispfrag == fragP; 2817 lie = lie->next_broken_word) 2818 { 2819 2820 if (lie->added) 2821 continue; 2822 2823 offset = (S_GET_VALUE (lie->add) 2824 + lie->addnum 2825 - S_GET_VALUE (lie->sub)); 2826 if (offset <= -32768 || offset >= 32767) 2827 { 2828 if (flag_warn_displacement) 2829 { 2830 char buf[50]; 2831 sprint_value (buf, (addressT) lie->addnum); 2832 as_warn_where (fragP->fr_file, fragP->fr_line, 2833 _(".word %s-%s+%s didn't fit"), 2834 S_GET_NAME (lie->add), 2835 S_GET_NAME (lie->sub), 2836 buf); 2837 } 2838 if (fragP->fr_subtype == 0) 2839 { 2840 fragP->fr_subtype++; 2841 growth += md_short_jump_size; 2842 } 2843 2844 /* Redirect *all* words of this table with the same 2845 target, lest we have to handle the case where the 2846 same target but with a offset that fits on this 2847 round overflows at the next relaxation round. */ 2848 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2849 untruth && untruth->dispfrag == lie->dispfrag; 2850 untruth = untruth->next_broken_word) 2851 if ((symbol_get_frag (untruth->add) 2852 == symbol_get_frag (lie->add)) 2853 && (S_GET_VALUE (untruth->add) 2854 == S_GET_VALUE (lie->add))) 2855 { 2856 untruth->added = 2; 2857 untruth->use_jump = lie; 2858 } 2859 2860 lie->added = 1; 2861 growth += md_long_jump_size; 2862 } 2863 } 2864 2865 break; 2866 } /* case rs_broken_word */ 2867 #endif 2868 case rs_align: 2869 case rs_align_code: 2870 case rs_align_test: 2871 { 2872 addressT oldoff, newoff; 2873 2874 oldoff = relax_align (was_address + fragP->fr_fix, 2875 (int) offset); 2876 newoff = relax_align (address + fragP->fr_fix, 2877 (int) offset); 2878 2879 if (fragP->fr_subtype != 0) 2880 { 2881 if (oldoff > fragP->fr_subtype) 2882 oldoff = 0; 2883 if (newoff > fragP->fr_subtype) 2884 newoff = 0; 2885 } 2886 2887 growth = newoff - oldoff; 2888 2889 /* If this align happens to follow a leb128 and 2890 we have determined that the leb128 is bouncing 2891 in size, then break the cycle by inserting an 2892 extra alignment. */ 2893 if (growth < 0 2894 && (rs_leb128_fudge & 16) != 0 2895 && (rs_leb128_fudge & 15) >= 2) 2896 { 2897 segment_info_type *seginfo = seg_info (segment); 2898 struct obstack *ob = &seginfo->frchainP->frch_obstack; 2899 struct frag *newf; 2900 2901 newf = frag_alloc (ob); 2902 obstack_blank_fast (ob, fragP->fr_var); 2903 obstack_finish (ob); 2904 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG); 2905 memcpy (newf->fr_literal, 2906 fragP->fr_literal + fragP->fr_fix, 2907 fragP->fr_var); 2908 newf->fr_type = rs_fill; 2909 newf->fr_address = address + fragP->fr_fix + newoff; 2910 newf->fr_fix = 0; 2911 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset) 2912 / fragP->fr_var); 2913 if (newf->fr_offset * newf->fr_var 2914 != (offsetT) 1 << fragP->fr_offset) 2915 { 2916 newf->fr_offset = (offsetT) 1 << fragP->fr_offset; 2917 newf->fr_var = 1; 2918 } 2919 /* Include size of new frag in GROWTH. */ 2920 growth += newf->fr_offset * newf->fr_var; 2921 /* Adjust the new frag address for the amount 2922 we'll add when we process the new frag. */ 2923 newf->fr_address -= stretch + growth; 2924 newf->relax_marker ^= 1; 2925 fragP->fr_next = newf; 2926 #ifdef DEBUG 2927 as_warn (_("padding added")); 2928 #endif 2929 } 2930 } 2931 break; 2932 2933 case rs_org: 2934 { 2935 addressT target = offset; 2936 addressT after; 2937 2938 if (symbolP) 2939 { 2940 /* Convert from an actual address to an octet offset 2941 into the section. Here it is assumed that the 2942 section's VMA is zero, and can omit subtracting it 2943 from the symbol's value to get the address offset. */ 2944 know (S_GET_SEGMENT (symbolP)->vma == 0); 2945 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE; 2946 } 2947 2948 know (fragP->fr_next); 2949 after = fragP->fr_next->fr_address + stretch; 2950 growth = target - after; 2951 2952 /* Growth may be negative, but variable part of frag 2953 cannot have fewer than 0 chars. That is, we can't 2954 .org backwards. */ 2955 if (address + fragP->fr_fix > target) 2956 { 2957 growth = 0; 2958 2959 /* Don't error on first few frag relax passes. 2960 The symbol might be an expression involving 2961 symbol values from other sections. If those 2962 sections have not yet been processed their 2963 frags will all have zero addresses, so we 2964 will calculate incorrect values for them. The 2965 number of passes we allow before giving an 2966 error is somewhat arbitrary. It should be at 2967 least one, with larger values requiring 2968 increasingly contrived dependencies between 2969 frags to trigger a false error. */ 2970 if (pass < 2) 2971 { 2972 /* Force another pass. */ 2973 ret = 1; 2974 break; 2975 } 2976 2977 as_bad_where (fragP->fr_file, fragP->fr_line, 2978 _("attempt to move .org backwards")); 2979 2980 /* We've issued an error message. Change the 2981 frag to avoid cascading errors. */ 2982 fragP->fr_type = rs_align; 2983 fragP->fr_subtype = 0; 2984 fragP->fr_offset = 0; 2985 fragP->fr_fix = after - address; 2986 } 2987 } 2988 break; 2989 2990 case rs_space: 2991 case rs_space_nop: 2992 growth = 0; 2993 if (symbolP) 2994 { 2995 offsetT amount; 2996 2997 amount = S_GET_VALUE (symbolP); 2998 if (S_GET_SEGMENT (symbolP) != absolute_section 2999 || S_IS_COMMON (symbolP) 3000 || ! S_IS_DEFINED (symbolP)) 3001 { 3002 as_bad_where (fragP->fr_file, fragP->fr_line, 3003 _(".space specifies non-absolute value")); 3004 /* Prevent repeat of this error message. */ 3005 fragP->fr_symbol = 0; 3006 } 3007 else if (amount < 0) 3008 { 3009 /* Don't error on first few frag relax passes. 3010 See rs_org comment for a longer explanation. */ 3011 if (pass < 2) 3012 { 3013 ret = 1; 3014 break; 3015 } 3016 3017 as_warn_where (fragP->fr_file, fragP->fr_line, 3018 _(".space, .nops or .fill with negative value, ignored")); 3019 fragP->fr_symbol = 0; 3020 } 3021 else 3022 growth = (was_address + fragP->fr_fix + amount 3023 - fragP->fr_next->fr_address); 3024 } 3025 break; 3026 3027 case rs_machine_dependent: 3028 #ifdef md_relax_frag 3029 growth = md_relax_frag (segment, fragP, stretch); 3030 #else 3031 #ifdef TC_GENERIC_RELAX_TABLE 3032 /* The default way to relax a frag is to look through 3033 TC_GENERIC_RELAX_TABLE. */ 3034 growth = relax_frag (segment, fragP, stretch); 3035 #endif /* TC_GENERIC_RELAX_TABLE */ 3036 #endif 3037 break; 3038 3039 case rs_leb128: 3040 { 3041 valueT value; 3042 offsetT size; 3043 3044 value = resolve_symbol_value (fragP->fr_symbol); 3045 size = sizeof_leb128 (value, fragP->fr_subtype); 3046 growth = size - fragP->fr_offset; 3047 fragP->fr_offset = size; 3048 } 3049 break; 3050 3051 case rs_cfa: 3052 growth = eh_frame_relax_frag (fragP); 3053 break; 3054 3055 case rs_dwarf2dbg: 3056 growth = dwarf2dbg_relax_frag (fragP); 3057 break; 3058 3059 default: 3060 BAD_CASE (fragP->fr_type); 3061 break; 3062 } 3063 if (growth) 3064 { 3065 stretch += growth; 3066 stretched = 1; 3067 if (fragP->fr_type == rs_leb128) 3068 rs_leb128_fudge += 16; 3069 else if (fragP->fr_type == rs_align 3070 && (rs_leb128_fudge & 16) != 0 3071 && stretch == 0) 3072 rs_leb128_fudge += 16; 3073 else 3074 rs_leb128_fudge = 0; 3075 } 3076 } 3077 3078 if (stretch == 0 3079 && (rs_leb128_fudge & 16) == 0 3080 && (rs_leb128_fudge & -16) != 0) 3081 rs_leb128_fudge += 1; 3082 else 3083 rs_leb128_fudge = 0; 3084 } 3085 /* Until nothing further to relax. */ 3086 while (stretched && -- max_iterations); 3087 3088 if (stretched) 3089 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"), 3090 segment_name (segment)); 3091 } 3092 3093 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 3094 if (fragP->last_fr_address != fragP->fr_address) 3095 { 3096 fragP->last_fr_address = fragP->fr_address; 3097 ret = 1; 3098 } 3099 return ret; 3100 } 3101 3102 void 3103 number_to_chars_bigendian (char *buf, valueT val, int n) 3104 { 3105 if (n <= 0) 3106 abort (); 3107 while (n--) 3108 { 3109 buf[n] = val & 0xff; 3110 val >>= 8; 3111 } 3112 } 3113 3114 void 3115 number_to_chars_littleendian (char *buf, valueT val, int n) 3116 { 3117 if (n <= 0) 3118 abort (); 3119 while (n--) 3120 { 3121 *buf++ = val & 0xff; 3122 val >>= 8; 3123 } 3124 } 3125 3126 void 3127 write_print_statistics (FILE *file) 3128 { 3129 fprintf (file, "fixups: %d\n", n_fixups); 3130 } 3131 3132 /* For debugging. */ 3133 extern int indent_level; 3134 3135 void 3136 print_fixup (fixS *fixp) 3137 { 3138 indent_level = 1; 3139 fprintf (stderr, "fix "); 3140 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp)); 3141 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line); 3142 if (fixp->fx_pcrel) 3143 fprintf (stderr, " pcrel"); 3144 if (fixp->fx_pcrel_adjust) 3145 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust); 3146 if (fixp->fx_im_disp) 3147 { 3148 #ifdef TC_NS32K 3149 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp); 3150 #else 3151 fprintf (stderr, " im_disp"); 3152 #endif 3153 } 3154 if (fixp->fx_tcbit) 3155 fprintf (stderr, " tcbit"); 3156 if (fixp->fx_done) 3157 fprintf (stderr, " done"); 3158 fprintf (stderr, "\n size=%d frag=", fixp->fx_size); 3159 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag)); 3160 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx", 3161 (long) fixp->fx_where, 3162 (unsigned long) fixp->fx_offset, 3163 (unsigned long) fixp->fx_addnumber); 3164 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), 3165 fixp->fx_r_type); 3166 if (fixp->fx_addsy) 3167 { 3168 fprintf (stderr, "\n +<"); 3169 print_symbol_value_1 (stderr, fixp->fx_addsy); 3170 fprintf (stderr, ">"); 3171 } 3172 if (fixp->fx_subsy) 3173 { 3174 fprintf (stderr, "\n -<"); 3175 print_symbol_value_1 (stderr, fixp->fx_subsy); 3176 fprintf (stderr, ">"); 3177 } 3178 fprintf (stderr, "\n"); 3179 #ifdef TC_FIX_DATA_PRINT 3180 TC_FIX_DATA_PRINT (stderr, fixp); 3181 #endif 3182 } 3183