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_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 know (fragP->fr_next != NULL); 447 fragP->fr_offset = (fragP->fr_next->fr_address 448 - fragP->fr_address 449 - fragP->fr_fix) / fragP->fr_var; 450 if (fragP->fr_offset < 0) 451 { 452 as_bad_where (fragP->fr_file, fragP->fr_line, 453 _("attempt to .org/.space backwards? (%ld)"), 454 (long) fragP->fr_offset); 455 fragP->fr_offset = 0; 456 } 457 fragP->fr_type = rs_fill; 458 break; 459 460 case rs_fill: 461 break; 462 463 case rs_leb128: 464 { 465 valueT value = S_GET_VALUE (fragP->fr_symbol); 466 int size; 467 468 if (!S_IS_DEFINED (fragP->fr_symbol)) 469 { 470 as_bad_where (fragP->fr_file, fragP->fr_line, 471 _("leb128 operand is an undefined symbol: %s"), 472 S_GET_NAME (fragP->fr_symbol)); 473 } 474 475 size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value, 476 fragP->fr_subtype); 477 478 fragP->fr_fix += size; 479 fragP->fr_type = rs_fill; 480 fragP->fr_var = 0; 481 fragP->fr_offset = 0; 482 fragP->fr_symbol = NULL; 483 } 484 break; 485 486 case rs_cfa: 487 eh_frame_convert_frag (fragP); 488 break; 489 490 case rs_dwarf2dbg: 491 dwarf2dbg_convert_frag (fragP); 492 break; 493 494 case rs_machine_dependent: 495 md_convert_frag (stdoutput, sec, fragP); 496 497 gas_assert (fragP->fr_next == NULL 498 || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address) 499 == fragP->fr_fix)); 500 501 /* After md_convert_frag, we make the frag into a ".space 0". 502 md_convert_frag() should set up any fixSs and constants 503 required. */ 504 frag_wane (fragP); 505 break; 506 507 #ifndef WORKING_DOT_WORD 508 case rs_broken_word: 509 { 510 struct broken_word *lie; 511 512 if (fragP->fr_subtype) 513 { 514 fragP->fr_fix += md_short_jump_size; 515 for (lie = (struct broken_word *) (fragP->fr_symbol); 516 lie && lie->dispfrag == fragP; 517 lie = lie->next_broken_word) 518 if (lie->added == 1) 519 fragP->fr_fix += md_long_jump_size; 520 } 521 frag_wane (fragP); 522 } 523 break; 524 #endif 525 526 default: 527 BAD_CASE (fragP->fr_type); 528 break; 529 } 530 #ifdef md_frag_check 531 md_frag_check (fragP); 532 #endif 533 } 534 535 struct relax_seg_info 536 { 537 int pass; 538 int changed; 539 }; 540 541 static void 542 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx) 543 { 544 segment_info_type *seginfo = seg_info (sec); 545 struct relax_seg_info *info = (struct relax_seg_info *) xxx; 546 547 if (seginfo && seginfo->frchainP 548 && relax_segment (seginfo->frchainP->frch_root, sec, info->pass)) 549 info->changed = 1; 550 } 551 552 static void 553 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 554 { 555 flagword flags; 556 fragS *fragp; 557 segment_info_type *seginfo; 558 int x; 559 valueT size, newsize; 560 561 subseg_change (sec, 0); 562 563 seginfo = seg_info (sec); 564 if (seginfo && seginfo->frchainP) 565 { 566 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next) 567 cvt_frag_to_fill (sec, fragp); 568 for (fragp = seginfo->frchainP->frch_root; 569 fragp->fr_next; 570 fragp = fragp->fr_next) 571 /* Walk to last elt. */ 572 ; 573 size = fragp->fr_address + fragp->fr_fix; 574 } 575 else 576 size = 0; 577 578 flags = bfd_get_section_flags (abfd, sec); 579 if (size == 0 && bfd_get_section_size (sec) != 0 && 580 (flags & SEC_HAS_CONTENTS) != 0) 581 return; 582 583 if (size > 0 && ! seginfo->bss) 584 flags |= SEC_HAS_CONTENTS; 585 586 flags &= ~SEC_RELOC; 587 x = bfd_set_section_flags (abfd, sec, flags); 588 gas_assert (x); 589 590 /* If permitted, allow the backend to pad out the section 591 to some alignment boundary. */ 592 if (do_not_pad_sections_to_alignment) 593 newsize = size; 594 else 595 newsize = md_section_align (sec, size); 596 x = bfd_set_section_size (abfd, sec, newsize); 597 gas_assert (x); 598 599 /* If the size had to be rounded up, add some padding in the last 600 non-empty frag. */ 601 gas_assert (newsize >= size); 602 if (size != newsize) 603 { 604 fragS *last = seginfo->frchainP->frch_last; 605 fragp = seginfo->frchainP->frch_root; 606 while (fragp->fr_next != last) 607 fragp = fragp->fr_next; 608 last->fr_address = size; 609 if ((newsize - size) % fragp->fr_var == 0) 610 fragp->fr_offset += (newsize - size) / fragp->fr_var; 611 else 612 /* If we hit this abort, it's likely due to subsegs_finish not 613 providing sufficient alignment on the last frag, and the 614 machine dependent code using alignment frags with fr_var 615 greater than 1. */ 616 abort (); 617 } 618 619 #ifdef tc_frob_section 620 tc_frob_section (sec); 621 #endif 622 #ifdef obj_frob_section 623 obj_frob_section (sec); 624 #endif 625 } 626 627 #ifdef DEBUG2 628 static void 629 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream) 630 { 631 segment_info_type *seginfo = seg_info (sec); 632 fixS *fixp = seginfo->fix_root; 633 634 if (!fixp) 635 return; 636 637 fprintf (stream, "sec %s relocs:\n", sec->name); 638 while (fixp) 639 { 640 symbolS *s = fixp->fx_addsy; 641 642 fprintf (stream, " %08lx: type %d ", (unsigned long) fixp, 643 (int) fixp->fx_r_type); 644 if (s == NULL) 645 fprintf (stream, "no sym\n"); 646 else 647 { 648 print_symbol_value_1 (stream, s); 649 fprintf (stream, "\n"); 650 } 651 fixp = fixp->fx_next; 652 } 653 } 654 #else 655 #define dump_section_relocs(ABFD,SEC,STREAM) ((void) 0) 656 #endif 657 658 #ifndef EMIT_SECTION_SYMBOLS 659 #define EMIT_SECTION_SYMBOLS 1 660 #endif 661 662 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries, 663 and check for validity. Convert RELOC_LIST from using U.A fields 664 to U.B fields. */ 665 static void 666 resolve_reloc_expr_symbols (void) 667 { 668 bfd_vma addr_mask = 1; 669 struct reloc_list *r; 670 671 /* Avoid a shift by the width of type. */ 672 addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1; 673 addr_mask <<= 1; 674 addr_mask -= 1; 675 676 for (r = reloc_list; r; r = r->next) 677 { 678 reloc_howto_type *howto = r->u.a.howto; 679 expressionS *symval; 680 symbolS *sym; 681 bfd_vma offset, addend; 682 asection *sec; 683 684 resolve_symbol_value (r->u.a.offset_sym); 685 symval = symbol_get_value_expression (r->u.a.offset_sym); 686 687 offset = 0; 688 sym = NULL; 689 if (symval->X_op == O_constant) 690 sym = r->u.a.offset_sym; 691 else if (symval->X_op == O_symbol) 692 { 693 sym = symval->X_add_symbol; 694 offset = symval->X_add_number; 695 symval = symbol_get_value_expression (symval->X_add_symbol); 696 } 697 if (sym == NULL 698 || symval->X_op != O_constant 699 || (sec = S_GET_SEGMENT (sym)) == NULL 700 || !SEG_NORMAL (sec)) 701 { 702 as_bad_where (r->file, r->line, _("invalid offset expression")); 703 sec = NULL; 704 } 705 else 706 offset += S_GET_VALUE (sym); 707 708 sym = NULL; 709 addend = r->u.a.addend; 710 if (r->u.a.sym != NULL) 711 { 712 resolve_symbol_value (r->u.a.sym); 713 symval = symbol_get_value_expression (r->u.a.sym); 714 if (symval->X_op == O_constant) 715 sym = r->u.a.sym; 716 else if (symval->X_op == O_symbol) 717 { 718 sym = symval->X_add_symbol; 719 addend += symval->X_add_number; 720 symval = symbol_get_value_expression (symval->X_add_symbol); 721 } 722 if (symval->X_op != O_constant) 723 { 724 as_bad_where (r->file, r->line, _("invalid reloc expression")); 725 sec = NULL; 726 } 727 else if (sym != NULL && sec != NULL) 728 { 729 /* Convert relocs against local symbols to refer to the 730 corresponding section symbol plus offset instead. Keep 731 PC-relative relocs of the REL variety intact though to 732 prevent the offset from overflowing the relocated field, 733 unless it has enough bits to cover the whole address 734 space. */ 735 if (S_IS_LOCAL (sym) && !symbol_section_p (sym) 736 && (sec->use_rela_p 737 || (howto->partial_inplace 738 && (!howto->pc_relative 739 || howto->src_mask == addr_mask)))) 740 { 741 asection *symsec = S_GET_SEGMENT (sym); 742 if (!(((symsec->flags & SEC_MERGE) != 0 743 && addend != 0) 744 || (symsec->flags & SEC_THREAD_LOCAL) != 0)) 745 { 746 addend += S_GET_VALUE (sym); 747 sym = section_symbol (symsec); 748 } 749 } 750 symbol_mark_used_in_reloc (sym); 751 } 752 } 753 if (sym == NULL) 754 { 755 if (abs_section_sym == NULL) 756 abs_section_sym = section_symbol (absolute_section); 757 sym = abs_section_sym; 758 } 759 760 r->u.b.sec = sec; 761 r->u.b.s = symbol_get_bfdsym (sym); 762 r->u.b.r.sym_ptr_ptr = &r->u.b.s; 763 r->u.b.r.address = offset; 764 r->u.b.r.addend = addend; 765 r->u.b.r.howto = howto; 766 } 767 } 768 769 /* This pass over fixups decides whether symbols can be replaced with 770 section symbols. */ 771 772 static void 773 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED, 774 asection *sec, 775 void *xxx ATTRIBUTE_UNUSED) 776 { 777 segment_info_type *seginfo = seg_info (sec); 778 fixS *fixp; 779 780 if (seginfo == NULL) 781 return; 782 783 dump_section_relocs (abfd, sec, stderr); 784 785 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 786 if (fixp->fx_done) 787 /* Ignore it. */ 788 ; 789 else if (fixp->fx_addsy) 790 { 791 symbolS *sym; 792 asection *symsec; 793 794 #ifdef DEBUG5 795 fprintf (stderr, "\n\nadjusting fixup:\n"); 796 print_fixup (fixp); 797 #endif 798 799 sym = fixp->fx_addsy; 800 801 /* All symbols should have already been resolved at this 802 point. It is possible to see unresolved expression 803 symbols, though, since they are not in the regular symbol 804 table. */ 805 resolve_symbol_value (sym); 806 807 if (fixp->fx_subsy != NULL) 808 resolve_symbol_value (fixp->fx_subsy); 809 810 /* If this symbol is equated to an undefined or common symbol, 811 convert the fixup to being against that symbol. */ 812 while (symbol_equated_reloc_p (sym) 813 || S_IS_WEAKREFR (sym)) 814 { 815 symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol; 816 if (sym == newsym) 817 break; 818 fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number; 819 fixp->fx_addsy = newsym; 820 sym = newsym; 821 } 822 823 if (symbol_mri_common_p (sym)) 824 { 825 fixp->fx_offset += S_GET_VALUE (sym); 826 fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol; 827 continue; 828 } 829 830 /* If the symbol is undefined, common, weak, or global (ELF 831 shared libs), we can't replace it with the section symbol. */ 832 if (S_FORCE_RELOC (fixp->fx_addsy, 1)) 833 continue; 834 835 /* Is there some other (target cpu dependent) reason we can't adjust 836 this one? (E.g. relocations involving function addresses on 837 the PA. */ 838 #ifdef tc_fix_adjustable 839 if (! tc_fix_adjustable (fixp)) 840 continue; 841 #endif 842 843 /* Since we're reducing to section symbols, don't attempt to reduce 844 anything that's already using one. */ 845 if (symbol_section_p (sym)) 846 continue; 847 848 symsec = S_GET_SEGMENT (sym); 849 if (symsec == NULL) 850 abort (); 851 852 if (bfd_is_abs_section (symsec) 853 || symsec == reg_section) 854 { 855 /* The fixup_segment routine normally will not use this 856 symbol in a relocation. */ 857 continue; 858 } 859 860 /* Don't try to reduce relocs which refer to non-local symbols 861 in .linkonce sections. It can lead to confusion when a 862 debugging section refers to a .linkonce section. I hope 863 this will always be correct. */ 864 if (symsec != sec && ! S_IS_LOCAL (sym)) 865 { 866 if ((symsec->flags & SEC_LINK_ONCE) != 0 867 || (IS_ELF 868 /* The GNU toolchain uses an extension for ELF: a 869 section beginning with the magic string 870 .gnu.linkonce is a linkonce section. */ 871 && strncmp (segment_name (symsec), ".gnu.linkonce", 872 sizeof ".gnu.linkonce" - 1) == 0)) 873 continue; 874 } 875 876 /* Never adjust a reloc against local symbol in a merge section 877 with non-zero addend. */ 878 if ((symsec->flags & SEC_MERGE) != 0 879 && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL)) 880 continue; 881 882 /* Never adjust a reloc against TLS local symbol. */ 883 if ((symsec->flags & SEC_THREAD_LOCAL) != 0) 884 continue; 885 886 /* We refetch the segment when calling section_symbol, rather 887 than using symsec, because S_GET_VALUE may wind up changing 888 the section when it calls resolve_symbol_value. */ 889 fixp->fx_offset += S_GET_VALUE (sym); 890 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym)); 891 #ifdef DEBUG5 892 fprintf (stderr, "\nadjusted fixup:\n"); 893 print_fixup (fixp); 894 #endif 895 } 896 897 dump_section_relocs (abfd, sec, stderr); 898 } 899 900 /* fixup_segment() 901 902 Go through all the fixS's in a segment and see which ones can be 903 handled now. (These consist of fixS where we have since discovered 904 the value of a symbol, or the address of the frag involved.) 905 For each one, call md_apply_fix to put the fix into the frag data. 906 Ones that we couldn't completely handle here will be output later 907 by emit_relocations. */ 908 909 static void 910 fixup_segment (fixS *fixP, segT this_segment) 911 { 912 valueT add_number; 913 fragS *fragP; 914 segT add_symbol_segment = absolute_section; 915 916 if (fixP != NULL && abs_section_sym == NULL) 917 abs_section_sym = section_symbol (absolute_section); 918 919 /* If the linker is doing the relaxing, we must not do any fixups. 920 921 Well, strictly speaking that's not true -- we could do any that 922 are PC-relative and don't cross regions that could change size. 923 And for the i960 we might be able to turn callx/callj into bal 924 anyways in cases where we know the maximum displacement. */ 925 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment)) 926 { 927 for (; fixP; fixP = fixP->fx_next) 928 if (!fixP->fx_done) 929 { 930 if (fixP->fx_addsy == NULL) 931 { 932 /* There was no symbol required by this relocation. 933 However, BFD doesn't really handle relocations 934 without symbols well. So fake up a local symbol in 935 the absolute section. */ 936 fixP->fx_addsy = abs_section_sym; 937 } 938 symbol_mark_used_in_reloc (fixP->fx_addsy); 939 if (fixP->fx_subsy != NULL) 940 symbol_mark_used_in_reloc (fixP->fx_subsy); 941 } 942 return; 943 } 944 945 for (; fixP; fixP = fixP->fx_next) 946 { 947 #ifdef DEBUG5 948 fprintf (stderr, "\nprocessing fixup:\n"); 949 print_fixup (fixP); 950 #endif 951 952 fragP = fixP->fx_frag; 953 know (fragP); 954 #ifdef TC_VALIDATE_FIX 955 TC_VALIDATE_FIX (fixP, this_segment, skip); 956 #endif 957 add_number = fixP->fx_offset; 958 959 if (fixP->fx_addsy != NULL) 960 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy); 961 962 if (fixP->fx_subsy != NULL) 963 { 964 segT sub_symbol_segment; 965 resolve_symbol_value (fixP->fx_subsy); 966 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy); 967 if (fixP->fx_addsy != NULL 968 && sub_symbol_segment == add_symbol_segment 969 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 970 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 971 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment)) 972 { 973 add_number += S_GET_VALUE (fixP->fx_addsy); 974 add_number -= S_GET_VALUE (fixP->fx_subsy); 975 fixP->fx_offset = add_number; 976 fixP->fx_addsy = NULL; 977 fixP->fx_subsy = NULL; 978 #ifdef TC_M68K 979 /* See the comment below about 68k weirdness. */ 980 fixP->fx_pcrel = 0; 981 #endif 982 } 983 else if (sub_symbol_segment == absolute_section 984 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 985 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment)) 986 { 987 add_number -= S_GET_VALUE (fixP->fx_subsy); 988 fixP->fx_offset = add_number; 989 fixP->fx_subsy = NULL; 990 } 991 else if (sub_symbol_segment == this_segment 992 && !S_FORCE_RELOC (fixP->fx_subsy, 0) 993 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment)) 994 { 995 add_number -= S_GET_VALUE (fixP->fx_subsy); 996 fixP->fx_offset = (add_number + fixP->fx_dot_value 997 + fixP->fx_dot_frag->fr_address); 998 999 /* Make it pc-relative. If the back-end code has not 1000 selected a pc-relative reloc, cancel the adjustment 1001 we do later on all pc-relative relocs. */ 1002 if (0 1003 #ifdef TC_M68K 1004 /* Do this for m68k even if it's already described 1005 as pc-relative. On the m68k, an operand of 1006 "pc@(foo-.-2)" should address "foo" in a 1007 pc-relative mode. */ 1008 || 1 1009 #endif 1010 || !fixP->fx_pcrel) 1011 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment); 1012 fixP->fx_subsy = NULL; 1013 fixP->fx_pcrel = 1; 1014 } 1015 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment)) 1016 { 1017 if (!md_register_arithmetic 1018 && (add_symbol_segment == reg_section 1019 || sub_symbol_segment == reg_section)) 1020 as_bad_where (fixP->fx_file, fixP->fx_line, 1021 _("register value used as expression")); 1022 else 1023 as_bad_where (fixP->fx_file, fixP->fx_line, 1024 _("can't resolve `%s' {%s section} - `%s' {%s section}"), 1025 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0", 1026 segment_name (add_symbol_segment), 1027 S_GET_NAME (fixP->fx_subsy), 1028 segment_name (sub_symbol_segment)); 1029 } 1030 else if (sub_symbol_segment != undefined_section 1031 && ! bfd_is_com_section (sub_symbol_segment) 1032 && MD_APPLY_SYM_VALUE (fixP)) 1033 add_number -= S_GET_VALUE (fixP->fx_subsy); 1034 } 1035 1036 if (fixP->fx_addsy) 1037 { 1038 if (add_symbol_segment == this_segment 1039 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 1040 && !TC_FORCE_RELOCATION_LOCAL (fixP)) 1041 { 1042 /* This fixup was made when the symbol's segment was 1043 SEG_UNKNOWN, but it is now in the local segment. 1044 So we know how to do the address without relocation. */ 1045 add_number += S_GET_VALUE (fixP->fx_addsy); 1046 fixP->fx_offset = add_number; 1047 if (fixP->fx_pcrel) 1048 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 1049 fixP->fx_addsy = NULL; 1050 fixP->fx_pcrel = 0; 1051 } 1052 else if (add_symbol_segment == absolute_section 1053 && !S_FORCE_RELOC (fixP->fx_addsy, 0) 1054 && !TC_FORCE_RELOCATION_ABS (fixP)) 1055 { 1056 add_number += S_GET_VALUE (fixP->fx_addsy); 1057 fixP->fx_offset = add_number; 1058 fixP->fx_addsy = NULL; 1059 } 1060 else if (add_symbol_segment != undefined_section 1061 && ! bfd_is_com_section (add_symbol_segment) 1062 && MD_APPLY_SYM_VALUE (fixP)) 1063 add_number += S_GET_VALUE (fixP->fx_addsy); 1064 } 1065 1066 if (fixP->fx_pcrel) 1067 { 1068 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 1069 if (!fixP->fx_done && fixP->fx_addsy == NULL) 1070 { 1071 /* There was no symbol required by this relocation. 1072 However, BFD doesn't really handle relocations 1073 without symbols well. So fake up a local symbol in 1074 the absolute section. */ 1075 fixP->fx_addsy = abs_section_sym; 1076 } 1077 } 1078 1079 if (!fixP->fx_done) 1080 md_apply_fix (fixP, &add_number, this_segment); 1081 1082 if (!fixP->fx_done) 1083 { 1084 if (fixP->fx_addsy == NULL) 1085 fixP->fx_addsy = abs_section_sym; 1086 symbol_mark_used_in_reloc (fixP->fx_addsy); 1087 if (fixP->fx_subsy != NULL) 1088 symbol_mark_used_in_reloc (fixP->fx_subsy); 1089 } 1090 1091 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0) 1092 { 1093 if (fixP->fx_size < sizeof (valueT)) 1094 { 1095 valueT mask; 1096 1097 mask = 0; 1098 mask--; /* Set all bits to one. */ 1099 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0); 1100 if ((add_number & mask) != 0 && (add_number & mask) != mask) 1101 { 1102 char buf[50], buf2[50]; 1103 sprint_value (buf, fragP->fr_address + fixP->fx_where); 1104 if (add_number > 1000) 1105 sprint_value (buf2, add_number); 1106 else 1107 sprintf (buf2, "%ld", (long) add_number); 1108 as_bad_where (fixP->fx_file, fixP->fx_line, 1109 ngettext ("value of %s too large for field " 1110 "of %d byte at %s", 1111 "value of %s too large for field " 1112 "of %d bytes at %s", 1113 fixP->fx_size), 1114 buf2, fixP->fx_size, buf); 1115 } /* Generic error checking. */ 1116 } 1117 #ifdef WARN_SIGNED_OVERFLOW_WORD 1118 /* Warn if a .word value is too large when treated as a signed 1119 number. We already know it is not too negative. This is to 1120 catch over-large switches generated by gcc on the 68k. */ 1121 if (!flag_signed_overflow_ok 1122 && fixP->fx_size == 2 1123 && add_number > 0x7fff) 1124 as_bad_where (fixP->fx_file, fixP->fx_line, 1125 _("signed .word overflow; switch may be too large; %ld at 0x%lx"), 1126 (long) add_number, 1127 (long) (fragP->fr_address + fixP->fx_where)); 1128 #endif 1129 } /* Not a bit fix. */ 1130 1131 #ifdef TC_VALIDATE_FIX 1132 skip: ATTRIBUTE_UNUSED_LABEL 1133 ; 1134 #endif 1135 #ifdef DEBUG5 1136 fprintf (stderr, "result:\n"); 1137 print_fixup (fixP); 1138 #endif 1139 } /* For each fixS in this segment. */ 1140 } 1141 1142 static void 1143 fix_segment (bfd *abfd ATTRIBUTE_UNUSED, 1144 asection *sec, 1145 void *xxx ATTRIBUTE_UNUSED) 1146 { 1147 segment_info_type *seginfo = seg_info (sec); 1148 1149 fixup_segment (seginfo->fix_root, sec); 1150 } 1151 1152 static void 1153 install_reloc (asection *sec, arelent *reloc, fragS *fragp, 1154 const char *file, unsigned int line) 1155 { 1156 char *err; 1157 bfd_reloc_status_type s; 1158 asymbol *sym; 1159 1160 if (reloc->sym_ptr_ptr != NULL 1161 && (sym = *reloc->sym_ptr_ptr) != NULL 1162 && (sym->flags & BSF_KEEP) == 0 1163 && ((sym->flags & BSF_SECTION_SYM) == 0 1164 || (EMIT_SECTION_SYMBOLS 1165 && !bfd_is_abs_section (sym->section)))) 1166 as_bad_where (file, line, _("redefined symbol cannot be used on reloc")); 1167 1168 s = bfd_install_relocation (stdoutput, reloc, 1169 fragp->fr_literal, fragp->fr_address, 1170 sec, &err); 1171 switch (s) 1172 { 1173 case bfd_reloc_ok: 1174 break; 1175 case bfd_reloc_overflow: 1176 as_bad_where (file, line, _("relocation overflow")); 1177 break; 1178 case bfd_reloc_outofrange: 1179 as_bad_where (file, line, _("relocation out of range")); 1180 break; 1181 default: 1182 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"), 1183 file, line, s); 1184 } 1185 } 1186 1187 static fragS * 1188 get_frag_for_reloc (fragS *last_frag, 1189 const segment_info_type *seginfo, 1190 const struct reloc_list *r) 1191 { 1192 fragS *f; 1193 1194 for (f = last_frag; f != NULL; f = f->fr_next) 1195 if (f->fr_address <= r->u.b.r.address 1196 && r->u.b.r.address < f->fr_address + f->fr_fix) 1197 return f; 1198 1199 for (f = seginfo->frchainP->frch_root; 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 as_bad_where (r->file, r->line, 1210 _("reloc not within (fixed part of) section")); 1211 return NULL; 1212 } 1213 1214 static void 1215 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 1216 { 1217 segment_info_type *seginfo = seg_info (sec); 1218 unsigned int n; 1219 struct reloc_list *my_reloc_list, **rp, *r; 1220 arelent **relocs; 1221 fixS *fixp; 1222 fragS *last_frag; 1223 1224 /* If seginfo is NULL, we did not create this section; don't do 1225 anything with it. */ 1226 if (seginfo == NULL) 1227 return; 1228 1229 n = 0; 1230 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 1231 if (!fixp->fx_done) 1232 n++; 1233 1234 #ifdef RELOC_EXPANSION_POSSIBLE 1235 n *= MAX_RELOC_EXPANSION; 1236 #endif 1237 1238 /* Extract relocs for this section from reloc_list. */ 1239 rp = &reloc_list; 1240 my_reloc_list = NULL; 1241 while ((r = *rp) != NULL) 1242 { 1243 if (r->u.b.sec == sec) 1244 { 1245 *rp = r->next; 1246 r->next = my_reloc_list; 1247 my_reloc_list = r; 1248 n++; 1249 } 1250 else 1251 rp = &r->next; 1252 } 1253 1254 relocs = XCNEWVEC (arelent *, n); 1255 1256 n = 0; 1257 r = my_reloc_list; 1258 last_frag = NULL; 1259 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) 1260 { 1261 int fx_size, slack; 1262 offsetT loc; 1263 arelent **reloc; 1264 #ifndef RELOC_EXPANSION_POSSIBLE 1265 arelent *rel; 1266 1267 reloc = &rel; 1268 #endif 1269 1270 if (fixp->fx_done) 1271 continue; 1272 1273 fx_size = fixp->fx_size; 1274 slack = TC_FX_SIZE_SLACK (fixp); 1275 if (slack > 0) 1276 fx_size = fx_size > slack ? fx_size - slack : 0; 1277 loc = fixp->fx_where + fx_size; 1278 if (slack >= 0 && loc > fixp->fx_frag->fr_fix) 1279 as_bad_where (fixp->fx_file, fixp->fx_line, 1280 _("internal error: fixup not contained within frag")); 1281 1282 #ifndef RELOC_EXPANSION_POSSIBLE 1283 *reloc = tc_gen_reloc (sec, fixp); 1284 #else 1285 reloc = tc_gen_reloc (sec, fixp); 1286 #endif 1287 1288 while (*reloc) 1289 { 1290 while (r != NULL && r->u.b.r.address < (*reloc)->address) 1291 { 1292 fragS *f = get_frag_for_reloc (last_frag, seginfo, r); 1293 if (f != NULL) 1294 { 1295 last_frag = f; 1296 relocs[n++] = &r->u.b.r; 1297 install_reloc (sec, &r->u.b.r, f, r->file, r->line); 1298 } 1299 r = r->next; 1300 } 1301 relocs[n++] = *reloc; 1302 install_reloc (sec, *reloc, fixp->fx_frag, 1303 fixp->fx_file, fixp->fx_line); 1304 #ifndef RELOC_EXPANSION_POSSIBLE 1305 break; 1306 #else 1307 reloc++; 1308 #endif 1309 } 1310 } 1311 1312 while (r != NULL) 1313 { 1314 fragS *f = get_frag_for_reloc (last_frag, seginfo, r); 1315 if (f != NULL) 1316 { 1317 last_frag = f; 1318 relocs[n++] = &r->u.b.r; 1319 install_reloc (sec, &r->u.b.r, f, r->file, r->line); 1320 } 1321 r = r->next; 1322 } 1323 1324 #ifdef DEBUG4 1325 { 1326 unsigned int k, j, nsyms; 1327 asymbol **sympp; 1328 sympp = bfd_get_outsymbols (stdoutput); 1329 nsyms = bfd_get_symcount (stdoutput); 1330 for (k = 0; k < n; k++) 1331 if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0) 1332 { 1333 for (j = 0; j < nsyms; j++) 1334 if (sympp[j] == *relocs[k]->sym_ptr_ptr) 1335 break; 1336 if (j == nsyms) 1337 abort (); 1338 } 1339 } 1340 #endif 1341 1342 if (n) 1343 { 1344 flagword flags = bfd_get_section_flags (abfd, sec); 1345 flags |= SEC_RELOC; 1346 bfd_set_section_flags (abfd, sec, flags); 1347 bfd_set_reloc (stdoutput, sec, relocs, n); 1348 } 1349 1350 #ifdef SET_SECTION_RELOCS 1351 SET_SECTION_RELOCS (sec, relocs, n); 1352 #endif 1353 1354 #ifdef DEBUG3 1355 { 1356 unsigned int k; 1357 1358 fprintf (stderr, "relocs for sec %s\n", sec->name); 1359 for (k = 0; k < n; k++) 1360 { 1361 arelent *rel = relocs[k]; 1362 asymbol *s = *rel->sym_ptr_ptr; 1363 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n", 1364 k, rel, (unsigned long)rel->address, s->name, 1365 (unsigned long)rel->addend); 1366 } 1367 } 1368 #endif 1369 } 1370 1371 static int 1372 compress_frag (struct z_stream_s *strm, const char *contents, int in_size, 1373 fragS **last_newf, struct obstack *ob) 1374 { 1375 int out_size; 1376 int total_out_size = 0; 1377 fragS *f = *last_newf; 1378 char *next_out; 1379 int avail_out; 1380 1381 /* Call the compression routine repeatedly until it has finished 1382 processing the frag. */ 1383 while (in_size > 0) 1384 { 1385 /* Reserve all the space available in the current chunk. 1386 If none is available, start a new frag. */ 1387 avail_out = obstack_room (ob); 1388 if (avail_out <= 0) 1389 { 1390 obstack_finish (ob); 1391 f = frag_alloc (ob); 1392 f->fr_type = rs_fill; 1393 (*last_newf)->fr_next = f; 1394 *last_newf = f; 1395 avail_out = obstack_room (ob); 1396 } 1397 if (avail_out <= 0) 1398 as_fatal (_("can't extend frag")); 1399 next_out = obstack_next_free (ob); 1400 obstack_blank_fast (ob, avail_out); 1401 out_size = compress_data (strm, &contents, &in_size, 1402 &next_out, &avail_out); 1403 if (out_size < 0) 1404 return -1; 1405 1406 f->fr_fix += out_size; 1407 total_out_size += out_size; 1408 1409 /* Return unused space. */ 1410 if (avail_out > 0) 1411 obstack_blank_fast (ob, -avail_out); 1412 } 1413 1414 return total_out_size; 1415 } 1416 1417 static void 1418 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 1419 { 1420 segment_info_type *seginfo = seg_info (sec); 1421 fragS *f; 1422 fragS *first_newf; 1423 fragS *last_newf; 1424 struct obstack *ob = &seginfo->frchainP->frch_obstack; 1425 bfd_size_type uncompressed_size = (bfd_size_type) sec->size; 1426 bfd_size_type compressed_size; 1427 const char *section_name; 1428 char *compressed_name; 1429 char *header; 1430 struct z_stream_s *strm; 1431 int x; 1432 flagword flags = bfd_get_section_flags (abfd, sec); 1433 unsigned int header_size, compression_header_size; 1434 1435 if (seginfo == NULL 1436 || sec->size < 32 1437 || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC) 1438 return; 1439 1440 section_name = bfd_get_section_name (stdoutput, sec); 1441 if (strncmp (section_name, ".debug_", 7) != 0) 1442 return; 1443 1444 strm = compress_init (); 1445 if (strm == NULL) 1446 return; 1447 1448 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB) 1449 { 1450 compression_header_size 1451 = bfd_get_compression_header_size (stdoutput, NULL); 1452 header_size = compression_header_size; 1453 } 1454 else 1455 { 1456 compression_header_size = 0; 1457 header_size = 12; 1458 } 1459 1460 /* Create a new frag to contain the compression header. */ 1461 first_newf = frag_alloc (ob); 1462 if (obstack_room (ob) < header_size) 1463 first_newf = frag_alloc (ob); 1464 if (obstack_room (ob) < header_size) 1465 as_fatal (ngettext ("can't extend frag %lu char", 1466 "can't extend frag %lu chars", 1467 (unsigned long) header_size), 1468 (unsigned long) header_size); 1469 last_newf = first_newf; 1470 obstack_blank_fast (ob, header_size); 1471 last_newf->fr_type = rs_fill; 1472 last_newf->fr_fix = header_size; 1473 header = last_newf->fr_literal; 1474 compressed_size = header_size; 1475 1476 /* Stream the frags through the compression engine, adding new frags 1477 as necessary to accommodate the compressed output. */ 1478 for (f = seginfo->frchainP->frch_root; 1479 f; 1480 f = f->fr_next) 1481 { 1482 offsetT fill_size; 1483 char *fill_literal; 1484 offsetT count; 1485 int out_size; 1486 1487 gas_assert (f->fr_type == rs_fill); 1488 if (f->fr_fix) 1489 { 1490 out_size = compress_frag (strm, f->fr_literal, f->fr_fix, 1491 &last_newf, ob); 1492 if (out_size < 0) 1493 return; 1494 compressed_size += out_size; 1495 } 1496 fill_literal = f->fr_literal + f->fr_fix; 1497 fill_size = f->fr_var; 1498 count = f->fr_offset; 1499 gas_assert (count >= 0); 1500 if (fill_size && count) 1501 { 1502 while (count--) 1503 { 1504 out_size = compress_frag (strm, fill_literal, (int) fill_size, 1505 &last_newf, ob); 1506 if (out_size < 0) 1507 return; 1508 compressed_size += out_size; 1509 } 1510 } 1511 } 1512 1513 /* Flush the compression state. */ 1514 for (;;) 1515 { 1516 int avail_out; 1517 char *next_out; 1518 int out_size; 1519 1520 /* Reserve all the space available in the current chunk. 1521 If none is available, start a new frag. */ 1522 avail_out = obstack_room (ob); 1523 if (avail_out <= 0) 1524 { 1525 fragS *newf; 1526 1527 obstack_finish (ob); 1528 newf = frag_alloc (ob); 1529 newf->fr_type = rs_fill; 1530 last_newf->fr_next = newf; 1531 last_newf = newf; 1532 avail_out = obstack_room (ob); 1533 } 1534 if (avail_out <= 0) 1535 as_fatal (_("can't extend frag")); 1536 next_out = obstack_next_free (ob); 1537 obstack_blank_fast (ob, avail_out); 1538 x = compress_finish (strm, &next_out, &avail_out, &out_size); 1539 if (x < 0) 1540 return; 1541 1542 last_newf->fr_fix += out_size; 1543 compressed_size += out_size; 1544 1545 /* Return unused space. */ 1546 if (avail_out > 0) 1547 obstack_blank_fast (ob, -avail_out); 1548 1549 if (x == 0) 1550 break; 1551 } 1552 1553 /* PR binutils/18087: If compression didn't make the section smaller, 1554 just keep it uncompressed. */ 1555 if (compressed_size >= uncompressed_size) 1556 return; 1557 1558 /* Replace the uncompressed frag list with the compressed frag list. */ 1559 seginfo->frchainP->frch_root = first_newf; 1560 seginfo->frchainP->frch_last = last_newf; 1561 1562 /* Update the section size and its name. */ 1563 bfd_update_compression_header (abfd, (bfd_byte *) header, sec); 1564 x = bfd_set_section_size (abfd, sec, compressed_size); 1565 gas_assert (x); 1566 if (!compression_header_size) 1567 { 1568 compressed_name = concat (".z", section_name + 1, (char *) NULL); 1569 bfd_section_name (stdoutput, sec) = compressed_name; 1570 } 1571 } 1572 1573 static void 1574 write_contents (bfd *abfd ATTRIBUTE_UNUSED, 1575 asection *sec, 1576 void *xxx ATTRIBUTE_UNUSED) 1577 { 1578 segment_info_type *seginfo = seg_info (sec); 1579 addressT offset = 0; 1580 fragS *f; 1581 1582 /* Write out the frags. */ 1583 if (seginfo == NULL 1584 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)) 1585 return; 1586 1587 for (f = seginfo->frchainP->frch_root; 1588 f; 1589 f = f->fr_next) 1590 { 1591 int x; 1592 addressT fill_size; 1593 char *fill_literal; 1594 offsetT count; 1595 1596 gas_assert (f->fr_type == rs_fill); 1597 if (f->fr_fix) 1598 { 1599 x = bfd_set_section_contents (stdoutput, sec, 1600 f->fr_literal, (file_ptr) offset, 1601 (bfd_size_type) f->fr_fix); 1602 if (!x) 1603 as_fatal (ngettext ("can't write %ld byte " 1604 "to section %s of %s: '%s'", 1605 "can't write %ld bytes " 1606 "to section %s of %s: '%s'", 1607 (long) f->fr_fix), 1608 (long) f->fr_fix, 1609 sec->name, stdoutput->filename, 1610 bfd_errmsg (bfd_get_error ())); 1611 offset += f->fr_fix; 1612 } 1613 fill_literal = f->fr_literal + f->fr_fix; 1614 fill_size = f->fr_var; 1615 count = f->fr_offset; 1616 gas_assert (count >= 0); 1617 if (fill_size && count) 1618 { 1619 char buf[256]; 1620 if (fill_size > sizeof (buf)) 1621 { 1622 /* Do it the old way. Can this ever happen? */ 1623 while (count--) 1624 { 1625 x = bfd_set_section_contents (stdoutput, sec, 1626 fill_literal, 1627 (file_ptr) offset, 1628 (bfd_size_type) fill_size); 1629 if (!x) 1630 as_fatal (ngettext ("can't fill %ld byte " 1631 "in section %s of %s: '%s'", 1632 "can't fill %ld bytes " 1633 "in section %s of %s: '%s'", 1634 (long) fill_size), 1635 (long) fill_size, 1636 sec->name, stdoutput->filename, 1637 bfd_errmsg (bfd_get_error ())); 1638 offset += fill_size; 1639 } 1640 } 1641 else 1642 { 1643 /* Build a buffer full of fill objects and output it as 1644 often as necessary. This saves on the overhead of 1645 potentially lots of bfd_set_section_contents calls. */ 1646 int n_per_buf, i; 1647 if (fill_size == 1) 1648 { 1649 n_per_buf = sizeof (buf); 1650 memset (buf, *fill_literal, n_per_buf); 1651 } 1652 else 1653 { 1654 char *bufp; 1655 n_per_buf = sizeof (buf) / fill_size; 1656 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size) 1657 memcpy (bufp, fill_literal, fill_size); 1658 } 1659 for (; count > 0; count -= n_per_buf) 1660 { 1661 n_per_buf = n_per_buf > count ? count : n_per_buf; 1662 x = bfd_set_section_contents 1663 (stdoutput, sec, buf, (file_ptr) offset, 1664 (bfd_size_type) n_per_buf * fill_size); 1665 if (!x) 1666 as_fatal (ngettext ("can't fill %ld byte " 1667 "in section %s of %s: '%s'", 1668 "can't fill %ld bytes " 1669 "in section %s of %s: '%s'", 1670 (long) (n_per_buf * fill_size)), 1671 (long) (n_per_buf * fill_size), 1672 sec->name, stdoutput->filename, 1673 bfd_errmsg (bfd_get_error ())); 1674 offset += n_per_buf * fill_size; 1675 } 1676 } 1677 } 1678 } 1679 } 1680 1681 static void 1682 merge_data_into_text (void) 1683 { 1684 seg_info (text_section)->frchainP->frch_last->fr_next = 1685 seg_info (data_section)->frchainP->frch_root; 1686 seg_info (text_section)->frchainP->frch_last = 1687 seg_info (data_section)->frchainP->frch_last; 1688 seg_info (data_section)->frchainP = 0; 1689 } 1690 1691 static void 1692 set_symtab (void) 1693 { 1694 int nsyms; 1695 asymbol **asympp; 1696 symbolS *symp; 1697 bfd_boolean result; 1698 1699 /* Count symbols. We can't rely on a count made by the loop in 1700 write_object_file, because *_frob_file may add a new symbol or 1701 two. */ 1702 nsyms = 0; 1703 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1704 nsyms++; 1705 1706 if (nsyms) 1707 { 1708 int i; 1709 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *); 1710 1711 asympp = (asymbol **) bfd_alloc (stdoutput, amt); 1712 symp = symbol_rootP; 1713 for (i = 0; i < nsyms; i++, symp = symbol_next (symp)) 1714 { 1715 asympp[i] = symbol_get_bfdsym (symp); 1716 if (asympp[i]->flags != BSF_SECTION_SYM 1717 || !(bfd_is_const_section (asympp[i]->section) 1718 && asympp[i]->section->symbol == asympp[i])) 1719 asympp[i]->flags |= BSF_KEEP; 1720 symbol_mark_written (symp); 1721 } 1722 } 1723 else 1724 asympp = 0; 1725 result = bfd_set_symtab (stdoutput, asympp, nsyms); 1726 gas_assert (result); 1727 symbol_table_frozen = 1; 1728 } 1729 1730 /* Finish the subsegments. After every sub-segment, we fake an 1731 ".align ...". This conforms to BSD4.2 brain-damage. We then fake 1732 ".fill 0" because that is the kind of frag that requires least 1733 thought. ".align" frags like to have a following frag since that 1734 makes calculating their intended length trivial. */ 1735 1736 #ifndef SUB_SEGMENT_ALIGN 1737 #ifdef HANDLE_ALIGN 1738 /* The last subsegment gets an alignment corresponding to the alignment 1739 of the section. This allows proper nop-filling at the end of 1740 code-bearing sections. */ 1741 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \ 1742 (!(FRCHAIN)->frch_next && subseg_text_p (SEG) \ 1743 && !do_not_pad_sections_to_alignment \ 1744 ? get_recorded_alignment (SEG) \ 1745 : 0) 1746 #else 1747 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 1748 #endif 1749 #endif 1750 1751 static void 1752 subsegs_finish_section (asection *s) 1753 { 1754 struct frchain *frchainP; 1755 segment_info_type *seginfo = seg_info (s); 1756 if (!seginfo) 1757 return; 1758 1759 for (frchainP = seginfo->frchainP; 1760 frchainP != NULL; 1761 frchainP = frchainP->frch_next) 1762 { 1763 int alignment; 1764 1765 subseg_set (s, frchainP->frch_subseg); 1766 1767 /* This now gets called even if we had errors. In that case, 1768 any alignment is meaningless, and, moreover, will look weird 1769 if we are generating a listing. */ 1770 if (had_errors ()) 1771 do_not_pad_sections_to_alignment = 1; 1772 1773 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP); 1774 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE) 1775 && now_seg->entsize) 1776 { 1777 unsigned int entsize = now_seg->entsize; 1778 int entalign = 0; 1779 1780 while ((entsize & 1) == 0) 1781 { 1782 ++entalign; 1783 entsize >>= 1; 1784 } 1785 1786 if (entalign > alignment) 1787 alignment = entalign; 1788 } 1789 1790 if (subseg_text_p (now_seg)) 1791 frag_align_code (alignment, 0); 1792 else 1793 frag_align (alignment, 0, 0); 1794 1795 /* frag_align will have left a new frag. 1796 Use this last frag for an empty ".fill". 1797 1798 For this segment ... 1799 Create a last frag. Do not leave a "being filled in frag". */ 1800 frag_wane (frag_now); 1801 frag_now->fr_fix = 0; 1802 know (frag_now->fr_next == NULL); 1803 } 1804 } 1805 1806 static void 1807 subsegs_finish (void) 1808 { 1809 asection *s; 1810 1811 for (s = stdoutput->sections; s; s = s->next) 1812 subsegs_finish_section (s); 1813 } 1814 1815 #ifdef OBJ_ELF 1816 static void 1817 create_obj_attrs_section (void) 1818 { 1819 segT s; 1820 char *p; 1821 offsetT size; 1822 const char *name; 1823 1824 size = bfd_elf_obj_attr_size (stdoutput); 1825 if (size) 1826 { 1827 name = get_elf_backend_data (stdoutput)->obj_attrs_section; 1828 if (!name) 1829 name = ".gnu.attributes"; 1830 s = subseg_new (name, 0); 1831 elf_section_type (s) 1832 = get_elf_backend_data (stdoutput)->obj_attrs_section_type; 1833 bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA); 1834 frag_now_fix (); 1835 p = frag_more (size); 1836 bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size); 1837 1838 subsegs_finish_section (s); 1839 relax_segment (seg_info (s)->frchainP->frch_root, s, 0); 1840 size_seg (stdoutput, s, NULL); 1841 } 1842 } 1843 #endif 1844 1845 /* Write the object file. */ 1846 1847 void 1848 write_object_file (void) 1849 { 1850 struct relax_seg_info rsi; 1851 #ifndef WORKING_DOT_WORD 1852 fragS *fragP; /* Track along all frags. */ 1853 #endif 1854 1855 subsegs_finish (); 1856 1857 #ifdef md_pre_output_hook 1858 md_pre_output_hook; 1859 #endif 1860 1861 #ifdef md_pre_relax_hook 1862 md_pre_relax_hook; 1863 #endif 1864 1865 /* From now on, we don't care about sub-segments. Build one frag chain 1866 for each segment. Linked through fr_next. */ 1867 1868 /* Remove the sections created by gas for its own purposes. */ 1869 { 1870 int i; 1871 1872 bfd_section_list_remove (stdoutput, reg_section); 1873 bfd_section_list_remove (stdoutput, expr_section); 1874 stdoutput->section_count -= 2; 1875 i = 0; 1876 bfd_map_over_sections (stdoutput, renumber_sections, &i); 1877 } 1878 1879 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0); 1880 1881 /* We have two segments. If user gave -R flag, then we must put the 1882 data frags into the text segment. Do this before relaxing so 1883 we know to take advantage of -R and make shorter addresses. */ 1884 if (flag_readonly_data_in_text) 1885 { 1886 merge_data_into_text (); 1887 } 1888 1889 rsi.pass = 0; 1890 while (1) 1891 { 1892 #ifndef WORKING_DOT_WORD 1893 /* We need to reset the markers in the broken word list and 1894 associated frags between calls to relax_segment (via 1895 relax_seg). Since the broken word list is global, we do it 1896 once per round, rather than locally in relax_segment for each 1897 segment. */ 1898 struct broken_word *brokp; 1899 1900 for (brokp = broken_words; 1901 brokp != (struct broken_word *) NULL; 1902 brokp = brokp->next_broken_word) 1903 { 1904 brokp->added = 0; 1905 1906 if (brokp->dispfrag != (fragS *) NULL 1907 && brokp->dispfrag->fr_type == rs_broken_word) 1908 brokp->dispfrag->fr_subtype = 0; 1909 } 1910 #endif 1911 1912 rsi.changed = 0; 1913 bfd_map_over_sections (stdoutput, relax_seg, &rsi); 1914 rsi.pass++; 1915 if (!rsi.changed) 1916 break; 1917 } 1918 1919 /* Note - Most ports will use the default value of 1920 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force 1921 local symbols to be resolved, removing their frag information. 1922 Some ports however, will not have finished relaxing all of 1923 their frags and will still need the local symbol frag 1924 information. These ports can set 1925 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */ 1926 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG; 1927 1928 bfd_map_over_sections (stdoutput, size_seg, (char *) 0); 1929 1930 /* Relaxation has completed. Freeze all syms. */ 1931 finalize_syms = 1; 1932 1933 dwarf2dbg_final_check (); 1934 1935 #ifdef md_post_relax_hook 1936 md_post_relax_hook; 1937 #endif 1938 1939 #ifdef OBJ_ELF 1940 if (IS_ELF) 1941 create_obj_attrs_section (); 1942 #endif 1943 1944 #ifndef WORKING_DOT_WORD 1945 { 1946 struct broken_word *lie; 1947 struct broken_word **prevP; 1948 1949 prevP = &broken_words; 1950 for (lie = broken_words; lie; lie = lie->next_broken_word) 1951 if (!lie->added) 1952 { 1953 expressionS exp; 1954 1955 subseg_change (lie->seg, lie->subseg); 1956 exp.X_op = O_subtract; 1957 exp.X_add_symbol = lie->add; 1958 exp.X_op_symbol = lie->sub; 1959 exp.X_add_number = lie->addnum; 1960 #ifdef TC_CONS_FIX_NEW 1961 TC_CONS_FIX_NEW (lie->frag, 1962 lie->word_goes_here - lie->frag->fr_literal, 1963 2, &exp, TC_PARSE_CONS_RETURN_NONE); 1964 #else 1965 fix_new_exp (lie->frag, 1966 lie->word_goes_here - lie->frag->fr_literal, 1967 2, &exp, 0, BFD_RELOC_16); 1968 #endif 1969 *prevP = lie->next_broken_word; 1970 } 1971 else 1972 prevP = &(lie->next_broken_word); 1973 1974 for (lie = broken_words; lie;) 1975 { 1976 struct broken_word *untruth; 1977 char *table_ptr; 1978 addressT table_addr; 1979 addressT from_addr, to_addr; 1980 int n, m; 1981 1982 subseg_change (lie->seg, lie->subseg); 1983 fragP = lie->dispfrag; 1984 1985 /* Find out how many broken_words go here. */ 1986 n = 0; 1987 for (untruth = lie; 1988 untruth && untruth->dispfrag == fragP; 1989 untruth = untruth->next_broken_word) 1990 if (untruth->added == 1) 1991 n++; 1992 1993 table_ptr = lie->dispfrag->fr_opcode; 1994 table_addr = (lie->dispfrag->fr_address 1995 + (table_ptr - lie->dispfrag->fr_literal)); 1996 /* Create the jump around the long jumps. This is a short 1997 jump from table_ptr+0 to table_ptr+n*long_jump_size. */ 1998 from_addr = table_addr; 1999 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size; 2000 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2001 lie->add); 2002 table_ptr += md_short_jump_size; 2003 table_addr += md_short_jump_size; 2004 2005 for (m = 0; 2006 lie && lie->dispfrag == fragP; 2007 m++, lie = lie->next_broken_word) 2008 { 2009 if (lie->added == 2) 2010 continue; 2011 /* Patch the jump table. */ 2012 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2013 untruth && untruth->dispfrag == fragP; 2014 untruth = untruth->next_broken_word) 2015 { 2016 if (untruth->use_jump == lie) 2017 { 2018 /* This is the offset from ??? to table_ptr+0. 2019 The target is the same for all users of this 2020 md_long_jump, but the "sub" bases (and hence the 2021 offsets) may be different. */ 2022 addressT to_word = table_addr - S_GET_VALUE (untruth->sub); 2023 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD 2024 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth); 2025 #endif 2026 md_number_to_chars (untruth->word_goes_here, to_word, 2); 2027 } 2028 } 2029 2030 /* Install the long jump. */ 2031 /* This is a long jump from table_ptr+0 to the final target. */ 2032 from_addr = table_addr; 2033 to_addr = S_GET_VALUE (lie->add) + lie->addnum; 2034 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 2035 lie->add); 2036 table_ptr += md_long_jump_size; 2037 table_addr += md_long_jump_size; 2038 } 2039 } 2040 } 2041 #endif /* not WORKING_DOT_WORD */ 2042 2043 /* Resolve symbol values. This needs to be done before processing 2044 the relocations. */ 2045 if (symbol_rootP) 2046 { 2047 symbolS *symp; 2048 2049 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2050 resolve_symbol_value (symp); 2051 } 2052 resolve_local_symbol_values (); 2053 resolve_reloc_expr_symbols (); 2054 2055 PROGRESS (1); 2056 2057 #ifdef tc_frob_file_before_adjust 2058 tc_frob_file_before_adjust (); 2059 #endif 2060 #ifdef obj_frob_file_before_adjust 2061 obj_frob_file_before_adjust (); 2062 #endif 2063 2064 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0); 2065 2066 #ifdef tc_frob_file_before_fix 2067 tc_frob_file_before_fix (); 2068 #endif 2069 #ifdef obj_frob_file_before_fix 2070 obj_frob_file_before_fix (); 2071 #endif 2072 2073 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0); 2074 2075 /* Set up symbol table, and write it out. */ 2076 if (symbol_rootP) 2077 { 2078 symbolS *symp; 2079 bfd_boolean skip_next_symbol = FALSE; 2080 2081 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 2082 { 2083 int punt = 0; 2084 const char *name; 2085 2086 if (skip_next_symbol) 2087 { 2088 /* Don't do anything besides moving the value of the 2089 symbol from the GAS value-field to the BFD value-field. */ 2090 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2091 skip_next_symbol = FALSE; 2092 continue; 2093 } 2094 2095 if (symbol_mri_common_p (symp)) 2096 { 2097 if (S_IS_EXTERNAL (symp)) 2098 as_bad (_("%s: global symbols not supported in common sections"), 2099 S_GET_NAME (symp)); 2100 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2101 continue; 2102 } 2103 2104 name = S_GET_NAME (symp); 2105 if (name) 2106 { 2107 const char *name2 = 2108 decode_local_label_name ((char *) S_GET_NAME (symp)); 2109 /* They only differ if `name' is a fb or dollar local 2110 label name. */ 2111 if (name2 != name && ! S_IS_DEFINED (symp)) 2112 as_bad (_("local label `%s' is not defined"), name2); 2113 } 2114 2115 /* Do it again, because adjust_reloc_syms might introduce 2116 more symbols. They'll probably only be section symbols, 2117 but they'll still need to have the values computed. */ 2118 resolve_symbol_value (symp); 2119 2120 /* Skip symbols which were equated to undefined or common 2121 symbols. */ 2122 if (symbol_equated_reloc_p (symp) 2123 || S_IS_WEAKREFR (symp)) 2124 { 2125 const char *sname = S_GET_NAME (symp); 2126 2127 if (S_IS_COMMON (symp) 2128 && !TC_FAKE_LABEL (sname) 2129 && !S_IS_WEAKREFR (symp)) 2130 { 2131 expressionS *e = symbol_get_value_expression (symp); 2132 2133 as_bad (_("`%s' can't be equated to common symbol `%s'"), 2134 sname, S_GET_NAME (e->X_add_symbol)); 2135 } 2136 if (S_GET_SEGMENT (symp) == reg_section) 2137 { 2138 /* Report error only if we know the symbol name. */ 2139 if (S_GET_NAME (symp) != reg_section->name) 2140 as_bad (_("can't make global register symbol `%s'"), 2141 sname); 2142 } 2143 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2144 continue; 2145 } 2146 2147 #ifdef obj_frob_symbol 2148 obj_frob_symbol (symp, punt); 2149 #endif 2150 #ifdef tc_frob_symbol 2151 if (! punt || symbol_used_in_reloc_p (symp)) 2152 tc_frob_symbol (symp, punt); 2153 #endif 2154 2155 /* If we don't want to keep this symbol, splice it out of 2156 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never 2157 want section symbols. Otherwise, we skip local symbols 2158 and symbols that the frob_symbol macros told us to punt, 2159 but we keep such symbols if they are used in relocs. */ 2160 if (symp == abs_section_sym 2161 || (! EMIT_SECTION_SYMBOLS 2162 && symbol_section_p (symp)) 2163 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always 2164 opposites. Sometimes the former checks flags and the 2165 latter examines the name... */ 2166 || (!S_IS_EXTERNAL (symp) 2167 && (punt || S_IS_LOCAL (symp) || 2168 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp))) 2169 && ! symbol_used_in_reloc_p (symp))) 2170 { 2171 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 2172 2173 /* After symbol_remove, symbol_next(symp) still returns 2174 the one that came after it in the chain. So we don't 2175 need to do any extra cleanup work here. */ 2176 continue; 2177 } 2178 2179 /* Make sure we really got a value for the symbol. */ 2180 if (! symbol_resolved_p (symp)) 2181 { 2182 as_bad (_("can't resolve value for symbol `%s'"), 2183 S_GET_NAME (symp)); 2184 symbol_mark_resolved (symp); 2185 } 2186 2187 /* Set the value into the BFD symbol. Up til now the value 2188 has only been kept in the gas symbolS struct. */ 2189 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 2190 2191 /* A warning construct is a warning symbol followed by the 2192 symbol warned about. Don't let anything object-format or 2193 target-specific muck with it; it's ready for output. */ 2194 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING) 2195 skip_next_symbol = TRUE; 2196 } 2197 } 2198 2199 PROGRESS (1); 2200 2201 /* Now do any format-specific adjustments to the symbol table, such 2202 as adding file symbols. */ 2203 #ifdef tc_adjust_symtab 2204 tc_adjust_symtab (); 2205 #endif 2206 #ifdef obj_adjust_symtab 2207 obj_adjust_symtab (); 2208 #endif 2209 2210 /* Stop if there is an error. */ 2211 if (had_errors ()) 2212 return; 2213 2214 /* Now that all the sizes are known, and contents correct, we can 2215 start writing to the file. */ 2216 set_symtab (); 2217 2218 /* If *_frob_file changes the symbol value at this point, it is 2219 responsible for moving the changed value into symp->bsym->value 2220 as well. Hopefully all symbol value changing can be done in 2221 *_frob_symbol. */ 2222 #ifdef tc_frob_file 2223 tc_frob_file (); 2224 #endif 2225 #ifdef obj_frob_file 2226 obj_frob_file (); 2227 #endif 2228 #ifdef obj_coff_generate_pdata 2229 obj_coff_generate_pdata (); 2230 #endif 2231 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0); 2232 2233 #ifdef tc_frob_file_after_relocs 2234 tc_frob_file_after_relocs (); 2235 #endif 2236 #ifdef obj_frob_file_after_relocs 2237 obj_frob_file_after_relocs (); 2238 #endif 2239 2240 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF 2241 if (IS_ELF && flag_use_elf_stt_common) 2242 stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON; 2243 #endif 2244 2245 /* Once all relocations have been written, we can compress the 2246 contents of the debug sections. This needs to be done before 2247 we start writing any sections, because it will affect the file 2248 layout, which is fixed once we start writing contents. */ 2249 if (flag_compress_debug) 2250 { 2251 if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB) 2252 stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI; 2253 else 2254 stdoutput->flags |= BFD_COMPRESS; 2255 bfd_map_over_sections (stdoutput, compress_debug, (char *) 0); 2256 } 2257 2258 bfd_map_over_sections (stdoutput, write_contents, (char *) 0); 2259 } 2260 2261 #ifdef TC_GENERIC_RELAX_TABLE 2262 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ 2263 2264 long 2265 relax_frag (segT segment, fragS *fragP, long stretch) 2266 { 2267 const relax_typeS *this_type; 2268 const relax_typeS *start_type; 2269 relax_substateT next_state; 2270 relax_substateT this_state; 2271 offsetT growth; 2272 offsetT aim; 2273 addressT target; 2274 addressT address; 2275 symbolS *symbolP; 2276 const relax_typeS *table; 2277 2278 target = fragP->fr_offset; 2279 address = fragP->fr_address; 2280 table = TC_GENERIC_RELAX_TABLE; 2281 this_state = fragP->fr_subtype; 2282 start_type = this_type = table + this_state; 2283 symbolP = fragP->fr_symbol; 2284 2285 if (symbolP) 2286 { 2287 fragS *sym_frag; 2288 2289 sym_frag = symbol_get_frag (symbolP); 2290 2291 #ifndef DIFF_EXPR_OK 2292 know (sym_frag != NULL); 2293 #endif 2294 know (S_GET_SEGMENT (symbolP) != absolute_section 2295 || sym_frag == &zero_address_frag); 2296 target += S_GET_VALUE (symbolP); 2297 2298 /* If SYM_FRAG has yet to be reached on this pass, assume it 2299 will move by STRETCH just as we did, unless there is an 2300 alignment frag between here and SYM_FRAG. An alignment may 2301 well absorb any STRETCH, and we don't want to choose a larger 2302 branch insn by overestimating the needed reach of this 2303 branch. It isn't critical to calculate TARGET exactly; We 2304 know we'll be doing another pass if STRETCH is non-zero. */ 2305 2306 if (stretch != 0 2307 && sym_frag->relax_marker != fragP->relax_marker 2308 && S_GET_SEGMENT (symbolP) == segment) 2309 { 2310 if (stretch < 0 2311 || sym_frag->region == fragP->region) 2312 target += stretch; 2313 /* If we get here we know we have a forward branch. This 2314 relax pass may have stretched previous instructions so 2315 far that omitting STRETCH would make the branch 2316 negative. Don't allow this in case the negative reach is 2317 large enough to require a larger branch instruction. */ 2318 else if (target < address) 2319 target = fragP->fr_next->fr_address + stretch; 2320 } 2321 } 2322 2323 aim = target - address - fragP->fr_fix; 2324 #ifdef TC_PCREL_ADJUST 2325 /* Currently only the ns32k family needs this. */ 2326 aim += TC_PCREL_ADJUST (fragP); 2327 #endif 2328 2329 #ifdef md_prepare_relax_scan 2330 /* Formerly called M68K_AIM_KLUDGE. */ 2331 md_prepare_relax_scan (fragP, address, aim, this_state, this_type); 2332 #endif 2333 2334 if (aim < 0) 2335 { 2336 /* Look backwards. */ 2337 for (next_state = this_type->rlx_more; next_state;) 2338 if (aim >= this_type->rlx_backward) 2339 next_state = 0; 2340 else 2341 { 2342 /* Grow to next state. */ 2343 this_state = next_state; 2344 this_type = table + this_state; 2345 next_state = this_type->rlx_more; 2346 } 2347 } 2348 else 2349 { 2350 /* Look forwards. */ 2351 for (next_state = this_type->rlx_more; next_state;) 2352 if (aim <= this_type->rlx_forward) 2353 next_state = 0; 2354 else 2355 { 2356 /* Grow to next state. */ 2357 this_state = next_state; 2358 this_type = table + this_state; 2359 next_state = this_type->rlx_more; 2360 } 2361 } 2362 2363 growth = this_type->rlx_length - start_type->rlx_length; 2364 if (growth != 0) 2365 fragP->fr_subtype = this_state; 2366 return growth; 2367 } 2368 2369 #endif /* defined (TC_GENERIC_RELAX_TABLE) */ 2370 2371 /* Relax_align. Advance location counter to next address that has 'alignment' 2372 lowest order bits all 0s, return size of adjustment made. */ 2373 static relax_addressT 2374 relax_align (relax_addressT address, /* Address now. */ 2375 int alignment /* Alignment (binary). */) 2376 { 2377 relax_addressT mask; 2378 relax_addressT new_address; 2379 2380 mask = ~((relax_addressT) ~0 << alignment); 2381 new_address = (address + mask) & (~mask); 2382 #ifdef LINKER_RELAXING_SHRINKS_ONLY 2383 if (linkrelax) 2384 /* We must provide lots of padding, so the linker can discard it 2385 when needed. The linker will not add extra space, ever. */ 2386 new_address += (1 << alignment); 2387 #endif 2388 return (new_address - address); 2389 } 2390 2391 /* Now we have a segment, not a crowd of sub-segments, we can make 2392 fr_address values. 2393 2394 Relax the frags. 2395 2396 After this, all frags in this segment have addresses that are correct 2397 within the segment. Since segments live in different file addresses, 2398 these frag addresses may not be the same as final object-file 2399 addresses. */ 2400 2401 int 2402 relax_segment (struct frag *segment_frag_root, segT segment, int pass) 2403 { 2404 unsigned long frag_count; 2405 struct frag *fragP; 2406 relax_addressT address; 2407 int region; 2408 int ret; 2409 2410 /* In case md_estimate_size_before_relax() wants to make fixSs. */ 2411 subseg_change (segment, 0); 2412 2413 /* For each frag in segment: count and store (a 1st guess of) 2414 fr_address. */ 2415 address = 0; 2416 region = 0; 2417 for (frag_count = 0, fragP = segment_frag_root; 2418 fragP; 2419 fragP = fragP->fr_next, frag_count ++) 2420 { 2421 fragP->region = region; 2422 fragP->relax_marker = 0; 2423 fragP->fr_address = address; 2424 address += fragP->fr_fix; 2425 2426 switch (fragP->fr_type) 2427 { 2428 case rs_fill: 2429 address += fragP->fr_offset * fragP->fr_var; 2430 break; 2431 2432 case rs_align: 2433 case rs_align_code: 2434 case rs_align_test: 2435 { 2436 addressT offset = relax_align (address, (int) fragP->fr_offset); 2437 2438 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) 2439 offset = 0; 2440 2441 if (offset % fragP->fr_var != 0) 2442 { 2443 as_bad_where (fragP->fr_file, fragP->fr_line, 2444 ngettext ("alignment padding (%lu byte) " 2445 "not a multiple of %ld", 2446 "alignment padding (%lu bytes) " 2447 "not a multiple of %ld", 2448 (unsigned long) offset), 2449 (unsigned long) offset, (long) fragP->fr_var); 2450 offset -= (offset % fragP->fr_var); 2451 } 2452 2453 address += offset; 2454 region += 1; 2455 } 2456 break; 2457 2458 case rs_org: 2459 /* Assume .org is nugatory. It will grow with 1st relax. */ 2460 region += 1; 2461 break; 2462 2463 case rs_space: 2464 break; 2465 2466 case rs_machine_dependent: 2467 /* If fr_symbol is an expression, this call to 2468 resolve_symbol_value sets up the correct segment, which will 2469 likely be needed in md_estimate_size_before_relax. */ 2470 if (fragP->fr_symbol) 2471 resolve_symbol_value (fragP->fr_symbol); 2472 2473 address += md_estimate_size_before_relax (fragP, segment); 2474 break; 2475 2476 #ifndef WORKING_DOT_WORD 2477 /* Broken words don't concern us yet. */ 2478 case rs_broken_word: 2479 break; 2480 #endif 2481 2482 case rs_leb128: 2483 /* Initial guess is always 1; doing otherwise can result in 2484 stable solutions that are larger than the minimum. */ 2485 address += fragP->fr_offset = 1; 2486 break; 2487 2488 case rs_cfa: 2489 address += eh_frame_estimate_size_before_relax (fragP); 2490 break; 2491 2492 case rs_dwarf2dbg: 2493 address += dwarf2dbg_estimate_size_before_relax (fragP); 2494 break; 2495 2496 default: 2497 BAD_CASE (fragP->fr_type); 2498 break; 2499 } 2500 } 2501 2502 /* Do relax(). */ 2503 { 2504 unsigned long max_iterations; 2505 2506 /* Cumulative address adjustment. */ 2507 offsetT stretch; 2508 2509 /* Have we made any adjustment this pass? We can't just test 2510 stretch because one piece of code may have grown and another 2511 shrank. */ 2512 int stretched; 2513 2514 /* Most horrible, but gcc may give us some exception data that 2515 is impossible to assemble, of the form 2516 2517 .align 4 2518 .byte 0, 0 2519 .uleb128 end - start 2520 start: 2521 .space 128*128 - 1 2522 .align 4 2523 end: 2524 2525 If the leb128 is two bytes in size, then end-start is 128*128, 2526 which requires a three byte leb128. If the leb128 is three 2527 bytes in size, then end-start is 128*128-1, which requires a 2528 two byte leb128. We work around this dilemma by inserting 2529 an extra 4 bytes of alignment just after the .align. This 2530 works because the data after the align is accessed relative to 2531 the end label. 2532 2533 This counter is used in a tiny state machine to detect 2534 whether a leb128 followed by an align is impossible to 2535 relax. */ 2536 int rs_leb128_fudge = 0; 2537 2538 /* We want to prevent going into an infinite loop where one frag grows 2539 depending upon the location of a symbol which is in turn moved by 2540 the growing frag. eg: 2541 2542 foo = . 2543 .org foo+16 2544 foo = . 2545 2546 So we dictate that this algorithm can be at most O2. */ 2547 max_iterations = frag_count * frag_count; 2548 /* Check for overflow. */ 2549 if (max_iterations < frag_count) 2550 max_iterations = frag_count; 2551 2552 ret = 0; 2553 do 2554 { 2555 stretch = 0; 2556 stretched = 0; 2557 2558 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2559 { 2560 offsetT growth = 0; 2561 addressT was_address; 2562 offsetT offset; 2563 symbolS *symbolP; 2564 2565 fragP->relax_marker ^= 1; 2566 was_address = fragP->fr_address; 2567 address = fragP->fr_address += stretch; 2568 symbolP = fragP->fr_symbol; 2569 offset = fragP->fr_offset; 2570 2571 switch (fragP->fr_type) 2572 { 2573 case rs_fill: /* .fill never relaxes. */ 2574 growth = 0; 2575 break; 2576 2577 #ifndef WORKING_DOT_WORD 2578 /* JF: This is RMS's idea. I do *NOT* want to be blamed 2579 for it I do not want to write it. I do not want to have 2580 anything to do with it. This is not the proper way to 2581 implement this misfeature. */ 2582 case rs_broken_word: 2583 { 2584 struct broken_word *lie; 2585 struct broken_word *untruth; 2586 2587 /* Yes this is ugly (storing the broken_word pointer 2588 in the symbol slot). Still, this whole chunk of 2589 code is ugly, and I don't feel like doing anything 2590 about it. Think of it as stubbornness in action. */ 2591 growth = 0; 2592 for (lie = (struct broken_word *) (fragP->fr_symbol); 2593 lie && lie->dispfrag == fragP; 2594 lie = lie->next_broken_word) 2595 { 2596 2597 if (lie->added) 2598 continue; 2599 2600 offset = (S_GET_VALUE (lie->add) 2601 + lie->addnum 2602 - S_GET_VALUE (lie->sub)); 2603 if (offset <= -32768 || offset >= 32767) 2604 { 2605 if (flag_warn_displacement) 2606 { 2607 char buf[50]; 2608 sprint_value (buf, (addressT) lie->addnum); 2609 as_warn_where (fragP->fr_file, fragP->fr_line, 2610 _(".word %s-%s+%s didn't fit"), 2611 S_GET_NAME (lie->add), 2612 S_GET_NAME (lie->sub), 2613 buf); 2614 } 2615 if (fragP->fr_subtype == 0) 2616 { 2617 fragP->fr_subtype++; 2618 growth += md_short_jump_size; 2619 } 2620 2621 /* Redirect *all* words of this table with the same 2622 target, lest we have to handle the case where the 2623 same target but with a offset that fits on this 2624 round overflows at the next relaxation round. */ 2625 for (untruth = (struct broken_word *) (fragP->fr_symbol); 2626 untruth && untruth->dispfrag == lie->dispfrag; 2627 untruth = untruth->next_broken_word) 2628 if ((symbol_get_frag (untruth->add) 2629 == symbol_get_frag (lie->add)) 2630 && (S_GET_VALUE (untruth->add) 2631 == S_GET_VALUE (lie->add))) 2632 { 2633 untruth->added = 2; 2634 untruth->use_jump = lie; 2635 } 2636 2637 lie->added = 1; 2638 growth += md_long_jump_size; 2639 } 2640 } 2641 2642 break; 2643 } /* case rs_broken_word */ 2644 #endif 2645 case rs_align: 2646 case rs_align_code: 2647 case rs_align_test: 2648 { 2649 addressT oldoff, newoff; 2650 2651 oldoff = relax_align (was_address + fragP->fr_fix, 2652 (int) offset); 2653 newoff = relax_align (address + fragP->fr_fix, 2654 (int) offset); 2655 2656 if (fragP->fr_subtype != 0) 2657 { 2658 if (oldoff > fragP->fr_subtype) 2659 oldoff = 0; 2660 if (newoff > fragP->fr_subtype) 2661 newoff = 0; 2662 } 2663 2664 growth = newoff - oldoff; 2665 2666 /* If this align happens to follow a leb128 and 2667 we have determined that the leb128 is bouncing 2668 in size, then break the cycle by inserting an 2669 extra alignment. */ 2670 if (growth < 0 2671 && (rs_leb128_fudge & 16) != 0 2672 && (rs_leb128_fudge & 15) >= 2) 2673 { 2674 segment_info_type *seginfo = seg_info (segment); 2675 struct obstack *ob = &seginfo->frchainP->frch_obstack; 2676 struct frag *newf; 2677 2678 newf = frag_alloc (ob); 2679 obstack_blank_fast (ob, fragP->fr_var); 2680 obstack_finish (ob); 2681 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG); 2682 memcpy (newf->fr_literal, 2683 fragP->fr_literal + fragP->fr_fix, 2684 fragP->fr_var); 2685 newf->fr_type = rs_fill; 2686 newf->fr_address = address + fragP->fr_fix + newoff; 2687 newf->fr_fix = 0; 2688 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset) 2689 / fragP->fr_var); 2690 if (newf->fr_offset * newf->fr_var 2691 != (offsetT) 1 << fragP->fr_offset) 2692 { 2693 newf->fr_offset = (offsetT) 1 << fragP->fr_offset; 2694 newf->fr_var = 1; 2695 } 2696 /* Include size of new frag in GROWTH. */ 2697 growth += newf->fr_offset * newf->fr_var; 2698 /* Adjust the new frag address for the amount 2699 we'll add when we process the new frag. */ 2700 newf->fr_address -= stretch + growth; 2701 newf->relax_marker ^= 1; 2702 fragP->fr_next = newf; 2703 #ifdef DEBUG 2704 as_warn (_("padding added")); 2705 #endif 2706 } 2707 } 2708 break; 2709 2710 case rs_org: 2711 { 2712 addressT target = offset; 2713 addressT after; 2714 2715 if (symbolP) 2716 { 2717 /* Convert from an actual address to an octet offset 2718 into the section. Here it is assumed that the 2719 section's VMA is zero, and can omit subtracting it 2720 from the symbol's value to get the address offset. */ 2721 know (S_GET_SEGMENT (symbolP)->vma == 0); 2722 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE; 2723 } 2724 2725 know (fragP->fr_next); 2726 after = fragP->fr_next->fr_address + stretch; 2727 growth = target - after; 2728 2729 /* Growth may be negative, but variable part of frag 2730 cannot have fewer than 0 chars. That is, we can't 2731 .org backwards. */ 2732 if (address + fragP->fr_fix > target) 2733 { 2734 growth = 0; 2735 2736 /* Don't error on first few frag relax passes. 2737 The symbol might be an expression involving 2738 symbol values from other sections. If those 2739 sections have not yet been processed their 2740 frags will all have zero addresses, so we 2741 will calculate incorrect values for them. The 2742 number of passes we allow before giving an 2743 error is somewhat arbitrary. It should be at 2744 least one, with larger values requiring 2745 increasingly contrived dependencies between 2746 frags to trigger a false error. */ 2747 if (pass < 2) 2748 { 2749 /* Force another pass. */ 2750 ret = 1; 2751 break; 2752 } 2753 2754 as_bad_where (fragP->fr_file, fragP->fr_line, 2755 _("attempt to move .org backwards")); 2756 2757 /* We've issued an error message. Change the 2758 frag to avoid cascading errors. */ 2759 fragP->fr_type = rs_align; 2760 fragP->fr_subtype = 0; 2761 fragP->fr_offset = 0; 2762 fragP->fr_fix = after - address; 2763 } 2764 } 2765 break; 2766 2767 case rs_space: 2768 growth = 0; 2769 if (symbolP) 2770 { 2771 offsetT amount; 2772 2773 amount = S_GET_VALUE (symbolP); 2774 if (S_GET_SEGMENT (symbolP) != absolute_section 2775 || S_IS_COMMON (symbolP) 2776 || ! S_IS_DEFINED (symbolP)) 2777 { 2778 as_bad_where (fragP->fr_file, fragP->fr_line, 2779 _(".space specifies non-absolute value")); 2780 /* Prevent repeat of this error message. */ 2781 fragP->fr_symbol = 0; 2782 } 2783 else if (amount < 0) 2784 { 2785 /* Don't error on first few frag relax passes. 2786 See rs_org comment for a longer explanation. */ 2787 if (pass < 2) 2788 { 2789 ret = 1; 2790 break; 2791 } 2792 2793 as_warn_where (fragP->fr_file, fragP->fr_line, 2794 _(".space or .fill with negative value, ignored")); 2795 fragP->fr_symbol = 0; 2796 } 2797 else 2798 growth = (was_address + fragP->fr_fix + amount 2799 - fragP->fr_next->fr_address); 2800 } 2801 break; 2802 2803 case rs_machine_dependent: 2804 #ifdef md_relax_frag 2805 growth = md_relax_frag (segment, fragP, stretch); 2806 #else 2807 #ifdef TC_GENERIC_RELAX_TABLE 2808 /* The default way to relax a frag is to look through 2809 TC_GENERIC_RELAX_TABLE. */ 2810 growth = relax_frag (segment, fragP, stretch); 2811 #endif /* TC_GENERIC_RELAX_TABLE */ 2812 #endif 2813 break; 2814 2815 case rs_leb128: 2816 { 2817 valueT value; 2818 offsetT size; 2819 2820 value = resolve_symbol_value (fragP->fr_symbol); 2821 size = sizeof_leb128 (value, fragP->fr_subtype); 2822 growth = size - fragP->fr_offset; 2823 fragP->fr_offset = size; 2824 } 2825 break; 2826 2827 case rs_cfa: 2828 growth = eh_frame_relax_frag (fragP); 2829 break; 2830 2831 case rs_dwarf2dbg: 2832 growth = dwarf2dbg_relax_frag (fragP); 2833 break; 2834 2835 default: 2836 BAD_CASE (fragP->fr_type); 2837 break; 2838 } 2839 if (growth) 2840 { 2841 stretch += growth; 2842 stretched = 1; 2843 if (fragP->fr_type == rs_leb128) 2844 rs_leb128_fudge += 16; 2845 else if (fragP->fr_type == rs_align 2846 && (rs_leb128_fudge & 16) != 0 2847 && stretch == 0) 2848 rs_leb128_fudge += 16; 2849 else 2850 rs_leb128_fudge = 0; 2851 } 2852 } 2853 2854 if (stretch == 0 2855 && (rs_leb128_fudge & 16) == 0 2856 && (rs_leb128_fudge & -16) != 0) 2857 rs_leb128_fudge += 1; 2858 else 2859 rs_leb128_fudge = 0; 2860 } 2861 /* Until nothing further to relax. */ 2862 while (stretched && -- max_iterations); 2863 2864 if (stretched) 2865 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"), 2866 segment_name (segment)); 2867 } 2868 2869 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2870 if (fragP->last_fr_address != fragP->fr_address) 2871 { 2872 fragP->last_fr_address = fragP->fr_address; 2873 ret = 1; 2874 } 2875 return ret; 2876 } 2877 2878 void 2879 number_to_chars_bigendian (char *buf, valueT val, int n) 2880 { 2881 if (n <= 0) 2882 abort (); 2883 while (n--) 2884 { 2885 buf[n] = val & 0xff; 2886 val >>= 8; 2887 } 2888 } 2889 2890 void 2891 number_to_chars_littleendian (char *buf, valueT val, int n) 2892 { 2893 if (n <= 0) 2894 abort (); 2895 while (n--) 2896 { 2897 *buf++ = val & 0xff; 2898 val >>= 8; 2899 } 2900 } 2901 2902 void 2903 write_print_statistics (FILE *file) 2904 { 2905 fprintf (file, "fixups: %d\n", n_fixups); 2906 } 2907 2908 /* For debugging. */ 2909 extern int indent_level; 2910 2911 void 2912 print_fixup (fixS *fixp) 2913 { 2914 indent_level = 1; 2915 fprintf (stderr, "fix "); 2916 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp)); 2917 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line); 2918 if (fixp->fx_pcrel) 2919 fprintf (stderr, " pcrel"); 2920 if (fixp->fx_pcrel_adjust) 2921 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust); 2922 if (fixp->fx_im_disp) 2923 { 2924 #ifdef TC_NS32K 2925 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp); 2926 #else 2927 fprintf (stderr, " im_disp"); 2928 #endif 2929 } 2930 if (fixp->fx_tcbit) 2931 fprintf (stderr, " tcbit"); 2932 if (fixp->fx_done) 2933 fprintf (stderr, " done"); 2934 fprintf (stderr, "\n size=%d frag=", fixp->fx_size); 2935 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag)); 2936 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx", 2937 (long) fixp->fx_where, 2938 (unsigned long) fixp->fx_offset, 2939 (unsigned long) fixp->fx_addnumber); 2940 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), 2941 fixp->fx_r_type); 2942 if (fixp->fx_addsy) 2943 { 2944 fprintf (stderr, "\n +<"); 2945 print_symbol_value_1 (stderr, fixp->fx_addsy); 2946 fprintf (stderr, ">"); 2947 } 2948 if (fixp->fx_subsy) 2949 { 2950 fprintf (stderr, "\n -<"); 2951 print_symbol_value_1 (stderr, fixp->fx_subsy); 2952 fprintf (stderr, ">"); 2953 } 2954 fprintf (stderr, "\n"); 2955 #ifdef TC_FIX_DATA_PRINT 2956 TC_FIX_DATA_PRINT (stderr, fixp); 2957 #endif 2958 } 2959