gas/write.c

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