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