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. */ 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 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 228 fixS * 229 fix_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 245 fixS * 246 fix_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 313 fixS * 314 fix_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. */ 322 int 323 generic_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. */ 336 void 337 append (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 352 void 353 record_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 366 int 367 get_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 377 static void 378 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg) 379 { 380 int *countp = (int *) countparg; 381 382 sec->index = *countp; 383 ++*countp; 384 } 385 386 static fragS * 387 chain_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 412 static void 413 chain_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 431 static void 432 cvt_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 540 struct relax_seg_info 541 { 542 int pass; 543 int changed; 544 }; 545 546 static void 547 relax_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 557 static void 558 size_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 633 static void 634 dump_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. */ 670 static void 671 resolve_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 777 static void 778 adjust_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 914 static void 915 fixup_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 1145 static void 1146 fix_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 1155 static void 1156 install_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 1190 static fragS * 1191 get_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 1217 static void 1218 write_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 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_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 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_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 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_section_flags (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 (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 /* Create a relocation against an entry in a GNU Build attribute section. */ 1890 1891 static void 1892 create_note_reloc (segT sec, 1893 symbolS * sym, 1894 bfd_size_type note_offset, 1895 bfd_size_type desc2_offset, 1896 int reloc_type, 1897 bfd_vma addend, 1898 char * note) 1899 { 1900 struct reloc_list * reloc; 1901 1902 reloc = XNEW (struct reloc_list); 1903 1904 /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called. */ 1905 reloc->u.b.sec = sec; 1906 reloc->u.b.s = symbol_get_bfdsym (sym); 1907 reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s; 1908 reloc->u.b.r.address = note_offset + desc2_offset; 1909 reloc->u.b.r.addend = addend; 1910 reloc->u.b.r.howto = bfd_reloc_type_lookup (stdoutput, reloc_type); 1911 1912 if (reloc->u.b.r.howto == NULL) 1913 { 1914 as_bad (_("unable to create reloc for build note")); 1915 return; 1916 } 1917 1918 reloc->file = N_("<gnu build note>"); 1919 reloc->line = 0; 1920 1921 reloc->next = reloc_list; 1922 reloc_list = reloc; 1923 1924 /* For REL relocs, store the addend in the section. */ 1925 if (! sec->use_rela_p 1926 /* The SH target is a special case that uses RELA relocs 1927 but still stores the addend in the word being relocated. */ 1928 || strstr (bfd_get_target (stdoutput), "-sh") != NULL) 1929 { 1930 if (target_big_endian) 1931 { 1932 if (bfd_arch_bits_per_address (stdoutput) <= 32) 1933 note[desc2_offset + 3] = addend; 1934 else 1935 note[desc2_offset + 7] = addend; 1936 } 1937 else 1938 note[desc2_offset] = addend; 1939 } 1940 } 1941 1942 static void 1943 maybe_generate_build_notes (void) 1944 { 1945 segT sec; 1946 char * note; 1947 offsetT note_size; 1948 offsetT total_size; 1949 offsetT desc_size; 1950 offsetT desc2_offset; 1951 int desc_reloc; 1952 symbolS * sym; 1953 asymbol * bsym; 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 (sec, (SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA 1964 | SEC_OCTETS)); 1965 bfd_set_section_alignment (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 = symbol_next (sym)) 2008 if ((bsym = symbol_get_bfdsym (sym)) != NULL 2009 && bsym->flags & BSF_SECTION_SYM 2010 && bsym->section != NULL 2011 /* Skip linkonce sections - we cannot use these section symbols as they may disappear. */ 2012 && (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_section_size (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 #ifndef md_generic_table_relax_frag 2485 #define md_generic_table_relax_frag relax_frag 2486 #endif 2487 2488 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ 2489 2490 long 2491 relax_frag (segT segment, fragS *fragP, long stretch) 2492 { 2493 const relax_typeS *this_type; 2494 const relax_typeS *start_type; 2495 relax_substateT next_state; 2496 relax_substateT this_state; 2497 offsetT growth; 2498 offsetT aim; 2499 addressT target; 2500 addressT address; 2501 symbolS *symbolP; 2502 const relax_typeS *table; 2503 2504 target = fragP->fr_offset; 2505 address = fragP->fr_address + fragP->fr_fix; 2506 table = TC_GENERIC_RELAX_TABLE; 2507 this_state = fragP->fr_subtype; 2508 start_type = this_type = table + this_state; 2509 symbolP = fragP->fr_symbol; 2510 2511 if (symbolP) 2512 { 2513 fragS *sym_frag; 2514 2515 sym_frag = symbol_get_frag (symbolP); 2516 2517 #ifndef DIFF_EXPR_OK 2518 know (sym_frag != NULL); 2519 #endif 2520 know (S_GET_SEGMENT (symbolP) != absolute_section 2521 || sym_frag == &zero_address_frag); 2522 target += S_GET_VALUE (symbolP); 2523 2524 /* If SYM_FRAG has yet to be reached on this pass, assume it 2525 will move by STRETCH just as we did, unless there is an 2526 alignment frag between here and SYM_FRAG. An alignment may 2527 well absorb any STRETCH, and we don't want to choose a larger 2528 branch insn by overestimating the needed reach of this 2529 branch. It isn't critical to calculate TARGET exactly; We 2530 know we'll be doing another pass if STRETCH is non-zero. */ 2531 2532 if (stretch != 0 2533 && sym_frag->relax_marker != fragP->relax_marker 2534 && S_GET_SEGMENT (symbolP) == segment) 2535 { 2536 if (stretch < 0 2537 || sym_frag->region == fragP->region) 2538 target += stretch; 2539 /* If we get here we know we have a forward branch. This 2540 relax pass may have stretched previous instructions so 2541 far that omitting STRETCH would make the branch 2542 negative. Don't allow this in case the negative reach is 2543 large enough to require a larger branch instruction. */ 2544 else if (target < address) 2545 return 0; 2546 } 2547 } 2548 2549 aim = target - address; 2550 #ifdef TC_PCREL_ADJUST 2551 /* Currently only the ns32k and arc needs this. */ 2552 aim += TC_PCREL_ADJUST (fragP); 2553 #endif 2554 2555 #ifdef md_prepare_relax_scan 2556 /* Formerly called M68K_AIM_KLUDGE. */ 2557 md_prepare_relax_scan (fragP, address, aim, this_state, this_type); 2558 #endif 2559 2560 if (aim < 0) 2561 { 2562 /* Look backwards. */ 2563 for (next_state = this_type->rlx_more; next_state;) 2564 if (aim >= this_type->rlx_backward) 2565 next_state = 0; 2566 else 2567 { 2568 /* Grow to next state. */ 2569 this_state = next_state; 2570 this_type = table + this_state; 2571 next_state = this_type->rlx_more; 2572 } 2573 } 2574 else 2575 { 2576 /* Look forwards. */ 2577 for (next_state = this_type->rlx_more; next_state;) 2578 if (aim <= this_type->rlx_forward) 2579 next_state = 0; 2580 else 2581 { 2582 /* Grow to next state. */ 2583 this_state = next_state; 2584 this_type = table + this_state; 2585 next_state = this_type->rlx_more; 2586 } 2587 } 2588 2589 growth = this_type->rlx_length - start_type->rlx_length; 2590 if (growth != 0) 2591 fragP->fr_subtype = this_state; 2592 return growth; 2593 } 2594 2595 #endif /* defined (TC_GENERIC_RELAX_TABLE) */ 2596 2597 /* Relax_align. Advance location counter to next address that has 'alignment' 2598 lowest order bits all 0s, return size of adjustment made. */ 2599 static relax_addressT 2600 relax_align (relax_addressT address, /* Address now. */ 2601 int alignment /* Alignment (binary). */) 2602 { 2603 relax_addressT mask; 2604 relax_addressT new_address; 2605 2606 mask = ~((relax_addressT) ~0 << alignment); 2607 new_address = (address + mask) & (~mask); 2608 #ifdef LINKER_RELAXING_SHRINKS_ONLY 2609 if (linkrelax) 2610 /* We must provide lots of padding, so the linker can discard it 2611 when needed. The linker will not add extra space, ever. */ 2612 new_address += (1 << alignment); 2613 #endif 2614 return (new_address - address); 2615 } 2616 2617 /* Now we have a segment, not a crowd of sub-segments, we can make 2618 fr_address values. 2619 2620 Relax the frags. 2621 2622 After this, all frags in this segment have addresses that are correct 2623 within the segment. Since segments live in different file addresses, 2624 these frag addresses may not be the same as final object-file 2625 addresses. */ 2626 2627 int 2628 relax_segment (struct frag *segment_frag_root, segT segment, int pass) 2629 { 2630 unsigned long frag_count; 2631 struct frag *fragP; 2632 relax_addressT address; 2633 int region; 2634 int ret; 2635 2636 /* In case md_estimate_size_before_relax() wants to make fixSs. */ 2637 subseg_change (segment, 0); 2638 2639 /* For each frag in segment: count and store (a 1st guess of) 2640 fr_address. */ 2641 address = 0; 2642 region = 0; 2643 for (frag_count = 0, fragP = segment_frag_root; 2644 fragP; 2645 fragP = fragP->fr_next, frag_count ++) 2646 { 2647 fragP->region = region; 2648 fragP->relax_marker = 0; 2649 fragP->fr_address = address; 2650 address += fragP->fr_fix; 2651 2652 switch (fragP->fr_type) 2653 { 2654 case rs_fill: 2655 address += fragP->fr_offset * fragP->fr_var; 2656 break; 2657 2658 case rs_align: 2659 case rs_align_code: 2660 case rs_align_test: 2661 { 2662 addressT offset = relax_align (address, (int) fragP->fr_offset); 2663 2664 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) 2665 offset = 0; 2666 2667 if (offset % fragP->fr_var != 0) 2668 { 2669 as_bad_where (fragP->fr_file, fragP->fr_line, 2670 ngettext ("alignment padding (%lu byte) " 2671 "not a multiple of %ld", 2672 "alignment padding (%lu bytes) " 2673 "not a multiple of %ld", 2674 (unsigned long) offset), 2675 (unsigned long) offset, (long) fragP->fr_var); 2676 offset -= (offset % fragP->fr_var); 2677 } 2678 2679 address += offset; 2680 region += 1; 2681 } 2682 break; 2683 2684 case rs_org: 2685 /* Assume .org is nugatory. It will grow with 1st relax. */ 2686 region += 1; 2687 break; 2688 2689 case rs_space: 2690 case rs_space_nop: 2691 break; 2692 2693 case rs_machine_dependent: 2694 /* If fr_symbol is an expression, this call to 2695 resolve_symbol_value sets up the correct segment, which will 2696 likely be needed in md_estimate_size_before_relax. */ 2697 if (fragP->fr_symbol) 2698 resolve_symbol_value (fragP->fr_symbol); 2699 2700 address += md_estimate_size_before_relax (fragP, segment); 2701 break; 2702 2703 #ifndef WORKING_DOT_WORD 2704 /* Broken words don't concern us yet. */ 2705 case rs_broken_word: 2706 break; 2707 #endif 2708 2709 case rs_leb128: 2710 /* Initial guess is always 1; doing otherwise can result in 2711 stable solutions that are larger than the minimum. */ 2712 address += fragP->fr_offset = 1; 2713 break; 2714 2715 case rs_cfa: 2716 address += eh_frame_estimate_size_before_relax (fragP); 2717 break; 2718 2719 case rs_dwarf2dbg: 2720 address += dwarf2dbg_estimate_size_before_relax (fragP); 2721 break; 2722 2723 default: 2724 BAD_CASE (fragP->fr_type); 2725 break; 2726 } 2727 } 2728 2729 /* Do relax(). */ 2730 { 2731 unsigned long max_iterations; 2732 2733 /* Cumulative address adjustment. */ 2734 offsetT stretch; 2735 2736 /* Have we made any adjustment this pass? We can't just test 2737 stretch because one piece of code may have grown and another 2738 shrank. */ 2739 int stretched; 2740 2741 /* Most horrible, but gcc may give us some exception data that 2742 is impossible to assemble, of the form 2743 2744 .align 4 2745 .byte 0, 0 2746 .uleb128 end - start 2747 start: 2748 .space 128*128 - 1 2749 .align 4 2750 end: 2751 2752 If the leb128 is two bytes in size, then end-start is 128*128, 2753 which requires a three byte leb128. If the leb128 is three 2754 bytes in size, then end-start is 128*128-1, which requires a 2755 two byte leb128. We work around this dilemma by inserting 2756 an extra 4 bytes of alignment just after the .align. This 2757 works because the data after the align is accessed relative to 2758 the end label. 2759 2760 This counter is used in a tiny state machine to detect 2761 whether a leb128 followed by an align is impossible to 2762 relax. */ 2763 int rs_leb128_fudge = 0; 2764 2765 /* We want to prevent going into an infinite loop where one frag grows 2766 depending upon the location of a symbol which is in turn moved by 2767 the growing frag. eg: 2768 2769 foo = . 2770 .org foo+16 2771 foo = . 2772 2773 So we dictate that this algorithm can be at most O2. */ 2774 max_iterations = frag_count * frag_count; 2775 /* Check for overflow. */ 2776 if (max_iterations < frag_count) 2777 max_iterations = frag_count; 2778 2779 ret = 0; 2780 do 2781 { 2782 stretch = 0; 2783 stretched = 0; 2784 2785 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2786 { 2787 offsetT growth = 0; 2788 addressT was_address; 2789 offsetT offset; 2790 symbolS *symbolP; 2791 2792 fragP->relax_marker ^= 1; 2793 was_address = fragP->fr_address; 2794 address = fragP->fr_address += stretch; 2795 symbolP = fragP->fr_symbol; 2796 offset = fragP->fr_offset; 2797 2798 switch (fragP->fr_type) 2799 { 2800 case rs_fill: /* .fill never relaxes. */ 2801 growth = 0; 2802 break; 2803 2804 #ifndef WORKING_DOT_WORD 2805 /* JF: This is RMS's idea. I do *NOT* want to be blamed 2806 for it I do not want to write it. I do not want to have 2807 anything to do with it. This is not the proper way to 2808 implement this misfeature. */ 2809 case rs_broken_word: 2810 { 2811 struct broken_word *lie; 2812 struct broken_word *untruth; 2813 2814 /* Yes this is ugly (storing the broken_word pointer 2815 in the symbol slot). Still, this whole chunk of 2816 code is ugly, and I don't feel like doing anything 2817 about it. Think of it as stubbornness in action. */ 2818 growth = 0; 2819 for (lie = (struct broken_word *) (fragP->fr_symbol); 2820 lie && lie->dispfrag == fragP; 2821 lie = lie->next_broken_word) 2822 { 2823 2824 if (lie->added) 2825 continue; 2826 2827 offset = (S_GET_VALUE (lie->add) 2828 + lie->addnum 2829 - S_GET_VALUE (lie->sub)); 2830 if (offset <= -32768 || offset >= 32767) 2831 { 2832 if (flag_warn_displacement) 2833 { 2834 char buf[50]; 2835 sprint_value (buf, (addressT) lie->addnum); 2836 as_warn_where (fragP->fr_file, fragP->fr_line, 2837 _(".word %s-%s+%s didn't fit"), 2838 S_GET_NAME (lie->add), 2839 S_GET_NAME (lie->sub), 2840 buf); 2841 } 2842 if (fragP->fr_subtype == 0) 2843 { 2844 fragP->fr_subtype++; 2845 growth += md_short_jump_size; 2846 } 2847 2848 /* Redirect *all* words of this table with the same 2849 target, lest we have to handle the case where the 2850 same target but with a offset that fits on this 2851 round overflows at the next relaxation round. */ 2852 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2853 untruth && untruth->dispfrag == lie->dispfrag; 2854 untruth = untruth->next_broken_word) 2855 if ((symbol_get_frag (untruth->add) 2856 == symbol_get_frag (lie->add)) 2857 && (S_GET_VALUE (untruth->add) 2858 == S_GET_VALUE (lie->add))) 2859 { 2860 untruth->added = 2; 2861 untruth->use_jump = lie; 2862 } 2863 2864 lie->added = 1; 2865 growth += md_long_jump_size; 2866 } 2867 } 2868 2869 break; 2870 } /* case rs_broken_word */ 2871 #endif 2872 case rs_align: 2873 case rs_align_code: 2874 case rs_align_test: 2875 { 2876 addressT oldoff, newoff; 2877 2878 oldoff = relax_align (was_address + fragP->fr_fix, 2879 (int) offset); 2880 newoff = relax_align (address + fragP->fr_fix, 2881 (int) offset); 2882 2883 if (fragP->fr_subtype != 0) 2884 { 2885 if (oldoff > fragP->fr_subtype) 2886 oldoff = 0; 2887 if (newoff > fragP->fr_subtype) 2888 newoff = 0; 2889 } 2890 2891 growth = newoff - oldoff; 2892 2893 /* If this align happens to follow a leb128 and 2894 we have determined that the leb128 is bouncing 2895 in size, then break the cycle by inserting an 2896 extra alignment. */ 2897 if (growth < 0 2898 && (rs_leb128_fudge & 16) != 0 2899 && (rs_leb128_fudge & 15) >= 2) 2900 { 2901 segment_info_type *seginfo = seg_info (segment); 2902 struct obstack *ob = &seginfo->frchainP->frch_obstack; 2903 struct frag *newf; 2904 2905 newf = frag_alloc (ob); 2906 obstack_blank_fast (ob, fragP->fr_var); 2907 obstack_finish (ob); 2908 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG); 2909 memcpy (newf->fr_literal, 2910 fragP->fr_literal + fragP->fr_fix, 2911 fragP->fr_var); 2912 newf->fr_type = rs_fill; 2913 newf->fr_address = address + fragP->fr_fix + newoff; 2914 newf->fr_fix = 0; 2915 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset) 2916 / fragP->fr_var); 2917 if (newf->fr_offset * newf->fr_var 2918 != (offsetT) 1 << fragP->fr_offset) 2919 { 2920 newf->fr_offset = (offsetT) 1 << fragP->fr_offset; 2921 newf->fr_var = 1; 2922 } 2923 /* Include size of new frag in GROWTH. */ 2924 growth += newf->fr_offset * newf->fr_var; 2925 /* Adjust the new frag address for the amount 2926 we'll add when we process the new frag. */ 2927 newf->fr_address -= stretch + growth; 2928 newf->relax_marker ^= 1; 2929 fragP->fr_next = newf; 2930 #ifdef DEBUG 2931 as_warn (_("padding added")); 2932 #endif 2933 } 2934 } 2935 break; 2936 2937 case rs_org: 2938 { 2939 addressT target = offset; 2940 addressT after; 2941 2942 if (symbolP) 2943 { 2944 /* Convert from an actual address to an octet offset 2945 into the section. Here it is assumed that the 2946 section's VMA is zero, and can omit subtracting it 2947 from the symbol's value to get the address offset. */ 2948 know (S_GET_SEGMENT (symbolP)->vma == 0); 2949 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE; 2950 } 2951 2952 know (fragP->fr_next); 2953 after = fragP->fr_next->fr_address + stretch; 2954 growth = target - after; 2955 2956 /* Growth may be negative, but variable part of frag 2957 cannot have fewer than 0 chars. That is, we can't 2958 .org backwards. */ 2959 if (address + fragP->fr_fix > target) 2960 { 2961 growth = 0; 2962 2963 /* Don't error on first few frag relax passes. 2964 The symbol might be an expression involving 2965 symbol values from other sections. If those 2966 sections have not yet been processed their 2967 frags will all have zero addresses, so we 2968 will calculate incorrect values for them. The 2969 number of passes we allow before giving an 2970 error is somewhat arbitrary. It should be at 2971 least one, with larger values requiring 2972 increasingly contrived dependencies between 2973 frags to trigger a false error. */ 2974 if (pass < 2) 2975 { 2976 /* Force another pass. */ 2977 ret = 1; 2978 break; 2979 } 2980 2981 as_bad_where (fragP->fr_file, fragP->fr_line, 2982 _("attempt to move .org backwards")); 2983 2984 /* We've issued an error message. Change the 2985 frag to avoid cascading errors. */ 2986 fragP->fr_type = rs_align; 2987 fragP->fr_subtype = 0; 2988 fragP->fr_offset = 0; 2989 fragP->fr_fix = after - address; 2990 } 2991 } 2992 break; 2993 2994 case rs_space: 2995 case rs_space_nop: 2996 growth = 0; 2997 if (symbolP) 2998 { 2999 offsetT amount; 3000 3001 amount = S_GET_VALUE (symbolP); 3002 if (S_GET_SEGMENT (symbolP) != absolute_section 3003 || S_IS_COMMON (symbolP) 3004 || ! S_IS_DEFINED (symbolP)) 3005 { 3006 as_bad_where (fragP->fr_file, fragP->fr_line, 3007 _(".space specifies non-absolute value")); 3008 /* Prevent repeat of this error message. */ 3009 fragP->fr_symbol = 0; 3010 } 3011 else if (amount < 0) 3012 { 3013 /* Don't error on first few frag relax passes. 3014 See rs_org comment for a longer explanation. */ 3015 if (pass < 2) 3016 { 3017 ret = 1; 3018 break; 3019 } 3020 3021 as_warn_where (fragP->fr_file, fragP->fr_line, 3022 _(".space, .nops or .fill with negative value, ignored")); 3023 fragP->fr_symbol = 0; 3024 } 3025 else 3026 growth = (was_address + fragP->fr_fix + amount 3027 - fragP->fr_next->fr_address); 3028 } 3029 break; 3030 3031 case rs_machine_dependent: 3032 #ifdef md_relax_frag 3033 growth = md_relax_frag (segment, fragP, stretch); 3034 #else 3035 #ifdef TC_GENERIC_RELAX_TABLE 3036 /* The default way to relax a frag is to look through 3037 TC_GENERIC_RELAX_TABLE. */ 3038 growth = md_generic_table_relax_frag (segment, fragP, 3039 stretch); 3040 #endif /* TC_GENERIC_RELAX_TABLE */ 3041 #endif 3042 break; 3043 3044 case rs_leb128: 3045 { 3046 valueT value; 3047 offsetT size; 3048 3049 value = resolve_symbol_value (fragP->fr_symbol); 3050 size = sizeof_leb128 (value, fragP->fr_subtype); 3051 growth = size - fragP->fr_offset; 3052 fragP->fr_offset = size; 3053 } 3054 break; 3055 3056 case rs_cfa: 3057 growth = eh_frame_relax_frag (fragP); 3058 break; 3059 3060 case rs_dwarf2dbg: 3061 growth = dwarf2dbg_relax_frag (fragP); 3062 break; 3063 3064 default: 3065 BAD_CASE (fragP->fr_type); 3066 break; 3067 } 3068 if (growth) 3069 { 3070 stretch += growth; 3071 stretched = 1; 3072 if (fragP->fr_type == rs_leb128) 3073 rs_leb128_fudge += 16; 3074 else if (fragP->fr_type == rs_align 3075 && (rs_leb128_fudge & 16) != 0 3076 && stretch == 0) 3077 rs_leb128_fudge += 16; 3078 else 3079 rs_leb128_fudge = 0; 3080 } 3081 } 3082 3083 if (stretch == 0 3084 && (rs_leb128_fudge & 16) == 0 3085 && (rs_leb128_fudge & -16) != 0) 3086 rs_leb128_fudge += 1; 3087 else 3088 rs_leb128_fudge = 0; 3089 } 3090 /* Until nothing further to relax. */ 3091 while (stretched && -- max_iterations); 3092 3093 if (stretched) 3094 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"), 3095 segment_name (segment)); 3096 } 3097 3098 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 3099 if (fragP->last_fr_address != fragP->fr_address) 3100 { 3101 fragP->last_fr_address = fragP->fr_address; 3102 ret = 1; 3103 } 3104 return ret; 3105 } 3106 3107 void 3108 number_to_chars_bigendian (char *buf, valueT val, int n) 3109 { 3110 if (n <= 0) 3111 abort (); 3112 while (n--) 3113 { 3114 buf[n] = val & 0xff; 3115 val >>= 8; 3116 } 3117 } 3118 3119 void 3120 number_to_chars_littleendian (char *buf, valueT val, int n) 3121 { 3122 if (n <= 0) 3123 abort (); 3124 while (n--) 3125 { 3126 *buf++ = val & 0xff; 3127 val >>= 8; 3128 } 3129 } 3130 3131 void 3132 write_print_statistics (FILE *file) 3133 { 3134 fprintf (file, "fixups: %d\n", n_fixups); 3135 } 3136 3137 /* For debugging. */ 3138 extern int indent_level; 3139 3140 void 3141 print_fixup (fixS *fixp) 3142 { 3143 indent_level = 1; 3144 fprintf (stderr, "fix "); 3145 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp)); 3146 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line); 3147 if (fixp->fx_pcrel) 3148 fprintf (stderr, " pcrel"); 3149 if (fixp->fx_pcrel_adjust) 3150 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust); 3151 if (fixp->fx_tcbit) 3152 fprintf (stderr, " tcbit"); 3153 if (fixp->fx_done) 3154 fprintf (stderr, " done"); 3155 fprintf (stderr, "\n size=%d frag=", fixp->fx_size); 3156 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag)); 3157 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx", 3158 (long) fixp->fx_where, 3159 (unsigned long) fixp->fx_offset, 3160 (unsigned long) fixp->fx_addnumber); 3161 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), 3162 fixp->fx_r_type); 3163 if (fixp->fx_addsy) 3164 { 3165 fprintf (stderr, "\n +<"); 3166 print_symbol_value_1 (stderr, fixp->fx_addsy); 3167 fprintf (stderr, ">"); 3168 } 3169 if (fixp->fx_subsy) 3170 { 3171 fprintf (stderr, "\n -<"); 3172 print_symbol_value_1 (stderr, fixp->fx_subsy); 3173 fprintf (stderr, ">"); 3174 } 3175 fprintf (stderr, "\n"); 3176 #ifdef TC_FIX_DATA_PRINT 3177 TC_FIX_DATA_PRINT (stderr, fixp); 3178 #endif 3179 } 3180