gas/write.c

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