gas/write.c

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