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             /* If the fix is valid, subtract fx_subsy here.  The addition of
1009                fx_addsy will be performed below.  Doing this prevents bogus
1010                warnings from the range check below.  */
1011               add_number -= S_GET_VALUE (fixP->fx_subsy);
1012           else
1013             {
1014               if (!md_register_arithmetic
1015                   && (add_symbol_segment == reg_section
1016                       || sub_symbol_segment == reg_section))
1017                 as_bad_where (fixP->fx_file, fixP->fx_line,
1018                               _("register value used as expression"));
1019               else
1020                 as_bad_where (fixP->fx_file, fixP->fx_line,
1021                               _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1022                               fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1023                               segment_name (add_symbol_segment),
1024                               S_GET_NAME (fixP->fx_subsy),
1025                               segment_name (sub_symbol_segment));
1026             }
1027         }
1028
1029       if (fixP->fx_addsy)
1030         {
1031           if (add_symbol_segment == this_segment
1032               && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1033               && !TC_FORCE_RELOCATION_LOCAL (fixP))
1034             {
1035               /* This fixup was made when the symbol's segment was
1036                  SEG_UNKNOWN, but it is now in the local segment.
1037                  So we know how to do the address without relocation.  */
1038               add_number += S_GET_VALUE (fixP->fx_addsy);
1039               fixP->fx_offset = add_number;
1040               if (fixP->fx_pcrel)
1041                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1042               fixP->fx_addsy = NULL;
1043               fixP->fx_pcrel = 0;
1044             }
1045           else if (add_symbol_segment == absolute_section
1046                    && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1047                    && !TC_FORCE_RELOCATION_ABS (fixP))
1048             {
1049               add_number += S_GET_VALUE (fixP->fx_addsy);
1050               fixP->fx_offset = add_number;
1051               fixP->fx_addsy = NULL;
1052             }
1053           else if (add_symbol_segment != undefined_section
1054                    && ! bfd_is_com_section (add_symbol_segment)
1055                    && MD_APPLY_SYM_VALUE (fixP))
1056             add_number += S_GET_VALUE (fixP->fx_addsy);
1057         }
1058
1059       if (fixP->fx_pcrel)
1060         {
1061           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1062           if (!fixP->fx_done && fixP->fx_addsy == NULL)
1063             {
1064               /* There was no symbol required by this relocation.
1065                  However, BFD doesn't really handle relocations
1066                  without symbols well. So fake up a local symbol in
1067                  the absolute section.  */
1068               fixP->fx_addsy = abs_section_sym;
1069             }
1070         }
1071
1072       if (!fixP->fx_done)
1073         md_apply_fix (fixP, &add_number, this_segment);
1074
1075       if (!fixP->fx_done)
1076         {
1077           ++seg_reloc_count;
1078           if (fixP->fx_addsy == NULL)
1079             fixP->fx_addsy = abs_section_sym;
1080           symbol_mark_used_in_reloc (fixP->fx_addsy);
1081           if (fixP->fx_subsy != NULL)
1082             symbol_mark_used_in_reloc (fixP->fx_subsy);
1083         }
1084
1085       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
1086         {
1087           if (fixP->fx_size < sizeof (valueT))
1088             {
1089               valueT mask;
1090
1091               mask = 0;
1092               mask--;           /* Set all bits to one.  */
1093               mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1094               if ((add_number & mask) != 0 && (add_number & mask) != mask)
1095                 {
1096                   char buf[50], buf2[50];
1097                   sprint_value (buf, fragP->fr_address + fixP->fx_where);
1098                   if (add_number > 1000)
1099                     sprint_value (buf2, add_number);
1100                   else
1101                     sprintf (buf2, "%ld", (long) add_number);
1102                   as_bad_where (fixP->fx_file, fixP->fx_line,
1103                                 _("value of %s too large for field of %d bytes at %s"),
1104                                 buf2, fixP->fx_size, buf);
1105                 } /* Generic error checking.  */
1106             }
1107 #ifdef WARN_SIGNED_OVERFLOW_WORD
1108           /* Warn if a .word value is too large when treated as a signed
1109              number.  We already know it is not too negative.  This is to
1110              catch over-large switches generated by gcc on the 68k.  */
1111           if (!flag_signed_overflow_ok
1112               && fixP->fx_size == 2
1113               && add_number > 0x7fff)
1114             as_bad_where (fixP->fx_file, fixP->fx_line,
1115                           _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1116                           (long) add_number,
1117                           (long) (fragP->fr_address + fixP->fx_where));
1118 #endif
1119         }                       /* Not a bit fix.  */
1120
1121 #ifdef TC_VALIDATE_FIX
1122     skip:  ATTRIBUTE_UNUSED_LABEL
1123       ;
1124 #endif
1125 #ifdef DEBUG5
1126       fprintf (stderr, "result:\n");
1127       print_fixup (fixP);
1128 #endif
1129     }                           /* For each fixS in this segment.  */
1130
1131   TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
1132   return seg_reloc_count;
1133 }
1134
1135 static void
1136 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1137              asection *sec,
1138              void *xxx ATTRIBUTE_UNUSED)
1139 {
1140   segment_info_type *seginfo = seg_info (sec);
1141
1142   fixup_segment (seginfo->fix_root, sec);
1143 }
1144
1145 static void
1146 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1147                char *file, unsigned int line)
1148 {
1149   char *err;
1150   bfd_reloc_status_type s;
1151   asymbol *sym;
1152
1153   if (reloc->sym_ptr_ptr != NULL
1154       && (sym = *reloc->sym_ptr_ptr) != NULL
1155       && (sym->flags & BSF_KEEP) == 0
1156       && ((sym->flags & BSF_SECTION_SYM) == 0
1157           || (EMIT_SECTION_SYMBOLS
1158               && !bfd_is_abs_section (sym->section))))
1159     as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1160
1161   s = bfd_install_relocation (stdoutput, reloc,
1162                               fragp->fr_literal, fragp->fr_address,
1163                               sec, &err);
1164   switch (s)
1165     {
1166     case bfd_reloc_ok:
1167       break;
1168     case bfd_reloc_overflow:
1169       as_bad_where (file, line, _("relocation overflow"));
1170       break;
1171     case bfd_reloc_outofrange:
1172       as_bad_where (file, line, _("relocation out of range"));
1173       break;
1174     default:
1175       as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1176                 file, line, s);
1177     }
1178 }
1179
1180 static fragS *
1181 get_frag_for_reloc (fragS *last_frag,
1182                     const segment_info_type *seginfo,
1183                     const struct reloc_list *r)
1184 {
1185   fragS *f;
1186
1187   for (f = last_frag; 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   for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1193     if (f->fr_address <= r->u.b.r.address
1194         && r->u.b.r.address < f->fr_address + f->fr_fix)
1195       return f;
1196
1197   as_bad_where (r->file, r->line,
1198                 _("reloc not within (fixed part of) section"));
1199   return NULL;
1200 }
1201
1202 static void
1203 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1204 {
1205   segment_info_type *seginfo = seg_info (sec);
1206   unsigned int n;
1207   struct reloc_list *my_reloc_list, **rp, *r;
1208   arelent **relocs;
1209   fixS *fixp;
1210   fragS *last_frag;
1211
1212   /* If seginfo is NULL, we did not create this section; don't do
1213      anything with it.  */
1214   if (seginfo == NULL)
1215     return;
1216
1217   n = 0;
1218   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1219     if (!fixp->fx_done)
1220       n++;
1221
1222 #ifdef RELOC_EXPANSION_POSSIBLE
1223   n *= MAX_RELOC_EXPANSION;
1224 #endif
1225
1226   /* Extract relocs for this section from reloc_list.  */
1227   rp = &reloc_list;
1228   my_reloc_list = NULL;
1229   while ((r = *rp) != NULL)
1230     {
1231       if (r->u.b.sec == sec)
1232         {
1233           *rp = r->next;
1234           r->next = my_reloc_list;
1235           my_reloc_list = r;
1236           n++;
1237         }
1238       else
1239         rp = &r->next;
1240     }
1241
1242   relocs = (arelent **) xcalloc (n, sizeof (arelent *));
1243
1244   n = 0;
1245   r = my_reloc_list;
1246   last_frag = NULL;
1247   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1248     {
1249       int fx_size, slack;
1250       offsetT loc;
1251       arelent **reloc;
1252 #ifndef RELOC_EXPANSION_POSSIBLE
1253       arelent *rel;
1254
1255       reloc = &rel;
1256 #endif
1257
1258       if (fixp->fx_done)
1259         continue;
1260
1261       fx_size = fixp->fx_size;
1262       slack = TC_FX_SIZE_SLACK (fixp);
1263       if (slack > 0)
1264         fx_size = fx_size > slack ? fx_size - slack : 0;
1265       loc = fixp->fx_where + fx_size;
1266       if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1267         as_bad_where (fixp->fx_file, fixp->fx_line,
1268                       _("internal error: fixup not contained within frag"));
1269
1270 #ifndef RELOC_EXPANSION_POSSIBLE
1271       *reloc = tc_gen_reloc (sec, fixp);
1272 #else
1273       reloc = tc_gen_reloc (sec, fixp);
1274 #endif
1275
1276       while (*reloc)
1277         {
1278           while (r != NULL && r->u.b.r.address < (*reloc)->address)
1279             {
1280               fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1281               if (f != NULL)
1282                 {
1283                   last_frag = f;
1284                   relocs[n++] = &r->u.b.r;
1285                   install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1286                 }
1287               r = r->next;
1288             }
1289           relocs[n++] = *reloc;
1290           install_reloc (sec, *reloc, fixp->fx_frag,
1291                          fixp->fx_file, fixp->fx_line);
1292 #ifndef RELOC_EXPANSION_POSSIBLE
1293           break;
1294 #else
1295           reloc++;
1296 #endif
1297         }
1298     }
1299
1300   while (r != NULL)
1301     {
1302       fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1303       if (f != NULL)
1304         {
1305           last_frag = f;
1306           relocs[n++] = &r->u.b.r;
1307           install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1308         }
1309       r = r->next;
1310     }
1311
1312 #ifdef DEBUG4
1313   {
1314     unsigned int k, j, nsyms;
1315     asymbol **sympp;
1316     sympp = bfd_get_outsymbols (stdoutput);
1317     nsyms = bfd_get_symcount (stdoutput);
1318     for (k = 0; k < n; k++)
1319       if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1320         {
1321           for (j = 0; j < nsyms; j++)
1322             if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1323               break;
1324           if (j == nsyms)
1325             abort ();
1326         }
1327   }
1328 #endif
1329
1330   if (n)
1331     {
1332       flagword flags = bfd_get_section_flags (abfd, sec);
1333       flags |= SEC_RELOC;
1334       bfd_set_section_flags (abfd, sec, flags);
1335       bfd_set_reloc (stdoutput, sec, relocs, n);
1336     }
1337
1338 #ifdef SET_SECTION_RELOCS
1339   SET_SECTION_RELOCS (sec, relocs, n);
1340 #endif
1341
1342 #ifdef DEBUG3
1343   {
1344     unsigned int k;
1345
1346     fprintf (stderr, "relocs for sec %s\n", sec->name);
1347     for (k = 0; k < n; k++)
1348       {
1349         arelent *rel = relocs[k];
1350         asymbol *s = *rel->sym_ptr_ptr;
1351         fprintf (stderr, "  reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1352                  k, rel, (unsigned long)rel->address, s->name,
1353                  (unsigned long)rel->addend);
1354       }
1355   }
1356 #endif
1357 }
1358
1359 static int
1360 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1361                fragS **last_newf, struct obstack *ob)
1362 {
1363   int out_size;
1364   int total_out_size = 0;
1365   fragS *f = *last_newf;
1366   char *next_out;
1367   int avail_out;
1368
1369   /* Call the compression routine repeatedly until it has finished
1370      processing the frag.  */
1371   while (in_size > 0)
1372     {
1373       /* Reserve all the space available in the current chunk.
1374          If none is available, start a new frag.  */
1375       avail_out = obstack_room (ob);
1376       if (avail_out <= 0)
1377         {
1378           obstack_finish (ob);
1379           f = frag_alloc (ob);
1380           f->fr_type = rs_fill;
1381           (*last_newf)->fr_next = f;
1382           *last_newf = f;
1383           avail_out = obstack_room (ob);
1384         }
1385       if (avail_out <= 0)
1386         as_fatal (_("can't extend frag"));
1387       next_out = obstack_next_free (ob);
1388       obstack_blank_fast (ob, avail_out);
1389       out_size = compress_data (strm, &contents, &in_size,
1390                                 &next_out, &avail_out);
1391       if (out_size < 0)
1392         return -1;
1393
1394       f->fr_fix += out_size;
1395       total_out_size += out_size;
1396
1397       /* Return unused space.  */
1398       if (avail_out > 0)
1399         obstack_blank_fast (ob, -avail_out);
1400     }
1401
1402   return total_out_size;
1403 }
1404
1405 static void
1406 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1407 {
1408   segment_info_type *seginfo = seg_info (sec);
1409   fragS *f;
1410   fragS *first_newf;
1411   fragS *last_newf;
1412   struct obstack *ob = &seginfo->frchainP->frch_obstack;
1413   bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1414   bfd_size_type compressed_size;
1415   const char *section_name;
1416   char *compressed_name;
1417   char *header;
1418   struct z_stream_s *strm;
1419   int x;
1420   flagword flags = bfd_get_section_flags (abfd, sec);
1421
1422   if (seginfo == NULL
1423       || sec->size < 32
1424       || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1425     return;
1426
1427   section_name = bfd_get_section_name (stdoutput, sec);
1428   if (strncmp (section_name, ".debug_", 7) != 0)
1429     return;
1430
1431   strm = compress_init ();
1432   if (strm == NULL)
1433     return;
1434
1435   /* Create a new frag to contain the "ZLIB" header.  */
1436   first_newf = frag_alloc (ob);
1437   if (obstack_room (ob) < 12)
1438     first_newf = frag_alloc (ob);
1439   if (obstack_room (ob) < 12)
1440     as_fatal (_("can't extend frag %u chars"), 12);
1441   last_newf = first_newf;
1442   obstack_blank_fast (ob, 12);
1443   last_newf->fr_type = rs_fill;
1444   last_newf->fr_fix = 12;
1445   header = last_newf->fr_literal;
1446   memcpy (header, "ZLIB", 4);
1447   header[11] = uncompressed_size; uncompressed_size >>= 8;
1448   header[10] = uncompressed_size; uncompressed_size >>= 8;
1449   header[9] = uncompressed_size; uncompressed_size >>= 8;
1450   header[8] = uncompressed_size; uncompressed_size >>= 8;
1451   header[7] = uncompressed_size; uncompressed_size >>= 8;
1452   header[6] = uncompressed_size; uncompressed_size >>= 8;
1453   header[5] = uncompressed_size; uncompressed_size >>= 8;
1454   header[4] = uncompressed_size;
1455   compressed_size = 12;
1456
1457   /* Stream the frags through the compression engine, adding new frags
1458      as necessary to accomodate the compressed output.  */
1459   for (f = seginfo->frchainP->frch_root;
1460        f;
1461        f = f->fr_next)
1462     {
1463       offsetT fill_size;
1464       char *fill_literal;
1465       offsetT count;
1466       int out_size;
1467
1468       gas_assert (f->fr_type == rs_fill);
1469       if (f->fr_fix)
1470         {
1471           out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1472                                     &last_newf, ob);
1473           if (out_size < 0)
1474             return;
1475           compressed_size += out_size;
1476         }
1477       fill_literal = f->fr_literal + f->fr_fix;
1478       fill_size = f->fr_var;
1479       count = f->fr_offset;
1480       gas_assert (count >= 0);
1481       if (fill_size && count)
1482         {
1483           while (count--)
1484             {
1485               out_size = compress_frag (strm, fill_literal, (int) fill_size,
1486                                         &last_newf, ob);
1487               if (out_size < 0)
1488                 return;
1489               compressed_size += out_size;
1490             }
1491         }
1492     }
1493
1494   /* Flush the compression state.  */
1495   for (;;)
1496     {
1497       int avail_out;
1498       char *next_out;
1499       int out_size;
1500
1501       /* Reserve all the space available in the current chunk.
1502          If none is available, start a new frag.  */
1503       avail_out = obstack_room (ob);
1504       if (avail_out <= 0)
1505         {
1506           fragS *newf;
1507
1508           obstack_finish (ob);
1509           newf = frag_alloc (ob);
1510           newf->fr_type = rs_fill;
1511           last_newf->fr_next = newf;
1512           last_newf = newf;
1513           avail_out = obstack_room (ob);
1514         }
1515       if (avail_out <= 0)
1516         as_fatal (_("can't extend frag"));
1517       next_out = obstack_next_free (ob);
1518       obstack_blank_fast (ob, avail_out);
1519       x = compress_finish (strm, &next_out, &avail_out, &out_size);
1520       if (x < 0)
1521         return;
1522
1523       last_newf->fr_fix += out_size;
1524       compressed_size += out_size;
1525
1526       /* Return unused space.  */
1527       if (avail_out > 0)
1528         obstack_blank_fast (ob, -avail_out);
1529
1530       if (x == 0)
1531         break;
1532     }
1533
1534   /* Replace the uncompressed frag list with the compressed frag list.  */
1535   seginfo->frchainP->frch_root = first_newf;
1536   seginfo->frchainP->frch_last = last_newf;
1537
1538   /* Update the section size and its name.  */
1539   x = bfd_set_section_size (abfd, sec, compressed_size);
1540   gas_assert (x);
1541   compressed_name = (char *) xmalloc (strlen (section_name) + 2);
1542   compressed_name[0] = '.';
1543   compressed_name[1] = 'z';
1544   strcpy (compressed_name + 2, section_name + 1);
1545   bfd_section_name (stdoutput, sec) = compressed_name;
1546 }
1547
1548 static void
1549 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1550                 asection *sec,
1551                 void *xxx ATTRIBUTE_UNUSED)
1552 {
1553   segment_info_type *seginfo = seg_info (sec);
1554   addressT offset = 0;
1555   fragS *f;
1556
1557   /* Write out the frags.  */
1558   if (seginfo == NULL
1559       || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1560     return;
1561
1562   for (f = seginfo->frchainP->frch_root;
1563        f;
1564        f = f->fr_next)
1565     {
1566       int x;
1567       addressT fill_size;
1568       char *fill_literal;
1569       offsetT count;
1570
1571       gas_assert (f->fr_type == rs_fill);
1572       if (f->fr_fix)
1573         {
1574           x = bfd_set_section_contents (stdoutput, sec,
1575                                         f->fr_literal, (file_ptr) offset,
1576                                         (bfd_size_type) f->fr_fix);
1577           if (!x)
1578             as_fatal (_("can't write %s: %s"), stdoutput->filename,
1579                       bfd_errmsg (bfd_get_error ()));
1580           offset += f->fr_fix;
1581         }
1582       fill_literal = f->fr_literal + f->fr_fix;
1583       fill_size = f->fr_var;
1584       count = f->fr_offset;
1585       gas_assert (count >= 0);
1586       if (fill_size && count)
1587         {
1588           char buf[256];
1589           if (fill_size > sizeof (buf))
1590             {
1591               /* Do it the old way. Can this ever happen?  */
1592               while (count--)
1593                 {
1594                   x = bfd_set_section_contents (stdoutput, sec,
1595                                                 fill_literal,
1596                                                 (file_ptr) offset,
1597                                                 (bfd_size_type) fill_size);
1598                   if (!x)
1599                     as_fatal (_("can't write %s: %s"), stdoutput->filename,
1600                               bfd_errmsg (bfd_get_error ()));
1601                   offset += fill_size;
1602                 }
1603             }
1604           else
1605             {
1606               /* Build a buffer full of fill objects and output it as
1607                  often as necessary. This saves on the overhead of
1608                  potentially lots of bfd_set_section_contents calls.  */
1609               int n_per_buf, i;
1610               if (fill_size == 1)
1611                 {
1612                   n_per_buf = sizeof (buf);
1613                   memset (buf, *fill_literal, n_per_buf);
1614                 }
1615               else
1616                 {
1617                   char *bufp;
1618                   n_per_buf = sizeof (buf) / fill_size;
1619                   for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1620                     memcpy (bufp, fill_literal, fill_size);
1621                 }
1622               for (; count > 0; count -= n_per_buf)
1623                 {
1624                   n_per_buf = n_per_buf > count ? count : n_per_buf;
1625                   x = bfd_set_section_contents
1626                     (stdoutput, sec, buf, (file_ptr) offset,
1627                      (bfd_size_type) n_per_buf * fill_size);
1628                   if (!x)
1629                     as_fatal (_("cannot write to output file '%s': %s"),
1630                               stdoutput->filename,
1631                               bfd_errmsg (bfd_get_error ()));
1632                   offset += n_per_buf * fill_size;
1633                 }
1634             }
1635         }
1636     }
1637 }
1638
1639 static void
1640 merge_data_into_text (void)
1641 {
1642   seg_info (text_section)->frchainP->frch_last->fr_next =
1643     seg_info (data_section)->frchainP->frch_root;
1644   seg_info (text_section)->frchainP->frch_last =
1645     seg_info (data_section)->frchainP->frch_last;
1646   seg_info (data_section)->frchainP = 0;
1647 }
1648
1649 static void
1650 set_symtab (void)
1651 {
1652   int nsyms;
1653   asymbol **asympp;
1654   symbolS *symp;
1655   bfd_boolean result;
1656
1657   /* Count symbols.  We can't rely on a count made by the loop in
1658      write_object_file, because *_frob_file may add a new symbol or
1659      two.  */
1660   nsyms = 0;
1661   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1662     nsyms++;
1663
1664   if (nsyms)
1665     {
1666       int i;
1667       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1668
1669       asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1670       symp = symbol_rootP;
1671       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1672         {
1673           asympp[i] = symbol_get_bfdsym (symp);
1674           if (asympp[i]->flags != BSF_SECTION_SYM
1675               || !(bfd_is_const_section (asympp[i]->section)
1676                    && asympp[i]->section->symbol == asympp[i]))
1677             asympp[i]->flags |= BSF_KEEP;
1678           symbol_mark_written (symp);
1679         }
1680     }
1681   else
1682     asympp = 0;
1683   result = bfd_set_symtab (stdoutput, asympp, nsyms);
1684   gas_assert (result);
1685   symbol_table_frozen = 1;
1686 }
1687
1688 /* Finish the subsegments.  After every sub-segment, we fake an
1689    ".align ...".  This conforms to BSD4.2 brane-damage.  We then fake
1690    ".fill 0" because that is the kind of frag that requires least
1691    thought.  ".align" frags like to have a following frag since that
1692    makes calculating their intended length trivial.  */
1693
1694 #ifndef SUB_SEGMENT_ALIGN
1695 #ifdef HANDLE_ALIGN
1696 /* The last subsegment gets an alignment corresponding to the alignment
1697    of the section.  This allows proper nop-filling at the end of
1698    code-bearing sections.  */
1699 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
1700   (!(FRCHAIN)->frch_next ? get_recorded_alignment (SEG) : 0)
1701 #else
1702 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1703 #endif
1704 #endif
1705
1706 void
1707 subsegs_finish (void)
1708 {
1709   struct frchain *frchainP;
1710   asection *s;
1711
1712   for (s = stdoutput->sections; s; s = s->next)
1713     {
1714       segment_info_type *seginfo = seg_info (s);
1715       if (!seginfo)
1716         continue;
1717
1718       for (frchainP = seginfo->frchainP;
1719            frchainP != NULL;
1720            frchainP = frchainP->frch_next)
1721         {
1722           int alignment = 0;
1723
1724           subseg_set (s, frchainP->frch_subseg);
1725
1726           /* This now gets called even if we had errors.  In that case,
1727              any alignment is meaningless, and, moreover, will look weird
1728              if we are generating a listing.  */
1729           if (!had_errors ())
1730             {
1731               alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1732               if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1733                   && now_seg->entsize)
1734                 {
1735                   unsigned int entsize = now_seg->entsize;
1736                   int entalign = 0;
1737
1738                   while ((entsize & 1) == 0)
1739                     {
1740                       ++entalign;
1741                       entsize >>= 1;
1742                     }
1743                   if (entalign > alignment)
1744                     alignment = entalign;
1745                 }
1746             }
1747
1748           if (subseg_text_p (now_seg))
1749             frag_align_code (alignment, 0);
1750           else
1751             frag_align (alignment, 0, 0);
1752
1753           /* frag_align will have left a new frag.
1754              Use this last frag for an empty ".fill".
1755
1756              For this segment ...
1757              Create a last frag. Do not leave a "being filled in frag".  */
1758           frag_wane (frag_now);
1759           frag_now->fr_fix = 0;
1760           know (frag_now->fr_next == NULL);
1761         }
1762     }
1763 }
1764
1765 /* Write the object file.  */
1766
1767 void
1768 write_object_file (void)
1769 {
1770   struct relax_seg_info rsi;
1771 #ifndef WORKING_DOT_WORD
1772   fragS *fragP;                 /* Track along all frags.  */
1773 #endif
1774
1775 #ifdef md_pre_output_hook
1776   md_pre_output_hook;
1777 #endif
1778
1779   /* Do we really want to write it?  */
1780   {
1781     int n_warns, n_errs;
1782     n_warns = had_warnings ();
1783     n_errs = had_errors ();
1784     /* The -Z flag indicates that an object file should be generated,
1785        regardless of warnings and errors.  */
1786     if (flag_always_generate_output)
1787       {
1788         if (n_warns || n_errs)
1789           as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1790                    n_errs, n_errs == 1 ? "" : "s",
1791                    n_warns, n_warns == 1 ? "" : "s");
1792       }
1793     else
1794       {
1795         if (n_errs)
1796           as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1797                     n_errs, n_errs == 1 ? "" : "s",
1798                     n_warns, n_warns == 1 ? "" : "s");
1799       }
1800   }
1801
1802 #ifdef md_pre_relax_hook
1803   md_pre_relax_hook;
1804 #endif
1805
1806   /* From now on, we don't care about sub-segments.  Build one frag chain
1807      for each segment. Linked thru fr_next.  */
1808
1809   /* Remove the sections created by gas for its own purposes.  */
1810   {
1811     int i;
1812
1813     bfd_section_list_remove (stdoutput, reg_section);
1814     bfd_section_list_remove (stdoutput, expr_section);
1815     stdoutput->section_count -= 2;
1816     i = 0;
1817     bfd_map_over_sections (stdoutput, renumber_sections, &i);
1818   }
1819
1820   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1821
1822   /* We have two segments. If user gave -R flag, then we must put the
1823      data frags into the text segment. Do this before relaxing so
1824      we know to take advantage of -R and make shorter addresses.  */
1825   if (flag_readonly_data_in_text)
1826     {
1827       merge_data_into_text ();
1828     }
1829
1830   rsi.pass = 0;
1831   while (1)
1832     {
1833 #ifndef WORKING_DOT_WORD
1834       /* We need to reset the markers in the broken word list and
1835          associated frags between calls to relax_segment (via
1836          relax_seg).  Since the broken word list is global, we do it
1837          once per round, rather than locally in relax_segment for each
1838          segment.  */
1839       struct broken_word *brokp;
1840
1841       for (brokp = broken_words;
1842            brokp != (struct broken_word *) NULL;
1843            brokp = brokp->next_broken_word)
1844         {
1845           brokp->added = 0;
1846
1847           if (brokp->dispfrag != (fragS *) NULL
1848               && brokp->dispfrag->fr_type == rs_broken_word)
1849             brokp->dispfrag->fr_subtype = 0;
1850         }
1851 #endif
1852
1853       rsi.changed = 0;
1854       bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1855       rsi.pass++;
1856       if (!rsi.changed)
1857         break;
1858     }
1859
1860   /* Note - Most ports will use the default value of
1861      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
1862      local symbols to be resolved, removing their frag information.
1863      Some ports however, will not have finished relaxing all of
1864      their frags and will still need the local symbol frag
1865      information.  These ports can set
1866      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
1867   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1868
1869   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1870
1871   /* Relaxation has completed.  Freeze all syms.  */
1872   finalize_syms = 1;
1873
1874 #ifdef md_post_relax_hook
1875   md_post_relax_hook;
1876 #endif
1877
1878 #ifndef WORKING_DOT_WORD
1879   {
1880     struct broken_word *lie;
1881     struct broken_word **prevP;
1882
1883     prevP = &broken_words;
1884     for (lie = broken_words; lie; lie = lie->next_broken_word)
1885       if (!lie->added)
1886         {
1887           expressionS exp;
1888
1889           subseg_change (lie->seg, lie->subseg);
1890           exp.X_op = O_subtract;
1891           exp.X_add_symbol = lie->add;
1892           exp.X_op_symbol = lie->sub;
1893           exp.X_add_number = lie->addnum;
1894 #ifdef TC_CONS_FIX_NEW
1895           TC_CONS_FIX_NEW (lie->frag,
1896                            lie->word_goes_here - lie->frag->fr_literal,
1897                            2, &exp);
1898 #else
1899           fix_new_exp (lie->frag,
1900                        lie->word_goes_here - lie->frag->fr_literal,
1901                        2, &exp, 0, BFD_RELOC_16);
1902 #endif
1903           *prevP = lie->next_broken_word;
1904         }
1905       else
1906         prevP = &(lie->next_broken_word);
1907
1908     for (lie = broken_words; lie;)
1909       {
1910         struct broken_word *untruth;
1911         char *table_ptr;
1912         addressT table_addr;
1913         addressT from_addr, to_addr;
1914         int n, m;
1915
1916         subseg_change (lie->seg, lie->subseg);
1917         fragP = lie->dispfrag;
1918
1919         /* Find out how many broken_words go here.  */
1920         n = 0;
1921         for (untruth = lie;
1922              untruth && untruth->dispfrag == fragP;
1923              untruth = untruth->next_broken_word)
1924           if (untruth->added == 1)
1925             n++;
1926
1927         table_ptr = lie->dispfrag->fr_opcode;
1928         table_addr = (lie->dispfrag->fr_address
1929                       + (table_ptr - lie->dispfrag->fr_literal));
1930         /* Create the jump around the long jumps.  This is a short
1931            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
1932         from_addr = table_addr;
1933         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1934         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1935                               lie->add);
1936         table_ptr += md_short_jump_size;
1937         table_addr += md_short_jump_size;
1938
1939         for (m = 0;
1940              lie && lie->dispfrag == fragP;
1941              m++, lie = lie->next_broken_word)
1942           {
1943             if (lie->added == 2)
1944               continue;
1945             /* Patch the jump table.  */
1946             for (untruth = (struct broken_word *) (fragP->fr_symbol);
1947                  untruth && untruth->dispfrag == fragP;
1948                  untruth = untruth->next_broken_word)
1949               {
1950                 if (untruth->use_jump == lie)
1951                   {
1952                     /* This is the offset from ??? to table_ptr+0.
1953                        The target is the same for all users of this
1954                        md_long_jump, but the "sub" bases (and hence the
1955                        offsets) may be different.  */
1956                     addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
1957 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1958                     TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
1959 #endif
1960                     md_number_to_chars (untruth->word_goes_here, to_word, 2);
1961                   }
1962               }
1963
1964             /* Install the long jump.  */
1965             /* This is a long jump from table_ptr+0 to the final target.  */
1966             from_addr = table_addr;
1967             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1968             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1969                                  lie->add);
1970             table_ptr += md_long_jump_size;
1971             table_addr += md_long_jump_size;
1972           }
1973       }
1974   }
1975 #endif /* not WORKING_DOT_WORD  */
1976
1977   /* Resolve symbol values.  This needs to be done before processing
1978      the relocations.  */
1979   if (symbol_rootP)
1980     {
1981       symbolS *symp;
1982
1983       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1984         resolve_symbol_value (symp);
1985     }
1986   resolve_local_symbol_values ();
1987   resolve_reloc_expr_symbols ();
1988
1989   PROGRESS (1);
1990
1991 #ifdef tc_frob_file_before_adjust
1992   tc_frob_file_before_adjust ();
1993 #endif
1994 #ifdef obj_frob_file_before_adjust
1995   obj_frob_file_before_adjust ();
1996 #endif
1997
1998   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1999
2000 #ifdef tc_frob_file_before_fix
2001   tc_frob_file_before_fix ();
2002 #endif
2003 #ifdef obj_frob_file_before_fix
2004   obj_frob_file_before_fix ();
2005 #endif
2006
2007   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2008
2009   /* Set up symbol table, and write it out.  */
2010   if (symbol_rootP)
2011     {
2012       symbolS *symp;
2013       bfd_boolean skip_next_symbol = FALSE;
2014
2015       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2016         {
2017           int punt = 0;
2018           const char *name;
2019
2020           if (skip_next_symbol)
2021             {
2022               /* Don't do anything besides moving the value of the
2023                  symbol from the GAS value-field to the BFD value-field.  */
2024               symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2025               skip_next_symbol = FALSE;
2026               continue;
2027             }
2028
2029           if (symbol_mri_common_p (symp))
2030             {
2031               if (S_IS_EXTERNAL (symp))
2032                 as_bad (_("%s: global symbols not supported in common sections"),
2033                         S_GET_NAME (symp));
2034               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2035               continue;
2036             }
2037
2038           name = S_GET_NAME (symp);
2039           if (name)
2040             {
2041               const char *name2 =
2042                 decode_local_label_name ((char *) S_GET_NAME (symp));
2043               /* They only differ if `name' is a fb or dollar local
2044                  label name.  */
2045               if (name2 != name && ! S_IS_DEFINED (symp))
2046                 as_bad (_("local label `%s' is not defined"), name2);
2047             }
2048
2049           /* Do it again, because adjust_reloc_syms might introduce
2050              more symbols.  They'll probably only be section symbols,
2051              but they'll still need to have the values computed.  */
2052           resolve_symbol_value (symp);
2053
2054           /* Skip symbols which were equated to undefined or common
2055              symbols.  */
2056           if (symbol_equated_reloc_p (symp)
2057               || S_IS_WEAKREFR (symp))
2058             {
2059               const char *sname = S_GET_NAME (symp);
2060
2061               if (S_IS_COMMON (symp)
2062                   && !TC_FAKE_LABEL (sname)
2063                   && !S_IS_WEAKREFR (symp)
2064                   && (!S_IS_EXTERNAL (symp) || S_IS_LOCAL (symp)))
2065                 {
2066                   expressionS *e = symbol_get_value_expression (symp);
2067
2068                   as_bad (_("Local symbol `%s' can't be equated to common symbol `%s'"),
2069                           sname, S_GET_NAME (e->X_add_symbol));
2070                 }
2071               if (S_GET_SEGMENT (symp) == reg_section)
2072                 {
2073                   /* Report error only if we know the symbol name.  */
2074                   if (S_GET_NAME (symp) != reg_section->name)
2075                     as_bad (_("can't make global register symbol `%s'"),
2076                             sname);
2077                 }
2078               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2079               continue;
2080             }
2081
2082 #ifdef obj_frob_symbol
2083           obj_frob_symbol (symp, punt);
2084 #endif
2085 #ifdef tc_frob_symbol
2086           if (! punt || symbol_used_in_reloc_p (symp))
2087             tc_frob_symbol (symp, punt);
2088 #endif
2089
2090           /* If we don't want to keep this symbol, splice it out of
2091              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
2092              want section symbols.  Otherwise, we skip local symbols
2093              and symbols that the frob_symbol macros told us to punt,
2094              but we keep such symbols if they are used in relocs.  */
2095           if (symp == abs_section_sym
2096               || (! EMIT_SECTION_SYMBOLS
2097                   && symbol_section_p (symp))
2098               /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2099                  opposites.  Sometimes the former checks flags and the
2100                  latter examines the name...  */
2101               || (!S_IS_EXTERNAL (symp)
2102                   && (punt || S_IS_LOCAL (symp) ||
2103                       (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2104                   && ! symbol_used_in_reloc_p (symp)))
2105             {
2106               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2107
2108               /* After symbol_remove, symbol_next(symp) still returns
2109                  the one that came after it in the chain.  So we don't
2110                  need to do any extra cleanup work here.  */
2111               continue;
2112             }
2113
2114           /* Make sure we really got a value for the symbol.  */
2115           if (! symbol_resolved_p (symp))
2116             {
2117               as_bad (_("can't resolve value for symbol `%s'"),
2118                       S_GET_NAME (symp));
2119               symbol_mark_resolved (symp);
2120             }
2121
2122           /* Set the value into the BFD symbol.  Up til now the value
2123              has only been kept in the gas symbolS struct.  */
2124           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2125
2126           /* A warning construct is a warning symbol followed by the
2127              symbol warned about.  Don't let anything object-format or
2128              target-specific muck with it; it's ready for output.  */
2129           if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2130             skip_next_symbol = TRUE;
2131         }
2132     }
2133
2134   PROGRESS (1);
2135
2136   /* Now do any format-specific adjustments to the symbol table, such
2137      as adding file symbols.  */
2138 #ifdef tc_adjust_symtab
2139   tc_adjust_symtab ();
2140 #endif
2141 #ifdef obj_adjust_symtab
2142   obj_adjust_symtab ();
2143 #endif
2144
2145   /* Stop if there is an error.  */
2146   if (had_errors ())
2147     return;
2148
2149   /* Now that all the sizes are known, and contents correct, we can
2150      start writing to the file.  */
2151   set_symtab ();
2152
2153   /* If *_frob_file changes the symbol value at this point, it is
2154      responsible for moving the changed value into symp->bsym->value
2155      as well.  Hopefully all symbol value changing can be done in
2156      *_frob_symbol.  */
2157 #ifdef tc_frob_file
2158   tc_frob_file ();
2159 #endif
2160 #ifdef obj_frob_file
2161   obj_frob_file ();
2162 #endif
2163 #ifdef obj_coff_generate_pdata
2164   obj_coff_generate_pdata ();
2165 #endif
2166   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2167
2168 #ifdef tc_frob_file_after_relocs
2169   tc_frob_file_after_relocs ();
2170 #endif
2171 #ifdef obj_frob_file_after_relocs
2172   obj_frob_file_after_relocs ();
2173 #endif
2174
2175   /* Once all relocations have been written, we can compress the
2176      contents of the debug sections.  This needs to be done before
2177      we start writing any sections, because it will affect the file
2178      layout, which is fixed once we start writing contents.  */
2179   if (flag_compress_debug)
2180     bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2181
2182   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2183 }
2184
2185 #ifdef TC_GENERIC_RELAX_TABLE
2186 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2187
2188 long
2189 relax_frag (segT segment, fragS *fragP, long stretch)
2190 {
2191   const relax_typeS *this_type;
2192   const relax_typeS *start_type;
2193   relax_substateT next_state;
2194   relax_substateT this_state;
2195   offsetT growth;
2196   offsetT aim;
2197   addressT target;
2198   addressT address;
2199   symbolS *symbolP;
2200   const relax_typeS *table;
2201
2202   target = fragP->fr_offset;
2203   address = fragP->fr_address;
2204   table = TC_GENERIC_RELAX_TABLE;
2205   this_state = fragP->fr_subtype;
2206   start_type = this_type = table + this_state;
2207   symbolP = fragP->fr_symbol;
2208
2209   if (symbolP)
2210     {
2211       fragS *sym_frag;
2212
2213       sym_frag = symbol_get_frag (symbolP);
2214
2215 #ifndef DIFF_EXPR_OK
2216       know (sym_frag != NULL);
2217 #endif
2218       know (S_GET_SEGMENT (symbolP) != absolute_section
2219             || sym_frag == &zero_address_frag);
2220       target += S_GET_VALUE (symbolP);
2221
2222       /* If SYM_FRAG has yet to be reached on this pass, assume it
2223          will move by STRETCH just as we did, unless there is an
2224          alignment frag between here and SYM_FRAG.  An alignment may
2225          well absorb any STRETCH, and we don't want to choose a larger
2226          branch insn by overestimating the needed reach of this
2227          branch.  It isn't critical to calculate TARGET exactly;  We
2228          know we'll be doing another pass if STRETCH is non-zero.  */
2229
2230       if (stretch != 0
2231           && sym_frag->relax_marker != fragP->relax_marker
2232           && S_GET_SEGMENT (symbolP) == segment)
2233         {
2234           if (stretch < 0
2235               || sym_frag->region == fragP->region)
2236             target += stretch;
2237           /* If we get here we know we have a forward branch.  This
2238              relax pass may have stretched previous instructions so
2239              far that omitting STRETCH would make the branch
2240              negative.  Don't allow this in case the negative reach is
2241              large enough to require a larger branch instruction.  */
2242           else if (target < address)
2243             target = fragP->fr_next->fr_address + stretch;
2244         }
2245     }
2246
2247   aim = target - address - fragP->fr_fix;
2248 #ifdef TC_PCREL_ADJUST
2249   /* Currently only the ns32k family needs this.  */
2250   aim += TC_PCREL_ADJUST (fragP);
2251 #endif
2252
2253 #ifdef md_prepare_relax_scan
2254   /* Formerly called M68K_AIM_KLUDGE.  */
2255   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2256 #endif
2257
2258   if (aim < 0)
2259     {
2260       /* Look backwards.  */
2261       for (next_state = this_type->rlx_more; next_state;)
2262         if (aim >= this_type->rlx_backward)
2263           next_state = 0;
2264         else
2265           {
2266             /* Grow to next state.  */
2267             this_state = next_state;
2268             this_type = table + this_state;
2269             next_state = this_type->rlx_more;
2270           }
2271     }
2272   else
2273     {
2274       /* Look forwards.  */
2275       for (next_state = this_type->rlx_more; next_state;)
2276         if (aim <= this_type->rlx_forward)
2277           next_state = 0;
2278         else
2279           {
2280             /* Grow to next state.  */
2281             this_state = next_state;
2282             this_type = table + this_state;
2283             next_state = this_type->rlx_more;
2284           }
2285     }
2286
2287   growth = this_type->rlx_length - start_type->rlx_length;
2288   if (growth != 0)
2289     fragP->fr_subtype = this_state;
2290   return growth;
2291 }
2292
2293 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2294
2295 /* Relax_align. Advance location counter to next address that has 'alignment'
2296    lowest order bits all 0s, return size of adjustment made.  */
2297 static relax_addressT
2298 relax_align (register relax_addressT address,   /* Address now.  */
2299              register int alignment     /* Alignment (binary).  */)
2300 {
2301   relax_addressT mask;
2302   relax_addressT new_address;
2303
2304   mask = ~((~0) << alignment);
2305   new_address = (address + mask) & (~mask);
2306 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2307   if (linkrelax)
2308     /* We must provide lots of padding, so the linker can discard it
2309        when needed.  The linker will not add extra space, ever.  */
2310     new_address += (1 << alignment);
2311 #endif
2312   return (new_address - address);
2313 }
2314
2315 /* Now we have a segment, not a crowd of sub-segments, we can make
2316    fr_address values.
2317
2318    Relax the frags.
2319
2320    After this, all frags in this segment have addresses that are correct
2321    within the segment. Since segments live in different file addresses,
2322    these frag addresses may not be the same as final object-file
2323    addresses.  */
2324
2325 int
2326 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2327 {
2328   unsigned long frag_count;
2329   struct frag *fragP;
2330   relax_addressT address;
2331   int region;
2332   int ret;
2333
2334   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2335   subseg_change (segment, 0);
2336
2337   /* For each frag in segment: count and store  (a 1st guess of)
2338      fr_address.  */
2339   address = 0;
2340   region = 0;
2341   for (frag_count = 0, fragP = segment_frag_root;
2342        fragP;
2343        fragP = fragP->fr_next, frag_count ++)
2344     {
2345       fragP->region = region;
2346       fragP->relax_marker = 0;
2347       fragP->fr_address = address;
2348       address += fragP->fr_fix;
2349
2350       switch (fragP->fr_type)
2351         {
2352         case rs_fill:
2353           address += fragP->fr_offset * fragP->fr_var;
2354           break;
2355
2356         case rs_align:
2357         case rs_align_code:
2358         case rs_align_test:
2359           {
2360             addressT offset = relax_align (address, (int) fragP->fr_offset);
2361
2362             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2363               offset = 0;
2364
2365             if (offset % fragP->fr_var != 0)
2366               {
2367                 as_bad_where (fragP->fr_file, fragP->fr_line,
2368                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2369                               (unsigned long) offset, (long) fragP->fr_var);
2370                 offset -= (offset % fragP->fr_var);
2371               }
2372
2373             address += offset;
2374             region += 1;
2375           }
2376           break;
2377
2378         case rs_org:
2379           /* Assume .org is nugatory. It will grow with 1st relax.  */
2380           region += 1;
2381           break;
2382
2383         case rs_space:
2384           break;
2385
2386         case rs_machine_dependent:
2387           /* If fr_symbol is an expression, this call to
2388              resolve_symbol_value sets up the correct segment, which will
2389              likely be needed in md_estimate_size_before_relax.  */
2390           if (fragP->fr_symbol)
2391             resolve_symbol_value (fragP->fr_symbol);
2392
2393           address += md_estimate_size_before_relax (fragP, segment);
2394           break;
2395
2396 #ifndef WORKING_DOT_WORD
2397           /* Broken words don't concern us yet.  */
2398         case rs_broken_word:
2399           break;
2400 #endif
2401
2402         case rs_leb128:
2403           /* Initial guess is always 1; doing otherwise can result in
2404              stable solutions that are larger than the minimum.  */
2405           address += fragP->fr_offset = 1;
2406           break;
2407
2408         case rs_cfa:
2409           address += eh_frame_estimate_size_before_relax (fragP);
2410           break;
2411
2412         case rs_dwarf2dbg:
2413           address += dwarf2dbg_estimate_size_before_relax (fragP);
2414           break;
2415
2416         default:
2417           BAD_CASE (fragP->fr_type);
2418           break;
2419         }
2420     }
2421
2422   /* Do relax().  */
2423   {
2424     unsigned long max_iterations;
2425
2426     /* Cumulative address adjustment.  */
2427     offsetT stretch;
2428
2429     /* Have we made any adjustment this pass?  We can't just test
2430        stretch because one piece of code may have grown and another
2431        shrank.  */
2432     int stretched;
2433
2434     /* Most horrible, but gcc may give us some exception data that
2435        is impossible to assemble, of the form
2436
2437        .align 4
2438        .byte 0, 0
2439        .uleb128 end - start
2440        start:
2441        .space 128*128 - 1
2442        .align 4
2443        end:
2444
2445        If the leb128 is two bytes in size, then end-start is 128*128,
2446        which requires a three byte leb128.  If the leb128 is three
2447        bytes in size, then end-start is 128*128-1, which requires a
2448        two byte leb128.  We work around this dilemma by inserting
2449        an extra 4 bytes of alignment just after the .align.  This
2450        works because the data after the align is accessed relative to
2451        the end label.
2452
2453        This counter is used in a tiny state machine to detect
2454        whether a leb128 followed by an align is impossible to
2455        relax.  */
2456     int rs_leb128_fudge = 0;
2457
2458     /* We want to prevent going into an infinite loop where one frag grows
2459        depending upon the location of a symbol which is in turn moved by
2460        the growing frag.  eg:
2461
2462          foo = .
2463          .org foo+16
2464          foo = .
2465
2466        So we dictate that this algorithm can be at most O2.  */
2467     max_iterations = frag_count * frag_count;
2468     /* Check for overflow.  */
2469     if (max_iterations < frag_count)
2470       max_iterations = frag_count;
2471
2472     ret = 0;
2473     do
2474       {
2475         stretch = 0;
2476         stretched = 0;
2477
2478         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2479           {
2480             offsetT growth = 0;
2481             addressT was_address;
2482             offsetT offset;
2483             symbolS *symbolP;
2484
2485             fragP->relax_marker ^= 1;
2486             was_address = fragP->fr_address;
2487             address = fragP->fr_address += stretch;
2488             symbolP = fragP->fr_symbol;
2489             offset = fragP->fr_offset;
2490
2491             switch (fragP->fr_type)
2492               {
2493               case rs_fill:     /* .fill never relaxes.  */
2494                 growth = 0;
2495                 break;
2496
2497 #ifndef WORKING_DOT_WORD
2498                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2499                    for it I do not want to write it.  I do not want to have
2500                    anything to do with it.  This is not the proper way to
2501                    implement this misfeature.  */
2502               case rs_broken_word:
2503                 {
2504                   struct broken_word *lie;
2505                   struct broken_word *untruth;
2506
2507                   /* Yes this is ugly (storing the broken_word pointer
2508                      in the symbol slot).  Still, this whole chunk of
2509                      code is ugly, and I don't feel like doing anything
2510                      about it.  Think of it as stubbornness in action.  */
2511                   growth = 0;
2512                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2513                        lie && lie->dispfrag == fragP;
2514                        lie = lie->next_broken_word)
2515                     {
2516
2517                       if (lie->added)
2518                         continue;
2519
2520                       offset = (S_GET_VALUE (lie->add)
2521                                 + lie->addnum
2522                                 - S_GET_VALUE (lie->sub));
2523                       if (offset <= -32768 || offset >= 32767)
2524                         {
2525                           if (flag_warn_displacement)
2526                             {
2527                               char buf[50];
2528                               sprint_value (buf, (addressT) lie->addnum);
2529                               as_warn_where (fragP->fr_file, fragP->fr_line,
2530                                              _(".word %s-%s+%s didn't fit"),
2531                                              S_GET_NAME (lie->add),
2532                                              S_GET_NAME (lie->sub),
2533                                              buf);
2534                             }
2535                           if (fragP->fr_subtype == 0)
2536                             {
2537                               fragP->fr_subtype++;
2538                               growth += md_short_jump_size;
2539                             }
2540
2541                           /* Redirect *all* words of this table with the same
2542                              target, lest we have to handle the case where the
2543                              same target but with a offset that fits on this
2544                              round overflows at the next relaxation round.  */
2545                           for (untruth = (struct broken_word *) (fragP->fr_symbol);
2546                                untruth && untruth->dispfrag == lie->dispfrag;
2547                                untruth = untruth->next_broken_word)
2548                             if ((symbol_get_frag (untruth->add)
2549                                  == symbol_get_frag (lie->add))
2550                                 && (S_GET_VALUE (untruth->add)
2551                                     == S_GET_VALUE (lie->add)))
2552                               {
2553                                 untruth->added = 2;
2554                                 untruth->use_jump = lie;
2555                               }
2556
2557                           lie->added = 1;
2558                           growth += md_long_jump_size;
2559                         }
2560                     }
2561
2562                   break;
2563                 }               /* case rs_broken_word  */
2564 #endif
2565               case rs_align:
2566               case rs_align_code:
2567               case rs_align_test:
2568                 {
2569                   addressT oldoff, newoff;
2570
2571                   oldoff = relax_align (was_address + fragP->fr_fix,
2572                                         (int) offset);
2573                   newoff = relax_align (address + fragP->fr_fix,
2574                                         (int) offset);
2575
2576                   if (fragP->fr_subtype != 0)
2577                     {
2578                       if (oldoff > fragP->fr_subtype)
2579                         oldoff = 0;
2580                       if (newoff > fragP->fr_subtype)
2581                         newoff = 0;
2582                     }
2583
2584                   growth = newoff - oldoff;
2585
2586                   /* If this align happens to follow a leb128 and
2587                      we have determined that the leb128 is bouncing
2588                      in size, then break the cycle by inserting an
2589                      extra alignment.  */
2590                   if (growth < 0
2591                       && (rs_leb128_fudge & 16) != 0
2592                       && (rs_leb128_fudge & 15) >= 2)
2593                     {
2594                       segment_info_type *seginfo = seg_info (segment);
2595                       struct obstack *ob = &seginfo->frchainP->frch_obstack;
2596                       struct frag *newf;
2597
2598                       newf = frag_alloc (ob);
2599                       obstack_blank_fast (ob, fragP->fr_var);
2600                       obstack_finish (ob);
2601                       memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2602                       memcpy (newf->fr_literal,
2603                               fragP->fr_literal + fragP->fr_fix,
2604                               fragP->fr_var);
2605                       newf->fr_type = rs_fill;
2606                       newf->fr_address = address + fragP->fr_fix + newoff;
2607                       newf->fr_fix = 0;
2608                       newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2609                                          / fragP->fr_var);
2610                       if (newf->fr_offset * newf->fr_var
2611                           != (offsetT) 1 << fragP->fr_offset)
2612                         {
2613                           newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2614                           newf->fr_var = 1;
2615                         }
2616                       /* Include size of new frag in GROWTH.  */
2617                       growth += newf->fr_offset * newf->fr_var;
2618                       /* Adjust the new frag address for the amount
2619                          we'll add when we process the new frag.  */
2620                       newf->fr_address -= stretch + growth;
2621                       newf->relax_marker ^= 1;
2622                       fragP->fr_next = newf;
2623 #ifdef DEBUG
2624                       as_warn (_("padding added"));
2625 #endif
2626                     }
2627                 }
2628                 break;
2629
2630               case rs_org:
2631                 {
2632                   addressT target = offset;
2633                   addressT after;
2634
2635                   if (symbolP)
2636                     {
2637                       /* Convert from an actual address to an octet offset
2638                          into the section.  Here it is assumed that the
2639                          section's VMA is zero, and can omit subtracting it
2640                          from the symbol's value to get the address offset.  */
2641                       know (S_GET_SEGMENT (symbolP)->vma == 0);
2642                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2643                     }
2644
2645                   know (fragP->fr_next);
2646                   after = fragP->fr_next->fr_address + stretch;
2647                   growth = target - after;
2648                   if (growth < 0)
2649                     {
2650                       growth = 0;
2651
2652                       /* Don't error on first few frag relax passes.
2653                          The symbol might be an expression involving
2654                          symbol values from other sections.  If those
2655                          sections have not yet been processed their
2656                          frags will all have zero addresses, so we
2657                          will calculate incorrect values for them.  The
2658                          number of passes we allow before giving an
2659                          error is somewhat arbitrary.  It should be at
2660                          least one, with larger values requiring
2661                          increasingly contrived dependencies between
2662                          frags to trigger a false error.  */
2663                       if (pass < 2)
2664                         {
2665                           /* Force another pass.  */
2666                           ret = 1;
2667                           break;
2668                         }
2669
2670                       /* Growth may be negative, but variable part of frag
2671                          cannot have fewer than 0 chars.  That is, we can't
2672                          .org backwards.  */
2673                       as_bad_where (fragP->fr_file, fragP->fr_line,
2674                                     _("attempt to move .org backwards"));
2675
2676                       /* We've issued an error message.  Change the
2677                          frag to avoid cascading errors.  */
2678                       fragP->fr_type = rs_align;
2679                       fragP->fr_subtype = 0;
2680                       fragP->fr_offset = 0;
2681                       fragP->fr_fix = after - address;
2682                     }
2683                 }
2684                 break;
2685
2686               case rs_space:
2687                 growth = 0;
2688                 if (symbolP)
2689                   {
2690                     offsetT amount;
2691
2692                     amount = S_GET_VALUE (symbolP);
2693                     if (S_GET_SEGMENT (symbolP) != absolute_section
2694                         || S_IS_COMMON (symbolP)
2695                         || ! S_IS_DEFINED (symbolP))
2696                       {
2697                         as_bad_where (fragP->fr_file, fragP->fr_line,
2698                                       _(".space specifies non-absolute value"));
2699                         /* Prevent repeat of this error message.  */
2700                         fragP->fr_symbol = 0;
2701                       }
2702                     else if (amount < 0)
2703                       {
2704                         /* Don't error on first few frag relax passes.
2705                            See rs_org comment for a longer explanation.  */
2706                         if (pass < 2)
2707                           {
2708                             ret = 1;
2709                             break;
2710                           }
2711
2712                         as_warn_where (fragP->fr_file, fragP->fr_line,
2713                                        _(".space or .fill with negative value, ignored"));
2714                         fragP->fr_symbol = 0;
2715                       }
2716                     else
2717                       growth = (was_address + fragP->fr_fix + amount
2718                                 - fragP->fr_next->fr_address);
2719                   }
2720                 break;
2721
2722               case rs_machine_dependent:
2723 #ifdef md_relax_frag
2724                 growth = md_relax_frag (segment, fragP, stretch);
2725 #else
2726 #ifdef TC_GENERIC_RELAX_TABLE
2727                 /* The default way to relax a frag is to look through
2728                    TC_GENERIC_RELAX_TABLE.  */
2729                 growth = relax_frag (segment, fragP, stretch);
2730 #endif /* TC_GENERIC_RELAX_TABLE  */
2731 #endif
2732                 break;
2733
2734               case rs_leb128:
2735                 {
2736                   valueT value;
2737                   offsetT size;
2738
2739                   value = resolve_symbol_value (fragP->fr_symbol);
2740                   size = sizeof_leb128 (value, fragP->fr_subtype);
2741                   growth = size - fragP->fr_offset;
2742                   fragP->fr_offset = size;
2743                 }
2744                 break;
2745
2746               case rs_cfa:
2747                 growth = eh_frame_relax_frag (fragP);
2748                 break;
2749
2750               case rs_dwarf2dbg:
2751                 growth = dwarf2dbg_relax_frag (fragP);
2752                 break;
2753
2754               default:
2755                 BAD_CASE (fragP->fr_type);
2756                 break;
2757               }
2758             if (growth)
2759               {
2760                 stretch += growth;
2761                 stretched = 1;
2762                 if (fragP->fr_type == rs_leb128)
2763                   rs_leb128_fudge += 16;
2764                 else if (fragP->fr_type == rs_align
2765                          && (rs_leb128_fudge & 16) != 0
2766                          && stretch == 0)
2767                   rs_leb128_fudge += 16;
2768                 else
2769                   rs_leb128_fudge = 0;
2770               }
2771           }
2772
2773         if (stretch == 0
2774             && (rs_leb128_fudge & 16) == 0
2775             && (rs_leb128_fudge & -16) != 0)
2776           rs_leb128_fudge += 1;
2777         else
2778           rs_leb128_fudge = 0;
2779       }
2780     /* Until nothing further to relax.  */
2781     while (stretched && -- max_iterations);
2782
2783     if (stretched)
2784       as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2785                 segment_name (segment));
2786   }
2787
2788   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2789     if (fragP->last_fr_address != fragP->fr_address)
2790       {
2791         fragP->last_fr_address = fragP->fr_address;
2792         ret = 1;
2793       }
2794   return ret;
2795 }
2796
2797 void
2798 number_to_chars_bigendian (char *buf, valueT val, int n)
2799 {
2800   if (n <= 0)
2801     abort ();
2802   while (n--)
2803     {
2804       buf[n] = val & 0xff;
2805       val >>= 8;
2806     }
2807 }
2808
2809 void
2810 number_to_chars_littleendian (char *buf, valueT val, int n)
2811 {
2812   if (n <= 0)
2813     abort ();
2814   while (n--)
2815     {
2816       *buf++ = val & 0xff;
2817       val >>= 8;
2818     }
2819 }
2820
2821 void
2822 write_print_statistics (FILE *file)
2823 {
2824   fprintf (file, "fixups: %d\n", n_fixups);
2825 }
2826
2827 /* For debugging.  */
2828 extern int indent_level;
2829
2830 void
2831 print_fixup (fixS *fixp)
2832 {
2833   indent_level = 1;
2834   fprintf (stderr, "fix ");
2835   fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2836   fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2837   if (fixp->fx_pcrel)
2838     fprintf (stderr, " pcrel");
2839   if (fixp->fx_pcrel_adjust)
2840     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2841   if (fixp->fx_im_disp)
2842     {
2843 #ifdef TC_NS32K
2844       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2845 #else
2846       fprintf (stderr, " im_disp");
2847 #endif
2848     }
2849   if (fixp->fx_tcbit)
2850     fprintf (stderr, " tcbit");
2851   if (fixp->fx_done)
2852     fprintf (stderr, " done");
2853   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
2854   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2855   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2856            (long) fixp->fx_where,
2857            (unsigned long) fixp->fx_offset,
2858            (unsigned long) fixp->fx_addnumber);
2859   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2860            fixp->fx_r_type);
2861   if (fixp->fx_addsy)
2862     {
2863       fprintf (stderr, "\n   +<");
2864       print_symbol_value_1 (stderr, fixp->fx_addsy);
2865       fprintf (stderr, ">");
2866     }
2867   if (fixp->fx_subsy)
2868     {
2869       fprintf (stderr, "\n   -<");
2870       print_symbol_value_1 (stderr, fixp->fx_subsy);
2871       fprintf (stderr, ">");
2872     }
2873   fprintf (stderr, "\n");
2874 #ifdef TC_FIX_DATA_PRINT
2875   TC_FIX_DATA_PRINT (stderr, fixp);
2876 #endif
2877 }