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 /* Create a relocation against an entry in a GNU Build attribute section.  */
1890
1891 static void
1892 create_note_reloc (segT           sec,
1893                    symbolS *      sym,
1894                    bfd_size_type  offset,
1895                    int            reloc_type,
1896                    bfd_vma        addend,
1897                    char *         note)
1898 {
1899   struct reloc_list * reloc;
1900
1901   reloc = XNEW (struct reloc_list);
1902
1903   /* We create a .b type reloc as resolve_reloc_expr_symbols() has already been called.  */
1904   reloc->u.b.sec   = sec;
1905   reloc->u.b.s     = symbol_get_bfdsym (sym);
1906   reloc->u.b.r.sym_ptr_ptr = & reloc->u.b.s;
1907   reloc->u.b.r.address     = offset;
1908   reloc->u.b.r.addend      = addend;
1909   reloc->u.b.r.howto       = bfd_reloc_type_lookup (stdoutput, reloc_type);
1910
1911   if (reloc->u.b.r.howto == NULL)
1912     {
1913       as_bad (_("unable to create reloc for build note"));
1914       return;
1915     }
1916
1917   reloc->file = N_("<gnu build note>");
1918   reloc->line = 0;
1919
1920   reloc->next = reloc_list;
1921   reloc_list = reloc;
1922
1923   /* For REL relocs, store the addend in the section.  */
1924   if (! sec->use_rela_p
1925       /* The SH target is a special case that uses RELA relocs
1926          but still stores the addend in the word being relocated.  */
1927       || strstr (bfd_get_target (stdoutput), "-sh") != NULL)
1928     {
1929       if (target_big_endian)
1930         {
1931           if (bfd_arch_bits_per_address (stdoutput) <= 32)
1932             note[offset + 3] = addend;
1933           else
1934             note[offset + 7] = addend;
1935         }
1936       else
1937         note[offset] = addend;
1938     }
1939 }
1940
1941 static void
1942 maybe_generate_build_notes (void)
1943 {
1944   segT      sec;
1945   char *    note;
1946   offsetT   note_size;
1947   offsetT   total_size;
1948   offsetT   desc_size;
1949   offsetT   desc2_offset;
1950   int       desc_reloc;
1951   symbolS * sym;
1952   asymbol * bsym;
1953
1954   if (! flag_generate_build_notes
1955       || bfd_get_section_by_name (stdoutput,
1956                                   GNU_BUILD_ATTRS_SECTION_NAME) != NULL)
1957     return;
1958
1959   /* Create a GNU Build Attribute section.  */
1960   sec = subseg_new (GNU_BUILD_ATTRS_SECTION_NAME, FALSE);
1961   elf_section_type (sec) = SHT_NOTE;
1962   bfd_set_section_flags (stdoutput, sec,
1963                          SEC_READONLY | SEC_HAS_CONTENTS | SEC_DATA);
1964   bfd_set_section_alignment (stdoutput, sec, 2);
1965
1966   /* Work out the size of the notes that we will create,
1967      and the relocation we should use.  */
1968   if (bfd_arch_bits_per_address (stdoutput) <= 32)
1969     {
1970       note_size = 28;
1971       desc_size = 8; /* Two 4-byte offsets.  */
1972       desc2_offset = 24;
1973
1974       /* FIXME: The BFD backend for the CRX target does not support the
1975          BFD_RELOC_32, even though it really should.  Likewise for the
1976          CR16 target.  So we have special case code here...  */
1977       if (strstr (bfd_get_target (stdoutput), "-crx") != NULL)
1978         desc_reloc = BFD_RELOC_CRX_NUM32;
1979       else if (strstr (bfd_get_target (stdoutput), "-cr16") != NULL)
1980         desc_reloc = BFD_RELOC_CR16_NUM32;
1981       else
1982         desc_reloc = BFD_RELOC_32;
1983     }
1984   else
1985     {
1986       note_size = 36;
1987       desc_size = 16; /* Two  8-byte offsets.  */
1988       desc2_offset = 28;
1989       /* FIXME: The BFD backend for the IA64 target does not support the
1990          BFD_RELOC_64, even though it really should.  The HPPA backend
1991          has a similar issue, although it does not support BFD_RELOCs at
1992          all!  So we have special case code to handle these targets.  */
1993       if (strstr (bfd_get_target (stdoutput), "-ia64") != NULL)
1994         desc_reloc = target_big_endian ? BFD_RELOC_IA64_DIR32MSB : BFD_RELOC_IA64_DIR32LSB;
1995       else if (strstr (bfd_get_target (stdoutput), "-hppa") != NULL)
1996         desc_reloc = 80; /* R_PARISC_DIR64.  */
1997       else
1998         desc_reloc = BFD_RELOC_64;
1999     }
2000
2001   /* We have to create a note for *each* code section.
2002      Linker garbage collection might discard some.  */
2003   total_size = 0;
2004   note = NULL;
2005
2006   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
2007     if ((bsym = symbol_get_bfdsym (sym)) != NULL
2008         && bsym->flags & BSF_SECTION_SYM
2009         && bsym->section != NULL
2010         /* Skip linkonce sections - we cannot use these section symbols as they may disappear.  */
2011         && (bsym->section->flags & (SEC_CODE | SEC_LINK_ONCE)) == SEC_CODE
2012         /* Not all linkonce sections are flagged...  */
2013         && strncmp (S_GET_NAME (sym), ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) != 0)
2014       {
2015         /* Create a version note.  */
2016         frag_now_fix ();
2017         note = frag_more (note_size);
2018         memset (note, 0, note_size);
2019
2020         if (target_big_endian)
2021           {
2022             note[3] = 8; /* strlen (name) + 1.  */
2023             note[7] = desc_size; /* Two 8-byte offsets.  */
2024             note[10] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
2025             note[11] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2026           }
2027         else
2028           {
2029             note[0] = 8; /* strlen (name) + 1.  */
2030             note[4] = desc_size; /* Two 8-byte offsets.  */
2031             note[8] = NT_GNU_BUILD_ATTRIBUTE_OPEN & 0xff;
2032             note[9] = NT_GNU_BUILD_ATTRIBUTE_OPEN >> 8;
2033           }
2034
2035         /* The a1 version number indicates that this note was
2036            generated by the assembler and not the gcc annobin plugin.  */
2037         memcpy (note + 12, "GA$\ 13a1", 8);
2038
2039         /* Create a relocation to install the start address of the note...  */
2040         create_note_reloc (sec, sym, total_size + 20, desc_reloc, 0, note);
2041
2042         /* ...and another one to install the end address.  */
2043         create_note_reloc (sec, sym, total_size + desc2_offset, desc_reloc,
2044                            bfd_get_section_size (bsym->section),
2045                            note);
2046
2047         total_size += note_size;
2048         /* FIXME: Maybe add a note recording the assembler command line and version ?  */
2049       }
2050
2051   /* Install the note(s) into the section.  */
2052   if (total_size)
2053     bfd_set_section_contents (stdoutput, sec, (bfd_byte *) note, 0, total_size);
2054   subsegs_finish_section (sec);
2055   relax_segment (seg_info (sec)->frchainP->frch_root, sec, 0);
2056   size_seg (stdoutput, sec, NULL);
2057 }
2058 #endif /* OBJ_ELF */
2059
2060 /* Write the object file.  */
2061
2062 void
2063 write_object_file (void)
2064 {
2065   struct relax_seg_info rsi;
2066 #ifndef WORKING_DOT_WORD
2067   fragS *fragP;                 /* Track along all frags.  */
2068 #endif
2069
2070   subsegs_finish ();
2071
2072 #ifdef md_pre_output_hook
2073   md_pre_output_hook;
2074 #endif
2075
2076 #ifdef md_pre_relax_hook
2077   md_pre_relax_hook;
2078 #endif
2079
2080   /* From now on, we don't care about sub-segments.  Build one frag chain
2081      for each segment. Linked through fr_next.  */
2082
2083   /* Remove the sections created by gas for its own purposes.  */
2084   {
2085     int i;
2086
2087     bfd_section_list_remove (stdoutput, reg_section);
2088     bfd_section_list_remove (stdoutput, expr_section);
2089     stdoutput->section_count -= 2;
2090     i = 0;
2091     bfd_map_over_sections (stdoutput, renumber_sections, &i);
2092   }
2093
2094   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
2095
2096   /* We have two segments. If user gave -R flag, then we must put the
2097      data frags into the text segment. Do this before relaxing so
2098      we know to take advantage of -R and make shorter addresses.  */
2099   if (flag_readonly_data_in_text)
2100     {
2101       merge_data_into_text ();
2102     }
2103
2104   rsi.pass = 0;
2105   while (1)
2106     {
2107 #ifndef WORKING_DOT_WORD
2108       /* We need to reset the markers in the broken word list and
2109          associated frags between calls to relax_segment (via
2110          relax_seg).  Since the broken word list is global, we do it
2111          once per round, rather than locally in relax_segment for each
2112          segment.  */
2113       struct broken_word *brokp;
2114
2115       for (brokp = broken_words;
2116            brokp != (struct broken_word *) NULL;
2117            brokp = brokp->next_broken_word)
2118         {
2119           brokp->added = 0;
2120
2121           if (brokp->dispfrag != (fragS *) NULL
2122               && brokp->dispfrag->fr_type == rs_broken_word)
2123             brokp->dispfrag->fr_subtype = 0;
2124         }
2125 #endif
2126
2127       rsi.changed = 0;
2128       bfd_map_over_sections (stdoutput, relax_seg, &rsi);
2129       rsi.pass++;
2130       if (!rsi.changed)
2131         break;
2132     }
2133
2134   /* Note - Most ports will use the default value of
2135      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
2136      local symbols to be resolved, removing their frag information.
2137      Some ports however, will not have finished relaxing all of
2138      their frags and will still need the local symbol frag
2139      information.  These ports can set
2140      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
2141   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
2142
2143   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
2144
2145   /* Relaxation has completed.  Freeze all syms.  */
2146   finalize_syms = 1;
2147
2148   dwarf2dbg_final_check ();
2149
2150 #ifdef md_post_relax_hook
2151   md_post_relax_hook;
2152 #endif
2153
2154 #ifdef OBJ_ELF
2155   if (IS_ELF)
2156     create_obj_attrs_section ();
2157 #endif
2158
2159 #ifndef WORKING_DOT_WORD
2160   {
2161     struct broken_word *lie;
2162     struct broken_word **prevP;
2163
2164     prevP = &broken_words;
2165     for (lie = broken_words; lie; lie = lie->next_broken_word)
2166       if (!lie->added)
2167         {
2168           expressionS exp;
2169
2170           subseg_change (lie->seg, lie->subseg);
2171           exp.X_op = O_subtract;
2172           exp.X_add_symbol = lie->add;
2173           exp.X_op_symbol = lie->sub;
2174           exp.X_add_number = lie->addnum;
2175 #ifdef TC_CONS_FIX_NEW
2176           TC_CONS_FIX_NEW (lie->frag,
2177                            lie->word_goes_here - lie->frag->fr_literal,
2178                            2, &exp, TC_PARSE_CONS_RETURN_NONE);
2179 #else
2180           fix_new_exp (lie->frag,
2181                        lie->word_goes_here - lie->frag->fr_literal,
2182                        2, &exp, 0, BFD_RELOC_16);
2183 #endif
2184           *prevP = lie->next_broken_word;
2185         }
2186       else
2187         prevP = &(lie->next_broken_word);
2188
2189     for (lie = broken_words; lie;)
2190       {
2191         struct broken_word *untruth;
2192         char *table_ptr;
2193         addressT table_addr;
2194         addressT from_addr, to_addr;
2195         int n, m;
2196
2197         subseg_change (lie->seg, lie->subseg);
2198         fragP = lie->dispfrag;
2199
2200         /* Find out how many broken_words go here.  */
2201         n = 0;
2202         for (untruth = lie;
2203              untruth && untruth->dispfrag == fragP;
2204              untruth = untruth->next_broken_word)
2205           if (untruth->added == 1)
2206             n++;
2207
2208         table_ptr = lie->dispfrag->fr_opcode;
2209         table_addr = (lie->dispfrag->fr_address
2210                       + (table_ptr - lie->dispfrag->fr_literal));
2211         /* Create the jump around the long jumps.  This is a short
2212            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
2213         from_addr = table_addr;
2214         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
2215         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2216                               lie->add);
2217         table_ptr += md_short_jump_size;
2218         table_addr += md_short_jump_size;
2219
2220         for (m = 0;
2221              lie && lie->dispfrag == fragP;
2222              m++, lie = lie->next_broken_word)
2223           {
2224             if (lie->added == 2)
2225               continue;
2226             /* Patch the jump table.  */
2227             for (untruth = (struct broken_word *) (fragP->fr_symbol);
2228                  untruth && untruth->dispfrag == fragP;
2229                  untruth = untruth->next_broken_word)
2230               {
2231                 if (untruth->use_jump == lie)
2232                   {
2233                     /* This is the offset from ??? to table_ptr+0.
2234                        The target is the same for all users of this
2235                        md_long_jump, but the "sub" bases (and hence the
2236                        offsets) may be different.  */
2237                     addressT to_word = table_addr - S_GET_VALUE (untruth->sub);
2238 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
2239                     TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_word, untruth);
2240 #endif
2241                     md_number_to_chars (untruth->word_goes_here, to_word, 2);
2242                   }
2243               }
2244
2245             /* Install the long jump.  */
2246             /* This is a long jump from table_ptr+0 to the final target.  */
2247             from_addr = table_addr;
2248             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
2249             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
2250                                  lie->add);
2251             table_ptr += md_long_jump_size;
2252             table_addr += md_long_jump_size;
2253           }
2254       }
2255   }
2256 #endif /* not WORKING_DOT_WORD  */
2257
2258   /* Resolve symbol values.  This needs to be done before processing
2259      the relocations.  */
2260   if (symbol_rootP)
2261     {
2262       symbolS *symp;
2263
2264       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2265         resolve_symbol_value (symp);
2266     }
2267   resolve_local_symbol_values ();
2268   resolve_reloc_expr_symbols ();
2269
2270 #ifdef OBJ_ELF
2271   if (IS_ELF)
2272     maybe_generate_build_notes ();
2273 #endif
2274
2275   PROGRESS (1);
2276
2277 #ifdef tc_frob_file_before_adjust
2278   tc_frob_file_before_adjust ();
2279 #endif
2280 #ifdef obj_frob_file_before_adjust
2281   obj_frob_file_before_adjust ();
2282 #endif
2283
2284   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
2285
2286 #ifdef tc_frob_file_before_fix
2287   tc_frob_file_before_fix ();
2288 #endif
2289 #ifdef obj_frob_file_before_fix
2290   obj_frob_file_before_fix ();
2291 #endif
2292
2293   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
2294
2295   /* Set up symbol table, and write it out.  */
2296   if (symbol_rootP)
2297     {
2298       symbolS *symp;
2299       bfd_boolean skip_next_symbol = FALSE;
2300
2301       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2302         {
2303           int punt = 0;
2304           const char *name;
2305
2306           if (skip_next_symbol)
2307             {
2308               /* Don't do anything besides moving the value of the
2309                  symbol from the GAS value-field to the BFD value-field.  */
2310               symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2311               skip_next_symbol = FALSE;
2312               continue;
2313             }
2314
2315           if (symbol_mri_common_p (symp))
2316             {
2317               if (S_IS_EXTERNAL (symp))
2318                 as_bad (_("%s: global symbols not supported in common sections"),
2319                         S_GET_NAME (symp));
2320               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2321               continue;
2322             }
2323
2324           name = S_GET_NAME (symp);
2325           if (name)
2326             {
2327               const char *name2 =
2328                 decode_local_label_name ((char *) S_GET_NAME (symp));
2329               /* They only differ if `name' is a fb or dollar local
2330                  label name.  */
2331               if (name2 != name && ! S_IS_DEFINED (symp))
2332                 as_bad (_("local label `%s' is not defined"), name2);
2333             }
2334
2335           /* Do it again, because adjust_reloc_syms might introduce
2336              more symbols.  They'll probably only be section symbols,
2337              but they'll still need to have the values computed.  */
2338           resolve_symbol_value (symp);
2339
2340           /* Skip symbols which were equated to undefined or common
2341              symbols.  */
2342           if (symbol_equated_reloc_p (symp)
2343               || S_IS_WEAKREFR (symp))
2344             {
2345               const char *sname = S_GET_NAME (symp);
2346
2347               if (S_IS_COMMON (symp)
2348                   && !TC_FAKE_LABEL (sname)
2349                   && !S_IS_WEAKREFR (symp))
2350                 {
2351                   expressionS *e = symbol_get_value_expression (symp);
2352
2353                   as_bad (_("`%s' can't be equated to common symbol `%s'"),
2354                           sname, S_GET_NAME (e->X_add_symbol));
2355                 }
2356               if (S_GET_SEGMENT (symp) == reg_section)
2357                 {
2358                   /* Report error only if we know the symbol name.  */
2359                   if (S_GET_NAME (symp) != reg_section->name)
2360                     as_bad (_("can't make global register symbol `%s'"),
2361                             sname);
2362                 }
2363               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2364               continue;
2365             }
2366
2367 #ifdef obj_frob_symbol
2368           obj_frob_symbol (symp, punt);
2369 #endif
2370 #ifdef tc_frob_symbol
2371           if (! punt || symbol_used_in_reloc_p (symp))
2372             tc_frob_symbol (symp, punt);
2373 #endif
2374
2375           /* If we don't want to keep this symbol, splice it out of
2376              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
2377              want section symbols.  Otherwise, we skip local symbols
2378              and symbols that the frob_symbol macros told us to punt,
2379              but we keep such symbols if they are used in relocs.  */
2380           if (symp == abs_section_sym
2381               || (! EMIT_SECTION_SYMBOLS
2382                   && symbol_section_p (symp))
2383               /* Note that S_IS_EXTERNAL and S_IS_LOCAL are not always
2384                  opposites.  Sometimes the former checks flags and the
2385                  latter examines the name...  */
2386               || (!S_IS_EXTERNAL (symp)
2387                   && (punt || S_IS_LOCAL (symp) ||
2388                       (S_IS_WEAKREFD (symp) && ! symbol_used_p (symp)))
2389                   && ! symbol_used_in_reloc_p (symp)))
2390             {
2391               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2392
2393               /* After symbol_remove, symbol_next(symp) still returns
2394                  the one that came after it in the chain.  So we don't
2395                  need to do any extra cleanup work here.  */
2396               continue;
2397             }
2398
2399           /* Make sure we really got a value for the symbol.  */
2400           if (! symbol_resolved_p (symp))
2401             {
2402               as_bad (_("can't resolve value for symbol `%s'"),
2403                       S_GET_NAME (symp));
2404               symbol_mark_resolved (symp);
2405             }
2406
2407           /* Set the value into the BFD symbol.  Up til now the value
2408              has only been kept in the gas symbolS struct.  */
2409           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2410
2411           /* A warning construct is a warning symbol followed by the
2412              symbol warned about.  Don't let anything object-format or
2413              target-specific muck with it; it's ready for output.  */
2414           if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
2415             skip_next_symbol = TRUE;
2416         }
2417     }
2418
2419   PROGRESS (1);
2420
2421   /* Now do any format-specific adjustments to the symbol table, such
2422      as adding file symbols.  */
2423 #ifdef tc_adjust_symtab
2424   tc_adjust_symtab ();
2425 #endif
2426 #ifdef obj_adjust_symtab
2427   obj_adjust_symtab ();
2428 #endif
2429
2430   /* Stop if there is an error.  */
2431   if (had_errors ())
2432     return;
2433
2434   /* Now that all the sizes are known, and contents correct, we can
2435      start writing to the file.  */
2436   set_symtab ();
2437
2438   /* If *_frob_file changes the symbol value at this point, it is
2439      responsible for moving the changed value into symp->bsym->value
2440      as well.  Hopefully all symbol value changing can be done in
2441      *_frob_symbol.  */
2442 #ifdef tc_frob_file
2443   tc_frob_file ();
2444 #endif
2445 #ifdef obj_frob_file
2446   obj_frob_file ();
2447 #endif
2448 #ifdef obj_coff_generate_pdata
2449   obj_coff_generate_pdata ();
2450 #endif
2451
2452   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2453
2454 #ifdef tc_frob_file_after_relocs
2455   tc_frob_file_after_relocs ();
2456 #endif
2457 #ifdef obj_frob_file_after_relocs
2458   obj_frob_file_after_relocs ();
2459 #endif
2460
2461 #if defined OBJ_ELF || defined OBJ_MAYBE_ELF
2462   if (IS_ELF && flag_use_elf_stt_common)
2463     stdoutput->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
2464 #endif
2465
2466   /* Once all relocations have been written, we can compress the
2467      contents of the debug sections.  This needs to be done before
2468      we start writing any sections, because it will affect the file
2469      layout, which is fixed once we start writing contents.  */
2470   if (flag_compress_debug)
2471     {
2472       if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
2473         stdoutput->flags |= BFD_COMPRESS | BFD_COMPRESS_GABI;
2474       else
2475         stdoutput->flags |= BFD_COMPRESS;
2476       bfd_map_over_sections (stdoutput, compress_debug, (char *) 0);
2477     }
2478
2479   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2480 }
2481
2482 #ifdef TC_GENERIC_RELAX_TABLE
2483 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2484
2485 long
2486 relax_frag (segT segment, fragS *fragP, long stretch)
2487 {
2488   const relax_typeS *this_type;
2489   const relax_typeS *start_type;
2490   relax_substateT next_state;
2491   relax_substateT this_state;
2492   offsetT growth;
2493   offsetT aim;
2494   addressT target;
2495   addressT address;
2496   symbolS *symbolP;
2497   const relax_typeS *table;
2498
2499   target = fragP->fr_offset;
2500   address = fragP->fr_address;
2501   table = TC_GENERIC_RELAX_TABLE;
2502   this_state = fragP->fr_subtype;
2503   start_type = this_type = table + this_state;
2504   symbolP = fragP->fr_symbol;
2505
2506   if (symbolP)
2507     {
2508       fragS *sym_frag;
2509
2510       sym_frag = symbol_get_frag (symbolP);
2511
2512 #ifndef DIFF_EXPR_OK
2513       know (sym_frag != NULL);
2514 #endif
2515       know (S_GET_SEGMENT (symbolP) != absolute_section
2516             || sym_frag == &zero_address_frag);
2517       target += S_GET_VALUE (symbolP);
2518
2519       /* If SYM_FRAG has yet to be reached on this pass, assume it
2520          will move by STRETCH just as we did, unless there is an
2521          alignment frag between here and SYM_FRAG.  An alignment may
2522          well absorb any STRETCH, and we don't want to choose a larger
2523          branch insn by overestimating the needed reach of this
2524          branch.  It isn't critical to calculate TARGET exactly;  We
2525          know we'll be doing another pass if STRETCH is non-zero.  */
2526
2527       if (stretch != 0
2528           && sym_frag->relax_marker != fragP->relax_marker
2529           && S_GET_SEGMENT (symbolP) == segment)
2530         {
2531           if (stretch < 0
2532               || sym_frag->region == fragP->region)
2533             target += stretch;
2534           /* If we get here we know we have a forward branch.  This
2535              relax pass may have stretched previous instructions so
2536              far that omitting STRETCH would make the branch
2537              negative.  Don't allow this in case the negative reach is
2538              large enough to require a larger branch instruction.  */
2539           else if (target < address)
2540             target = fragP->fr_next->fr_address + stretch;
2541         }
2542     }
2543
2544   aim = target - address - fragP->fr_fix;
2545 #ifdef TC_PCREL_ADJUST
2546   /* Currently only the ns32k family needs this.  */
2547   aim += TC_PCREL_ADJUST (fragP);
2548 #endif
2549
2550 #ifdef md_prepare_relax_scan
2551   /* Formerly called M68K_AIM_KLUDGE.  */
2552   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2553 #endif
2554
2555   if (aim < 0)
2556     {
2557       /* Look backwards.  */
2558       for (next_state = this_type->rlx_more; next_state;)
2559         if (aim >= this_type->rlx_backward)
2560           next_state = 0;
2561         else
2562           {
2563             /* Grow to next state.  */
2564             this_state = next_state;
2565             this_type = table + this_state;
2566             next_state = this_type->rlx_more;
2567           }
2568     }
2569   else
2570     {
2571       /* Look forwards.  */
2572       for (next_state = this_type->rlx_more; next_state;)
2573         if (aim <= this_type->rlx_forward)
2574           next_state = 0;
2575         else
2576           {
2577             /* Grow to next state.  */
2578             this_state = next_state;
2579             this_type = table + this_state;
2580             next_state = this_type->rlx_more;
2581           }
2582     }
2583
2584   growth = this_type->rlx_length - start_type->rlx_length;
2585   if (growth != 0)
2586     fragP->fr_subtype = this_state;
2587   return growth;
2588 }
2589
2590 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2591
2592 /* Relax_align. Advance location counter to next address that has 'alignment'
2593    lowest order bits all 0s, return size of adjustment made.  */
2594 static relax_addressT
2595 relax_align (relax_addressT address,    /* Address now.  */
2596              int alignment      /* Alignment (binary).  */)
2597 {
2598   relax_addressT mask;
2599   relax_addressT new_address;
2600
2601   mask = ~((relax_addressT) ~0 << alignment);
2602   new_address = (address + mask) & (~mask);
2603 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2604   if (linkrelax)
2605     /* We must provide lots of padding, so the linker can discard it
2606        when needed.  The linker will not add extra space, ever.  */
2607     new_address += (1 << alignment);
2608 #endif
2609   return (new_address - address);
2610 }
2611
2612 /* Now we have a segment, not a crowd of sub-segments, we can make
2613    fr_address values.
2614
2615    Relax the frags.
2616
2617    After this, all frags in this segment have addresses that are correct
2618    within the segment. Since segments live in different file addresses,
2619    these frag addresses may not be the same as final object-file
2620    addresses.  */
2621
2622 int
2623 relax_segment (struct frag *segment_frag_root, segT segment, int pass)
2624 {
2625   unsigned long frag_count;
2626   struct frag *fragP;
2627   relax_addressT address;
2628   int region;
2629   int ret;
2630
2631   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2632   subseg_change (segment, 0);
2633
2634   /* For each frag in segment: count and store  (a 1st guess of)
2635      fr_address.  */
2636   address = 0;
2637   region = 0;
2638   for (frag_count = 0, fragP = segment_frag_root;
2639        fragP;
2640        fragP = fragP->fr_next, frag_count ++)
2641     {
2642       fragP->region = region;
2643       fragP->relax_marker = 0;
2644       fragP->fr_address = address;
2645       address += fragP->fr_fix;
2646
2647       switch (fragP->fr_type)
2648         {
2649         case rs_fill:
2650           address += fragP->fr_offset * fragP->fr_var;
2651           break;
2652
2653         case rs_align:
2654         case rs_align_code:
2655         case rs_align_test:
2656           {
2657             addressT offset = relax_align (address, (int) fragP->fr_offset);
2658
2659             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2660               offset = 0;
2661
2662             if (offset % fragP->fr_var != 0)
2663               {
2664                 as_bad_where (fragP->fr_file, fragP->fr_line,
2665                               ngettext ("alignment padding (%lu byte) "
2666                                         "not a multiple of %ld",
2667                                         "alignment padding (%lu bytes) "
2668                                         "not a multiple of %ld",
2669                                         (unsigned long) offset),
2670                               (unsigned long) offset, (long) fragP->fr_var);
2671                 offset -= (offset % fragP->fr_var);
2672               }
2673
2674             address += offset;
2675             region += 1;
2676           }
2677           break;
2678
2679         case rs_org:
2680           /* Assume .org is nugatory. It will grow with 1st relax.  */
2681           region += 1;
2682           break;
2683
2684         case rs_space:
2685         case rs_space_nop:
2686           break;
2687
2688         case rs_machine_dependent:
2689           /* If fr_symbol is an expression, this call to
2690              resolve_symbol_value sets up the correct segment, which will
2691              likely be needed in md_estimate_size_before_relax.  */
2692           if (fragP->fr_symbol)
2693             resolve_symbol_value (fragP->fr_symbol);
2694
2695           address += md_estimate_size_before_relax (fragP, segment);
2696           break;
2697
2698 #ifndef WORKING_DOT_WORD
2699           /* Broken words don't concern us yet.  */
2700         case rs_broken_word:
2701           break;
2702 #endif
2703
2704         case rs_leb128:
2705           /* Initial guess is always 1; doing otherwise can result in
2706              stable solutions that are larger than the minimum.  */
2707           address += fragP->fr_offset = 1;
2708           break;
2709
2710         case rs_cfa:
2711           address += eh_frame_estimate_size_before_relax (fragP);
2712           break;
2713
2714         case rs_dwarf2dbg:
2715           address += dwarf2dbg_estimate_size_before_relax (fragP);
2716           break;
2717
2718         default:
2719           BAD_CASE (fragP->fr_type);
2720           break;
2721         }
2722     }
2723
2724   /* Do relax().  */
2725   {
2726     unsigned long max_iterations;
2727
2728     /* Cumulative address adjustment.  */
2729     offsetT stretch;
2730
2731     /* Have we made any adjustment this pass?  We can't just test
2732        stretch because one piece of code may have grown and another
2733        shrank.  */
2734     int stretched;
2735
2736     /* Most horrible, but gcc may give us some exception data that
2737        is impossible to assemble, of the form
2738
2739        .align 4
2740        .byte 0, 0
2741        .uleb128 end - start
2742        start:
2743        .space 128*128 - 1
2744        .align 4
2745        end:
2746
2747        If the leb128 is two bytes in size, then end-start is 128*128,
2748        which requires a three byte leb128.  If the leb128 is three
2749        bytes in size, then end-start is 128*128-1, which requires a
2750        two byte leb128.  We work around this dilemma by inserting
2751        an extra 4 bytes of alignment just after the .align.  This
2752        works because the data after the align is accessed relative to
2753        the end label.
2754
2755        This counter is used in a tiny state machine to detect
2756        whether a leb128 followed by an align is impossible to
2757        relax.  */
2758     int rs_leb128_fudge = 0;
2759
2760     /* We want to prevent going into an infinite loop where one frag grows
2761        depending upon the location of a symbol which is in turn moved by
2762        the growing frag.  eg:
2763
2764          foo = .
2765          .org foo+16
2766          foo = .
2767
2768        So we dictate that this algorithm can be at most O2.  */
2769     max_iterations = frag_count * frag_count;
2770     /* Check for overflow.  */
2771     if (max_iterations < frag_count)
2772       max_iterations = frag_count;
2773
2774     ret = 0;
2775     do
2776       {
2777         stretch = 0;
2778         stretched = 0;
2779
2780         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2781           {
2782             offsetT growth = 0;
2783             addressT was_address;
2784             offsetT offset;
2785             symbolS *symbolP;
2786
2787             fragP->relax_marker ^= 1;
2788             was_address = fragP->fr_address;
2789             address = fragP->fr_address += stretch;
2790             symbolP = fragP->fr_symbol;
2791             offset = fragP->fr_offset;
2792
2793             switch (fragP->fr_type)
2794               {
2795               case rs_fill:     /* .fill never relaxes.  */
2796                 growth = 0;
2797                 break;
2798
2799 #ifndef WORKING_DOT_WORD
2800                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2801                    for it I do not want to write it.  I do not want to have
2802                    anything to do with it.  This is not the proper way to
2803                    implement this misfeature.  */
2804               case rs_broken_word:
2805                 {
2806                   struct broken_word *lie;
2807                   struct broken_word *untruth;
2808
2809                   /* Yes this is ugly (storing the broken_word pointer
2810                      in the symbol slot).  Still, this whole chunk of
2811                      code is ugly, and I don't feel like doing anything
2812                      about it.  Think of it as stubbornness in action.  */
2813                   growth = 0;
2814                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2815                        lie && lie->dispfrag == fragP;
2816                        lie = lie->next_broken_word)
2817                     {
2818
2819                       if (lie->added)
2820                         continue;
2821
2822                       offset = (S_GET_VALUE (lie->add)
2823                                 + lie->addnum
2824                                 - S_GET_VALUE (lie->sub));
2825                       if (offset <= -32768 || offset >= 32767)
2826                         {
2827                           if (flag_warn_displacement)
2828                             {
2829                               char buf[50];
2830                               sprint_value (buf, (addressT) lie->addnum);
2831                               as_warn_where (fragP->fr_file, fragP->fr_line,
2832                                              _(".word %s-%s+%s didn't fit"),
2833                                              S_GET_NAME (lie->add),
2834                                              S_GET_NAME (lie->sub),
2835                                              buf);
2836                             }
2837                           if (fragP->fr_subtype == 0)
2838                             {
2839                               fragP->fr_subtype++;
2840                               growth += md_short_jump_size;
2841                             }
2842
2843                           /* Redirect *all* words of this table with the same
2844                              target, lest we have to handle the case where the
2845                              same target but with a offset that fits on this
2846                              round overflows at the next relaxation round.  */
2847                           for (untruth = (struct broken_word *) (fragP->fr_symbol);
2848                                untruth && untruth->dispfrag == lie->dispfrag;
2849                                untruth = untruth->next_broken_word)
2850                             if ((symbol_get_frag (untruth->add)
2851                                  == symbol_get_frag (lie->add))
2852                                 && (S_GET_VALUE (untruth->add)
2853                                     == S_GET_VALUE (lie->add)))
2854                               {
2855                                 untruth->added = 2;
2856                                 untruth->use_jump = lie;
2857                               }
2858
2859                           lie->added = 1;
2860                           growth += md_long_jump_size;
2861                         }
2862                     }
2863
2864                   break;
2865                 }               /* case rs_broken_word  */
2866 #endif
2867               case rs_align:
2868               case rs_align_code:
2869               case rs_align_test:
2870                 {
2871                   addressT oldoff, newoff;
2872
2873                   oldoff = relax_align (was_address + fragP->fr_fix,
2874                                         (int) offset);
2875                   newoff = relax_align (address + fragP->fr_fix,
2876                                         (int) offset);
2877
2878                   if (fragP->fr_subtype != 0)
2879                     {
2880                       if (oldoff > fragP->fr_subtype)
2881                         oldoff = 0;
2882                       if (newoff > fragP->fr_subtype)
2883                         newoff = 0;
2884                     }
2885
2886                   growth = newoff - oldoff;
2887
2888                   /* If this align happens to follow a leb128 and
2889                      we have determined that the leb128 is bouncing
2890                      in size, then break the cycle by inserting an
2891                      extra alignment.  */
2892                   if (growth < 0
2893                       && (rs_leb128_fudge & 16) != 0
2894                       && (rs_leb128_fudge & 15) >= 2)
2895                     {
2896                       segment_info_type *seginfo = seg_info (segment);
2897                       struct obstack *ob = &seginfo->frchainP->frch_obstack;
2898                       struct frag *newf;
2899
2900                       newf = frag_alloc (ob);
2901                       obstack_blank_fast (ob, fragP->fr_var);
2902                       obstack_finish (ob);
2903                       memcpy (newf, fragP, SIZEOF_STRUCT_FRAG);
2904                       memcpy (newf->fr_literal,
2905                               fragP->fr_literal + fragP->fr_fix,
2906                               fragP->fr_var);
2907                       newf->fr_type = rs_fill;
2908                       newf->fr_address = address + fragP->fr_fix + newoff;
2909                       newf->fr_fix = 0;
2910                       newf->fr_offset = (((offsetT) 1 << fragP->fr_offset)
2911                                          / fragP->fr_var);
2912                       if (newf->fr_offset * newf->fr_var
2913                           != (offsetT) 1 << fragP->fr_offset)
2914                         {
2915                           newf->fr_offset = (offsetT) 1 << fragP->fr_offset;
2916                           newf->fr_var = 1;
2917                         }
2918                       /* Include size of new frag in GROWTH.  */
2919                       growth += newf->fr_offset * newf->fr_var;
2920                       /* Adjust the new frag address for the amount
2921                          we'll add when we process the new frag.  */
2922                       newf->fr_address -= stretch + growth;
2923                       newf->relax_marker ^= 1;
2924                       fragP->fr_next = newf;
2925 #ifdef DEBUG
2926                       as_warn (_("padding added"));
2927 #endif
2928                     }
2929                 }
2930                 break;
2931
2932               case rs_org:
2933                 {
2934                   addressT target = offset;
2935                   addressT after;
2936
2937                   if (symbolP)
2938                     {
2939                       /* Convert from an actual address to an octet offset
2940                          into the section.  Here it is assumed that the
2941                          section's VMA is zero, and can omit subtracting it
2942                          from the symbol's value to get the address offset.  */
2943                       know (S_GET_SEGMENT (symbolP)->vma == 0);
2944                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2945                     }
2946
2947                   know (fragP->fr_next);
2948                   after = fragP->fr_next->fr_address + stretch;
2949                   growth = target - after;
2950
2951                   /* Growth may be negative, but variable part of frag
2952                      cannot have fewer than 0 chars.  That is, we can't
2953                      .org backwards.  */
2954                   if (address + fragP->fr_fix > target)
2955                     {
2956                       growth = 0;
2957
2958                       /* Don't error on first few frag relax passes.
2959                          The symbol might be an expression involving
2960                          symbol values from other sections.  If those
2961                          sections have not yet been processed their
2962                          frags will all have zero addresses, so we
2963                          will calculate incorrect values for them.  The
2964                          number of passes we allow before giving an
2965                          error is somewhat arbitrary.  It should be at
2966                          least one, with larger values requiring
2967                          increasingly contrived dependencies between
2968                          frags to trigger a false error.  */
2969                       if (pass < 2)
2970                         {
2971                           /* Force another pass.  */
2972                           ret = 1;
2973                           break;
2974                         }
2975
2976                       as_bad_where (fragP->fr_file, fragP->fr_line,
2977                                     _("attempt to move .org backwards"));
2978
2979                       /* We've issued an error message.  Change the
2980                          frag to avoid cascading errors.  */
2981                       fragP->fr_type = rs_align;
2982                       fragP->fr_subtype = 0;
2983                       fragP->fr_offset = 0;
2984                       fragP->fr_fix = after - address;
2985                     }
2986                 }
2987                 break;
2988
2989               case rs_space:
2990               case rs_space_nop:
2991                 growth = 0;
2992                 if (symbolP)
2993                   {
2994                     offsetT amount;
2995
2996                     amount = S_GET_VALUE (symbolP);
2997                     if (S_GET_SEGMENT (symbolP) != absolute_section
2998                         || S_IS_COMMON (symbolP)
2999                         || ! S_IS_DEFINED (symbolP))
3000                       {
3001                         as_bad_where (fragP->fr_file, fragP->fr_line,
3002                                       _(".space specifies non-absolute value"));
3003                         /* Prevent repeat of this error message.  */
3004                         fragP->fr_symbol = 0;
3005                       }
3006                     else if (amount < 0)
3007                       {
3008                         /* Don't error on first few frag relax passes.
3009                            See rs_org comment for a longer explanation.  */
3010                         if (pass < 2)
3011                           {
3012                             ret = 1;
3013                             break;
3014                           }
3015
3016                         as_warn_where (fragP->fr_file, fragP->fr_line,
3017                                        _(".space, .nops or .fill with negative value, ignored"));
3018                         fragP->fr_symbol = 0;
3019                       }
3020                     else
3021                       growth = (was_address + fragP->fr_fix + amount
3022                                 - fragP->fr_next->fr_address);
3023                   }
3024                 break;
3025
3026               case rs_machine_dependent:
3027 #ifdef md_relax_frag
3028                 growth = md_relax_frag (segment, fragP, stretch);
3029 #else
3030 #ifdef TC_GENERIC_RELAX_TABLE
3031                 /* The default way to relax a frag is to look through
3032                    TC_GENERIC_RELAX_TABLE.  */
3033                 growth = relax_frag (segment, fragP, stretch);
3034 #endif /* TC_GENERIC_RELAX_TABLE  */
3035 #endif
3036                 break;
3037
3038               case rs_leb128:
3039                 {
3040                   valueT value;
3041                   offsetT size;
3042
3043                   value = resolve_symbol_value (fragP->fr_symbol);
3044                   size = sizeof_leb128 (value, fragP->fr_subtype);
3045                   growth = size - fragP->fr_offset;
3046                   fragP->fr_offset = size;
3047                 }
3048                 break;
3049
3050               case rs_cfa:
3051                 growth = eh_frame_relax_frag (fragP);
3052                 break;
3053
3054               case rs_dwarf2dbg:
3055                 growth = dwarf2dbg_relax_frag (fragP);
3056                 break;
3057
3058               default:
3059                 BAD_CASE (fragP->fr_type);
3060                 break;
3061               }
3062             if (growth)
3063               {
3064                 stretch += growth;
3065                 stretched = 1;
3066                 if (fragP->fr_type == rs_leb128)
3067                   rs_leb128_fudge += 16;
3068                 else if (fragP->fr_type == rs_align
3069                          && (rs_leb128_fudge & 16) != 0
3070                          && stretch == 0)
3071                   rs_leb128_fudge += 16;
3072                 else
3073                   rs_leb128_fudge = 0;
3074               }
3075           }
3076
3077         if (stretch == 0
3078             && (rs_leb128_fudge & 16) == 0
3079             && (rs_leb128_fudge & -16) != 0)
3080           rs_leb128_fudge += 1;
3081         else
3082           rs_leb128_fudge = 0;
3083       }
3084     /* Until nothing further to relax.  */
3085     while (stretched && -- max_iterations);
3086
3087     if (stretched)
3088       as_fatal (_("Infinite loop encountered whilst attempting to compute the addresses of symbols in section %s"),
3089                 segment_name (segment));
3090   }
3091
3092   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
3093     if (fragP->last_fr_address != fragP->fr_address)
3094       {
3095         fragP->last_fr_address = fragP->fr_address;
3096         ret = 1;
3097       }
3098   return ret;
3099 }
3100
3101 void
3102 number_to_chars_bigendian (char *buf, valueT val, int n)
3103 {
3104   if (n <= 0)
3105     abort ();
3106   while (n--)
3107     {
3108       buf[n] = val & 0xff;
3109       val >>= 8;
3110     }
3111 }
3112
3113 void
3114 number_to_chars_littleendian (char *buf, valueT val, int n)
3115 {
3116   if (n <= 0)
3117     abort ();
3118   while (n--)
3119     {
3120       *buf++ = val & 0xff;
3121       val >>= 8;
3122     }
3123 }
3124
3125 void
3126 write_print_statistics (FILE *file)
3127 {
3128   fprintf (file, "fixups: %d\n", n_fixups);
3129 }
3130
3131 /* For debugging.  */
3132 extern int indent_level;
3133
3134 void
3135 print_fixup (fixS *fixp)
3136 {
3137   indent_level = 1;
3138   fprintf (stderr, "fix ");
3139   fprintf_vma (stderr, (bfd_vma)((bfd_hostptr_t) fixp));
3140   fprintf (stderr, " %s:%d",fixp->fx_file, fixp->fx_line);
3141   if (fixp->fx_pcrel)
3142     fprintf (stderr, " pcrel");
3143   if (fixp->fx_pcrel_adjust)
3144     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
3145   if (fixp->fx_im_disp)
3146     {
3147 #ifdef TC_NS32K
3148       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
3149 #else
3150       fprintf (stderr, " im_disp");
3151 #endif
3152     }
3153   if (fixp->fx_tcbit)
3154     fprintf (stderr, " tcbit");
3155   if (fixp->fx_done)
3156     fprintf (stderr, " done");
3157   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
3158   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
3159   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
3160            (long) fixp->fx_where,
3161            (unsigned long) fixp->fx_offset,
3162            (unsigned long) fixp->fx_addnumber);
3163   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3164            fixp->fx_r_type);
3165   if (fixp->fx_addsy)
3166     {
3167       fprintf (stderr, "\n   +<");
3168       print_symbol_value_1 (stderr, fixp->fx_addsy);
3169       fprintf (stderr, ">");
3170     }
3171   if (fixp->fx_subsy)
3172     {
3173       fprintf (stderr, "\n   -<");
3174       print_symbol_value_1 (stderr, fixp->fx_subsy);
3175       fprintf (stderr, ">");
3176     }
3177   fprintf (stderr, "\n");
3178 #ifdef TC_FIX_DATA_PRINT
3179   TC_FIX_DATA_PRINT (stderr, fixp);
3180 #endif
3181 }