gas/write.c

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