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