gas/write.c

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