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