contrib/binutils-2.25/gas/write.c

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