gas/write.c

   1 /* write.c - emit .o file
   2    Copyright (C) 1986-2017 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)
 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                                 _("value of %s too large for field of %d bytes at %s"),
1110                                 buf2, fixP->fx_size, buf);
1111                 } /* Generic error checking.  */
1112             }
1113 #ifdef WARN_SIGNED_OVERFLOW_WORD
1114           /* Warn if a .word value is too large when treated as a signed
1115              number.  We already know it is not too negative.  This is to
1116              catch over-large switches generated by gcc on the 68k.  */
1117           if (!flag_signed_overflow_ok
1118               && fixP->fx_size == 2
1119               && add_number > 0x7fff)
1120             as_bad_where (fixP->fx_file, fixP->fx_line,
1121                           _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1122                           (long) add_number,
1123                           (long) (fragP->fr_address + fixP->fx_where));
1124 #endif
1125         }                       /* Not a bit fix.  */
1126
1127 #ifdef TC_VALIDATE_FIX
1128     skip:  ATTRIBUTE_UNUSED_LABEL
1129       ;
1130 #endif
1131 #ifdef DEBUG5
1132       fprintf (stderr, "result:\n");
1133       print_fixup (fixP);
1134 #endif
1135     }                           /* For each fixS in this segment.  */
1136 }
1137
1138 static void
1139 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1140              asection *sec,
1141              void *xxx ATTRIBUTE_UNUSED)
1142 {
1143   segment_info_type *seginfo = seg_info (sec);
1144
1145   fixup_segment (seginfo->fix_root, sec);
1146 }
1147
1148 static void
1149 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1150                const char *file, unsigned int line)
1151 {
1152   char *err;
1153   bfd_reloc_status_type s;
1154   asymbol *sym;
1155
1156   if (reloc->sym_ptr_ptr != NULL
1157       && (sym = *reloc->sym_ptr_ptr) != NULL
1158       && (sym->flags & BSF_KEEP) == 0
1159       && ((sym->flags & BSF_SECTION_SYM) == 0
1160           || (EMIT_SECTION_SYMBOLS
1161               && !bfd_is_abs_section (sym->section))))
1162     as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1163
1164   s = bfd_install_relocation (stdoutput, reloc,
1165                               fragp->fr_literal, fragp->fr_address,
1166                               sec, &err);
1167   switch (s)
1168     {
1169     case bfd_reloc_ok:
1170       break;
1171     case bfd_reloc_overflow:
1172       as_bad_where (file, line, _("relocation overflow"));
1173       break;
1174     case bfd_reloc_outofrange:
1175       as_bad_where (file, line, _("relocation out of range"));
1176       break;
1177     default:
1178       as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1179                 file, line, s);
1180     }
1181 }
1182
1183 static fragS *
1184 get_frag_for_reloc (fragS *last_frag,
1185                     const segment_info_type *seginfo,
1186                     const struct reloc_list *r)
1187 {
1188   fragS *f;
1189
1190   for (f = last_frag; f != NULL; f = f->fr_next)
1191     if (f->fr_address <= r->u.b.r.address
1192         && r->u.b.r.address < f->fr_address + f->fr_fix)
1193       return f;
1194
1195   for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1196     if (f->fr_address <= r->u.b.r.address
1197         && r->u.b.r.address < f->fr_address + f->fr_fix)
1198       return f;
1199
1200   for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1201     if (f->fr_address <= r->u.b.r.address
1202         && r->u.b.r.address <= f->fr_address + f->fr_fix)
1203       return f;
1204
1205   as_bad_where (r->file, r->line,
1206                 _("reloc not within (fixed part of) section"));
1207   return NULL;
1208 }
1209
1210 static void
1211 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1212 {
1213   segment_info_type *seginfo = seg_info (sec);
1214   unsigned int n;
1215   struct reloc_list *my_reloc_list, **rp, *r;
1216   arelent **relocs;
1217   fixS *fixp;
1218   fragS *last_frag;
1219
1220   /* If seginfo is NULL, we did not create this section; don't do
1221      anything with it.  */
1222   if (seginfo == NULL)
1223     return;
1224
1225   n = 0;
1226   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1227     if (!fixp->fx_done)
1228       n++;
1229
1230 #ifdef RELOC_EXPANSION_POSSIBLE
1231   n *= MAX_RELOC_EXPANSION;
1232 #endif
1233
1234   /* Extract relocs for this section from reloc_list.  */
1235   rp = &reloc_list;
1236   my_reloc_list = NULL;
1237   while ((r = *rp) != NULL)
1238     {
1239       if (r->u.b.sec == sec)
1240         {
1241           *rp = r->next;
1242           r->next = my_reloc_list;
1243           my_reloc_list = r;
1244           n++;
1245         }
1246       else
1247         rp = &r->next;
1248     }
1249
1250   relocs = XCNEWVEC (arelent *, n);
1251
1252   n = 0;
1253   r = my_reloc_list;
1254   last_frag = NULL;
1255   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1256     {
1257       int fx_size, slack;
1258       offsetT loc;
1259       arelent **reloc;
1260 #ifndef RELOC_EXPANSION_POSSIBLE
1261       arelent *rel;
1262
1263       reloc = &rel;
1264 #endif
1265
1266       if (fixp->fx_done)
1267         continue;
1268
1269       fx_size = fixp->fx_size;
1270       slack = TC_FX_SIZE_SLACK (fixp);
1271       if (slack > 0)
1272         fx_size = fx_size > slack ? fx_size - slack : 0;
1273       loc = fixp->fx_where + fx_size;
1274       if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1275         as_bad_where (fixp->fx_file, fixp->fx_line,
1276                       _("internal error: fixup not contained within frag"));
1277
1278 #ifndef RELOC_EXPANSION_POSSIBLE
1279       *reloc = tc_gen_reloc (sec, fixp);
1280 #else
1281       reloc = tc_gen_reloc (sec, fixp);
1282 #endif
1283
1284       while (*reloc)
1285         {
1286           while (r != NULL && r->u.b.r.address < (*reloc)->address)
1287             {
1288               fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1289               if (f != NULL)
1290                 {
1291                   last_frag = f;
1292                   relocs[n++] = &r->u.b.r;
1293                   install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1294                 }
1295               r = r->next;
1296             }
1297           relocs[n++] = *reloc;
1298           install_reloc (sec, *reloc, fixp->fx_frag,
1299                          fixp->fx_file, fixp->fx_line);
1300 #ifndef RELOC_EXPANSION_POSSIBLE
1301           break;
1302 #else
1303           reloc++;
1304 #endif
1305         }
1306     }
1307
1308   while (r != NULL)
1309     {
1310       fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1311       if (f != NULL)
1312         {
1313           last_frag = f;
1314           relocs[n++] = &r->u.b.r;
1315           install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1316         }
1317       r = r->next;
1318     }
1319
1320 #ifdef DEBUG4
1321   {
1322     unsigned int k, j, nsyms;
1323     asymbol **sympp;
1324     sympp = bfd_get_outsymbols (stdoutput);
1325     nsyms = bfd_get_symcount (stdoutput);
1326     for (k = 0; k < n; k++)
1327       if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1328         {
1329           for (j = 0; j < nsyms; j++)
1330             if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1331               break;
1332           if (j == nsyms)
1333             abort ();
1334         }
1335   }
1336 #endif
1337
1338   if (n)
1339     {
1340       flagword flags = bfd_get_section_flags (abfd, sec);
1341       flags |= SEC_RELOC;
1342       bfd_set_section_flags (abfd, sec, flags);
1343       bfd_set_reloc (stdoutput, sec, relocs, n);
1344     }
1345
1346 #ifdef SET_SECTION_RELOCS
1347   SET_SECTION_RELOCS (sec, relocs, n);
1348 #endif
1349
1350 #ifdef DEBUG3
1351   {
1352     unsigned int k;
1353
1354     fprintf (stderr, "relocs for sec %s\n", sec->name);
1355     for (k = 0; k < n; k++)
1356       {
1357         arelent *rel = relocs[k];
1358         asymbol *s = *rel->sym_ptr_ptr;
1359         fprintf (stderr, "  reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1360                  k, rel, (unsigned long)rel->address, s->name,
1361                  (unsigned long)rel->addend);
1362       }
1363   }
1364 #endif
1365 }
1366
1367 static int
1368 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1369                fragS **last_newf, struct obstack *ob)
1370 {
1371   int out_size;
1372   int total_out_size = 0;
1373   fragS *f = *last_newf;
1374   char *next_out;
1375   int avail_out;
1376
1377   /* Call the compression routine repeatedly until it has finished
1378      processing the frag.  */
1379   while (in_size > 0)
1380     {
1381       /* Reserve all the space available in the current chunk.
1382          If none is available, start a new frag.  */
1383       avail_out = obstack_room (ob);
1384       if (avail_out <= 0)
1385         {
1386           obstack_finish (ob);
1387           f = frag_alloc (ob);
1388           f->fr_type = rs_fill;
1389           (*last_newf)->fr_next = f;
1390           *last_newf = f;
1391           avail_out = obstack_room (ob);
1392         }
1393       if (avail_out <= 0)
1394         as_fatal (_("can't extend frag"));
1395       next_out = obstack_next_free (ob);
1396       obstack_blank_fast (ob, avail_out);
1397       out_size = compress_data (strm, &contents, &in_size,
1398                                 &next_out, &avail_out);
1399       if (out_size < 0)
1400         return -1;
1401
1402       f->fr_fix += out_size;
1403       total_out_size += out_size;
1404
1405       /* Return unused space.  */
1406       if (avail_out > 0)
1407         obstack_blank_fast (ob, -avail_out);
1408     }
1409
1410   return total_out_size;
1411 }
1412
1413 static void
1414 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1415 {
1416   segment_info_type *seginfo = seg_info (sec);
1417   fragS *f;
1418   fragS *first_newf;
1419   fragS *last_newf;
1420   struct obstack *ob = &seginfo->frchainP->frch_obstack;
1421   bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1422   bfd_size_type compressed_size;
1423   const char *section_name;
1424   char *compressed_name;
1425   char *header;
1426   struct z_stream_s *strm;
1427   int x;
1428   flagword flags = bfd_get_section_flags (abfd, sec);
1429   unsigned int header_size, compression_header_size;
1430
1431   if (seginfo == NULL
1432       || sec->size < 32
1433       || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1434     return;
1435
1436   section_name = bfd_get_section_name (stdoutput, sec);
1437   if (strncmp (section_name, ".debug_", 7) != 0)
1438     return;
1439
1440   strm = compress_init ();
1441   if (strm == NULL)
1442     return;
1443
1444   if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
1445     {
1446       compression_header_size
1447         = bfd_get_compression_header_size (stdoutput, NULL);
1448       header_size = compression_header_size;
1449     }
1450   else
1451     {
1452       compression_header_size = 0;
1453       header_size = 12;
1454     }
1455
1456   /* Create a new frag to contain the compression header.  */
1457   first_newf = frag_alloc (ob);
1458   if (obstack_room (ob) < header_size)
1459     first_newf = frag_alloc (ob);
1460   if (obstack_room (ob) < header_size)
1461     as_fatal (_("can't extend frag %u chars"), header_size);
1462   last_newf = first_newf;
1463   obstack_blank_fast (ob, header_size);
1464   last_newf->fr_type = rs_fill;
1465   last_newf->fr_fix = header_size;
1466   header = last_newf->fr_literal;
1467   compressed_size = header_size;
1468
1469   /* Stream the frags through the compression engine, adding new frags
1470      as necessary to accommodate the compressed output.  */
1471   for (f = seginfo->frchainP->frch_root;
1472        f;
1473        f = f->fr_next)
1474     {
1475       offsetT fill_size;
1476       char *fill_literal;
1477       offsetT count;
1478       int out_size;
1479
1480       gas_assert (f->fr_type == rs_fill);
1481       if (f->fr_fix)
1482         {
1483           out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1484                                     &last_newf, ob);
1485           if (out_size < 0)
1486             return;
1487           compressed_size += out_size;
1488         }
1489       fill_literal = f->fr_literal + f->fr_fix;
1490       fill_size = f->fr_var;
1491       count = f->fr_offset;
1492       gas_assert (count >= 0);
1493       if (fill_size && count)
1494         {
1495           while (count--)
1496             {
1497               out_size = compress_frag (strm, fill_literal, (int) fill_size,
1498                                         &last_newf, ob);
1499               if (out_size < 0)
1500                 return;
1501               compressed_size += out_size;
1502             }
1503         }
1504     }
1505
1506   /* Flush the compression state.  */
1507   for (;;)
1508     {
1509       int avail_out;
1510       char *next_out;
1511       int out_size;
1512
1513       /* Reserve all the space available in the current chunk.
1514          If none is available, start a new frag.  */
1515       avail_out = obstack_room (ob);
1516       if (avail_out <= 0)
1517         {
1518           fragS *newf;
1519
1520           obstack_finish (ob);
1521           newf = frag_alloc (ob);
1522           newf->fr_type = rs_fill;
1523           last_newf->fr_next = newf;
1524           last_newf = newf;
1525           avail_out = obstack_room (ob);
1526         }
1527       if (avail_out <= 0)
1528         as_fatal (_("can't extend frag"));
1529       next_out = obstack_next_free (ob);
1530       obstack_blank_fast (ob, avail_out);
1531       x = compress_finish (strm, &next_out, &avail_out, &out_size);
1532       if (x < 0)
1533         return;
1534
1535       last_newf->fr_fix += out_size;
1536       compressed_size += out_size;
1537
1538       /* Return unused space.  */
1539       if (avail_out > 0)
1540         obstack_blank_fast (ob, -avail_out);
1541
1542       if (x == 0)
1543         break;
1544     }
1545
1546   /* PR binutils/18087: If compression didn't make the section smaller,
1547      just keep it uncompressed.  */
1548   if (compressed_size >= uncompressed_size)
1549     return;
1550
1551   /* Replace the uncompressed frag list with the compressed frag list.  */
1552   seginfo->frchainP->frch_root = first_newf;
1553   seginfo->frchainP->frch_last = last_newf;
1554
1555   /* Update the section size and its name.  */
1556   bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
1557   x = bfd_set_section_size (abfd, sec, compressed_size);
1558   gas_assert (x);
1559   if (!compression_header_size)
1560     {
1561       compressed_name = concat (".z", section_name + 1, (char *) NULL);
1562       bfd_section_name (stdoutput, sec) = compressed_name;
1563     }
1564 }
1565
1566 static void
1567 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1568                 asection *sec,
1569                 void *xxx ATTRIBUTE_UNUSED)
1570 {
1571   segment_info_type *seginfo = seg_info (sec);
1572   addressT offset = 0;
1573   fragS *f;
1574
1575   /* Write out the frags.  */
1576   if (seginfo == NULL
1577       || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1578     return;
1579
1580   for (f = seginfo->frchainP->frch_root;
1581        f;
1582        f = f->fr_next)
1583     {
1584       int x;
1585       addressT fill_size;
1586       char *fill_literal;
1587       offsetT count;
1588
1589       gas_assert (f->fr_type == rs_fill);
1590       if (f->fr_fix)
1591         {
1592           x = bfd_set_section_contents (stdoutput, sec,
1593                                         f->fr_literal, (file_ptr) offset,
1594                                         (bfd_size_type) f->fr_fix);
1595           if (!x)
1596             as_fatal (_("can't write %ld bytes to section %s of %s because: '%s'"),
1597                       (long) f->fr_fix, sec->name,
1598                       stdoutput->filename,
1599                       bfd_errmsg (bfd_get_error ()));
1600           offset += f->fr_fix;
1601         }
1602       fill_literal = f->fr_literal + f->fr_fix;
1603       fill_size = f->fr_var;
1604       count = f->fr_offset;
1605       gas_assert (count >= 0);
1606       if (fill_size && count)
1607         {
1608           char buf[256];
1609           if (fill_size > sizeof (buf))
1610             {
1611               /* Do it the old way. Can this ever happen?  */
1612               while (count--)
1613                 {
1614                   x = bfd_set_section_contents (stdoutput, sec,
1615                                                 fill_literal,
1616                                                 (file_ptr) offset,
1617                                                 (bfd_size_type) fill_size);
1618                   if (!x)
1619                     as_fatal (_("can't fill %ld bytes in section %s of %s because '%s'"),
1620                               (long) fill_size, sec->name,
1621                               stdoutput->filename,
1622                               bfd_errmsg (bfd_get_error ()));
1623                   offset += fill_size;
1624                 }
1625             }
1626           else
1627             {
1628               /* Build a buffer full of fill objects and output it as
1629                  often as necessary. This saves on the overhead of
1630                  potentially lots of bfd_set_section_contents calls.  */
1631               int n_per_buf, i;
1632               if (fill_size == 1)
1633                 {
1634                   n_per_buf = sizeof (buf);
1635                   memset (buf, *fill_literal, n_per_buf);
1636                 }
1637               else
1638                 {
1639                   char *bufp;
1640                   n_per_buf = sizeof (buf) / fill_size;
1641                   for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1642                     memcpy (bufp, fill_literal, fill_size);
1643                 }
1644               for (; count > 0; count -= n_per_buf)
1645                 {
1646                   n_per_buf = n_per_buf > count ? count : n_per_buf;
1647                   x = bfd_set_section_contents
1648                     (stdoutput, sec, buf, (file_ptr) offset,
1649                      (bfd_size_type) n_per_buf * fill_size);
1650                   if (!x)
1651                     as_fatal (_("cannot fill %ld bytes in section %s of %s because: '%s'"),
1652                               (long)(n_per_buf * fill_size), sec->name,
1653                               stdoutput->filename,
1654                               bfd_errmsg (bfd_get_error ()));
1655                   offset += n_per_buf * fill_size;
1656                 }
1657             }
1658         }
1659     }
1660 }
1661
1662 static void
1663 merge_data_into_text (void)
1664 {
1665   seg_info (text_section)->frchainP->frch_last->fr_next =
1666     seg_info (data_section)->frchainP->frch_root;
1667   seg_info (text_section)->frchainP->frch_last =
1668     seg_info (data_section)->frchainP->frch_last;
1669   seg_info (data_section)->frchainP = 0;
1670 }
1671
1672 static void
1673 set_symtab (void)
1674 {
1675   int nsyms;
1676   asymbol **asympp;
1677   symbolS *symp;
1678   bfd_boolean result;
1679
1680   /* Count symbols.  We can't rely on a count made by the loop in
1681      write_object_file, because *_frob_file may add a new symbol or
1682      two.  */
1683   nsyms = 0;
1684   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1685     nsyms++;
1686
1687   if (nsyms)
1688     {
1689       int i;
1690       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1691
1692       asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1693       symp = symbol_rootP;
1694       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1695         {
1696           asympp[i] = symbol_get_bfdsym (symp);
1697           if (asympp[i]->flags != BSF_SECTION_SYM
1698               || !(bfd_is_const_section (asympp[i]->section)
1699                    && asympp[i]->section->symbol == asympp[i]))
1700             asympp[i]->flags |= BSF_KEEP;
1701           symbol_mark_written (symp);
1702         }
1703     }
1704   else
1705     asympp = 0;
1706   result = bfd_set_symtab (stdoutput, asympp, nsyms);
1707   gas_assert (result);
1708   symbol_table_frozen = 1;
1709 }
1710
1711 /* Finish the subsegments.  After every sub-segment, we fake an
1712    ".align ...".  This conforms to BSD4.2 brain-damage.  We then fake
1713    ".fill 0" because that is the kind of frag that requires least
1714    thought.  ".align" frags like to have a following frag since that
1715    makes calculating their intended length trivial.  */
1716
1717 #ifndef SUB_SEGMENT_ALIGN
1718 #ifdef HANDLE_ALIGN
1719 /* The last subsegment gets an alignment corresponding to the alignment
1720    of the section.  This allows proper nop-filling at the end of
1721    code-bearing sections.  */
1722 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
1723   (!(FRCHAIN)->frch_next && subseg_text_p (SEG)                         \
1724    && !do_not_pad_sections_to_alignment                                 \
1725    ? get_recorded_alignment (SEG)                                       \
1726    : 0)
1727 #else
1728 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1729 #endif
1730 #endif
1731
1732 static void
1733 subsegs_finish_section (asection *s)
1734 {
1735   struct frchain *frchainP;
1736   segment_info_type *seginfo = seg_info (s);
1737   if (!seginfo)
1738     return;
1739
1740   for (frchainP = seginfo->frchainP;
1741        frchainP != NULL;
1742        frchainP = frchainP->frch_next)
1743     {
1744       int alignment;
1745
1746       subseg_set (s, frchainP->frch_subseg);
1747
1748       /* This now gets called even if we had errors.  In that case,
1749          any alignment is meaningless, and, moreover, will look weird
1750          if we are generating a listing.  */
1751       if (had_errors ())
1752         do_not_pad_sections_to_alignment = 1;
1753
1754       alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1755       if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1756           && now_seg->entsize)
1757         {
1758           unsigned int entsize = now_seg->entsize;
1759           int entalign = 0;
1760
1761           while ((entsize & 1) == 0)
1762             {
1763               ++entalign;
1764               entsize >>= 1;
1765             }
1766
1767           if (entalign > alignment)
1768             alignment = entalign;
1769         }
1770
1771       if (subseg_text_p (now_seg))
1772         frag_align_code (alignment, 0);
1773       else
1774         frag_align (alignment, 0, 0);
1775
1776       /* frag_align will have left a new frag.
1777          Use this last frag for an empty ".fill".
1778
1779          For this segment ...
1780          Create a last frag. Do not leave a "being filled in frag".  */
1781       frag_wane (frag_now);
1782       frag_now->fr_fix = 0;
1783       know (frag_now->fr_next == NULL);
1784     }
1785 }
1786
1787 static void
1788 subsegs_finish (void)
1789 {
1790   asection *s;
1791
1792   for (s = stdoutput->sections; s; s = s->next)
1793     subsegs_finish_section (s);
1794 }
1795
1796 #ifdef OBJ_ELF
1797 static void
1798 create_obj_attrs_section (void)
1799 {
1800   segT s;
1801   char *p;
1802   offsetT size;
1803   const char *name;
1804
1805   size = bfd_elf_obj_attr_size (stdoutput);
1806   if (size)
1807     {
1808       name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1809       if (!name)
1810         name = ".gnu.attributes";
1811       s = subseg_new (name, 0);
1812       elf_section_type (s)
1813         = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1814       bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1815       frag_now_fix ();
1816       p = frag_more (size);
1817       bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1818
1819       subsegs_finish_section (s);
1820       relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1821       size_seg (stdoutput, s, NULL);
1822     }
1823 }
1824 #endif
1825
1826 /* Write the object file.  */
1827
1828 void
1829 write_object_file (void)
1830 {
1831   struct relax_seg_info rsi;
1832 #ifndef WORKING_DOT_WORD
1833   fragS *fragP;                 /* Track along all frags.  */
1834 #endif
1835
1836   subsegs_finish ();
1837
1838 #ifdef md_pre_output_hook
1839   md_pre_output_hook;
1840 #endif
1841
1842 #ifdef md_pre_relax_hook
1843   md_pre_relax_hook;
1844 #endif
1845
1846   /* From now on, we don't care about sub-segments.  Build one frag chain
1847      for each segment. Linked through fr_next.  */
1848
1849   /* Remove the sections created by gas for its own purposes.  */
1850   {
1851     int i;
1852
1853     bfd_section_list_remove (stdoutput, reg_section);
1854     bfd_section_list_remove (stdoutput, expr_section);
1855     stdoutput->section_count -= 2;
1856     i = 0;
1857     bfd_map_over_sections (stdoutput, renumber_sections, &i);
1858   }
1859
1860   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1861
1862   /* We have two segments. If user gave -R flag, then we must put the
1863      data frags into the text segment. Do this before relaxing so
1864      we know to take advantage of -R and make shorter addresses.  */
1865   if (flag_readonly_data_in_text)
1866     {
1867       merge_data_into_text ();
1868     }
1869
1870   rsi.pass = 0;
1871   while (1)
1872     {
1873 #ifndef WORKING_DOT_WORD
1874       /* We need to reset the markers in the broken word list and
1875          associated frags between calls to relax_segment (via
1876          relax_seg).  Since the broken word list is global, we do it
1877          once per round, rather than locally in relax_segment for each
1878          segment.  */
1879       struct broken_word *brokp;
1880
1881       for (brokp = broken_words;
1882            brokp != (struct broken_word *) NULL;
1883            brokp = brokp->next_broken_word)
1884         {
1885           brokp->added = 0;
1886
1887           if (brokp->dispfrag != (fragS *) NULL
1888               && brokp->dispfrag->fr_type == rs_broken_word)
1889             brokp->dispfrag->fr_subtype = 0;
1890         }
1891 #endif
1892
1893       rsi.changed = 0;
1894       bfd_map_over_sections (stdoutput, relax_seg, &rsi);
1895       rsi.pass++;
1896       if (!rsi.changed)
1897         break;
1898     }
1899
1900   /* Note - Most ports will use the default value of
1901      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
1902      local symbols to be resolved, removing their frag information.
1903      Some ports however, will not have finished relaxing all of
1904      their frags and will still need the local symbol frag
1905      information.  These ports can set
1906      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
1907   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1908
1909   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1910
1911   /* Relaxation has completed.  Freeze all syms.  */
1912   finalize_syms = 1;
1913
1914   dwarf2dbg_final_check ();
1915
1916 #ifdef md_post_relax_hook
1917   md_post_relax_hook;
1918 #endif
1919
1920 #ifdef OBJ_ELF
1921   if (IS_ELF)
1922     create_obj_attrs_section ();
1923 #endif
1924
1925 #ifndef WORKING_DOT_WORD
1926   {
1927     struct broken_word *lie;
1928     struct broken_word **prevP;
1929
1930     prevP = &broken_words;
1931     for (lie = broken_words; lie; lie = lie->next_broken_word)
1932       if (!lie->added)
1933         {
1934           expressionS exp;
1935
1936           subseg_change (lie->seg, lie->subseg);
1937           exp.X_op = O_subtract;
1938           exp.X_add_symbol = lie->add;
1939           exp.X_op_symbol = lie->sub;
1940           exp.X_add_number = lie->addnum;
1941 #ifdef TC_CONS_FIX_NEW
1942           TC_CONS_FIX_NEW (lie->frag,
1943                            lie->word_goes_here - lie->frag->fr_literal,
1944                            2, &exp, TC_PARSE_CONS_RETURN_NONE);
1945 #else
1946           fix_new_exp (lie->frag,
1947                        lie->word_goes_here - lie->frag->fr_literal,
1948                        2, &exp, 0, BFD_RELOC_16);
1949 #endif
1950           *prevP = lie->next_broken_word;
1951         }
1952       else
1953         prevP = &(lie->next_broken_word);
1954
1955     for (lie = broken_words; lie;)
1956       {
1957         struct broken_word *untruth;
1958         char *table_ptr;
1959         addressT table_addr;
1960         addressT from_addr, to_addr;
1961         int n, m;
1962
1963         subseg_change (lie->seg, lie->subseg);
1964         fragP = lie->dispfrag;
1965
1966         /* Find out how many broken_words go here.  */
1967         n = 0;
1968         for (untruth = lie;
1969              untruth && untruth->dispfrag == fragP;
1970              untruth = untruth->next_broken_word)
1971           if (untruth->added == 1)
1972             n++;
1973
1974         table_ptr = lie->dispfrag->fr_opcode;
1975         table_addr = (lie->dispfrag->fr_address
1976                       + (table_ptr - lie->dispfrag->fr_literal));
1977         /* Create the jump around the long jumps.  This is a short
1978            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
1979         from_addr = table_addr;
1980         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1981         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1982                               lie->add);
1983         table_ptr += md_short_jump_size;
1984         table_addr += md_short_jump_size;
1985
1986         for (m = 0;
1987              lie && lie->dispfrag == fragP;
1988              m++, lie = lie->next_broken_word)
1989           {
1990             if (lie->added == 2)
1991               continue;
1992             /* Patch the jump table.  */
1993             for (untruth = (struct broken_word *) (fragP->fr_symbol);
1994                  untruth && untruth->dispfrag == fragP;
1995                  untruth = untruth->next_broken_word)
1996               {
1997                 if (untruth->use_jump == lie)
1998                   {
1999                     /* This is the offset from ??? to table_ptr+0.
2000                        The target is the same for all users of this
2001                        md_long_jump, but the "sub" bases (and hence the
2002                        offsets) may be different.  */
2003                     addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
2004 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2005                     TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
2006 #endif
2007                     md_number_to_chars (untruth->word_goes_here, to_word, 2);
2008                   }
2009               }
2010
2011             /* Install the long jump.  */
2012             /* This is a long jump from table_ptr+0 to the final target.  */
2013             from_addr = table_addr;
2014             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
2015             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2016                                  lie->add);
2017             table_ptr += md_long_jump_size;
2018             table_addr += md_long_jump_size;
2019           }
2020       }
2021   }
2022 #endif /* not WORKING_DOT_WORD  */
2023
2024   /* Resolve symbol values.  This needs to be done before processing
2025      the relocations.  */
2026   if (symbol_rootP)
2027     {
2028       symbolS *symp;
2029
2030       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2031         resolve_symbol_value (symp);
2032     }
2033   resolve_local_symbol_values ();
2034   resolve_reloc_expr_symbols ();
2035
2036   PROGRESS (1);
2037
2038 #ifdef tc_frob_file_before_adjust
2039   tc_frob_file_before_adjust ();
2040 #endif
2041 #ifdef obj_frob_file_before_adjust
2042   obj_frob_file_before_adjust ();
2043 #endif
2044
2045   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2046
2047 #ifdef tc_frob_file_before_fix
2048   tc_frob_file_before_fix ();
2049 #endif
2050 #ifdef obj_frob_file_before_fix
2051   obj_frob_file_before_fix ();
2052 #endif
2053
2054   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2055
2056   /* Set up symbol table, and write it out.  */
2057   if (symbol_rootP)
2058     {
2059       symbolS *symp;
2060       bfd_boolean skip_next_symbol = FALSE;
2061
2062       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2063         {
2064           int punt = 0;
2065           const char *name;
2066
2067           if (skip_next_symbol)
2068             {
2069               /* Don't do anything besides moving the value of the
2070                  symbol from the GAS value-field to the BFD value-field.  */
2071               symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2072               skip_next_symbol = FALSE;
2073               continue;
2074             }
2075
2076           if (symbol_mri_common_p (symp))
2077             {
2078               if (S_IS_EXTERNAL (symp))
2079                 as_bad (_("%s: global symbols not supported in common sections"),
2080                         S_GET_NAME (symp));
2081               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2082               continue;
2083             }
2084
2085           name = S_GET_NAME (symp);
2086           if (name)
2087             {
2088               const char *name2 =
2089                 decode_local_label_name ((char *) S_GET_NAME (symp));
2090               /* They only differ if `name' is a fb or dollar local
2091                  label name.  */
2092               if (name2 != name && ! S_IS_DEFINED (symp))
2093                 as_bad (_("local label `%s' is not defined"), name2);
2094             }
2095
2096           /* Do it again, because adjust_reloc_syms might introduce
2097              more symbols.  They'll probably only be section symbols,
2098              but they'll still need to have the values computed.  */
2099           resolve_symbol_value (symp);
2100
2101           /* Skip symbols which were equated to undefined or common
2102              symbols.  */
2103           if (symbol_equated_reloc_p (symp)
2104               || S_IS_WEAKREFR (symp))
2105             {
2106               const char *sname = S_GET_NAME (symp);
2107
2108               if (S_IS_COMMON (symp)
2109                   && !TC_FAKE_LABEL (sname)
2110                   && !S_IS_WEAKREFR (symp))
2111                 {
2112                   expressionS *e = symbol_get_value_expression (symp);
2113
2114                   as_bad (_("`%s' can't be equated to common symbol `%s'"),
2115                           sname, S_GET_NAME (e->X_add_symbol));
2116                 }
2117               if (S_GET_SEGMENT (symp) == reg_section)
2118                 {
2119                   /* Report error only if we know the symbol name.  */
2120                   if (S_GET_NAME (symp) != reg_section->name)
2121                     as_bad (_("can't make global register symbol `%s'"),
2122                             sname);
2123                 }
2124               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2125               continue;
2126             }
2127
2128 #ifdef obj_frob_symbol
2129           obj_frob_symbol (symp, punt);
2130 #endif
2131 #ifdef tc_frob_symbol
2132           if (! punt || symbol_used_in_reloc_p (symp))
2133             tc_frob_symbol (symp, punt);
2134 #endif
2135
2136           /* If we don't want to keep this symbol, splice it out of
2137              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
2138              want section symbols.  Otherwise, we skip local symbols
2139              and symbols that the frob_symbol macros told us to punt,
2140              but we keep such symbols if they are used in relocs.  */
2141           if (symp == abs_section_sym
2142               || (! EMIT_SECTION_SYMBOLS
2143                   && symbol_section_p (symp))
2144               /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2145                  opposites.  Sometimes the former checks flags and the
2146                  latter examines the name...  */
2147               || (!S_IS_EXTERNAL (symp)
2148                   && (punt || S_IS_LOCAL (symp) ||
2149                       (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2150                   && ! symbol_used_in_reloc_p (symp)))
2151             {
2152               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2153
2154               /* After symbol_remove, symbol_next(symp) still returns
2155                  the one that came after it in the chain.  So we don't
2156                  need to do any extra cleanup work here.  */
2157               continue;
2158             }
2159
2160           /* Make sure we really got a value for the symbol.  */
2161           if (! symbol_resolved_p (symp))
2162             {
2163               as_bad (_("can't resolve value for symbol `%s'"),
2164                       S_GET_NAME (symp));
2165               symbol_mark_resolved (symp);
2166             }
2167
2168           /* Set the value into the BFD symbol.  Up til now the value
2169              has only been kept in the gas symbolS struct.  */
2170           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2171
2172           /* A warning construct is a warning symbol followed by the
2173              symbol warned about.  Don't let anything object-format or
2174              target-specific muck with it; it's ready for output.  */
2175           if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2176             skip_next_symbol = TRUE;
2177         }
2178     }
2179
2180   PROGRESS (1);
2181
2182   /* Now do any format-specific adjustments to the symbol table, such
2183      as adding file symbols.  */
2184 #ifdef tc_adjust_symtab
2185   tc_adjust_symtab ();
2186 #endif
2187 #ifdef obj_adjust_symtab
2188   obj_adjust_symtab ();
2189 #endif
2190
2191   /* Stop if there is an error.  */
2192   if (had_errors ())
2193     return;
2194
2195   /* Now that all the sizes are known, and contents correct, we can
2196      start writing to the file.  */
2197   set_symtab ();
2198
2199   /* If *_frob_file changes the symbol value at this point, it is
2200      responsible for moving the changed value into symp->bsym->value
2201      as well.  Hopefully all symbol value changing can be done in
2202      *_frob_symbol.  */
2203 #ifdef tc_frob_file
2204   tc_frob_file ();
2205 #endif
2206 #ifdef obj_frob_file
2207   obj_frob_file ();
2208 #endif
2209 #ifdef obj_coff_generate_pdata
2210   obj_coff_generate_pdata ();
2211 #endif
2212   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2213
2214 #ifdef tc_frob_file_after_relocs
2215   tc_frob_file_after_relocs ();
2216 #endif
2217 #ifdef obj_frob_file_after_relocs
2218   obj_frob_file_after_relocs ();
2219 #endif
2220
2221 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2222   if (IS_ELF && flag_use_elf_stt_common)
2223     stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
2224 #endif
2225
2226   /* Once all relocations have been written, we can compress the
2227      contents of the debug sections.  This needs to be done before
2228      we start writing any sections, because it will affect the file
2229      layout, which is fixed once we start writing contents.  */
2230   if (flag_compress_debug)
2231     {
2232       if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
2233         stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
2234       else
2235         stdoutput->flags |= BFD_COMPRESS;
2236       bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2237     }
2238
2239   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2240 }
2241
2242 #ifdef TC_GENERIC_RELAX_TABLE
2243 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2244
2245 long
2246 relax_frag (segT segment, fragS *fragP, long stretch)
2247 {
2248   const relax_typeS *this_type;
2249   const relax_typeS *start_type;
2250   relax_substateT next_state;
2251   relax_substateT this_state;
2252   offsetT growth;
2253   offsetT aim;
2254   addressT target;
2255   addressT address;
2256   symbolS *symbolP;
2257   const relax_typeS *table;
2258
2259   target = fragP->fr_offset;
2260   address = fragP->fr_address;
2261   table = TC_GENERIC_RELAX_TABLE;
2262   this_state = fragP->fr_subtype;
2263   start_type = this_type = table + this_state;
2264   symbolP = fragP->fr_symbol;
2265
2266   if (symbolP)
2267     {
2268       fragS *sym_frag;
2269
2270       sym_frag = symbol_get_frag (symbolP);
2271
2272 #ifndef DIFF_EXPR_OK
2273       know (sym_frag != NULL);
2274 #endif
2275       know (S_GET_SEGMENT (symbolP) != absolute_section
2276             || sym_frag == &zero_address_frag);
2277       target += S_GET_VALUE (symbolP);
2278
2279       /* If SYM_FRAG has yet to be reached on this pass, assume it
2280          will move by STRETCH just as we did, unless there is an
2281          alignment frag between here and SYM_FRAG.  An alignment may
2282          well absorb any STRETCH, and we don't want to choose a larger
2283          branch insn by overestimating the needed reach of this
2284          branch.  It isn't critical to calculate TARGET exactly;  We
2285          know we'll be doing another pass if STRETCH is non-zero.  */
2286
2287       if (stretch != 0
2288           && sym_frag->relax_marker != fragP->relax_marker
2289           && S_GET_SEGMENT (symbolP) == segment)
2290         {
2291           if (stretch < 0
2292               || sym_frag->region == fragP->region)
2293             target += stretch;
2294           /* If we get here we know we have a forward branch.  This
2295              relax pass may have stretched previous instructions so
2296              far that omitting STRETCH would make the branch
2297              negative.  Don't allow this in case the negative reach is
2298              large enough to require a larger branch instruction.  */
2299           else if (target < address)
2300             target = fragP->fr_next->fr_address + stretch;
2301         }
2302     }
2303
2304   aim = target - address - fragP->fr_fix;
2305 #ifdef TC_PCREL_ADJUST
2306   /* Currently only the ns32k family needs this.  */
2307   aim += TC_PCREL_ADJUST (fragP);
2308 #endif
2309
2310 #ifdef md_prepare_relax_scan
2311   /* Formerly called M68K_AIM_KLUDGE.  */
2312   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2313 #endif
2314
2315   if (aim < 0)
2316     {
2317       /* Look backwards.  */
2318       for (next_state = this_type->rlx_more; next_state;)
2319         if (aim >= this_type->rlx_backward)
2320           next_state = 0;
2321         else
2322           {
2323             /* Grow to next state.  */
2324             this_state = next_state;
2325             this_type = table + this_state;
2326             next_state = this_type->rlx_more;
2327           }
2328     }
2329   else
2330     {
2331       /* Look forwards.  */
2332       for (next_state = this_type->rlx_more; next_state;)
2333         if (aim <= this_type->rlx_forward)
2334           next_state = 0;
2335         else
2336           {
2337             /* Grow to next state.  */
2338             this_state = next_state;
2339             this_type = table + this_state;
2340             next_state = this_type->rlx_more;
2341           }
2342     }
2343
2344   growth = this_type->rlx_length - start_type->rlx_length;
2345   if (growth != 0)
2346     fragP->fr_subtype = this_state;
2347   return growth;
2348 }
2349
2350 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2351
2352 /* Relax_align. Advance location counter to next address that has 'alignment'
2353    lowest order bits all 0s, return size of adjustment made.  */
2354 static relax_addressT
2355 relax_align (relax_addressT address,    /* Address now.  */
2356              int alignment      /* Alignment (binary).  */)
2357 {
2358   relax_addressT mask;
2359   relax_addressT new_address;
2360
2361   mask = ~((relax_addressT) ~0 << alignment);
2362   new_address = (address + mask) & (~mask);
2363 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2364   if (linkrelax)
2365     /* We must provide lots of padding, so the linker can discard it
2366        when needed.  The linker will not add extra space, ever.  */
2367     new_address += (1 << alignment);
2368 #endif
2369   return (new_address - address);
2370 }
2371
2372 /* Now we have a segment, not a crowd of sub-segments, we can make
2373    fr_address values.
2374
2375    Relax the frags.
2376
2377    After this, all frags in this segment have addresses that are correct
2378    within the segment. Since segments live in different file addresses,
2379    these frag addresses may not be the same as final object-file
2380    addresses.  */
2381
2382 int
2383 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2384 {
2385   unsigned long frag_count;
2386   struct frag *fragP;
2387   relax_addressT address;
2388   int region;
2389   int ret;
2390
2391   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2392   subseg_change (segment, 0);
2393
2394   /* For each frag in segment: count and store  (a 1st guess of)
2395      fr_address.  */
2396   address = 0;
2397   region = 0;
2398   for (frag_count = 0, fragP = segment_frag_root;
2399        fragP;
2400        fragP = fragP->fr_next, frag_count ++)
2401     {
2402       fragP->region = region;
2403       fragP->relax_marker = 0;
2404       fragP->fr_address = address;
2405       address += fragP->fr_fix;
2406
2407       switch (fragP->fr_type)
2408         {
2409         case rs_fill:
2410           address += fragP->fr_offset * fragP->fr_var;
2411           break;
2412
2413         case rs_align:
2414         case rs_align_code:
2415         case rs_align_test:
2416           {
2417             addressT offset = relax_align (address, (int) fragP->fr_offset);
2418
2419             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2420               offset = 0;
2421
2422             if (offset % fragP->fr_var != 0)
2423               {
2424                 as_bad_where (fragP->fr_file, fragP->fr_line,
2425                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2426                               (unsigned long) offset, (long) fragP->fr_var);
2427                 offset -= (offset % fragP->fr_var);
2428               }
2429
2430             address += offset;
2431             region += 1;
2432           }
2433           break;
2434
2435         case rs_org:
2436           /* Assume .org is nugatory. It will grow with 1st relax.  */
2437           region += 1;
2438           break;
2439
2440         case rs_space:
2441           break;
2442
2443         case rs_machine_dependent:
2444           /* If fr_symbol is an expression, this call to
2445              resolve_symbol_value sets up the correct segment, which will
2446              likely be needed in md_estimate_size_before_relax.  */
2447           if (fragP->fr_symbol)
2448             resolve_symbol_value (fragP->fr_symbol);
2449
2450           address += md_estimate_size_before_relax (fragP, segment);
2451           break;
2452
2453 #ifndef WORKING_DOT_WORD
2454           /* Broken words don't concern us yet.  */
2455         case rs_broken_word:
2456           break;
2457 #endif
2458
2459         case rs_leb128:
2460           /* Initial guess is always 1; doing otherwise can result in
2461              stable solutions that are larger than the minimum.  */
2462           address += fragP->fr_offset = 1;
2463           break;
2464
2465         case rs_cfa:
2466           address += eh_frame_estimate_size_before_relax (fragP);
2467           break;
2468
2469         case rs_dwarf2dbg:
2470           address += dwarf2dbg_estimate_size_before_relax (fragP);
2471           break;
2472
2473         default:
2474           BAD_CASE (fragP->fr_type);
2475           break;
2476         }
2477     }
2478
2479   /* Do relax().  */
2480   {
2481     unsigned long max_iterations;
2482
2483     /* Cumulative address adjustment.  */
2484     offsetT stretch;
2485
2486     /* Have we made any adjustment this pass?  We can't just test
2487        stretch because one piece of code may have grown and another
2488        shrank.  */
2489     int stretched;
2490
2491     /* Most horrible, but gcc may give us some exception data that
2492        is impossible to assemble, of the form
2493
2494        .align 4
2495        .byte 0, 0
2496        .uleb128 end - start
2497        start:
2498        .space 128*128 - 1
2499        .align 4
2500        end:
2501
2502        If the leb128 is two bytes in size, then end-start is 128*128,
2503        which requires a three byte leb128.  If the leb128 is three
2504        bytes in size, then end-start is 128*128-1, which requires a
2505        two byte leb128.  We work around this dilemma by inserting
2506        an extra 4 bytes of alignment just after the .align.  This
2507        works because the data after the align is accessed relative to
2508        the end label.
2509
2510        This counter is used in a tiny state machine to detect
2511        whether a leb128 followed by an align is impossible to
2512        relax.  */
2513     int rs_leb128_fudge = 0;
2514
2515     /* We want to prevent going into an infinite loop where one frag grows
2516        depending upon the location of a symbol which is in turn moved by
2517        the growing frag.  eg:
2518
2519          foo = .
2520          .org foo+16
2521          foo = .
2522
2523        So we dictate that this algorithm can be at most O2.  */
2524     max_iterations = frag_count * frag_count;
2525     /* Check for overflow.  */
2526     if (max_iterations < frag_count)
2527       max_iterations = frag_count;
2528
2529     ret = 0;
2530     do
2531       {
2532         stretch = 0;
2533         stretched = 0;
2534
2535         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2536           {
2537             offsetT growth = 0;
2538             addressT was_address;
2539             offsetT offset;
2540             symbolS *symbolP;
2541
2542             fragP->relax_marker ^= 1;
2543             was_address = fragP->fr_address;
2544             address = fragP->fr_address += stretch;
2545             symbolP = fragP->fr_symbol;
2546             offset = fragP->fr_offset;
2547
2548             switch (fragP->fr_type)
2549               {
2550               case rs_fill:     /* .fill never relaxes.  */
2551                 growth = 0;
2552                 break;
2553
2554 #ifndef WORKING_DOT_WORD
2555                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2556                    for it I do not want to write it.  I do not want to have
2557                    anything to do with it.  This is not the proper way to
2558                    implement this misfeature.  */
2559               case rs_broken_word:
2560                 {
2561                   struct broken_word *lie;
2562                   struct broken_word *untruth;
2563
2564                   /* Yes this is ugly (storing the broken_word pointer
2565                      in the symbol slot).  Still, this whole chunk of
2566                      code is ugly, and I don't feel like doing anything
2567                      about it.  Think of it as stubbornness in action.  */
2568                   growth = 0;
2569                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2570                        lie && lie->dispfrag == fragP;
2571                        lie = lie->next_broken_word)
2572                     {
2573
2574                       if (lie->added)
2575                         continue;
2576
2577                       offset = (S_GET_VALUE (lie->add)
2578                                 + lie->addnum
2579                                 - S_GET_VALUE (lie->sub));
2580                       if (offset <= -32768 || offset >= 32767)
2581                         {
2582                           if (flag_warn_displacement)
2583                             {
2584                               char buf[50];
2585                               sprint_value (buf, (addressT) lie->addnum);
2586                               as_warn_where (fragP->fr_file, fragP->fr_line,
2587                                              _(".word %s-%s+%s didn't fit"),
2588                                              S_GET_NAME (lie->add),
2589                                              S_GET_NAME (lie->sub),
2590                                              buf);
2591                             }
2592                           if (fragP->fr_subtype == 0)
2593                             {
2594                               fragP->fr_subtype++;
2595                               growth += md_short_jump_size;
2596                             }
2597
2598                           /* Redirect *all* words of this table with the same
2599                              target, lest we have to handle the case where the
2600                              same target but with a offset that fits on this
2601                              round overflows at the next relaxation round.  */
2602                           for (untruth = (struct broken_word *) (fragP->fr_symbol);
2603                                untruth && untruth->dispfrag == lie->dispfrag;
2604                                untruth = untruth->next_broken_word)
2605                             if ((symbol_get_frag (untruth->add)
2606                                  == symbol_get_frag (lie->add))
2607                                 && (S_GET_VALUE (untruth->add)
2608                                     == S_GET_VALUE (lie->add)))
2609                               {
2610                                 untruth->added = 2;
2611                                 untruth->use_jump = lie;
2612                               }
2613
2614                           lie->added = 1;
2615                           growth += md_long_jump_size;
2616                         }
2617                     }
2618
2619                   break;
2620                 }               /* case rs_broken_word  */
2621 #endif
2622               case rs_align:
2623               case rs_align_code:
2624               case rs_align_test:
2625                 {
2626                   addressT oldoff, newoff;
2627
2628                   oldoff = relax_align (was_address + fragP->fr_fix,
2629                                         (int) offset);
2630                   newoff = relax_align (address + fragP->fr_fix,
2631                                         (int) offset);
2632
2633                   if (fragP->fr_subtype != 0)
2634                     {
2635                       if (oldoff > fragP->fr_subtype)
2636                         oldoff = 0;
2637                       if (newoff > fragP->fr_subtype)
2638                         newoff = 0;
2639                     }
2640
2641                   growth = newoff - oldoff;
2642
2643                   /* If this align happens to follow a leb128 and
2644                      we have determined that the leb128 is bouncing
2645                      in size, then break the cycle by inserting an
2646                      extra alignment.  */
2647                   if (growth < 0
2648                       && (rs_leb128_fudge & 16) != 0
2649                       && (rs_leb128_fudge & 15) >= 2)
2650                     {
2651                       segment_info_type *seginfo = seg_info (segment);
2652                       struct obstack *ob = &seginfo->frchainP->frch_obstack;
2653                       struct frag *newf;
2654
2655                       newf = frag_alloc (ob);
2656                       obstack_blank_fast (ob, fragP->fr_var);
2657                       obstack_finish (ob);
2658                       memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2659                       memcpy (newf->fr_literal,
2660                               fragP->fr_literal + fragP->fr_fix,
2661                               fragP->fr_var);
2662                       newf->fr_type = rs_fill;
2663                       newf->fr_address = address + fragP->fr_fix + newoff;
2664                       newf->fr_fix = 0;
2665                       newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2666                                          / fragP->fr_var);
2667                       if (newf->fr_offset * newf->fr_var
2668                           != (offsetT) 1 << fragP->fr_offset)
2669                         {
2670                           newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2671                           newf->fr_var = 1;
2672                         }
2673                       /* Include size of new frag in GROWTH.  */
2674                       growth += newf->fr_offset * newf->fr_var;
2675                       /* Adjust the new frag address for the amount
2676                          we'll add when we process the new frag.  */
2677                       newf->fr_address -= stretch + growth;
2678                       newf->relax_marker ^= 1;
2679                       fragP->fr_next = newf;
2680 #ifdef DEBUG
2681                       as_warn (_("padding added"));
2682 #endif
2683                     }
2684                 }
2685                 break;
2686
2687               case rs_org:
2688                 {
2689                   addressT target = offset;
2690                   addressT after;
2691
2692                   if (symbolP)
2693                     {
2694                       /* Convert from an actual address to an octet offset
2695                          into the section.  Here it is assumed that the
2696                          section's VMA is zero, and can omit subtracting it
2697                          from the symbol's value to get the address offset.  */
2698                       know (S_GET_SEGMENT (symbolP)->vma == 0);
2699                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2700                     }
2701
2702                   know (fragP->fr_next);
2703                   after = fragP->fr_next->fr_address + stretch;
2704                   growth = target - after;
2705
2706                   /* Growth may be negative, but variable part of frag
2707                      cannot have fewer than 0 chars.  That is, we can't
2708                      .org backwards.  */
2709                   if (address + fragP->fr_fix > target)
2710                     {
2711                       growth = 0;
2712
2713                       /* Don't error on first few frag relax passes.
2714                          The symbol might be an expression involving
2715                          symbol values from other sections.  If those
2716                          sections have not yet been processed their
2717                          frags will all have zero addresses, so we
2718                          will calculate incorrect values for them.  The
2719                          number of passes we allow before giving an
2720                          error is somewhat arbitrary.  It should be at
2721                          least one, with larger values requiring
2722                          increasingly contrived dependencies between
2723                          frags to trigger a false error.  */
2724                       if (pass < 2)
2725                         {
2726                           /* Force another pass.  */
2727                           ret = 1;
2728                           break;
2729                         }
2730
2731                       as_bad_where (fragP->fr_file, fragP->fr_line,
2732                                     _("attempt to move .org backwards"));
2733
2734                       /* We've issued an error message.  Change the
2735                          frag to avoid cascading errors.  */
2736                       fragP->fr_type = rs_align;
2737                       fragP->fr_subtype = 0;
2738                       fragP->fr_offset = 0;
2739                       fragP->fr_fix = after - address;
2740                     }
2741                 }
2742                 break;
2743
2744               case rs_space:
2745                 growth = 0;
2746                 if (symbolP)
2747                   {
2748                     offsetT amount;
2749
2750                     amount = S_GET_VALUE (symbolP);
2751                     if (S_GET_SEGMENT (symbolP) != absolute_section
2752                         || S_IS_COMMON (symbolP)
2753                         || ! S_IS_DEFINED (symbolP))
2754                       {
2755                         as_bad_where (fragP->fr_file, fragP->fr_line,
2756                                       _(".space specifies non-absolute value"));
2757                         /* Prevent repeat of this error message.  */
2758                         fragP->fr_symbol = 0;
2759                       }
2760                     else if (amount < 0)
2761                       {
2762                         /* Don't error on first few frag relax passes.
2763                            See rs_org comment for a longer explanation.  */
2764                         if (pass < 2)
2765                           {
2766                             ret = 1;
2767                             break;
2768                           }
2769
2770                         as_warn_where (fragP->fr_file, fragP->fr_line,
2771                                        _(".space or .fill with negative value, ignored"));
2772                         fragP->fr_symbol = 0;
2773                       }
2774                     else
2775                       growth = (was_address + fragP->fr_fix + amount
2776                                 - fragP->fr_next->fr_address);
2777                   }
2778                 break;
2779
2780               case rs_machine_dependent:
2781 #ifdef md_relax_frag
2782                 growth = md_relax_frag (segment, fragP, stretch);
2783 #else
2784 #ifdef TC_GENERIC_RELAX_TABLE
2785                 /* The default way to relax a frag is to look through
2786                    TC_GENERIC_RELAX_TABLE.  */
2787                 growth = relax_frag (segment, fragP, stretch);
2788 #endif /* TC_GENERIC_RELAX_TABLE  */
2789 #endif
2790                 break;
2791
2792               case rs_leb128:
2793                 {
2794                   valueT value;
2795                   offsetT size;
2796
2797                   value = resolve_symbol_value (fragP->fr_symbol);
2798                   size = sizeof_leb128 (value, fragP->fr_subtype);
2799                   growth = size - fragP->fr_offset;
2800                   fragP->fr_offset = size;
2801                 }
2802                 break;
2803
2804               case rs_cfa:
2805                 growth = eh_frame_relax_frag (fragP);
2806                 break;
2807
2808               case rs_dwarf2dbg:
2809                 growth = dwarf2dbg_relax_frag (fragP);
2810                 break;
2811
2812               default:
2813                 BAD_CASE (fragP->fr_type);
2814                 break;
2815               }
2816             if (growth)
2817               {
2818                 stretch += growth;
2819                 stretched = 1;
2820                 if (fragP->fr_type == rs_leb128)
2821                   rs_leb128_fudge += 16;
2822                 else if (fragP->fr_type == rs_align
2823                          && (rs_leb128_fudge & 16) != 0
2824                          && stretch == 0)
2825                   rs_leb128_fudge += 16;
2826                 else
2827                   rs_leb128_fudge = 0;
2828               }
2829           }
2830
2831         if (stretch == 0
2832             && (rs_leb128_fudge & 16) == 0
2833             && (rs_leb128_fudge & -16) != 0)
2834           rs_leb128_fudge += 1;
2835         else
2836           rs_leb128_fudge = 0;
2837       }
2838     /* Until nothing further to relax.  */
2839     while (stretched && -- max_iterations);
2840
2841     if (stretched)
2842       as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
2843                 segment_name (segment));
2844   }
2845
2846   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2847     if (fragP->last_fr_address != fragP->fr_address)
2848       {
2849         fragP->last_fr_address = fragP->fr_address;
2850         ret = 1;
2851       }
2852   return ret;
2853 }
2854
2855 void
2856 number_to_chars_bigendian (char *buf, valueT val, int n)
2857 {
2858   if (n <= 0)
2859     abort ();
2860   while (n--)
2861     {
2862       buf[n] = val & 0xff;
2863       val >>= 8;
2864     }
2865 }
2866
2867 void
2868 number_to_chars_littleendian (char *buf, valueT val, int n)
2869 {
2870   if (n <= 0)
2871     abort ();
2872   while (n--)
2873     {
2874       *buf++ = val & 0xff;
2875       val >>= 8;
2876     }
2877 }
2878
2879 void
2880 write_print_statistics (FILE *file)
2881 {
2882   fprintf (file, "fixups: %d\n", n_fixups);
2883 }
2884
2885 /* For debugging.  */
2886 extern int indent_level;
2887
2888 void
2889 print_fixup (fixS *fixp)
2890 {
2891   indent_level = 1;
2892   fprintf (stderr, "fix ");
2893   fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
2894   fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
2895   if (fixp->fx_pcrel)
2896     fprintf (stderr, " pcrel");
2897   if (fixp->fx_pcrel_adjust)
2898     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2899   if (fixp->fx_im_disp)
2900     {
2901 #ifdef TC_NS32K
2902       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2903 #else
2904       fprintf (stderr, " im_disp");
2905 #endif
2906     }
2907   if (fixp->fx_tcbit)
2908     fprintf (stderr, " tcbit");
2909   if (fixp->fx_done)
2910     fprintf (stderr, " done");
2911   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
2912   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
2913   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
2914            (long) fixp->fx_where,
2915            (unsigned long) fixp->fx_offset,
2916            (unsigned long) fixp->fx_addnumber);
2917   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2918            fixp->fx_r_type);
2919   if (fixp->fx_addsy)
2920     {
2921       fprintf (stderr, "\n   +<");
2922       print_symbol_value_1 (stderr, fixp->fx_addsy);
2923       fprintf (stderr, ">");
2924     }
2925   if (fixp->fx_subsy)
2926     {
2927       fprintf (stderr, "\n   -<");
2928       print_symbol_value_1 (stderr, fixp->fx_subsy);
2929       fprintf (stderr, ">");
2930     }
2931   fprintf (stderr, "\n");
2932 #ifdef TC_FIX_DATA_PRINT
2933   TC_FIX_DATA_PRINT (stderr, fixp);
2934 #endif
2935 }