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