gas/write.c

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