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