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, 2012 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     /* 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 #ifdef md_pre_relax_hook
1794   md_pre_relax_hook;
1795 #endif
1796
1797   /* From now on, we don't care about sub-segments.  Build one frag chain
1798      for each segment. Linked thru fr_next.  */
1799
1800   /* Remove the sections created by gas for its own purposes.  */
1801   {
1802     int i;
1803
1804     bfd_section_list_remove (stdoutput, reg_section);
1805     bfd_section_list_remove (stdoutput, expr_section);
1806     stdoutput->section_count -= 2;
1807     i = 0;
1808     bfd_map_over_sections (stdoutput, renumber_sections, &i);
1809   }
1810
1811   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1812
1813   /* We have two segments. If user gave -R flag, then we must put the
1814      data frags into the text segment. Do this before relaxing so
1815      we know to take advantage of -R and make shorter addresses.  */
1816   if (flag_readonly_data_in_text)
1817     {
1818       merge_data_into_text ();
1819     }
1820
1821   rsi.pass = 0;
1822   while (1)
1823     {
1824 #ifndef WORKING_DOT_WORD
1825       /* We need to reset the markers in the broken word list and
1826          associated frags between calls to relax_segment (via
1827          relax_seg).  Since the broken word list is global, we do it
1828          once per round, rather than locally in relax_segment for each
1829          segment.  */
1830       struct broken_word *brokp;
1831
1832       for (brokp = broken_words;
1833            brokp != (struct broken_word *) NULL;
1834            brokp = brokp->next_broken_word)
1835         {
1836           brokp->added = 0;
1837
1838           if (brokp->dispfrag != (fragS *) NULL
1839               && brokp->dispfrag->fr_type == rs_broken_word)
1840             brokp->dispfrag->fr_subtype = 0;
1841         }
1842 #endif
1843
1844       rsi.changed = 0;
1845       bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1846       rsi.pass++;
1847       if (!rsi.changed)
1848         break;
1849     }
1850
1851   /* Note - Most ports will use the default value of
1852      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
1853      local symbols to be resolved, removing their frag information.
1854      Some ports however, will not have finished relaxing all of
1855      their frags and will still need the local symbol frag
1856      information.  These ports can set
1857      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
1858   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1859
1860   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1861
1862   /* Relaxation has completed.  Freeze all syms.  */
1863   finalize_syms = 1;
1864
1865 #ifdef md_post_relax_hook
1866   md_post_relax_hook;
1867 #endif
1868
1869 #ifndef WORKING_DOT_WORD
1870   {
1871     struct broken_word *lie;
1872     struct broken_word **prevP;
1873
1874     prevP = &broken_words;
1875     for (lie = broken_words; lie; lie = lie->next_broken_word)
1876       if (!lie->added)
1877         {
1878           expressionS exp;
1879
1880           subseg_change (lie->seg, lie->subseg);
1881           exp.X_op = O_subtract;
1882           exp.X_add_symbol = lie->add;
1883           exp.X_op_symbol = lie->sub;
1884           exp.X_add_number = lie->addnum;
1885 #ifdef TC_CONS_FIX_NEW
1886           TC_CONS_FIX_NEW (lie->frag,
1887                            lie->word_goes_here - lie->frag->fr_literal,
1888                            2, &exp);
1889 #else
1890           fix_new_exp (lie->frag,
1891                        lie->word_goes_here - lie->frag->fr_literal,
1892                        2, &exp, 0, BFD_RELOC_16);
1893 #endif
1894           *prevP = lie->next_broken_word;
1895         }
1896       else
1897         prevP = &(lie->next_broken_word);
1898
1899     for (lie = broken_words; lie;)
1900       {
1901         struct broken_word *untruth;
1902         char *table_ptr;
1903         addressT table_addr;
1904         addressT from_addr, to_addr;
1905         int n, m;
1906
1907         subseg_change (lie->seg, lie->subseg);
1908         fragP = lie->dispfrag;
1909
1910         /* Find out how many broken_words go here.  */
1911         n = 0;
1912         for (untruth = lie;
1913              untruth && untruth->dispfrag == fragP;
1914              untruth = untruth->next_broken_word)
1915           if (untruth->added == 1)
1916             n++;
1917
1918         table_ptr = lie->dispfrag->fr_opcode;
1919         table_addr = (lie->dispfrag->fr_address
1920                       + (table_ptr - lie->dispfrag->fr_literal));
1921         /* Create the jump around the long jumps.  This is a short
1922            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
1923         from_addr = table_addr;
1924         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1925         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1926                               lie->add);
1927         table_ptr += md_short_jump_size;
1928         table_addr += md_short_jump_size;
1929
1930         for (m = 0;
1931              lie && lie->dispfrag == fragP;
1932              m++, lie = lie->next_broken_word)
1933           {
1934             if (lie->added == 2)
1935               continue;
1936             /* Patch the jump table.  */
1937             for (untruth = (struct broken_word *) (fragP->fr_symbol);
1938                  untruth && untruth->dispfrag == fragP;
1939                  untruth = untruth->next_broken_word)
1940               {
1941                 if (untruth->use_jump == lie)
1942                   {
1943                     /* This is the offset from ??? to table_ptr+0.
1944                        The target is the same for all users of this
1945                        md_long_jump, but the "sub" bases (and hence the
1946                        offsets) may be different.  */
1947                     addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1948 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1949                     TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1950 #endif
1951                     md_number_to_chars (untruth->word_goes_here, to_word, 2);
1952                   }
1953               }
1954
1955             /* Install the long jump.  */
1956             /* This is a long jump from table_ptr+0 to the final target.  */
1957             from_addr = table_addr;
1958             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1959             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1960                                  lie->add);
1961             table_ptr += md_long_jump_size;
1962             table_addr += md_long_jump_size;
1963           }
1964       }
1965   }
1966 #endif /* not WORKING_DOT_WORD  */
1967
1968   /* Resolve symbol values.  This needs to be done before processing
1969      the relocations.  */
1970   if (symbol_rootP)
1971     {
1972       symbolS *symp;
1973
1974       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1975         resolve_symbol_value (symp);
1976     }
1977   resolve_local_symbol_values ();
1978   resolve_reloc_expr_symbols ();
1979
1980   PROGRESS (1);
1981
1982 #ifdef tc_frob_file_before_adjust
1983   tc_frob_file_before_adjust ();
1984 #endif
1985 #ifdef obj_frob_file_before_adjust
1986   obj_frob_file_before_adjust ();
1987 #endif
1988
1989   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1990
1991 #ifdef tc_frob_file_before_fix
1992   tc_frob_file_before_fix ();
1993 #endif
1994 #ifdef obj_frob_file_before_fix
1995   obj_frob_file_before_fix ();
1996 #endif
1997
1998   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1999
2000   /* Set up symbol table, and write it out.  */
2001   if (symbol_rootP)
2002     {
2003       symbolS *symp;
2004       bfd_boolean skip_next_symbol = FALSE;
2005
2006       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2007         {
2008           int punt = 0;
2009           const char *name;
2010
2011           if (skip_next_symbol)
2012             {
2013               /* Don't do anything besides moving the value of the
2014                  symbol from the GAS value-field to the BFD value-field.  */
2015               symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2016               skip_next_symbol = FALSE;
2017               continue;
2018             }
2019
2020           if (symbol_mri_common_p (symp))
2021             {
2022               if (S_IS_EXTERNAL (symp))
2023                 as_bad (_("%s: global symbols not supported in common sections"),
2024                         S_GET_NAME (symp));
2025               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2026               continue;
2027             }
2028
2029           name = S_GET_NAME (symp);
2030           if (name)
2031             {
2032               const char *name2 =
2033                 decode_local_label_name ((char *) S_GET_NAME (symp));
2034               /* They only differ if `name' is a fb or dollar local
2035                  label name.  */
2036               if (name2 != name && ! S_IS_DEFINED (symp))
2037                 as_bad (_("local label `%s' is not defined"), name2);
2038             }
2039
2040           /* Do it again, because adjust_reloc_syms might introduce
2041              more symbols.  They'll probably only be section symbols,
2042              but they'll still need to have the values computed.  */
2043           resolve_symbol_value (symp);
2044
2045           /* Skip symbols which were equated to undefined or common
2046              symbols.  */
2047           if (symbol_equated_reloc_p (symp)
2048               || S_IS_WEAKREFR (symp))
2049             {
2050               const char *sname = S_GET_NAME (symp);
2051
2052               if (S_IS_COMMON (symp)
2053                   && !TC_FAKE_LABEL (sname)
2054                   && !S_IS_WEAKREFR (symp)
2055                   && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2056                 {
2057                   expressionS *e = symbol_get_value_expression (symp);
2058
2059                   as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2060                           sname, S_GET_NAME (e->X_add_symbol));
2061                 }
2062               if (S_GET_SEGMENT (symp) == reg_section)
2063                 {
2064                   /* Report error only if we know the symbol name.  */
2065                   if (S_GET_NAME (symp) != reg_section->name)
2066                     as_bad (_("can't make global register symbol `%s'"),
2067                             sname);
2068                 }
2069               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2070               continue;
2071             }
2072
2073 #ifdef obj_frob_symbol
2074           obj_frob_symbol (symp, punt);
2075 #endif
2076 #ifdef tc_frob_symbol
2077           if (! punt || symbol_used_in_reloc_p (symp))
2078             tc_frob_symbol (symp, punt);
2079 #endif
2080
2081           /* If we don't want to keep this symbol, splice it out of
2082              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
2083              want section symbols.  Otherwise, we skip local symbols
2084              and symbols that the frob_symbol macros told us to punt,
2085              but we keep such symbols if they are used in relocs.  */
2086           if (symp == abs_section_sym
2087               || (! EMIT_SECTION_SYMBOLS
2088                   && symbol_section_p (symp))
2089               /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2090                  opposites.  Sometimes the former checks flags and the
2091                  latter examines the name...  */
2092               || (!S_IS_EXTERNAL (symp)
2093                   && (punt || S_IS_LOCAL (symp) ||
2094                       (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2095                   && ! symbol_used_in_reloc_p (symp)))
2096             {
2097               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2098
2099               /* After symbol_remove, symbol_next(symp) still returns
2100                  the one that came after it in the chain.  So we don't
2101                  need to do any extra cleanup work here.  */
2102               continue;
2103             }
2104
2105           /* Make sure we really got a value for the symbol.  */
2106           if (! symbol_resolved_p (symp))
2107             {
2108               as_bad (_("can't resolve value for symbol `%s'"),
2109                       S_GET_NAME (symp));
2110               symbol_mark_resolved (symp);
2111             }
2112
2113           /* Set the value into the BFD symbol.  Up til now the value
2114              has only been kept in the gas symbolS struct.  */
2115           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2116
2117           /* A warning construct is a warning symbol followed by the
2118              symbol warned about.  Don't let anything object-format or
2119              target-specific muck with it; it's ready for output.  */
2120           if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2121             skip_next_symbol = TRUE;
2122         }
2123     }
2124
2125   PROGRESS (1);
2126
2127   /* Now do any format-specific adjustments to the symbol table, such
2128      as adding file symbols.  */
2129 #ifdef tc_adjust_symtab
2130   tc_adjust_symtab ();
2131 #endif
2132 #ifdef obj_adjust_symtab
2133   obj_adjust_symtab ();
2134 #endif
2135
2136   /* Stop if there is an error.  */
2137   if (had_errors ())
2138     return;
2139
2140   /* Now that all the sizes are known, and contents correct, we can
2141      start writing to the file.  */
2142   set_symtab ();
2143
2144   /* If *_frob_file changes the symbol value at this point, it is
2145      responsible for moving the changed value into symp->bsym->value
2146      as well.  Hopefully all symbol value changing can be done in
2147      *_frob_symbol.  */
2148 #ifdef tc_frob_file
2149   tc_frob_file ();
2150 #endif
2151 #ifdef obj_frob_file
2152   obj_frob_file ();
2153 #endif
2154 #ifdef obj_coff_generate_pdata
2155   obj_coff_generate_pdata ();
2156 #endif
2157   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2158
2159 #ifdef tc_frob_file_after_relocs
2160   tc_frob_file_after_relocs ();
2161 #endif
2162 #ifdef obj_frob_file_after_relocs
2163   obj_frob_file_after_relocs ();
2164 #endif
2165
2166   /* Once all relocations have been written, we can compress the
2167      contents of the debug sections.  This needs to be done before
2168      we start writing any sections, because it will affect the file
2169      layout, which is fixed once we start writing contents.  */
2170   if (flag_compress_debug)
2171     bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2172
2173   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2174 }
2175
2176 #ifdef TC_GENERIC_RELAX_TABLE
2177 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2178
2179 long
2180 relax_frag (segT segment, fragS *fragP, long stretch)
2181 {
2182   const relax_typeS *this_type;
2183   const relax_typeS *start_type;
2184   relax_substateT next_state;
2185   relax_substateT this_state;
2186   offsetT growth;
2187   offsetT aim;
2188   addressT target;
2189   addressT address;
2190   symbolS *symbolP;
2191   const relax_typeS *table;
2192
2193   target = fragP->fr_offset;
2194   address = fragP->fr_address;
2195   table = TC_GENERIC_RELAX_TABLE;
2196   this_state = fragP->fr_subtype;
2197   start_type = this_type = table + this_state;
2198   symbolP = fragP->fr_symbol;
2199
2200   if (symbolP)
2201     {
2202       fragS *sym_frag;
2203
2204       sym_frag = symbol_get_frag (symbolP);
2205
2206 #ifndef DIFF_EXPR_OK
2207       know (sym_frag != NULL);
2208 #endif
2209       know (S_GET_SEGMENT (symbolP) != absolute_section
2210             || sym_frag == &zero_address_frag);
2211       target += S_GET_VALUE (symbolP);
2212
2213       /* If SYM_FRAG has yet to be reached on this pass, assume it
2214          will move by STRETCH just as we did, unless there is an
2215          alignment frag between here and SYM_FRAG.  An alignment may
2216          well absorb any STRETCH, and we don't want to choose a larger
2217          branch insn by overestimating the needed reach of this
2218          branch.  It isn't critical to calculate TARGET exactly;  We
2219          know we'll be doing another pass if STRETCH is non-zero.  */
2220
2221       if (stretch != 0
2222           && sym_frag->relax_marker != fragP->relax_marker
2223           && S_GET_SEGMENT (symbolP) == segment)
2224         {
2225           if (stretch < 0
2226               || sym_frag->region == fragP->region)
2227             target += stretch;
2228           /* If we get here we know we have a forward branch.  This
2229              relax pass may have stretched previous instructions so
2230              far that omitting STRETCH would make the branch
2231              negative.  Don't allow this in case the negative reach is
2232              large enough to require a larger branch instruction.  */
2233           else if (target < address)
2234             target = fragP->fr_next->fr_address + stretch;
2235         }
2236     }
2237
2238   aim = target - address - fragP->fr_fix;
2239 #ifdef TC_PCREL_ADJUST
2240   /* Currently only the ns32k family needs this.  */
2241   aim += TC_PCREL_ADJUST (fragP);
2242 #endif
2243
2244 #ifdef md_prepare_relax_scan
2245   /* Formerly called M68K_AIM_KLUDGE.  */
2246   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2247 #endif
2248
2249   if (aim < 0)
2250     {
2251       /* Look backwards.  */
2252       for (next_state = this_type->rlx_more; next_state;)
2253         if (aim >= this_type->rlx_backward)
2254           next_state = 0;
2255         else
2256           {
2257             /* Grow to next state.  */
2258             this_state = next_state;
2259             this_type = table + this_state;
2260             next_state = this_type->rlx_more;
2261           }
2262     }
2263   else
2264     {
2265       /* Look forwards.  */
2266       for (next_state = this_type->rlx_more; next_state;)
2267         if (aim <= this_type->rlx_forward)
2268           next_state = 0;
2269         else
2270           {
2271             /* Grow to next state.  */
2272             this_state = next_state;
2273             this_type = table + this_state;
2274             next_state = this_type->rlx_more;
2275           }
2276     }
2277
2278   growth = this_type->rlx_length - start_type->rlx_length;
2279   if (growth != 0)
2280     fragP->fr_subtype = this_state;
2281   return growth;
2282 }
2283
2284 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2285
2286 /* Relax_align. Advance location counter to next address that has 'alignment'
2287    lowest order bits all 0s, return size of adjustment made.  */
2288 static relax_addressT
2289 relax_align (register relax_addressT address,   /* Address now.  */
2290              register int alignment     /* Alignment (binary).  */)
2291 {
2292   relax_addressT mask;
2293   relax_addressT new_address;
2294
2295   mask = ~((~0) << alignment);
2296   new_address = (address + mask) & (~mask);
2297 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2298   if (linkrelax)
2299     /* We must provide lots of padding, so the linker can discard it
2300        when needed.  The linker will not add extra space, ever.  */
2301     new_address += (1 << alignment);
2302 #endif
2303   return (new_address - address);
2304 }
2305
2306 /* Now we have a segment, not a crowd of sub-segments, we can make
2307    fr_address values.
2308
2309    Relax the frags.
2310
2311    After this, all frags in this segment have addresses that are correct
2312    within the segment. Since segments live in different file addresses,
2313    these frag addresses may not be the same as final object-file
2314    addresses.  */
2315
2316 int
2317 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2318 {
2319   unsigned long frag_count;
2320   struct frag *fragP;
2321   relax_addressT address;
2322   int region;
2323   int ret;
2324
2325   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2326   subseg_change (segment, 0);
2327
2328   /* For each frag in segment: count and store  (a 1st guess of)
2329      fr_address.  */
2330   address = 0;
2331   region = 0;
2332   for (frag_count = 0, fragP = segment_frag_root;
2333        fragP;
2334        fragP = fragP->fr_next, frag_count ++)
2335     {
2336       fragP->region = region;
2337       fragP->relax_marker = 0;
2338       fragP->fr_address = address;
2339       address += fragP->fr_fix;
2340
2341       switch (fragP->fr_type)
2342         {
2343         case rs_fill:
2344           address += fragP->fr_offset * fragP->fr_var;
2345           break;
2346
2347         case rs_align:
2348         case rs_align_code:
2349         case rs_align_test:
2350           {
2351             addressT offset = relax_align (address, (int) fragP->fr_offset);
2352
2353             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2354               offset = 0;
2355
2356             if (offset % fragP->fr_var != 0)
2357               {
2358                 as_bad_where (fragP->fr_file, fragP->fr_line,
2359                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2360                               (unsigned long) offset, (long) fragP->fr_var);
2361                 offset -= (offset % fragP->fr_var);
2362               }
2363
2364             address += offset;
2365             region += 1;
2366           }
2367           break;
2368
2369         case rs_org:
2370           /* Assume .org is nugatory. It will grow with 1st relax.  */
2371           region += 1;
2372           break;
2373
2374         case rs_space:
2375           break;
2376
2377         case rs_machine_dependent:
2378           /* If fr_symbol is an expression, this call to
2379              resolve_symbol_value sets up the correct segment, which will
2380              likely be needed in md_estimate_size_before_relax.  */
2381           if (fragP->fr_symbol)
2382             resolve_symbol_value (fragP->fr_symbol);
2383
2384           address += md_estimate_size_before_relax (fragP, segment);
2385           break;
2386
2387 #ifndef WORKING_DOT_WORD
2388           /* Broken words don't concern us yet.  */
2389         case rs_broken_word:
2390           break;
2391 #endif
2392
2393         case rs_leb128:
2394           /* Initial guess is always 1; doing otherwise can result in
2395              stable solutions that are larger than the minimum.  */
2396           address += fragP->fr_offset = 1;
2397           break;
2398
2399         case rs_cfa:
2400           address += eh_frame_estimate_size_before_relax (fragP);
2401           break;
2402
2403         case rs_dwarf2dbg:
2404           address += dwarf2dbg_estimate_size_before_relax (fragP);
2405           break;
2406
2407         default:
2408           BAD_CASE (fragP->fr_type);
2409           break;
2410         }
2411     }
2412
2413   /* Do relax().  */
2414   {
2415     unsigned long max_iterations;
2416
2417     /* Cumulative address adjustment.  */
2418     offsetT stretch;
2419
2420     /* Have we made any adjustment this pass?  We can't just test
2421        stretch because one piece of code may have grown and another
2422        shrank.  */
2423     int stretched;
2424
2425     /* Most horrible, but gcc may give us some exception data that
2426        is impossible to assemble, of the form
2427
2428        .align 4
2429        .byte 0, 0
2430        .uleb128 end - start
2431        start:
2432        .space 128*128 - 1
2433        .align 4
2434        end:
2435
2436        If the leb128 is two bytes in size, then end-start is 128*128,
2437        which requires a three byte leb128.  If the leb128 is three
2438        bytes in size, then end-start is 128*128-1, which requires a
2439        two byte leb128.  We work around this dilemma by inserting
2440        an extra 4 bytes of alignment just after the .align.  This
2441        works because the data after the align is accessed relative to
2442        the end label.
2443
2444        This counter is used in a tiny state machine to detect
2445        whether a leb128 followed by an align is impossible to
2446        relax.  */
2447     int rs_leb128_fudge = 0;
2448
2449     /* We want to prevent going into an infinite loop where one frag grows
2450        depending upon the location of a symbol which is in turn moved by
2451        the growing frag.  eg:
2452
2453          foo = .
2454          .org foo+16
2455          foo = .
2456
2457        So we dictate that this algorithm can be at most O2.  */
2458     max_iterations = frag_count * frag_count;
2459     /* Check for overflow.  */
2460     if (max_iterations < frag_count)
2461       max_iterations = frag_count;
2462
2463     ret = 0;
2464     do
2465       {
2466         stretch = 0;
2467         stretched = 0;
2468
2469         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2470           {
2471             offsetT growth = 0;
2472             addressT was_address;
2473             offsetT offset;
2474             symbolS *symbolP;
2475
2476             fragP->relax_marker ^= 1;
2477             was_address = fragP->fr_address;
2478             address = fragP->fr_address += stretch;
2479             symbolP = fragP->fr_symbol;
2480             offset = fragP->fr_offset;
2481
2482             switch (fragP->fr_type)
2483               {
2484               case rs_fill:     /* .fill never relaxes.  */
2485                 growth = 0;
2486                 break;
2487
2488 #ifndef WORKING_DOT_WORD
2489                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2490                    for it I do not want to write it.  I do not want to have
2491                    anything to do with it.  This is not the proper way to
2492                    implement this misfeature.  */
2493               case rs_broken_word:
2494                 {
2495                   struct broken_word *lie;
2496                   struct broken_word *untruth;
2497
2498                   /* Yes this is ugly (storing the broken_word pointer
2499                      in the symbol slot).  Still, this whole chunk of
2500                      code is ugly, and I don't feel like doing anything
2501                      about it.  Think of it as stubbornness in action.  */
2502                   growth = 0;
2503                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2504                        lie && lie->dispfrag == fragP;
2505                        lie = lie->next_broken_word)
2506                     {
2507
2508                       if (lie->added)
2509                         continue;
2510
2511                       offset = (S_GET_VALUE (lie->add)
2512                                 + lie->addnum
2513                                 - S_GET_VALUE (lie->sub));
2514                       if (offset <= -32768 || offset >= 32767)
2515                         {
2516                           if (flag_warn_displacement)
2517                             {
2518                               char buf[50];
2519                               sprint_value (buf, (addressT) lie->addnum);
2520                               as_warn_where (fragP->fr_file, fragP->fr_line,
2521                                              _(".word %s-%s+%s didn't fit"),
2522                                              S_GET_NAME (lie->add),
2523                                              S_GET_NAME (lie->sub),
2524                                              buf);
2525                             }
2526                           if (fragP->fr_subtype == 0)
2527                             {
2528                               fragP->fr_subtype++;
2529                               growth += md_short_jump_size;
2530                             }
2531
2532                           /* Redirect *all* words of this table with the same
2533                              target, lest we have to handle the case where the
2534                              same target but with a offset that fits on this
2535                              round overflows at the next relaxation round.  */
2536                           for (untruth = (struct broken_word *) (fragP->fr_symbol);
2537                                untruth && untruth->dispfrag == lie->dispfrag;
2538                                untruth = untruth->next_broken_word)
2539                             if ((symbol_get_frag (untruth->add)
2540                                  == symbol_get_frag (lie->add))
2541                                 && (S_GET_VALUE (untruth->add)
2542                                     == S_GET_VALUE (lie->add)))
2543                               {
2544                                 untruth->added = 2;
2545                                 untruth->use_jump = lie;
2546                               }
2547
2548                           lie->added = 1;
2549                           growth += md_long_jump_size;
2550                         }
2551                     }
2552
2553                   break;
2554                 }               /* case rs_broken_word  */
2555 #endif
2556               case rs_align:
2557               case rs_align_code:
2558               case rs_align_test:
2559                 {
2560                   addressT oldoff, newoff;
2561
2562                   oldoff = relax_align (was_address + fragP->fr_fix,
2563                                         (int) offset);
2564                   newoff = relax_align (address + fragP->fr_fix,
2565                                         (int) offset);
2566
2567                   if (fragP->fr_subtype != 0)
2568                     {
2569                       if (oldoff > fragP->fr_subtype)
2570                         oldoff = 0;
2571                       if (newoff > fragP->fr_subtype)
2572                         newoff = 0;
2573                     }
2574
2575                   growth = newoff - oldoff;
2576
2577                   /* If this align happens to follow a leb128 and
2578                      we have determined that the leb128 is bouncing
2579                      in size, then break the cycle by inserting an
2580                      extra alignment.  */
2581                   if (growth < 0
2582                       && (rs_leb128_fudge & 16) != 0
2583                       && (rs_leb128_fudge & 15) >= 2)
2584                     {
2585                       segment_info_type *seginfo = seg_info (segment);
2586                       struct obstack *ob = &seginfo->frchainP->frch_obstack;
2587                       struct frag *newf;
2588
2589                       newf = frag_alloc (ob);
2590                       obstack_blank_fast (ob, fragP->fr_var);
2591                       obstack_finish (ob);
2592                       memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2593                       memcpy (newf->fr_literal,
2594                               fragP->fr_literal + fragP->fr_fix,
2595                               fragP->fr_var);
2596                       newf->fr_type = rs_fill;
2597                       newf->fr_address = address + fragP->fr_fix + newoff;
2598                       newf->fr_fix = 0;
2599                       newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2600                                          / fragP->fr_var);
2601                       if (newf->fr_offset * newf->fr_var
2602                           != (offsetT) 1 << fragP->fr_offset)
2603                         {
2604                           newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2605                           newf->fr_var = 1;
2606                         }
2607                       /* Include size of new frag in GROWTH.  */
2608                       growth += newf->fr_offset * newf->fr_var;
2609                       /* Adjust the new frag address for the amount
2610                          we'll add when we process the new frag.  */
2611                       newf->fr_address -= stretch + growth;
2612                       newf->relax_marker ^= 1;
2613                       fragP->fr_next = newf;
2614 #ifdef DEBUG
2615                       as_warn (_("padding added"));
2616 #endif
2617                     }
2618                 }
2619                 break;
2620
2621               case rs_org:
2622                 {
2623                   addressT target = offset;
2624                   addressT after;
2625
2626                   if (symbolP)
2627                     {
2628                       /* Convert from an actual address to an octet offset
2629                          into the section.  Here it is assumed that the
2630                          section's VMA is zero, and can omit subtracting it
2631                          from the symbol's value to get the address offset.  */
2632                       know (S_GET_SEGMENT (symbolP)->vma == 0);
2633                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2634                     }
2635
2636                   know (fragP->fr_next);
2637                   after = fragP->fr_next->fr_address + stretch;
2638                   growth = target - after;
2639                   if (growth < 0)
2640                     {
2641                       growth = 0;
2642
2643                       /* Don't error on first few frag relax passes.
2644                          The symbol might be an expression involving
2645                          symbol values from other sections.  If those
2646                          sections have not yet been processed their
2647                          frags will all have zero addresses, so we
2648                          will calculate incorrect values for them.  The
2649                          number of passes we allow before giving an
2650                          error is somewhat arbitrary.  It should be at
2651                          least one, with larger values requiring
2652                          increasingly contrived dependencies between
2653                          frags to trigger a false error.  */
2654                       if (pass < 2)
2655                         {
2656                           /* Force another pass.  */
2657                           ret = 1;
2658                           break;
2659                         }
2660
2661                       /* Growth may be negative, but variable part of frag
2662                          cannot have fewer than 0 chars.  That is, we can't
2663                          .org backwards.  */
2664                       as_bad_where (fragP->fr_file, fragP->fr_line,
2665                                     _("attempt to move .org backwards"));
2666
2667                       /* We've issued an error message.  Change the
2668                          frag to avoid cascading errors.  */
2669                       fragP->fr_type = rs_align;
2670                       fragP->fr_subtype = 0;
2671                       fragP->fr_offset = 0;
2672                       fragP->fr_fix = after - address;
2673                     }
2674                 }
2675                 break;
2676
2677               case rs_space:
2678                 growth = 0;
2679                 if (symbolP)
2680                   {
2681                     offsetT amount;
2682
2683                     amount = S_GET_VALUE (symbolP);
2684                     if (S_GET_SEGMENT (symbolP) != absolute_section
2685                         || S_IS_COMMON (symbolP)
2686                         || ! S_IS_DEFINED (symbolP))
2687                       {
2688                         as_bad_where (fragP->fr_file, fragP->fr_line,
2689                                       _(".space specifies non-absolute value"));
2690                         /* Prevent repeat of this error message.  */
2691                         fragP->fr_symbol = 0;
2692                       }
2693                     else if (amount < 0)
2694                       {
2695                         /* Don't error on first few frag relax passes.
2696                            See rs_org comment for a longer explanation.  */
2697                         if (pass < 2)
2698                           {
2699                             ret = 1;
2700                             break;
2701                           }
2702
2703                         as_warn_where (fragP->fr_file, fragP->fr_line,
2704                                        _(".space or .fill with negative value, ignored"));
2705                         fragP->fr_symbol = 0;
2706                       }
2707                     else
2708                       growth = (was_address + fragP->fr_fix + amount
2709                                 - fragP->fr_next->fr_address);
2710                   }
2711                 break;
2712
2713               case rs_machine_dependent:
2714 #ifdef md_relax_frag
2715                 growth = md_relax_frag (segment, fragP, stretch);
2716 #else
2717 #ifdef TC_GENERIC_RELAX_TABLE
2718                 /* The default way to relax a frag is to look through
2719                    TC_GENERIC_RELAX_TABLE.  */
2720                 growth = relax_frag (segment, fragP, stretch);
2721 #endif /* TC_GENERIC_RELAX_TABLE  */
2722 #endif
2723                 break;
2724
2725               case rs_leb128:
2726                 {
2727                   valueT value;
2728                   offsetT size;
2729
2730                   value = resolve_symbol_value (fragP->fr_symbol);
2731                   size = sizeof_leb128 (value, fragP->fr_subtype);
2732                   growth = size - fragP->fr_offset;
2733                   fragP->fr_offset = size;
2734                 }
2735                 break;
2736
2737               case rs_cfa:
2738                 growth = eh_frame_relax_frag (fragP);
2739                 break;
2740
2741               case rs_dwarf2dbg:
2742                 growth = dwarf2dbg_relax_frag (fragP);
2743                 break;
2744
2745               default:
2746                 BAD_CASE (fragP->fr_type);
2747                 break;
2748               }
2749             if (growth)
2750               {
2751                 stretch += growth;
2752                 stretched = 1;
2753                 if (fragP->fr_type == rs_leb128)
2754                   rs_leb128_fudge += 16;
2755                 else if (fragP->fr_type == rs_align
2756                          && (rs_leb128_fudge & 16) != 0
2757                          && stretch == 0)
2758                   rs_leb128_fudge += 16;
2759                 else
2760                   rs_leb128_fudge = 0;
2761               }
2762           }
2763
2764         if (stretch == 0
2765             && (rs_leb128_fudge & 16) == 0
2766             && (rs_leb128_fudge & -16) != 0)
2767           rs_leb128_fudge += 1;
2768         else
2769           rs_leb128_fudge = 0;
2770       }
2771     /* Until nothing further to relax.  */
2772     while (stretched && -- max_iterations);
2773
2774     if (stretched)
2775       as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2776                 segment_name (segment));
2777   }
2778
2779   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2780     if (fragP->last_fr_address != fragP->fr_address)
2781       {
2782         fragP->last_fr_address = fragP->fr_address;
2783         ret = 1;
2784       }
2785   return ret;
2786 }
2787
2788 void
2789 number_to_chars_bigendian (char *buf, valueT val, int n)
2790 {
2791   if (n <= 0)
2792     abort ();
2793   while (n--)
2794     {
2795       buf[n] = val & 0xff;
2796       val >>= 8;
2797     }
2798 }
2799
2800 void
2801 number_to_chars_littleendian (char *buf, valueT val, int n)
2802 {
2803   if (n <= 0)
2804     abort ();
2805   while (n--)
2806     {
2807       *buf++ = val & 0xff;
2808       val >>= 8;
2809     }
2810 }
2811
2812 void
2813 write_print_statistics (FILE *file)
2814 {
2815   fprintf (file, "fixups: %d\n", n_fixups);
2816 }
2817
2818 /* For debugging.  */
2819 extern int indent_level;
2820
2821 void
2822 print_fixup (fixS *fixp)
2823 {
2824   indent_level = 1;
2825   fprintf (stderr, "fix ");
2826   fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2827   fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2828   if (fixp->fx_pcrel)
2829     fprintf (stderr, " pcrel");
2830   if (fixp->fx_pcrel_adjust)
2831     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2832   if (fixp->fx_im_disp)
2833     {
2834 #ifdef TC_NS32K
2835       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2836 #else
2837       fprintf (stderr, " im_disp");
2838 #endif
2839     }
2840   if (fixp->fx_tcbit)
2841     fprintf (stderr, " tcbit");
2842   if (fixp->fx_done)
2843     fprintf (stderr, " done");
2844   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
2845   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2846   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2847            (long) fixp->fx_where,
2848            (unsigned long) fixp->fx_offset,
2849            (unsigned long) fixp->fx_addnumber);
2850   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2851            fixp->fx_r_type);
2852   if (fixp->fx_addsy)
2853     {
2854       fprintf (stderr, "\n   +<");
2855       print_symbol_value_1 (stderr, fixp->fx_addsy);
2856       fprintf (stderr, ">");
2857     }
2858   if (fixp->fx_subsy)
2859     {
2860       fprintf (stderr, "\n   -<");
2861       print_symbol_value_1 (stderr, fixp->fx_subsy);
2862       fprintf (stderr, ">");
2863     }
2864   fprintf (stderr, "\n");
2865 #ifdef TC_FIX_DATA_PRINT
2866   TC_FIX_DATA_PRINT (stderr, fixp);
2867 #endif
2868 }