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