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