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