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