gas/write.c

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