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 with 825 a non-zero addend if the addend would place the relocation otside 826 the section's limits. */ 827 if ((symsec->flags & SEC_MERGE) != 0 828 && (S_GET_VALUE(sym) + fixp->fx_offset >= bfd_get_section_size(symsec) 829 || fixp->fx_subsy != NULL)) 830 continue; 831 832 /* Never adjust a reloc against TLS local symbol. */ 833 if ((symsec->flags & SEC_THREAD_LOCAL) != 0) 834 continue; 835 836 /* We refetch the segment when calling section_symbol, rather 837 than using symsec, because S_GET_VALUE may wind up changing 838 the section when it calls resolve_symbol_value. */ 839 fixp->fx_offset += S_GET_VALUE (sym); 840 fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym)); 841 #ifdef DEBUG5 842 fprintf (stderr, "\nadjusted fixup:\n"); 843 print_fixup (fixp); 844 #endif 845 } 846 847 dump_section_relocs (abfd, sec, stderr); 848 } 849 850 /* fixup_segment() 851 852 Go through all the fixS's in a segment and see which ones can be 853 handled now. (These consist of fixS where we have since discovered 854 the value of a symbol, or the address of the frag involved.) 855 For each one, call md_apply_fix to put the fix into the frag data. 856 857 Result is a count of how many relocation structs will be needed to 858 handle the remaining fixS's that we couldn't completely handle here. 859 These will be output later by emit_relocations(). */ 860 861 static long 862 fixup_segment (fixS *fixP, segT this_segment) 863 { 864 long seg_reloc_count = 0; 865 valueT add_number; 866 fragS *fragP; 867 segT add_symbol_segment = absolute_section; 868 869 if (fixP != NULL && abs_section_sym == NULL) 870 abs_section_sym = section_symbol (absolute_section); 871 872 /* If the linker is doing the relaxing, we must not do any fixups. 873 874 Well, strictly speaking that's not true -- we could do any that 875 are PC-relative and don't cross regions that could change size. 876 And for the i960 we might be able to turn callx/callj into bal 877 anyways in cases where we know the maximum displacement. */ 878 if (linkrelax && TC_LINKRELAX_FIXUP (this_segment)) 879 { 880 for (; fixP; fixP = fixP->fx_next) 881 if (!fixP->fx_done) 882 { 883 if (fixP->fx_addsy == NULL) 884 { 885 /* There was no symbol required by this relocation. 886 However, BFD doesn't really handle relocations 887 without symbols well. So fake up a local symbol in 888 the absolute section. */ 889 fixP->fx_addsy = abs_section_sym; 890 } 891 symbol_mark_used_in_reloc (fixP->fx_addsy); 892 if (fixP->fx_subsy != NULL) 893 symbol_mark_used_in_reloc (fixP->fx_subsy); 894 seg_reloc_count++; 895 } 896 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count); 897 return seg_reloc_count; 898 } 899 900 for (; fixP; fixP = fixP->fx_next) 901 { 902 #ifdef DEBUG5 903 fprintf (stderr, "\nprocessing fixup:\n"); 904 print_fixup (fixP); 905 #endif 906 907 fragP = fixP->fx_frag; 908 know (fragP); 909 #ifdef TC_VALIDATE_FIX 910 TC_VALIDATE_FIX (fixP, this_segment, skip); 911 #endif 912 add_number = fixP->fx_offset; 913 914 if (fixP->fx_addsy != NULL) 915 add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy); 916 917 if (fixP->fx_subsy != NULL) 918 { 919 segT sub_symbol_segment; 920 resolve_symbol_value (fixP->fx_subsy); 921 sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy); 922 if (fixP->fx_addsy != NULL 923 && sub_symbol_segment == add_symbol_segment 924 && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment)) 925 { 926 add_number += S_GET_VALUE (fixP->fx_addsy); 927 add_number -= S_GET_VALUE (fixP->fx_subsy); 928 fixP->fx_offset = add_number; 929 fixP->fx_addsy = NULL; 930 fixP->fx_subsy = NULL; 931 #ifdef TC_M68K 932 /* See the comment below about 68k weirdness. */ 933 fixP->fx_pcrel = 0; 934 #endif 935 } 936 else if (sub_symbol_segment == absolute_section 937 && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment)) 938 { 939 add_number -= S_GET_VALUE (fixP->fx_subsy); 940 fixP->fx_offset = add_number; 941 fixP->fx_subsy = NULL; 942 } 943 else if (sub_symbol_segment == this_segment 944 && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment)) 945 { 946 add_number -= S_GET_VALUE (fixP->fx_subsy); 947 fixP->fx_offset = (add_number + fixP->fx_dot_value 948 + fixP->fx_frag->fr_address); 949 950 /* Make it pc-relative. If the back-end code has not 951 selected a pc-relative reloc, cancel the adjustment 952 we do later on all pc-relative relocs. */ 953 if (0 954 #ifdef TC_M68K 955 /* Do this for m68k even if it's already described 956 as pc-relative. On the m68k, an operand of 957 "pc@(foo-.-2)" should address "foo" in a 958 pc-relative mode. */ 959 || 1 960 #endif 961 || !fixP->fx_pcrel) 962 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment); 963 fixP->fx_subsy = NULL; 964 fixP->fx_pcrel = 1; 965 } 966 else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment)) 967 { 968 if (!md_register_arithmetic 969 && (add_symbol_segment == reg_section 970 || sub_symbol_segment == reg_section)) 971 as_bad_where (fixP->fx_file, fixP->fx_line, 972 _("register value used as expression")); 973 else 974 as_bad_where (fixP->fx_file, fixP->fx_line, 975 _("can't resolve `%s' {%s section} - `%s' {%s section}"), 976 fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0", 977 segment_name (add_symbol_segment), 978 S_GET_NAME (fixP->fx_subsy), 979 segment_name (sub_symbol_segment)); 980 } 981 } 982 983 if (fixP->fx_addsy) 984 { 985 if (add_symbol_segment == this_segment 986 && !TC_FORCE_RELOCATION_LOCAL (fixP)) 987 { 988 /* This fixup was made when the symbol's segment was 989 SEG_UNKNOWN, but it is now in the local segment. 990 So we know how to do the address without relocation. */ 991 add_number += S_GET_VALUE (fixP->fx_addsy); 992 fixP->fx_offset = add_number; 993 if (fixP->fx_pcrel) 994 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 995 fixP->fx_addsy = NULL; 996 fixP->fx_pcrel = 0; 997 } 998 else if (add_symbol_segment == absolute_section 999 && !TC_FORCE_RELOCATION_ABS (fixP)) 1000 { 1001 add_number += S_GET_VALUE (fixP->fx_addsy); 1002 fixP->fx_offset = add_number; 1003 fixP->fx_addsy = NULL; 1004 } 1005 else if (add_symbol_segment != undefined_section 1006 && ! bfd_is_com_section (add_symbol_segment) 1007 && MD_APPLY_SYM_VALUE (fixP)) 1008 add_number += S_GET_VALUE (fixP->fx_addsy); 1009 } 1010 1011 if (fixP->fx_pcrel) 1012 { 1013 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment); 1014 if (!fixP->fx_done && fixP->fx_addsy == NULL) 1015 { 1016 /* There was no symbol required by this relocation. 1017 However, BFD doesn't really handle relocations 1018 without symbols well. So fake up a local symbol in 1019 the absolute section. */ 1020 fixP->fx_addsy = abs_section_sym; 1021 } 1022 } 1023 1024 if (!fixP->fx_done) 1025 md_apply_fix (fixP, &add_number, this_segment); 1026 1027 if (!fixP->fx_done) 1028 { 1029 ++seg_reloc_count; 1030 if (fixP->fx_addsy == NULL) 1031 fixP->fx_addsy = abs_section_sym; 1032 symbol_mark_used_in_reloc (fixP->fx_addsy); 1033 if (fixP->fx_subsy != NULL) 1034 symbol_mark_used_in_reloc (fixP->fx_subsy); 1035 } 1036 1037 if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0) 1038 { 1039 if (fixP->fx_size < sizeof (valueT)) 1040 { 1041 valueT mask; 1042 1043 mask = 0; 1044 mask--; /* Set all bits to one. */ 1045 mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0); 1046 if ((add_number & mask) != 0 && (add_number & mask) != mask) 1047 { 1048 char buf[50], buf2[50]; 1049 sprint_value (buf, fragP->fr_address + fixP->fx_where); 1050 if (add_number > 1000) 1051 sprint_value (buf2, add_number); 1052 else 1053 sprintf (buf2, "%ld", (long) add_number); 1054 as_bad_where (fixP->fx_file, fixP->fx_line, 1055 _("value of %s too large for field of %d bytes at %s"), 1056 buf2, fixP->fx_size, buf); 1057 } /* Generic error checking. */ 1058 } 1059 #ifdef WARN_SIGNED_OVERFLOW_WORD 1060 /* Warn if a .word value is too large when treated as a signed 1061 number. We already know it is not too negative. This is to 1062 catch over-large switches generated by gcc on the 68k. */ 1063 if (!flag_signed_overflow_ok 1064 && fixP->fx_size == 2 1065 && add_number > 0x7fff) 1066 as_bad_where (fixP->fx_file, fixP->fx_line, 1067 _("signed .word overflow; switch may be too large; %ld at 0x%lx"), 1068 (long) add_number, 1069 (long) (fragP->fr_address + fixP->fx_where)); 1070 #endif 1071 } /* Not a bit fix. */ 1072 1073 #ifdef TC_VALIDATE_FIX 1074 skip: ATTRIBUTE_UNUSED_LABEL 1075 ; 1076 #endif 1077 #ifdef DEBUG5 1078 fprintf (stderr, "result:\n"); 1079 print_fixup (fixP); 1080 #endif 1081 } /* For each fixS in this segment. */ 1082 1083 TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count); 1084 return seg_reloc_count; 1085 } 1086 1087 static void 1088 fix_segment (bfd *abfd ATTRIBUTE_UNUSED, 1089 asection *sec, 1090 void *xxx ATTRIBUTE_UNUSED) 1091 { 1092 segment_info_type *seginfo = seg_info (sec); 1093 1094 fixup_segment (seginfo->fix_root, sec); 1095 } 1096 1097 static void 1098 install_reloc (asection *sec, arelent *reloc, fragS *fragp, 1099 char *file, unsigned int line) 1100 { 1101 char *err; 1102 bfd_reloc_status_type s; 1103 asymbol *sym; 1104 1105 if (reloc->sym_ptr_ptr != NULL 1106 && (sym = *reloc->sym_ptr_ptr) != NULL 1107 && (sym->flags & BSF_KEEP) == 0 1108 && ((sym->flags & BSF_SECTION_SYM) == 0 1109 || (EMIT_SECTION_SYMBOLS 1110 && !bfd_is_abs_section (sym->section)))) 1111 as_bad_where (file, line, _("redefined symbol cannot be used on reloc")); 1112 1113 s = bfd_install_relocation (stdoutput, reloc, 1114 fragp->fr_literal, fragp->fr_address, 1115 sec, &err); 1116 switch (s) 1117 { 1118 case bfd_reloc_ok: 1119 break; 1120 case bfd_reloc_overflow: 1121 as_bad_where (file, line, _("relocation overflow")); 1122 break; 1123 case bfd_reloc_outofrange: 1124 as_bad_where (file, line, _("relocation out of range")); 1125 break; 1126 default: 1127 as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"), 1128 file, line, s); 1129 } 1130 } 1131 1132 static void 1133 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED) 1134 { 1135 segment_info_type *seginfo = seg_info (sec); 1136 unsigned int i; 1137 unsigned int n; 1138 struct reloc_list *my_reloc_list, **rp, *r; 1139 arelent **relocs; 1140 fixS *fixp; 1141 1142 /* If seginfo is NULL, we did not create this section; don't do 1143 anything with it. */ 1144 if (seginfo == NULL) 1145 return; 1146 1147 n = 0; 1148 for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next) 1149 if (!fixp->fx_done) 1150 n++; 1151 1152 #ifdef RELOC_EXPANSION_POSSIBLE 1153 n *= MAX_RELOC_EXPANSION; 1154 #endif 1155 1156 /* Extract relocs for this section from reloc_list. */ 1157 rp = &reloc_list; 1158 my_reloc_list = NULL; 1159 while ((r = *rp) != NULL) 1160 { 1161 if (r->u.b.sec == sec) 1162 { 1163 *rp = r->next; 1164 r->next = my_reloc_list; 1165 my_reloc_list = r; 1166 n++; 1167 } 1168 else 1169 rp = &r->next; 1170 } 1171 1172 relocs = xcalloc (n, sizeof (arelent *)); 1173 1174 i = 0; 1175 for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next) 1176 { 1177 int j; 1178 int fx_size, slack; 1179 offsetT loc; 1180 1181 if (fixp->fx_done) 1182 continue; 1183 1184 fx_size = fixp->fx_size; 1185 slack = TC_FX_SIZE_SLACK (fixp); 1186 if (slack > 0) 1187 fx_size = fx_size > slack ? fx_size - slack : 0; 1188 loc = fixp->fx_where + fx_size; 1189 if (slack >= 0 && loc > fixp->fx_frag->fr_fix) 1190 as_bad_where (fixp->fx_file, fixp->fx_line, 1191 _("internal error: fixup not contained within frag")); 1192 1193 #ifndef RELOC_EXPANSION_POSSIBLE 1194 { 1195 arelent *reloc = tc_gen_reloc (sec, fixp); 1196 1197 if (!reloc) 1198 continue; 1199 relocs[i++] = reloc; 1200 j = 1; 1201 } 1202 #else 1203 { 1204 arelent **reloc = tc_gen_reloc (sec, fixp); 1205 1206 for (j = 0; reloc[j]; j++) 1207 relocs[i++] = reloc[j]; 1208 } 1209 #endif 1210 1211 for ( ; j != 0; --j) 1212 install_reloc (sec, relocs[i - j], fixp->fx_frag, 1213 fixp->fx_file, fixp->fx_line); 1214 } 1215 n = i; 1216 1217 #ifdef DEBUG4 1218 { 1219 unsigned int i, j, nsyms; 1220 asymbol **sympp; 1221 sympp = bfd_get_outsymbols (stdoutput); 1222 nsyms = bfd_get_symcount (stdoutput); 1223 for (i = 0; i < n; i++) 1224 if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0) 1225 { 1226 for (j = 0; j < nsyms; j++) 1227 if (sympp[j] == *relocs[i]->sym_ptr_ptr) 1228 break; 1229 if (j == nsyms) 1230 abort (); 1231 } 1232 } 1233 #endif 1234 1235 for (r = my_reloc_list; r != NULL; r = r->next) 1236 { 1237 fragS *f; 1238 for (f = seginfo->frchainP->frch_root; f; f = f->fr_next) 1239 if (f->fr_address <= r->u.b.r.address 1240 && r->u.b.r.address < f->fr_address + f->fr_fix) 1241 break; 1242 if (f == NULL) 1243 as_bad_where (r->file, r->line, 1244 _("reloc not within (fixed part of) section")); 1245 else 1246 { 1247 relocs[n++] = &r->u.b.r; 1248 install_reloc (sec, &r->u.b.r, f, r->file, r->line); 1249 } 1250 } 1251 1252 if (n) 1253 { 1254 flagword flags = bfd_get_section_flags (abfd, sec); 1255 flags |= SEC_RELOC; 1256 bfd_set_section_flags (abfd, sec, flags); 1257 bfd_set_reloc (stdoutput, sec, relocs, n); 1258 } 1259 1260 #ifdef SET_SECTION_RELOCS 1261 SET_SECTION_RELOCS (sec, relocs, n); 1262 #endif 1263 1264 #ifdef DEBUG3 1265 { 1266 unsigned int i; 1267 arelent *r; 1268 asymbol *s; 1269 fprintf (stderr, "relocs for sec %s\n", sec->name); 1270 for (i = 0; i < n; i++) 1271 { 1272 r = relocs[i]; 1273 s = *r->sym_ptr_ptr; 1274 fprintf (stderr, " reloc %2d @%p off %4lx : sym %-10s addend %lx\n", 1275 i, r, (unsigned long)r->address, s->name, (unsigned long)r->addend); 1276 } 1277 } 1278 #endif 1279 } 1280 1281 static void 1282 write_contents (bfd *abfd ATTRIBUTE_UNUSED, 1283 asection *sec, 1284 void *xxx ATTRIBUTE_UNUSED) 1285 { 1286 segment_info_type *seginfo = seg_info (sec); 1287 addressT offset = 0; 1288 fragS *f; 1289 1290 /* Write out the frags. */ 1291 if (seginfo == NULL 1292 || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS)) 1293 return; 1294 1295 for (f = seginfo->frchainP->frch_root; 1296 f; 1297 f = f->fr_next) 1298 { 1299 int x; 1300 addressT fill_size; 1301 char *fill_literal; 1302 offsetT count; 1303 1304 assert (f->fr_type == rs_fill); 1305 if (f->fr_fix) 1306 { 1307 x = bfd_set_section_contents (stdoutput, sec, 1308 f->fr_literal, (file_ptr) offset, 1309 (bfd_size_type) f->fr_fix); 1310 if (!x) 1311 as_fatal (_("can't write %s: %s"), stdoutput->filename, 1312 bfd_errmsg (bfd_get_error ())); 1313 offset += f->fr_fix; 1314 } 1315 fill_literal = f->fr_literal + f->fr_fix; 1316 fill_size = f->fr_var; 1317 count = f->fr_offset; 1318 assert (count >= 0); 1319 if (fill_size && count) 1320 { 1321 char buf[256]; 1322 if (fill_size > sizeof (buf)) 1323 { 1324 /* Do it the old way. Can this ever happen? */ 1325 while (count--) 1326 { 1327 x = bfd_set_section_contents (stdoutput, sec, 1328 fill_literal, 1329 (file_ptr) offset, 1330 (bfd_size_type) fill_size); 1331 if (!x) 1332 as_fatal (_("can't write %s: %s"), stdoutput->filename, 1333 bfd_errmsg (bfd_get_error ())); 1334 offset += fill_size; 1335 } 1336 } 1337 else 1338 { 1339 /* Build a buffer full of fill objects and output it as 1340 often as necessary. This saves on the overhead of 1341 potentially lots of bfd_set_section_contents calls. */ 1342 int n_per_buf, i; 1343 if (fill_size == 1) 1344 { 1345 n_per_buf = sizeof (buf); 1346 memset (buf, *fill_literal, n_per_buf); 1347 } 1348 else 1349 { 1350 char *bufp; 1351 n_per_buf = sizeof (buf) / fill_size; 1352 for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size) 1353 memcpy (bufp, fill_literal, fill_size); 1354 } 1355 for (; count > 0; count -= n_per_buf) 1356 { 1357 n_per_buf = n_per_buf > count ? count : n_per_buf; 1358 x = bfd_set_section_contents 1359 (stdoutput, sec, buf, (file_ptr) offset, 1360 (bfd_size_type) n_per_buf * fill_size); 1361 if (!x) 1362 as_fatal (_("cannot write to output file")); 1363 offset += n_per_buf * fill_size; 1364 } 1365 } 1366 } 1367 } 1368 } 1369 1370 static void 1371 merge_data_into_text (void) 1372 { 1373 seg_info (text_section)->frchainP->frch_last->fr_next = 1374 seg_info (data_section)->frchainP->frch_root; 1375 seg_info (text_section)->frchainP->frch_last = 1376 seg_info (data_section)->frchainP->frch_last; 1377 seg_info (data_section)->frchainP = 0; 1378 } 1379 1380 static void 1381 set_symtab (void) 1382 { 1383 int nsyms; 1384 asymbol **asympp; 1385 symbolS *symp; 1386 bfd_boolean result; 1387 1388 /* Count symbols. We can't rely on a count made by the loop in 1389 write_object_file, because *_frob_file may add a new symbol or 1390 two. */ 1391 nsyms = 0; 1392 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1393 nsyms++; 1394 1395 if (nsyms) 1396 { 1397 int i; 1398 bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *); 1399 1400 asympp = bfd_alloc (stdoutput, amt); 1401 symp = symbol_rootP; 1402 for (i = 0; i < nsyms; i++, symp = symbol_next (symp)) 1403 { 1404 asympp[i] = symbol_get_bfdsym (symp); 1405 if (asympp[i]->flags != BSF_SECTION_SYM 1406 || !(bfd_is_const_section (asympp[i]->section) 1407 && asympp[i]->section->symbol == asympp[i])) 1408 asympp[i]->flags |= BSF_KEEP; 1409 symbol_mark_written (symp); 1410 } 1411 } 1412 else 1413 asympp = 0; 1414 result = bfd_set_symtab (stdoutput, asympp, nsyms); 1415 assert (result); 1416 symbol_table_frozen = 1; 1417 } 1418 1419 /* Finish the subsegments. After every sub-segment, we fake an 1420 ".align ...". This conforms to BSD4.2 brane-damage. We then fake 1421 ".fill 0" because that is the kind of frag that requires least 1422 thought. ".align" frags like to have a following frag since that 1423 makes calculating their intended length trivial. */ 1424 1425 #ifndef SUB_SEGMENT_ALIGN 1426 #ifdef HANDLE_ALIGN 1427 /* The last subsegment gets an alignment corresponding to the alignment 1428 of the section. This allows proper nop-filling at the end of 1429 code-bearing sections. */ 1430 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \ 1431 (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0) 1432 #else 1433 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0 1434 #endif 1435 #endif 1436 1437 void 1438 subsegs_finish (void) 1439 { 1440 struct frchain *frchainP; 1441 asection *s; 1442 1443 for (s = stdoutput->sections; s; s = s->next) 1444 { 1445 segment_info_type *seginfo = seg_info (s); 1446 if (!seginfo) 1447 continue; 1448 1449 for (frchainP = seginfo->frchainP; 1450 frchainP != NULL; 1451 frchainP = frchainP->frch_next) 1452 { 1453 int alignment = 0; 1454 1455 subseg_set (s, frchainP->frch_subseg); 1456 1457 /* This now gets called even if we had errors. In that case, 1458 any alignment is meaningless, and, moreover, will look weird 1459 if we are generating a listing. */ 1460 if (!had_errors ()) 1461 { 1462 alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP); 1463 if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE) 1464 && now_seg->entsize) 1465 { 1466 unsigned int entsize = now_seg->entsize; 1467 int entalign = 0; 1468 1469 while ((entsize & 1) == 0) 1470 { 1471 ++entalign; 1472 entsize >>= 1; 1473 } 1474 if (entalign > alignment) 1475 alignment = entalign; 1476 } 1477 } 1478 1479 if (subseg_text_p (now_seg)) 1480 frag_align_code (alignment, 0); 1481 else 1482 frag_align (alignment, 0, 0); 1483 1484 /* frag_align will have left a new frag. 1485 Use this last frag for an empty ".fill". 1486 1487 For this segment ... 1488 Create a last frag. Do not leave a "being filled in frag". */ 1489 frag_wane (frag_now); 1490 frag_now->fr_fix = 0; 1491 know (frag_now->fr_next == NULL); 1492 } 1493 } 1494 } 1495 1496 /* Write the object file. */ 1497 1498 void 1499 write_object_file (void) 1500 { 1501 struct relax_seg_info rsi; 1502 #ifndef WORKING_DOT_WORD 1503 fragS *fragP; /* Track along all frags. */ 1504 #endif 1505 1506 /* Do we really want to write it? */ 1507 { 1508 int n_warns, n_errs; 1509 n_warns = had_warnings (); 1510 n_errs = had_errors (); 1511 /* The -Z flag indicates that an object file should be generated, 1512 regardless of warnings and errors. */ 1513 if (flag_always_generate_output) 1514 { 1515 if (n_warns || n_errs) 1516 as_warn (_("%d error%s, %d warning%s, generating bad object file"), 1517 n_errs, n_errs == 1 ? "" : "s", 1518 n_warns, n_warns == 1 ? "" : "s"); 1519 } 1520 else 1521 { 1522 if (n_errs) 1523 as_fatal (_("%d error%s, %d warning%s, no object file generated"), 1524 n_errs, n_errs == 1 ? "" : "s", 1525 n_warns, n_warns == 1 ? "" : "s"); 1526 } 1527 } 1528 1529 #ifdef OBJ_VMS 1530 /* Under VMS we try to be compatible with VAX-11 "C". Thus, we call 1531 a routine to check for the definition of the procedure "_main", 1532 and if so -- fix it up so that it can be program entry point. */ 1533 vms_check_for_main (); 1534 #endif /* OBJ_VMS */ 1535 1536 /* From now on, we don't care about sub-segments. Build one frag chain 1537 for each segment. Linked thru fr_next. */ 1538 1539 /* Remove the sections created by gas for its own purposes. */ 1540 { 1541 int i; 1542 1543 bfd_section_list_remove (stdoutput, reg_section); 1544 bfd_section_list_remove (stdoutput, expr_section); 1545 stdoutput->section_count -= 2; 1546 i = 0; 1547 bfd_map_over_sections (stdoutput, renumber_sections, &i); 1548 } 1549 1550 bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0); 1551 1552 /* We have two segments. If user gave -R flag, then we must put the 1553 data frags into the text segment. Do this before relaxing so 1554 we know to take advantage of -R and make shorter addresses. */ 1555 if (flag_readonly_data_in_text) 1556 { 1557 merge_data_into_text (); 1558 } 1559 1560 rsi.pass = 0; 1561 while (1) 1562 { 1563 #ifndef WORKING_DOT_WORD 1564 /* We need to reset the markers in the broken word list and 1565 associated frags between calls to relax_segment (via 1566 relax_seg). Since the broken word list is global, we do it 1567 once per round, rather than locally in relax_segment for each 1568 segment. */ 1569 struct broken_word *brokp; 1570 1571 for (brokp = broken_words; 1572 brokp != (struct broken_word *) NULL; 1573 brokp = brokp->next_broken_word) 1574 { 1575 brokp->added = 0; 1576 1577 if (brokp->dispfrag != (fragS *) NULL 1578 && brokp->dispfrag->fr_type == rs_broken_word) 1579 brokp->dispfrag->fr_subtype = 0; 1580 } 1581 #endif 1582 1583 rsi.changed = 0; 1584 bfd_map_over_sections (stdoutput, relax_seg, &rsi); 1585 rsi.pass++; 1586 if (!rsi.changed) 1587 break; 1588 } 1589 1590 /* Note - Most ports will use the default value of 1591 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1. This will force 1592 local symbols to be resolved, removing their frag information. 1593 Some ports however, will not have finished relaxing all of 1594 their frags and will still need the local symbol frag 1595 information. These ports can set 1596 TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0. */ 1597 finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG; 1598 1599 bfd_map_over_sections (stdoutput, size_seg, (char *) 0); 1600 1601 /* Relaxation has completed. Freeze all syms. */ 1602 finalize_syms = 1; 1603 1604 #ifdef md_post_relax_hook 1605 md_post_relax_hook; 1606 #endif 1607 1608 #ifndef WORKING_DOT_WORD 1609 { 1610 struct broken_word *lie; 1611 struct broken_word **prevP; 1612 1613 prevP = &broken_words; 1614 for (lie = broken_words; lie; lie = lie->next_broken_word) 1615 if (!lie->added) 1616 { 1617 expressionS exp; 1618 1619 subseg_change (lie->seg, lie->subseg); 1620 exp.X_op = O_subtract; 1621 exp.X_add_symbol = lie->add; 1622 exp.X_op_symbol = lie->sub; 1623 exp.X_add_number = lie->addnum; 1624 #ifdef TC_CONS_FIX_NEW 1625 TC_CONS_FIX_NEW (lie->frag, 1626 lie->word_goes_here - lie->frag->fr_literal, 1627 2, &exp); 1628 #else 1629 fix_new_exp (lie->frag, 1630 lie->word_goes_here - lie->frag->fr_literal, 1631 2, &exp, 0, BFD_RELOC_16); 1632 #endif 1633 *prevP = lie->next_broken_word; 1634 } 1635 else 1636 prevP = &(lie->next_broken_word); 1637 1638 for (lie = broken_words; lie;) 1639 { 1640 struct broken_word *untruth; 1641 char *table_ptr; 1642 addressT table_addr; 1643 addressT from_addr, to_addr; 1644 int n, m; 1645 1646 subseg_change (lie->seg, lie->subseg); 1647 fragP = lie->dispfrag; 1648 1649 /* Find out how many broken_words go here. */ 1650 n = 0; 1651 for (untruth = lie; 1652 untruth && untruth->dispfrag == fragP; 1653 untruth = untruth->next_broken_word) 1654 if (untruth->added == 1) 1655 n++; 1656 1657 table_ptr = lie->dispfrag->fr_opcode; 1658 table_addr = (lie->dispfrag->fr_address 1659 + (table_ptr - lie->dispfrag->fr_literal)); 1660 /* Create the jump around the long jumps. This is a short 1661 jump from table_ptr+0 to table_ptr+n*long_jump_size. */ 1662 from_addr = table_addr; 1663 to_addr = table_addr + md_short_jump_size + n * md_long_jump_size; 1664 md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 1665 lie->add); 1666 table_ptr += md_short_jump_size; 1667 table_addr += md_short_jump_size; 1668 1669 for (m = 0; 1670 lie && lie->dispfrag == fragP; 1671 m++, lie = lie->next_broken_word) 1672 { 1673 if (lie->added == 2) 1674 continue; 1675 /* Patch the jump table. */ 1676 /* This is the offset from ??? to table_ptr+0. */ 1677 to_addr = table_addr - S_GET_VALUE (lie->sub); 1678 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD 1679 TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie); 1680 #endif 1681 md_number_to_chars (lie->word_goes_here, to_addr, 2); 1682 for (untruth = lie->next_broken_word; 1683 untruth && untruth->dispfrag == fragP; 1684 untruth = untruth->next_broken_word) 1685 { 1686 if (untruth->use_jump == lie) 1687 md_number_to_chars (untruth->word_goes_here, to_addr, 2); 1688 } 1689 1690 /* Install the long jump. */ 1691 /* This is a long jump from table_ptr+0 to the final target. */ 1692 from_addr = table_addr; 1693 to_addr = S_GET_VALUE (lie->add) + lie->addnum; 1694 md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag, 1695 lie->add); 1696 table_ptr += md_long_jump_size; 1697 table_addr += md_long_jump_size; 1698 } 1699 } 1700 } 1701 #endif /* not WORKING_DOT_WORD */ 1702 1703 /* Resolve symbol values. This needs to be done before processing 1704 the relocations. */ 1705 if (symbol_rootP) 1706 { 1707 symbolS *symp; 1708 1709 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1710 resolve_symbol_value (symp); 1711 } 1712 resolve_local_symbol_values (); 1713 resolve_reloc_expr_symbols (); 1714 1715 PROGRESS (1); 1716 1717 #ifdef tc_frob_file_before_adjust 1718 tc_frob_file_before_adjust (); 1719 #endif 1720 #ifdef obj_frob_file_before_adjust 1721 obj_frob_file_before_adjust (); 1722 #endif 1723 1724 bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0); 1725 1726 #ifdef tc_frob_file_before_fix 1727 tc_frob_file_before_fix (); 1728 #endif 1729 #ifdef obj_frob_file_before_fix 1730 obj_frob_file_before_fix (); 1731 #endif 1732 1733 bfd_map_over_sections (stdoutput, fix_segment, (char *) 0); 1734 1735 /* Set up symbol table, and write it out. */ 1736 if (symbol_rootP) 1737 { 1738 symbolS *symp; 1739 bfd_boolean skip_next_symbol = FALSE; 1740 1741 for (symp = symbol_rootP; symp; symp = symbol_next (symp)) 1742 { 1743 int punt = 0; 1744 const char *name; 1745 1746 if (skip_next_symbol) 1747 { 1748 /* Don't do anything besides moving the value of the 1749 symbol from the GAS value-field to the BFD value-field. */ 1750 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 1751 skip_next_symbol = FALSE; 1752 continue; 1753 } 1754 1755 if (symbol_mri_common_p (symp)) 1756 { 1757 if (S_IS_EXTERNAL (symp)) 1758 as_bad (_("%s: global symbols not supported in common sections"), 1759 S_GET_NAME (symp)); 1760 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 1761 continue; 1762 } 1763 1764 name = S_GET_NAME (symp); 1765 if (name) 1766 { 1767 const char *name2 = 1768 decode_local_label_name ((char *) S_GET_NAME (symp)); 1769 /* They only differ if `name' is a fb or dollar local 1770 label name. */ 1771 if (name2 != name && ! S_IS_DEFINED (symp)) 1772 as_bad (_("local label `%s' is not defined"), name2); 1773 } 1774 1775 /* Do it again, because adjust_reloc_syms might introduce 1776 more symbols. They'll probably only be section symbols, 1777 but they'll still need to have the values computed. */ 1778 resolve_symbol_value (symp); 1779 1780 /* Skip symbols which were equated to undefined or common 1781 symbols. */ 1782 if (symbol_equated_reloc_p (symp) 1783 || S_IS_WEAKREFR (symp)) 1784 { 1785 const char *name = S_GET_NAME (symp); 1786 if (S_IS_COMMON (symp) 1787 && !TC_FAKE_LABEL (name) 1788 && !S_IS_WEAKREFR (symp) 1789 && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp))) 1790 { 1791 expressionS *e = symbol_get_value_expression (symp); 1792 as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"), 1793 name, S_GET_NAME (e->X_add_symbol)); 1794 } 1795 if (S_GET_SEGMENT (symp) == reg_section) 1796 { 1797 /* Report error only if we know the symbol name. */ 1798 if (S_GET_NAME (symp) != reg_section->name) 1799 as_bad (_("can't make global register symbol `%s'"), 1800 name); 1801 } 1802 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 1803 continue; 1804 } 1805 1806 #ifdef obj_frob_symbol 1807 obj_frob_symbol (symp, punt); 1808 #endif 1809 #ifdef tc_frob_symbol 1810 if (! punt || symbol_used_in_reloc_p (symp)) 1811 tc_frob_symbol (symp, punt); 1812 #endif 1813 1814 /* If we don't want to keep this symbol, splice it out of 1815 the chain now. If EMIT_SECTION_SYMBOLS is 0, we never 1816 want section symbols. Otherwise, we skip local symbols 1817 and symbols that the frob_symbol macros told us to punt, 1818 but we keep such symbols if they are used in relocs. */ 1819 if (symp == abs_section_sym 1820 || (! EMIT_SECTION_SYMBOLS 1821 && symbol_section_p (symp)) 1822 /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always 1823 opposites. Sometimes the former checks flags and the 1824 latter examines the name... */ 1825 || (!S_IS_EXTERNAL (symp) 1826 && (punt || S_IS_LOCAL (symp) || 1827 (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp))) 1828 && ! symbol_used_in_reloc_p (symp))) 1829 { 1830 symbol_remove (symp, &symbol_rootP, &symbol_lastP); 1831 1832 /* After symbol_remove, symbol_next(symp) still returns 1833 the one that came after it in the chain. So we don't 1834 need to do any extra cleanup work here. */ 1835 continue; 1836 } 1837 1838 /* Make sure we really got a value for the symbol. */ 1839 if (! symbol_resolved_p (symp)) 1840 { 1841 as_bad (_("can't resolve value for symbol `%s'"), 1842 S_GET_NAME (symp)); 1843 symbol_mark_resolved (symp); 1844 } 1845 1846 /* Set the value into the BFD symbol. Up til now the value 1847 has only been kept in the gas symbolS struct. */ 1848 symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp); 1849 1850 /* A warning construct is a warning symbol followed by the 1851 symbol warned about. Don't let anything object-format or 1852 target-specific muck with it; it's ready for output. */ 1853 if (symbol_get_bfdsym (symp)->flags & BSF_WARNING) 1854 skip_next_symbol = TRUE; 1855 } 1856 } 1857 1858 PROGRESS (1); 1859 1860 /* Now do any format-specific adjustments to the symbol table, such 1861 as adding file symbols. */ 1862 #ifdef tc_adjust_symtab 1863 tc_adjust_symtab (); 1864 #endif 1865 #ifdef obj_adjust_symtab 1866 obj_adjust_symtab (); 1867 #endif 1868 1869 /* Stop if there is an error. */ 1870 if (had_errors ()) 1871 return; 1872 1873 /* Now that all the sizes are known, and contents correct, we can 1874 start writing to the file. */ 1875 set_symtab (); 1876 1877 /* If *_frob_file changes the symbol value at this point, it is 1878 responsible for moving the changed value into symp->bsym->value 1879 as well. Hopefully all symbol value changing can be done in 1880 *_frob_symbol. */ 1881 #ifdef tc_frob_file 1882 tc_frob_file (); 1883 #endif 1884 #ifdef obj_frob_file 1885 obj_frob_file (); 1886 #endif 1887 1888 bfd_map_over_sections (stdoutput, write_relocs, (char *) 0); 1889 1890 #ifdef tc_frob_file_after_relocs 1891 tc_frob_file_after_relocs (); 1892 #endif 1893 #ifdef obj_frob_file_after_relocs 1894 obj_frob_file_after_relocs (); 1895 #endif 1896 1897 bfd_map_over_sections (stdoutput, write_contents, (char *) 0); 1898 } 1899 1900 #ifdef TC_GENERIC_RELAX_TABLE 1901 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE. */ 1902 1903 long 1904 relax_frag (segT segment, fragS *fragP, long stretch) 1905 { 1906 const relax_typeS *this_type; 1907 const relax_typeS *start_type; 1908 relax_substateT next_state; 1909 relax_substateT this_state; 1910 offsetT growth; 1911 offsetT aim; 1912 addressT target; 1913 addressT address; 1914 symbolS *symbolP; 1915 const relax_typeS *table; 1916 1917 target = fragP->fr_offset; 1918 address = fragP->fr_address; 1919 table = TC_GENERIC_RELAX_TABLE; 1920 this_state = fragP->fr_subtype; 1921 start_type = this_type = table + this_state; 1922 symbolP = fragP->fr_symbol; 1923 1924 if (symbolP) 1925 { 1926 fragS *sym_frag; 1927 1928 sym_frag = symbol_get_frag (symbolP); 1929 1930 #ifndef DIFF_EXPR_OK 1931 know (sym_frag != NULL); 1932 #endif 1933 know (S_GET_SEGMENT (symbolP) != absolute_section 1934 || sym_frag == &zero_address_frag); 1935 target += S_GET_VALUE (symbolP); 1936 1937 /* If frag has yet to be reached on this pass, 1938 assume it will move by STRETCH just as we did. 1939 If this is not so, it will be because some frag 1940 between grows, and that will force another pass. */ 1941 1942 if (stretch != 0 1943 && sym_frag->relax_marker != fragP->relax_marker 1944 && S_GET_SEGMENT (symbolP) == segment) 1945 { 1946 target += stretch; 1947 } 1948 } 1949 1950 aim = target - address - fragP->fr_fix; 1951 #ifdef TC_PCREL_ADJUST 1952 /* Currently only the ns32k family needs this. */ 1953 aim += TC_PCREL_ADJUST (fragP); 1954 #endif 1955 1956 #ifdef md_prepare_relax_scan 1957 /* Formerly called M68K_AIM_KLUDGE. */ 1958 md_prepare_relax_scan (fragP, address, aim, this_state, this_type); 1959 #endif 1960 1961 if (aim < 0) 1962 { 1963 /* Look backwards. */ 1964 for (next_state = this_type->rlx_more; next_state;) 1965 if (aim >= this_type->rlx_backward) 1966 next_state = 0; 1967 else 1968 { 1969 /* Grow to next state. */ 1970 this_state = next_state; 1971 this_type = table + this_state; 1972 next_state = this_type->rlx_more; 1973 } 1974 } 1975 else 1976 { 1977 /* Look forwards. */ 1978 for (next_state = this_type->rlx_more; next_state;) 1979 if (aim <= this_type->rlx_forward) 1980 next_state = 0; 1981 else 1982 { 1983 /* Grow to next state. */ 1984 this_state = next_state; 1985 this_type = table + this_state; 1986 next_state = this_type->rlx_more; 1987 } 1988 } 1989 1990 growth = this_type->rlx_length - start_type->rlx_length; 1991 if (growth != 0) 1992 fragP->fr_subtype = this_state; 1993 return growth; 1994 } 1995 1996 #endif /* defined (TC_GENERIC_RELAX_TABLE) */ 1997 1998 /* Relax_align. Advance location counter to next address that has 'alignment' 1999 lowest order bits all 0s, return size of adjustment made. */ 2000 static relax_addressT 2001 relax_align (register relax_addressT address, /* Address now. */ 2002 register int alignment /* Alignment (binary). */) 2003 { 2004 relax_addressT mask; 2005 relax_addressT new_address; 2006 2007 mask = ~((~0) << alignment); 2008 new_address = (address + mask) & (~mask); 2009 #ifdef LINKER_RELAXING_SHRINKS_ONLY 2010 if (linkrelax) 2011 /* We must provide lots of padding, so the linker can discard it 2012 when needed. The linker will not add extra space, ever. */ 2013 new_address += (1 << alignment); 2014 #endif 2015 return (new_address - address); 2016 } 2017 2018 /* Now we have a segment, not a crowd of sub-segments, we can make 2019 fr_address values. 2020 2021 Relax the frags. 2022 2023 After this, all frags in this segment have addresses that are correct 2024 within the segment. Since segments live in different file addresses, 2025 these frag addresses may not be the same as final object-file 2026 addresses. */ 2027 2028 int 2029 relax_segment (struct frag *segment_frag_root, segT segment, int pass) 2030 { 2031 unsigned long frag_count; 2032 struct frag *fragP; 2033 relax_addressT address; 2034 int ret; 2035 2036 /* In case md_estimate_size_before_relax() wants to make fixSs. */ 2037 subseg_change (segment, 0); 2038 2039 /* For each frag in segment: count and store (a 1st guess of) 2040 fr_address. */ 2041 address = 0; 2042 for (frag_count = 0, fragP = segment_frag_root; 2043 fragP; 2044 fragP = fragP->fr_next, frag_count ++) 2045 { 2046 fragP->relax_marker = 0; 2047 fragP->fr_address = address; 2048 address += fragP->fr_fix; 2049 2050 switch (fragP->fr_type) 2051 { 2052 case rs_fill: 2053 address += fragP->fr_offset * fragP->fr_var; 2054 break; 2055 2056 case rs_align: 2057 case rs_align_code: 2058 case rs_align_test: 2059 { 2060 addressT offset = relax_align (address, (int) fragP->fr_offset); 2061 2062 if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype) 2063 offset = 0; 2064 2065 if (offset % fragP->fr_var != 0) 2066 { 2067 as_bad_where (fragP->fr_file, fragP->fr_line, 2068 _("alignment padding (%lu bytes) not a multiple of %ld"), 2069 (unsigned long) offset, (long) fragP->fr_var); 2070 offset -= (offset % fragP->fr_var); 2071 } 2072 2073 address += offset; 2074 } 2075 break; 2076 2077 case rs_org: 2078 case rs_space: 2079 /* Assume .org is nugatory. It will grow with 1st relax. */ 2080 break; 2081 2082 case rs_machine_dependent: 2083 /* If fr_symbol is an expression, this call to 2084 resolve_symbol_value sets up the correct segment, which will 2085 likely be needed in md_estimate_size_before_relax. */ 2086 if (fragP->fr_symbol) 2087 resolve_symbol_value (fragP->fr_symbol); 2088 2089 address += md_estimate_size_before_relax (fragP, segment); 2090 break; 2091 2092 #ifndef WORKING_DOT_WORD 2093 /* Broken words don't concern us yet. */ 2094 case rs_broken_word: 2095 break; 2096 #endif 2097 2098 case rs_leb128: 2099 /* Initial guess is always 1; doing otherwise can result in 2100 stable solutions that are larger than the minimum. */ 2101 address += fragP->fr_offset = 1; 2102 break; 2103 2104 case rs_cfa: 2105 address += eh_frame_estimate_size_before_relax (fragP); 2106 break; 2107 2108 case rs_dwarf2dbg: 2109 address += dwarf2dbg_estimate_size_before_relax (fragP); 2110 break; 2111 2112 default: 2113 BAD_CASE (fragP->fr_type); 2114 break; 2115 } 2116 } 2117 2118 /* Do relax(). */ 2119 { 2120 unsigned long max_iterations; 2121 2122 /* Cumulative address adjustment. */ 2123 offsetT stretch; 2124 2125 /* Have we made any adjustment this pass? We can't just test 2126 stretch because one piece of code may have grown and another 2127 shrank. */ 2128 int stretched; 2129 2130 /* Most horrible, but gcc may give us some exception data that 2131 is impossible to assemble, of the form 2132 2133 .align 4 2134 .byte 0, 0 2135 .uleb128 end - start 2136 start: 2137 .space 128*128 - 1 2138 .align 4 2139 end: 2140 2141 If the leb128 is two bytes in size, then end-start is 128*128, 2142 which requires a three byte leb128. If the leb128 is three 2143 bytes in size, then end-start is 128*128-1, which requires a 2144 two byte leb128. We work around this dilemma by inserting 2145 an extra 4 bytes of alignment just after the .align. This 2146 works because the data after the align is accessed relative to 2147 the end label. 2148 2149 This counter is used in a tiny state machine to detect 2150 whether a leb128 followed by an align is impossible to 2151 relax. */ 2152 int rs_leb128_fudge = 0; 2153 2154 /* We want to prevent going into an infinite loop where one frag grows 2155 depending upon the location of a symbol which is in turn moved by 2156 the growing frag. eg: 2157 2158 foo = . 2159 .org foo+16 2160 foo = . 2161 2162 So we dictate that this algorithm can be at most O2. */ 2163 max_iterations = frag_count * frag_count; 2164 /* Check for overflow. */ 2165 if (max_iterations < frag_count) 2166 max_iterations = frag_count; 2167 2168 ret = 0; 2169 do 2170 { 2171 stretch = 0; 2172 stretched = 0; 2173 2174 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2175 { 2176 offsetT growth = 0; 2177 addressT was_address; 2178 offsetT offset; 2179 symbolS *symbolP; 2180 2181 fragP->relax_marker ^= 1; 2182 was_address = fragP->fr_address; 2183 address = fragP->fr_address += stretch; 2184 symbolP = fragP->fr_symbol; 2185 offset = fragP->fr_offset; 2186 2187 switch (fragP->fr_type) 2188 { 2189 case rs_fill: /* .fill never relaxes. */ 2190 growth = 0; 2191 break; 2192 2193 #ifndef WORKING_DOT_WORD 2194 /* JF: This is RMS's idea. I do *NOT* want to be blamed 2195 for it I do not want to write it. I do not want to have 2196 anything to do with it. This is not the proper way to 2197 implement this misfeature. */ 2198 case rs_broken_word: 2199 { 2200 struct broken_word *lie; 2201 struct broken_word *untruth; 2202 2203 /* Yes this is ugly (storing the broken_word pointer 2204 in the symbol slot). Still, this whole chunk of 2205 code is ugly, and I don't feel like doing anything 2206 about it. Think of it as stubbornness in action. */ 2207 growth = 0; 2208 for (lie = (struct broken_word *) (fragP->fr_symbol); 2209 lie && lie->dispfrag == fragP; 2210 lie = lie->next_broken_word) 2211 { 2212 2213 if (lie->added) 2214 continue; 2215 2216 offset = (S_GET_VALUE (lie->add) 2217 + lie->addnum 2218 - S_GET_VALUE (lie->sub)); 2219 if (offset <= -32768 || offset >= 32767) 2220 { 2221 if (flag_warn_displacement) 2222 { 2223 char buf[50]; 2224 sprint_value (buf, (addressT) lie->addnum); 2225 as_warn_where (fragP->fr_file, fragP->fr_line, 2226 _(".word %s-%s+%s didn't fit"), 2227 S_GET_NAME (lie->add), 2228 S_GET_NAME (lie->sub), 2229 buf); 2230 } 2231 lie->added = 1; 2232 if (fragP->fr_subtype == 0) 2233 { 2234 fragP->fr_subtype++; 2235 growth += md_short_jump_size; 2236 } 2237 for (untruth = lie->next_broken_word; 2238 untruth && untruth->dispfrag == lie->dispfrag; 2239 untruth = untruth->next_broken_word) 2240 if ((symbol_get_frag (untruth->add) 2241 == symbol_get_frag (lie->add)) 2242 && (S_GET_VALUE (untruth->add) 2243 == S_GET_VALUE (lie->add))) 2244 { 2245 untruth->added = 2; 2246 untruth->use_jump = lie; 2247 } 2248 growth += md_long_jump_size; 2249 } 2250 } 2251 2252 break; 2253 } /* case rs_broken_word */ 2254 #endif 2255 case rs_align: 2256 case rs_align_code: 2257 case rs_align_test: 2258 { 2259 addressT oldoff, newoff; 2260 2261 oldoff = relax_align (was_address + fragP->fr_fix, 2262 (int) offset); 2263 newoff = relax_align (address + fragP->fr_fix, 2264 (int) offset); 2265 2266 if (fragP->fr_subtype != 0) 2267 { 2268 if (oldoff > fragP->fr_subtype) 2269 oldoff = 0; 2270 if (newoff > fragP->fr_subtype) 2271 newoff = 0; 2272 } 2273 2274 growth = newoff - oldoff; 2275 2276 /* If this align happens to follow a leb128 and 2277 we have determined that the leb128 is bouncing 2278 in size, then break the cycle by inserting an 2279 extra alignment. */ 2280 if (growth < 0 2281 && (rs_leb128_fudge & 16) != 0 2282 && (rs_leb128_fudge & 15) >= 2) 2283 { 2284 segment_info_type *seginfo = seg_info (segment); 2285 struct obstack *ob = &seginfo->frchainP->frch_obstack; 2286 struct frag *newf; 2287 2288 newf = frag_alloc (ob); 2289 obstack_blank_fast (ob, fragP->fr_var); 2290 obstack_finish (ob); 2291 memcpy (newf, fragP, SIZEOF_STRUCT_FRAG); 2292 memcpy (newf->fr_literal, 2293 fragP->fr_literal + fragP->fr_fix, 2294 fragP->fr_var); 2295 newf->fr_type = rs_fill; 2296 newf->fr_fix = 0; 2297 newf->fr_offset = (((offsetT) 1 << fragP->fr_offset) 2298 / fragP->fr_var); 2299 if (newf->fr_offset * newf->fr_var 2300 != (offsetT) 1 << fragP->fr_offset) 2301 { 2302 newf->fr_offset = (offsetT) 1 << fragP->fr_offset; 2303 newf->fr_var = 1; 2304 } 2305 /* Include growth of new frag, because rs_fill 2306 frags don't normally grow. */ 2307 growth += newf->fr_offset * newf->fr_var; 2308 /* The new frag address is newoff. Adjust this 2309 for the amount we'll add when we process the 2310 new frag. */ 2311 newf->fr_address = newoff - stretch - growth; 2312 newf->relax_marker ^= 1; 2313 fragP->fr_next = newf; 2314 #ifdef DEBUG 2315 as_warn (_("padding added")); 2316 #endif 2317 } 2318 } 2319 break; 2320 2321 case rs_org: 2322 { 2323 addressT target = offset; 2324 addressT after; 2325 2326 if (symbolP) 2327 { 2328 /* Convert from an actual address to an octet offset 2329 into the section. Here it is assumed that the 2330 section's VMA is zero, and can omit subtracting it 2331 from the symbol's value to get the address offset. */ 2332 know (S_GET_SEGMENT (symbolP)->vma == 0); 2333 target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE; 2334 } 2335 2336 know (fragP->fr_next); 2337 after = fragP->fr_next->fr_address + stretch; 2338 growth = target - after; 2339 if (growth < 0) 2340 { 2341 growth = 0; 2342 2343 /* Don't error on first few frag relax passes. 2344 The symbol might be an expression involving 2345 symbol values from other sections. If those 2346 sections have not yet been processed their 2347 frags will all have zero addresses, so we 2348 will calculate incorrect values for them. The 2349 number of passes we allow before giving an 2350 error is somewhat arbitrary. It should be at 2351 least one, with larger values requiring 2352 increasingly contrived dependencies between 2353 frags to trigger a false error. */ 2354 if (pass < 2) 2355 { 2356 /* Force another pass. */ 2357 ret = 1; 2358 break; 2359 } 2360 2361 /* Growth may be negative, but variable part of frag 2362 cannot have fewer than 0 chars. That is, we can't 2363 .org backwards. */ 2364 as_bad_where (fragP->fr_file, fragP->fr_line, 2365 _("attempt to move .org backwards")); 2366 2367 /* We've issued an error message. Change the 2368 frag to avoid cascading errors. */ 2369 fragP->fr_type = rs_align; 2370 fragP->fr_subtype = 0; 2371 fragP->fr_offset = 0; 2372 fragP->fr_fix = after - address; 2373 } 2374 } 2375 break; 2376 2377 case rs_space: 2378 growth = 0; 2379 if (symbolP) 2380 { 2381 offsetT amount; 2382 2383 amount = S_GET_VALUE (symbolP); 2384 if (S_GET_SEGMENT (symbolP) != absolute_section 2385 || S_IS_COMMON (symbolP) 2386 || ! S_IS_DEFINED (symbolP)) 2387 { 2388 as_bad_where (fragP->fr_file, fragP->fr_line, 2389 _(".space specifies non-absolute value")); 2390 /* Prevent repeat of this error message. */ 2391 fragP->fr_symbol = 0; 2392 } 2393 else if (amount < 0) 2394 { 2395 /* Don't error on first few frag relax passes. 2396 See rs_org comment for a longer explanation. */ 2397 if (pass < 2) 2398 { 2399 ret = 1; 2400 break; 2401 } 2402 2403 as_warn_where (fragP->fr_file, fragP->fr_line, 2404 _(".space or .fill with negative value, ignored")); 2405 fragP->fr_symbol = 0; 2406 } 2407 else 2408 growth = (was_address + fragP->fr_fix + amount 2409 - fragP->fr_next->fr_address); 2410 } 2411 break; 2412 2413 case rs_machine_dependent: 2414 #ifdef md_relax_frag 2415 growth = md_relax_frag (segment, fragP, stretch); 2416 #else 2417 #ifdef TC_GENERIC_RELAX_TABLE 2418 /* The default way to relax a frag is to look through 2419 TC_GENERIC_RELAX_TABLE. */ 2420 growth = relax_frag (segment, fragP, stretch); 2421 #endif /* TC_GENERIC_RELAX_TABLE */ 2422 #endif 2423 break; 2424 2425 case rs_leb128: 2426 { 2427 valueT value; 2428 offsetT size; 2429 2430 value = resolve_symbol_value (fragP->fr_symbol); 2431 size = sizeof_leb128 (value, fragP->fr_subtype); 2432 growth = size - fragP->fr_offset; 2433 fragP->fr_offset = size; 2434 } 2435 break; 2436 2437 case rs_cfa: 2438 growth = eh_frame_relax_frag (fragP); 2439 break; 2440 2441 case rs_dwarf2dbg: 2442 growth = dwarf2dbg_relax_frag (fragP); 2443 break; 2444 2445 default: 2446 BAD_CASE (fragP->fr_type); 2447 break; 2448 } 2449 if (growth) 2450 { 2451 stretch += growth; 2452 stretched = 1; 2453 if (fragP->fr_type == rs_leb128) 2454 rs_leb128_fudge += 16; 2455 else if (fragP->fr_type == rs_align 2456 && (rs_leb128_fudge & 16) != 0 2457 && stretch == 0) 2458 rs_leb128_fudge += 16; 2459 else 2460 rs_leb128_fudge = 0; 2461 } 2462 } 2463 2464 if (stretch == 0 2465 && (rs_leb128_fudge & 16) == 0 2466 && (rs_leb128_fudge & -16) != 0) 2467 rs_leb128_fudge += 1; 2468 else 2469 rs_leb128_fudge = 0; 2470 } 2471 /* Until nothing further to relax. */ 2472 while (stretched && -- max_iterations); 2473 2474 if (stretched) 2475 as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"), 2476 segment_name (segment)); 2477 } 2478 2479 for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next) 2480 if (fragP->last_fr_address != fragP->fr_address) 2481 { 2482 fragP->last_fr_address = fragP->fr_address; 2483 ret = 1; 2484 } 2485 return ret; 2486 } 2487 2488 void 2489 number_to_chars_bigendian (char *buf, valueT val, int n) 2490 { 2491 if (n <= 0) 2492 abort (); 2493 while (n--) 2494 { 2495 buf[n] = val & 0xff; 2496 val >>= 8; 2497 } 2498 } 2499 2500 void 2501 number_to_chars_littleendian (char *buf, valueT val, int n) 2502 { 2503 if (n <= 0) 2504 abort (); 2505 while (n--) 2506 { 2507 *buf++ = val & 0xff; 2508 val >>= 8; 2509 } 2510 } 2511 2512 void 2513 write_print_statistics (FILE *file) 2514 { 2515 fprintf (file, "fixups: %d\n", n_fixups); 2516 } 2517 2518 /* For debugging. */ 2519 extern int indent_level; 2520 2521 void 2522 print_fixup (fixS *fixp) 2523 { 2524 indent_level = 1; 2525 fprintf (stderr, "fix "); 2526 fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp)); 2527 fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line); 2528 if (fixp->fx_pcrel) 2529 fprintf (stderr, " pcrel"); 2530 if (fixp->fx_pcrel_adjust) 2531 fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust); 2532 if (fixp->fx_im_disp) 2533 { 2534 #ifdef TC_NS32K 2535 fprintf (stderr, " im_disp=%d", fixp->fx_im_disp); 2536 #else 2537 fprintf (stderr, " im_disp"); 2538 #endif 2539 } 2540 if (fixp->fx_tcbit) 2541 fprintf (stderr, " tcbit"); 2542 if (fixp->fx_done) 2543 fprintf (stderr, " done"); 2544 fprintf (stderr, "\n size=%d frag=", fixp->fx_size); 2545 fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag)); 2546 fprintf (stderr, " where=%ld offset=%lx addnumber=%lx", 2547 (long) fixp->fx_where, 2548 (unsigned long) fixp->fx_offset, 2549 (unsigned long) fixp->fx_addnumber); 2550 fprintf (stderr, "\n %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type), 2551 fixp->fx_r_type); 2552 if (fixp->fx_addsy) 2553 { 2554 fprintf (stderr, "\n +<"); 2555 print_symbol_value_1 (stderr, fixp->fx_addsy); 2556 fprintf (stderr, ">"); 2557 } 2558 if (fixp->fx_subsy) 2559 { 2560 fprintf (stderr, "\n -<"); 2561 print_symbol_value_1 (stderr, fixp->fx_subsy); 2562 fprintf (stderr, ">"); 2563 } 2564 fprintf (stderr, "\n"); 2565 #ifdef TC_FIX_DATA_PRINT 2566 TC_FIX_DATA_PRINT (stderr, fixp); 2567 #endif 2568 } 2569