gas/write.c

   1 /* write.c - emit .o file
   2    Copyright (C) 1986-2019 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                   unsigned long where,  /* Where in that frag?  */
 147                   unsigned long 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 %lu"), 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_pcrel_adjust = 0;
 178   fixP->fx_addnumber = 0;
 179   fixP->fx_tcbit = 0;
 180   fixP->fx_tcbit2 = 0;
 181   fixP->fx_done = 0;
 182   fixP->fx_no_overflow = 0;
 183   fixP->fx_signed = 0;
 184
 185 #ifdef USING_CGEN
 186   fixP->fx_cgen.insn = NULL;
 187   fixP->fx_cgen.opinfo = 0;
 188 #endif
 189
 190 #ifdef TC_FIX_TYPE
 191   TC_INIT_FIX_DATA (fixP);
 192 #endif
 193
 194   fixP->fx_file = as_where (&fixP->fx_line);
 195
 196   {
 197
 198     fixS **seg_fix_rootP = (frags_chained
 199                             ? &seg_info (now_seg)->fix_root
 200                             : &frchain_now->fix_root);
 201     fixS **seg_fix_tailP = (frags_chained
 202                             ? &seg_info (now_seg)->fix_tail
 203                             : &frchain_now->fix_tail);
 204
 205     if (at_beginning)
 206       {
 207         fixP->fx_next = *seg_fix_rootP;
 208         *seg_fix_rootP = fixP;
 209         if (fixP->fx_next == NULL)
 210           *seg_fix_tailP = fixP;
 211       }
 212     else
 213       {
 214         fixP->fx_next = NULL;
 215         if (*seg_fix_tailP)
 216           (*seg_fix_tailP)->fx_next = fixP;
 217         else
 218           *seg_fix_rootP = fixP;
 219         *seg_fix_tailP = fixP;
 220       }
 221   }
 222
 223   return fixP;
 224 }
 225
 226 /* Create a fixup relative to a symbol (plus a constant).  */
 227
 228 fixS *
 229 fix_new (fragS *frag,                   /* Which frag?  */
 230          unsigned long where,           /* Where in that frag?  */
 231          unsigned long size,            /* 1, 2, or 4 usually.  */
 232          symbolS *add_symbol,           /* X_add_symbol.  */
 233          offsetT offset,                /* X_add_number.  */
 234          int pcrel,                     /* TRUE if PC-relative relocation.  */
 235          RELOC_ENUM r_type              /* Relocation type.  */)
 236 {
 237   return fix_new_internal (frag, where, size, add_symbol,
 238                            (symbolS *) NULL, offset, pcrel, r_type, FALSE);
 239 }
 240
 241 /* Create a fixup for an expression.  Currently we only support fixups
 242    for difference expressions.  That is itself more than most object
 243    file formats support anyhow.  */
 244
 245 fixS *
 246 fix_new_exp (fragS *frag,               /* Which frag?  */
 247              unsigned long where,       /* Where in that frag?  */
 248              unsigned long size,        /* 1, 2, or 4 usually.  */
 249              expressionS *exp,          /* Expression.  */
 250              int pcrel,                 /* TRUE if PC-relative relocation.  */
 251              RELOC_ENUM r_type          /* Relocation type.  */)
 252 {
 253   symbolS *add = NULL;
 254   symbolS *sub = NULL;
 255   offsetT off = 0;
 256
 257   switch (exp->X_op)
 258     {
 259     case O_absent:
 260       break;
 261
 262     case O_register:
 263       as_bad (_("register value used as expression"));
 264       break;
 265
 266     case O_add:
 267       /* This comes up when _GLOBAL_OFFSET_TABLE_+(.-L0) is read, if
 268          the difference expression cannot immediately be reduced.  */
 269       {
 270         symbolS *stmp = make_expr_symbol (exp);
 271
 272         exp->X_op = O_symbol;
 273         exp->X_op_symbol = 0;
 274         exp->X_add_symbol = stmp;
 275         exp->X_add_number = 0;
 276
 277         return fix_new_exp (frag, where, size, exp, pcrel, r_type);
 278       }
 279
 280     case O_symbol_rva:
 281       add = exp->X_add_symbol;
 282       off = exp->X_add_number;
 283       r_type = BFD_RELOC_RVA;
 284       break;
 285
 286     case O_uminus:
 287       sub = exp->X_add_symbol;
 288       off = exp->X_add_number;
 289       break;
 290
 291     case O_subtract:
 292       sub = exp->X_op_symbol;
 293       /* Fall through.  */
 294     case O_symbol:
 295       add = exp->X_add_symbol;
 296       /* Fall through.  */
 297     case O_constant:
 298       off = exp->X_add_number;
 299       break;
 300
 301     default:
 302       add = make_expr_symbol (exp);
 303       break;
 304     }
 305
 306   return fix_new_internal (frag, where, size, add, sub, off, pcrel,
 307                            r_type, FALSE);
 308 }
 309
 310 /* Create a fixup at the beginning of FRAG.  The arguments are the same
 311    as for fix_new, except that WHERE is implicitly 0.  */
 312
 313 fixS *
 314 fix_at_start (fragS *frag, unsigned long size, symbolS *add_symbol,
 315               offsetT offset, int pcrel, RELOC_ENUM r_type)
 316 {
 317   return fix_new_internal (frag, 0, size, add_symbol,
 318                            (symbolS *) NULL, offset, pcrel, r_type, TRUE);
 319 }
 320
 321 /* Generic function to determine whether a fixup requires a relocation.  */
 322 int
 323 generic_force_reloc (fixS *fix)
 324 {
 325   if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
 326       || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
 327     return 1;
 328
 329   if (fix->fx_addsy == NULL)
 330     return 0;
 331
 332   return S_FORCE_RELOC (fix->fx_addsy, fix->fx_subsy == NULL);
 333 }
 334
 335 /* Append a string onto another string, bumping the pointer along.  */
 336 void
 337 append (char **charPP, char *fromP, unsigned long length)
 338 {
 339   /* Don't trust memcpy() of 0 chars.  */
 340   if (length == 0)
 341     return;
 342
 343   memcpy (*charPP, fromP, length);
 344   *charPP += length;
 345 }
 346
 347 /* This routine records the largest alignment seen for each segment.
 348    If the beginning of the segment is aligned on the worst-case
 349    boundary, all of the other alignments within it will work.  At
 350    least one object format really uses this info.  */
 351
 352 void
 353 record_alignment (/* Segment to which alignment pertains.  */
 354                   segT seg,
 355                   /* Alignment, as a power of 2 (e.g., 1 => 2-byte
 356                      boundary, 2 => 4-byte boundary, etc.)  */
 357                   unsigned int align)
 358 {
 359   if (seg == absolute_section)
 360     return;
 361
 362   if (align > bfd_get_section_alignment (stdoutput, seg))
 363     bfd_set_section_alignment (stdoutput, seg, align);
 364 }
 365
 366 int
 367 get_recorded_alignment (segT seg)
 368 {
 369   if (seg == absolute_section)
 370     return 0;
 371
 372   return bfd_get_section_alignment (stdoutput, seg);
 373 }
 374
 375 /* Reset the section indices after removing the gas created sections.  */
 376
 377 static void
 378 renumber_sections (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *countparg)
 379 {
 380   int *countp = (int *) countparg;
 381
 382   sec->index = *countp;
 383   ++*countp;
 384 }
 385
 386 static fragS *
 387 chain_frchains_together_1 (segT section, struct frchain *frchp)
 388 {
 389   fragS dummy, *prev_frag = &dummy;
 390   fixS fix_dummy, *prev_fix = &fix_dummy;
 391
 392   for (; frchp; frchp = frchp->frch_next)
 393     {
 394       prev_frag->fr_next = frchp->frch_root;
 395       prev_frag = frchp->frch_last;
 396       gas_assert (prev_frag->fr_type != 0);
 397       if (frchp->fix_root != (fixS *) NULL)
 398         {
 399           if (seg_info (section)->fix_root == (fixS *) NULL)
 400             seg_info (section)->fix_root = frchp->fix_root;
 401           prev_fix->fx_next = frchp->fix_root;
 402           seg_info (section)->fix_tail = frchp->fix_tail;
 403           prev_fix = frchp->fix_tail;
 404         }
 405     }
 406   gas_assert (prev_frag != &dummy
 407               && prev_frag->fr_type != 0);
 408   prev_frag->fr_next = 0;
 409   return prev_frag;
 410 }
 411
 412 static void
 413 chain_frchains_together (bfd *abfd ATTRIBUTE_UNUSED,
 414                          segT section,
 415                          void *xxx ATTRIBUTE_UNUSED)
 416 {
 417   segment_info_type *info;
 418
 419   /* BFD may have introduced its own sections without using
 420      subseg_new, so it is possible that seg_info is NULL.  */
 421   info = seg_info (section);
 422   if (info != (segment_info_type *) NULL)
 423     info->frchainP->frch_last
 424       = chain_frchains_together_1 (section, info->frchainP);
 425
 426   /* Now that we've chained the frags together, we must add new fixups
 427      to the segment, not to the frag chain.  */
 428   frags_chained = 1;
 429 }
 430
 431 static void
 432 cvt_frag_to_fill (segT sec ATTRIBUTE_UNUSED, fragS *fragP)
 433 {
 434   switch (fragP->fr_type)
 435     {
 436     case rs_space_nop:
 437       goto skip_align;
 438     case rs_align:
 439     case rs_align_code:
 440     case rs_align_test:
 441     case rs_org:
 442     case rs_space:
 443 #ifdef HANDLE_ALIGN
 444       HANDLE_ALIGN (fragP);
 445 #endif
 446 skip_align:
 447       know (fragP->fr_next != NULL);
 448       fragP->fr_offset = (fragP->fr_next->fr_address
 449                           - fragP->fr_address
 450                           - fragP->fr_fix) / fragP->fr_var;
 451       if (fragP->fr_offset < 0)
 452         {
 453           as_bad_where (fragP->fr_file, fragP->fr_line,
 454                         _("attempt to .org/.space/.nops backwards? (%ld)"),
 455                         (long) fragP->fr_offset);
 456           fragP->fr_offset = 0;
 457         }
 458       if (fragP->fr_type == rs_space_nop)
 459         fragP->fr_type = rs_fill_nop;
 460       else
 461         fragP->fr_type = rs_fill;
 462       break;
 463
 464     case rs_fill:
 465     case rs_fill_nop:
 466       break;
 467
 468     case rs_leb128:
 469       {
 470         valueT value = S_GET_VALUE (fragP->fr_symbol);
 471         int size;
 472
 473         if (!S_IS_DEFINED (fragP->fr_symbol))
 474           {
 475             as_bad_where (fragP->fr_file, fragP->fr_line,
 476                           _("leb128 operand is an undefined symbol: %s"),
 477                           S_GET_NAME (fragP->fr_symbol));
 478           }
 479
 480         size = output_leb128 (fragP->fr_literal + fragP->fr_fix, value,
 481                               fragP->fr_subtype);
 482
 483         fragP->fr_fix += size;
 484         fragP->fr_type = rs_fill;
 485         fragP->fr_var = 0;
 486         fragP->fr_offset = 0;
 487         fragP->fr_symbol = NULL;
 488       }
 489       break;
 490
 491     case rs_cfa:
 492       eh_frame_convert_frag (fragP);
 493       break;
 494
 495     case rs_dwarf2dbg:
 496       dwarf2dbg_convert_frag (fragP);
 497       break;
 498
 499     case rs_machine_dependent:
 500       md_convert_frag (stdoutput, sec, fragP);
 501
 502       gas_assert (fragP->fr_next == NULL
 503                   || (fragP->fr_next->fr_address - fragP->fr_address
 504                       == fragP->fr_fix));
 505
 506       /* After md_convert_frag, we make the frag into a ".space 0".
 507          md_convert_frag() should set up any fixSs and constants
 508          required.  */
 509       frag_wane (fragP);
 510       break;
 511
 512 #ifndef WORKING_DOT_WORD
 513     case rs_broken_word:
 514       {
 515         struct broken_word *lie;
 516
 517         if (fragP->fr_subtype)
 518           {
 519             fragP->fr_fix += md_short_jump_size;
 520             for (lie = (struct broken_word *) (fragP->fr_symbol);
 521                  lie && lie->dispfrag == fragP;
 522                  lie = lie->next_broken_word)
 523               if (lie->added == 1)
 524                 fragP->fr_fix += md_long_jump_size;
 525           }
 526         frag_wane (fragP);
 527       }
 528       break;
 529 #endif
 530
 531     default:
 532       BAD_CASE (fragP->fr_type);
 533       break;
 534     }
 535 #ifdef md_frag_check
 536   md_frag_check (fragP);
 537 #endif
 538 }
 539
 540 struct relax_seg_info
 541 {
 542   int pass;
 543   int changed;
 544 };
 545
 546 static void
 547 relax_seg (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *xxx)
 548 {
 549   segment_info_type *seginfo = seg_info (sec);
 550   struct relax_seg_info *info = (struct relax_seg_info *) xxx;
 551
 552   if (seginfo && seginfo->frchainP
 553       && relax_segment (seginfo->frchainP->frch_root, sec, info->pass))
 554     info->changed = 1;
 555 }
 556
 557 static void
 558 size_seg (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
 559 {
 560   flagword flags;
 561   fragS *fragp;
 562   segment_info_type *seginfo;
 563   int x;
 564   valueT size, newsize;
 565
 566   subseg_change (sec, 0);
 567
 568   seginfo = seg_info (sec);
 569   if (seginfo && seginfo->frchainP)
 570     {
 571       for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next)
 572         cvt_frag_to_fill (sec, fragp);
 573       for (fragp = seginfo->frchainP->frch_root;
 574            fragp->fr_next;
 575            fragp = fragp->fr_next)
 576         /* Walk to last elt.  */
 577         ;
 578       size = fragp->fr_address + fragp->fr_fix;
 579     }
 580   else
 581     size = 0;
 582
 583   flags = bfd_get_section_flags (abfd, sec);
 584   if (size == 0 && bfd_get_section_size (sec) != 0 &&
 585     (flags & SEC_HAS_CONTENTS) != 0)
 586     return;
 587
 588   if (size > 0 && ! seginfo->bss)
 589     flags |= SEC_HAS_CONTENTS;
 590
 591   flags &= ~SEC_RELOC;
 592   x = bfd_set_section_flags (abfd, sec, flags);
 593   gas_assert (x);
 594
 595   /* If permitted, allow the backend to pad out the section
 596      to some alignment boundary.  */
 597   if (do_not_pad_sections_to_alignment)
 598     newsize = size;
 599   else
 600     newsize = md_section_align (sec, size);
 601   x = bfd_set_section_size (abfd, sec, newsize);
 602   gas_assert (x);
 603
 604   /* If the size had to be rounded up, add some padding in the last
 605      non-empty frag.  */
 606   gas_assert (newsize >= size);
 607   if (size != newsize)
 608     {
 609       fragS *last = seginfo->frchainP->frch_last;
 610       fragp = seginfo->frchainP->frch_root;
 611       while (fragp->fr_next != last)
 612         fragp = fragp->fr_next;
 613       last->fr_address = size;
 614       if ((newsize - size) % fragp->fr_var == 0)
 615         fragp->fr_offset += (newsize - size) / fragp->fr_var;
 616       else
 617         /* If we hit this abort, it's likely due to subsegs_finish not
 618            providing sufficient alignment on the last frag, and the
 619            machine dependent code using alignment frags with fr_var
 620            greater than 1.  */
 621         abort ();
 622     }
 623
 624 #ifdef tc_frob_section
 625   tc_frob_section (sec);
 626 #endif
 627 #ifdef obj_frob_section
 628   obj_frob_section (sec);
 629 #endif
 630 }
 631
 632 #ifdef DEBUG2
 633 static void
 634 dump_section_relocs (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, FILE *stream)
 635 {
 636   segment_info_type *seginfo = seg_info (sec);
 637   fixS *fixp = seginfo->fix_root;
 638
 639   if (!fixp)
 640     return;
 641
 642   fprintf (stream, "sec %s relocs:\n", sec->name);
 643   while (fixp)
 644     {
 645       symbolS *s = fixp->fx_addsy;
 646
 647       fprintf (stream, "  %08lx: type %d ", (unsigned long) fixp,
 648                (int) fixp->fx_r_type);
 649       if (s == NULL)
 650         fprintf (stream, "no sym\n");
 651       else
 652         {
 653           print_symbol_value_1 (stream, s);
 654           fprintf (stream, "\n");
 655         }
 656       fixp = fixp->fx_next;
 657     }
 658 }
 659 #else
 660 #define dump_section_relocs(ABFD,SEC,STREAM)    ((void) 0)
 661 #endif
 662
 663 #ifndef EMIT_SECTION_SYMBOLS
 664 #define EMIT_SECTION_SYMBOLS 1
 665 #endif
 666
 667 /* Resolve U.A.OFFSET_SYM and U.A.SYM fields of RELOC_LIST entries,
 668    and check for validity.  Convert RELOC_LIST from using U.A fields
 669    to U.B fields.  */
 670 static void
 671 resolve_reloc_expr_symbols (void)
 672 {
 673   bfd_vma addr_mask = 1;
 674   struct reloc_list *r;
 675
 676   /* Avoid a shift by the width of type.  */
 677   addr_mask <<= bfd_arch_bits_per_address (stdoutput) - 1;
 678   addr_mask <<= 1;
 679   addr_mask -= 1;
 680
 681   for (r = reloc_list; r; r = r->next)
 682     {
 683       reloc_howto_type *howto = r->u.a.howto;
 684       expressionS *symval;
 685       symbolS *sym;
 686       bfd_vma offset, addend;
 687       asection *sec;
 688
 689       resolve_symbol_value (r->u.a.offset_sym);
 690       symval = symbol_get_value_expression (r->u.a.offset_sym);
 691
 692       offset = 0;
 693       sym = NULL;
 694       if (symval->X_op == O_constant)
 695         sym = r->u.a.offset_sym;
 696       else if (symval->X_op == O_symbol)
 697         {
 698           sym = symval->X_add_symbol;
 699           offset = symval->X_add_number;
 700           symval = symbol_get_value_expression (symval->X_add_symbol);
 701         }
 702       if (sym == NULL
 703           || symval->X_op != O_constant
 704           || (sec = S_GET_SEGMENT (sym)) == NULL
 705           || !SEG_NORMAL (sec))
 706         {
 707           as_bad_where (r->file, r->line, _("invalid offset expression"));
 708           sec = NULL;
 709         }
 710       else
 711         offset += S_GET_VALUE (sym);
 712
 713       sym = NULL;
 714       addend = r->u.a.addend;
 715       if (r->u.a.sym != NULL)
 716         {
 717           resolve_symbol_value (r->u.a.sym);
 718           symval = symbol_get_value_expression (r->u.a.sym);
 719           if (symval->X_op == O_constant)
 720             sym = r->u.a.sym;
 721           else if (symval->X_op == O_symbol)
 722             {
 723               sym = symval->X_add_symbol;
 724               addend += symval->X_add_number;
 725               symval = symbol_get_value_expression (symval->X_add_symbol);
 726             }
 727           if (symval->X_op != O_constant)
 728             {
 729               as_bad_where (r->file, r->line, _("invalid reloc expression"));
 730               sec = NULL;
 731             }
 732           else if (sym != NULL && sec != NULL)
 733             {
 734               /* Convert relocs against local symbols to refer to the
 735                  corresponding section symbol plus offset instead.  Keep
 736                  PC-relative relocs of the REL variety intact though to
 737                  prevent the offset from overflowing the relocated field,
 738                  unless it has enough bits to cover the whole address
 739                  space.  */
 740               if (S_IS_LOCAL (sym) && !symbol_section_p (sym)
 741                   && (sec->use_rela_p
 742                       || (howto->partial_inplace
 743                           && (!howto->pc_relative
 744                               || howto->src_mask == addr_mask))))
 745                 {
 746                   asection *symsec = S_GET_SEGMENT (sym);
 747                   if (!(((symsec->flags & SEC_MERGE) != 0
 748                          && addend != 0)
 749                         || (symsec->flags & SEC_THREAD_LOCAL) != 0))
 750                     {
 751                       addend += S_GET_VALUE (sym);
 752                       sym = section_symbol (symsec);
 753                     }
 754                 }
 755               symbol_mark_used_in_reloc (sym);
 756             }
 757         }
 758       if (sym == NULL)
 759         {
 760           if (abs_section_sym == NULL)
 761             abs_section_sym = section_symbol (absolute_section);
 762           sym = abs_section_sym;
 763         }
 764
 765       r->u.b.sec = sec;
 766       r->u.b.s = symbol_get_bfdsym (sym);
 767       r->u.b.r.sym_ptr_ptr = &r->u.b.s;
 768       r->u.b.r.address = offset;
 769       r->u.b.r.addend = addend;
 770       r->u.b.r.howto = howto;
 771     }
 772 }
 773
 774 /* This pass over fixups decides whether symbols can be replaced with
 775    section symbols.  */
 776
 777 static void
 778 adjust_reloc_syms (bfd *abfd ATTRIBUTE_UNUSED,
 779                    asection *sec,
 780                    void *xxx ATTRIBUTE_UNUSED)
 781 {
 782   segment_info_type *seginfo = seg_info (sec);
 783   fixS *fixp;
 784
 785   if (seginfo == NULL)
 786     return;
 787
 788   dump_section_relocs (abfd, sec, stderr);
 789
 790   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
 791     if (fixp->fx_done)
 792       /* Ignore it.  */
 793       ;
 794     else if (fixp->fx_addsy)
 795       {
 796         symbolS *sym;
 797         asection *symsec;
 798
 799 #ifdef DEBUG5
 800         fprintf (stderr, "\n\nadjusting fixup:\n");
 801         print_fixup (fixp);
 802 #endif
 803
 804         sym = fixp->fx_addsy;
 805
 806         /* All symbols should have already been resolved at this
 807            point.  It is possible to see unresolved expression
 808            symbols, though, since they are not in the regular symbol
 809            table.  */
 810         resolve_symbol_value (sym);
 811
 812         if (fixp->fx_subsy != NULL)
 813           resolve_symbol_value (fixp->fx_subsy);
 814
 815         /* If this symbol is equated to an undefined or common symbol,
 816            convert the fixup to being against that symbol.  */
 817         while (symbol_equated_reloc_p (sym)
 818                || S_IS_WEAKREFR (sym))
 819           {
 820             symbolS *newsym = symbol_get_value_expression (sym)->X_add_symbol;
 821             if (sym == newsym)
 822               break;
 823             fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
 824             fixp->fx_addsy = newsym;
 825             sym = newsym;
 826           }
 827
 828         if (symbol_mri_common_p (sym))
 829           {
 830             fixp->fx_offset += S_GET_VALUE (sym);
 831             fixp->fx_addsy = symbol_get_value_expression (sym)->X_add_symbol;
 832             continue;
 833           }
 834
 835         /* If the symbol is undefined, common, weak, or global (ELF
 836            shared libs), we can't replace it with the section symbol.  */
 837         if (S_FORCE_RELOC (fixp->fx_addsy, 1))
 838           continue;
 839
 840         /* Is there some other (target cpu dependent) reason we can't adjust
 841            this one?  (E.g. relocations involving function addresses on
 842            the PA.  */
 843 #ifdef tc_fix_adjustable
 844         if (! tc_fix_adjustable (fixp))
 845           continue;
 846 #endif
 847
 848         /* Since we're reducing to section symbols, don't attempt to reduce
 849            anything that's already using one.  */
 850         if (symbol_section_p (sym))
 851           continue;
 852
 853         symsec = S_GET_SEGMENT (sym);
 854         if (symsec == NULL)
 855           abort ();
 856
 857         if (bfd_is_abs_section (symsec)
 858             || symsec == reg_section)
 859           {
 860             /* The fixup_segment routine normally will not use this
 861                symbol in a relocation.  */
 862             continue;
 863           }
 864
 865         /* Don't try to reduce relocs which refer to non-local symbols
 866            in .linkonce sections.  It can lead to confusion when a
 867            debugging section refers to a .linkonce section.  I hope
 868            this will always be correct.  */
 869         if (symsec != sec && ! S_IS_LOCAL (sym))
 870           {
 871             if ((symsec->flags & SEC_LINK_ONCE) != 0
 872                 || (IS_ELF
 873                     /* The GNU toolchain uses an extension for ELF: a
 874                        section beginning with the magic string
 875                        .gnu.linkonce is a linkonce section.  */
 876                     && strncmp (segment_name (symsec), ".gnu.linkonce",
 877                                 sizeof ".gnu.linkonce" - 1) == 0))
 878               continue;
 879           }
 880
 881         /* Never adjust a reloc against local symbol in a merge section
 882            with non-zero addend.  */
 883         if ((symsec->flags & SEC_MERGE) != 0
 884             && (fixp->fx_offset != 0 || fixp->fx_subsy != NULL))
 885           continue;
 886
 887         /* Never adjust a reloc against TLS local symbol.  */
 888         if ((symsec->flags & SEC_THREAD_LOCAL) != 0)
 889           continue;
 890
 891         /* We refetch the segment when calling section_symbol, rather
 892            than using symsec, because S_GET_VALUE may wind up changing
 893            the section when it calls resolve_symbol_value.  */
 894         fixp->fx_offset += S_GET_VALUE (sym);
 895         fixp->fx_addsy = section_symbol (S_GET_SEGMENT (sym));
 896 #ifdef DEBUG5
 897         fprintf (stderr, "\nadjusted fixup:\n");
 898         print_fixup (fixp);
 899 #endif
 900       }
 901
 902   dump_section_relocs (abfd, sec, stderr);
 903 }
 904
 905 /* fixup_segment()
 906
 907    Go through all the fixS's in a segment and see which ones can be
 908    handled now.  (These consist of fixS where we have since discovered
 909    the value of a symbol, or the address of the frag involved.)
 910    For each one, call md_apply_fix to put the fix into the frag data.
 911    Ones that we couldn't completely handle here will be output later
 912    by emit_relocations.  */
 913
 914 static void
 915 fixup_segment (fixS *fixP, segT this_segment)
 916 {
 917   valueT add_number;
 918   fragS *fragP;
 919   segT add_symbol_segment = absolute_section;
 920
 921   if (fixP != NULL && abs_section_sym == NULL)
 922     abs_section_sym = section_symbol (absolute_section);
 923
 924   /* If the linker is doing the relaxing, we must not do any fixups.
 925
 926      Well, strictly speaking that's not true -- we could do any that
 927      are PC-relative and don't cross regions that could change size.  */
 928   if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
 929     {
 930       for (; fixP; fixP = fixP->fx_next)
 931         if (!fixP->fx_done)
 932           {
 933             if (fixP->fx_addsy == NULL)
 934               {
 935                 /* There was no symbol required by this relocation.
 936                    However, BFD doesn't really handle relocations
 937                    without symbols well. So fake up a local symbol in
 938                    the absolute section.  */
 939                 fixP->fx_addsy = abs_section_sym;
 940               }
 941             symbol_mark_used_in_reloc (fixP->fx_addsy);
 942             if (fixP->fx_subsy != NULL)
 943               symbol_mark_used_in_reloc (fixP->fx_subsy);
 944           }
 945       return;
 946     }
 947
 948   for (; fixP; fixP = fixP->fx_next)
 949     {
 950 #ifdef DEBUG5
 951       fprintf (stderr, "\nprocessing fixup:\n");
 952       print_fixup (fixP);
 953 #endif
 954
 955       fragP = fixP->fx_frag;
 956       know (fragP);
 957 #ifdef TC_VALIDATE_FIX
 958       TC_VALIDATE_FIX (fixP, this_segment, skip);
 959 #endif
 960       add_number = fixP->fx_offset;
 961
 962       if (fixP->fx_addsy != NULL)
 963         add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
 964
 965       if (fixP->fx_subsy != NULL)
 966         {
 967           segT sub_symbol_segment;
 968           resolve_symbol_value (fixP->fx_subsy);
 969           sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
 970           if (fixP->fx_addsy != NULL
 971               && sub_symbol_segment == add_symbol_segment
 972               && !S_FORCE_RELOC (fixP->fx_addsy, 0)
 973               && !S_FORCE_RELOC (fixP->fx_subsy, 0)
 974               && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
 975             {
 976               add_number += S_GET_VALUE (fixP->fx_addsy);
 977               add_number -= S_GET_VALUE (fixP->fx_subsy);
 978               fixP->fx_offset = add_number;
 979               fixP->fx_addsy = NULL;
 980               fixP->fx_subsy = NULL;
 981 #ifdef TC_M68K
 982               /* See the comment below about 68k weirdness.  */
 983               fixP->fx_pcrel = 0;
 984 #endif
 985             }
 986           else if (sub_symbol_segment == absolute_section
 987                    && !S_FORCE_RELOC (fixP->fx_subsy, 0)
 988                    && !TC_FORCE_RELOCATION_SUB_ABS (fixP, add_symbol_segment))
 989             {
 990               add_number -= S_GET_VALUE (fixP->fx_subsy);
 991               fixP->fx_offset = add_number;
 992               fixP->fx_subsy = NULL;
 993             }
 994           else if (sub_symbol_segment == this_segment
 995                    && !S_FORCE_RELOC (fixP->fx_subsy, 0)
 996                    && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP, add_symbol_segment))
 997             {
 998               add_number -= S_GET_VALUE (fixP->fx_subsy);
 999               fixP->fx_offset = (add_number + fixP->fx_dot_value
1000                                  + fixP->fx_dot_frag->fr_address);
1001
1002               /* Make it pc-relative.  If the back-end code has not
1003                  selected a pc-relative reloc, cancel the adjustment
1004                  we do later on all pc-relative relocs.  */
1005               if (0
1006 #ifdef TC_M68K
1007                   /* Do this for m68k even if it's already described
1008                      as pc-relative.  On the m68k, an operand of
1009                      "pc@(foo-.-2)" should address "foo" in a
1010                      pc-relative mode.  */
1011                   || 1
1012 #endif
1013                   || !fixP->fx_pcrel)
1014                 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
1015               fixP->fx_subsy = NULL;
1016               fixP->fx_pcrel = 1;
1017             }
1018           else if (!TC_VALIDATE_FIX_SUB (fixP, add_symbol_segment))
1019             {
1020               if (!md_register_arithmetic
1021                   && (add_symbol_segment == reg_section
1022                       || sub_symbol_segment == reg_section))
1023                 as_bad_where (fixP->fx_file, fixP->fx_line,
1024                               _("register value used as expression"));
1025               else
1026                 as_bad_where (fixP->fx_file, fixP->fx_line,
1027                               _("can't resolve `%s' {%s section} - `%s' {%s section}"),
1028                               fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
1029                               segment_name (add_symbol_segment),
1030                               S_GET_NAME (fixP->fx_subsy),
1031                               segment_name (sub_symbol_segment));
1032             }
1033           else if (sub_symbol_segment != undefined_section
1034                    && ! bfd_is_com_section (sub_symbol_segment)
1035                    && MD_APPLY_SYM_VALUE (fixP))
1036             add_number -= S_GET_VALUE (fixP->fx_subsy);
1037         }
1038
1039       if (fixP->fx_addsy)
1040         {
1041           if (add_symbol_segment == this_segment
1042               && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1043               && !TC_FORCE_RELOCATION_LOCAL (fixP))
1044             {
1045               /* This fixup was made when the symbol's segment was
1046                  SEG_UNKNOWN, but it is now in the local segment.
1047                  So we know how to do the address without relocation.  */
1048               add_number += S_GET_VALUE (fixP->fx_addsy);
1049               fixP->fx_offset = add_number;
1050               if (fixP->fx_pcrel)
1051                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1052               fixP->fx_addsy = NULL;
1053               fixP->fx_pcrel = 0;
1054             }
1055           else if (add_symbol_segment == absolute_section
1056                    && !S_FORCE_RELOC (fixP->fx_addsy, 0)
1057                    && !TC_FORCE_RELOCATION_ABS (fixP))
1058             {
1059               add_number += S_GET_VALUE (fixP->fx_addsy);
1060               fixP->fx_offset = add_number;
1061               fixP->fx_addsy = NULL;
1062             }
1063           else if (add_symbol_segment != undefined_section
1064                    && ! bfd_is_com_section (add_symbol_segment)
1065                    && MD_APPLY_SYM_VALUE (fixP))
1066             add_number += S_GET_VALUE (fixP->fx_addsy);
1067         }
1068
1069       if (fixP->fx_pcrel)
1070         {
1071           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
1072           if (!fixP->fx_done && fixP->fx_addsy == NULL)
1073             {
1074               /* There was no symbol required by this relocation.
1075                  However, BFD doesn't really handle relocations
1076                  without symbols well. So fake up a local symbol in
1077                  the absolute section.  */
1078               fixP->fx_addsy = abs_section_sym;
1079             }
1080         }
1081
1082       if (!fixP->fx_done)
1083         md_apply_fix (fixP, &add_number, this_segment);
1084
1085       if (!fixP->fx_done)
1086         {
1087           if (fixP->fx_addsy == NULL)
1088             fixP->fx_addsy = abs_section_sym;
1089           symbol_mark_used_in_reloc (fixP->fx_addsy);
1090           if (fixP->fx_subsy != NULL)
1091             symbol_mark_used_in_reloc (fixP->fx_subsy);
1092         }
1093
1094       if (!fixP->fx_no_overflow && fixP->fx_size != 0)
1095         {
1096           if (fixP->fx_size < sizeof (valueT))
1097             {
1098               valueT mask;
1099
1100               mask = 0;
1101               mask--;           /* Set all bits to one.  */
1102               mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
1103               if ((add_number & mask) != 0 && (add_number & mask) != mask)
1104                 {
1105                   char buf[50], buf2[50];
1106                   sprint_value (buf, fragP->fr_address + fixP->fx_where);
1107                   if (add_number > 1000)
1108                     sprint_value (buf2, add_number);
1109                   else
1110                     sprintf (buf2, "%ld", (long) add_number);
1111                   as_bad_where (fixP->fx_file, fixP->fx_line,
1112                                 ngettext ("value of %s too large for field "
1113                                           "of %d byte at %s",
1114                                           "value of %s too large for field "
1115                                           "of %d bytes at %s",
1116                                           fixP->fx_size),
1117                                 buf2, fixP->fx_size, buf);
1118                 } /* Generic error checking.  */
1119             }
1120 #ifdef WARN_SIGNED_OVERFLOW_WORD
1121           /* Warn if a .word value is too large when treated as a signed
1122              number.  We already know it is not too negative.  This is to
1123              catch over-large switches generated by gcc on the 68k.  */
1124           if (!flag_signed_overflow_ok
1125               && fixP->fx_size == 2
1126               && add_number > 0x7fff)
1127             as_bad_where (fixP->fx_file, fixP->fx_line,
1128                           _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
1129                           (long) add_number,
1130                           (long) (fragP->fr_address + fixP->fx_where));
1131 #endif
1132         }
1133
1134 #ifdef TC_VALIDATE_FIX
1135     skip:  ATTRIBUTE_UNUSED_LABEL
1136       ;
1137 #endif
1138 #ifdef DEBUG5
1139       fprintf (stderr, "result:\n");
1140       print_fixup (fixP);
1141 #endif
1142     }                           /* For each fixS in this segment.  */
1143 }
1144
1145 static void
1146 fix_segment (bfd *abfd ATTRIBUTE_UNUSED,
1147              asection *sec,
1148              void *xxx ATTRIBUTE_UNUSED)
1149 {
1150   segment_info_type *seginfo = seg_info (sec);
1151
1152   fixup_segment (seginfo->fix_root, sec);
1153 }
1154
1155 static void
1156 install_reloc (asection *sec, arelent *reloc, fragS *fragp,
1157                const char *file, unsigned int line)
1158 {
1159   char *err;
1160   bfd_reloc_status_type s;
1161   asymbol *sym;
1162
1163   if (reloc->sym_ptr_ptr != NULL
1164       && (sym = *reloc->sym_ptr_ptr) != NULL
1165       && (sym->flags & BSF_KEEP) == 0
1166       && ((sym->flags & BSF_SECTION_SYM) == 0
1167           || (EMIT_SECTION_SYMBOLS
1168               && !bfd_is_abs_section (sym->section))))
1169     as_bad_where (file, line, _("redefined symbol cannot be used on reloc"));
1170
1171   s = bfd_install_relocation (stdoutput, reloc,
1172                               fragp->fr_literal, fragp->fr_address,
1173                               sec, &err);
1174   switch (s)
1175     {
1176     case bfd_reloc_ok:
1177       break;
1178     case bfd_reloc_overflow:
1179       as_bad_where (file, line, _("relocation overflow"));
1180       break;
1181     case bfd_reloc_outofrange:
1182       as_bad_where (file, line, _("relocation out of range"));
1183       break;
1184     default:
1185       as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1186                 file, line, s);
1187     }
1188 }
1189
1190 static fragS *
1191 get_frag_for_reloc (fragS *last_frag,
1192                     const segment_info_type *seginfo,
1193                     const struct reloc_list *r)
1194 {
1195   fragS *f;
1196
1197   for (f = last_frag; f != NULL; f = f->fr_next)
1198     if (f->fr_address <= r->u.b.r.address
1199         && r->u.b.r.address < f->fr_address + f->fr_fix)
1200       return f;
1201
1202   for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1203     if (f->fr_address <= r->u.b.r.address
1204         && r->u.b.r.address < f->fr_address + f->fr_fix)
1205       return f;
1206
1207   for (f = seginfo->frchainP->frch_root; f != NULL; f = f->fr_next)
1208     if (f->fr_address <= r->u.b.r.address
1209         && r->u.b.r.address <= f->fr_address + f->fr_fix)
1210       return f;
1211
1212   as_bad_where (r->file, r->line,
1213                 _("reloc not within (fixed part of) section"));
1214   return NULL;
1215 }
1216
1217 static void
1218 write_relocs (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1219 {
1220   segment_info_type *seginfo = seg_info (sec);
1221   unsigned int n;
1222   struct reloc_list *my_reloc_list, **rp, *r;
1223   arelent **relocs;
1224   fixS *fixp;
1225   fragS *last_frag;
1226
1227   /* If seginfo is NULL, we did not create this section; don't do
1228      anything with it.  */
1229   if (seginfo == NULL)
1230     return;
1231
1232   n = 0;
1233   for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
1234     if (!fixp->fx_done)
1235       n++;
1236
1237 #ifdef RELOC_EXPANSION_POSSIBLE
1238   n *= MAX_RELOC_EXPANSION;
1239 #endif
1240
1241   /* Extract relocs for this section from reloc_list.  */
1242   rp = &reloc_list;
1243
1244   my_reloc_list = NULL;
1245   while ((r = *rp) != NULL)
1246     {
1247       if (r->u.b.sec == sec)
1248         {
1249           *rp = r->next;
1250           r->next = my_reloc_list;
1251           my_reloc_list = r;
1252           n++;
1253         }
1254       else
1255         rp = &r->next;
1256     }
1257
1258   relocs = XCNEWVEC (arelent *, n);
1259
1260   n = 0;
1261   r = my_reloc_list;
1262   last_frag = NULL;
1263   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1264     {
1265       int fx_size, slack;
1266       valueT loc;
1267       arelent **reloc;
1268 #ifndef RELOC_EXPANSION_POSSIBLE
1269       arelent *rel;
1270
1271       reloc = &rel;
1272 #endif
1273
1274       if (fixp->fx_done)
1275         continue;
1276
1277       fx_size = fixp->fx_size;
1278       slack = TC_FX_SIZE_SLACK (fixp);
1279       if (slack > 0)
1280         fx_size = fx_size > slack ? fx_size - slack : 0;
1281       loc = fixp->fx_where + fx_size;
1282       if (slack >= 0 && loc > fixp->fx_frag->fr_fix)
1283         as_bad_where (fixp->fx_file, fixp->fx_line,
1284                       _("internal error: fixup not contained within frag"));
1285
1286 #ifndef RELOC_EXPANSION_POSSIBLE
1287       *reloc = tc_gen_reloc (sec, fixp);
1288 #else
1289       reloc = tc_gen_reloc (sec, fixp);
1290 #endif
1291
1292       while (*reloc)
1293         {
1294           while (r != NULL && r->u.b.r.address < (*reloc)->address)
1295             {
1296               fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1297               if (f != NULL)
1298                 {
1299                   last_frag = f;
1300                   relocs[n++] = &r->u.b.r;
1301                   install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1302                 }
1303               r = r->next;
1304             }
1305           relocs[n++] = *reloc;
1306           install_reloc (sec, *reloc, fixp->fx_frag,
1307                          fixp->fx_file, fixp->fx_line);
1308 #ifndef RELOC_EXPANSION_POSSIBLE
1309           break;
1310 #else
1311           reloc++;
1312 #endif
1313         }
1314     }
1315
1316   while (r != NULL)
1317     {
1318       fragS *f = get_frag_for_reloc (last_frag, seginfo, r);
1319       if (f != NULL)
1320         {
1321           last_frag = f;
1322           relocs[n++] = &r->u.b.r;
1323           install_reloc (sec, &r->u.b.r, f, r->file, r->line);
1324         }
1325       r = r->next;
1326     }
1327
1328 #ifdef DEBUG4
1329   {
1330     unsigned int k, j, nsyms;
1331     asymbol **sympp;
1332     sympp = bfd_get_outsymbols (stdoutput);
1333     nsyms = bfd_get_symcount (stdoutput);
1334     for (k = 0; k < n; k++)
1335       if (((*relocs[k]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1336         {
1337           for (j = 0; j < nsyms; j++)
1338             if (sympp[j] == *relocs[k]->sym_ptr_ptr)
1339               break;
1340           if (j == nsyms)
1341             abort ();
1342         }
1343   }
1344 #endif
1345
1346   if (n)
1347     {
1348       flagword flags = bfd_get_section_flags (abfd, sec);
1349       flags |= SEC_RELOC;
1350       bfd_set_section_flags (abfd, sec, flags);
1351       bfd_set_reloc (stdoutput, sec, relocs, n);
1352     }
1353
1354 #ifdef SET_SECTION_RELOCS
1355   SET_SECTION_RELOCS (sec, relocs, n);
1356 #endif
1357
1358 #ifdef DEBUG3
1359   {
1360     unsigned int k;
1361
1362     fprintf (stderr, "relocs for sec %s\n", sec->name);
1363     for (k = 0; k < n; k++)
1364       {
1365         arelent *rel = relocs[k];
1366         asymbol *s = *rel->sym_ptr_ptr;
1367         fprintf (stderr, "  reloc %2d @%p off %4lx : sym %-10s addend %lx\n",
1368                  k, rel, (unsigned long)rel->address, s->name,
1369                  (unsigned long)rel->addend);
1370       }
1371   }
1372 #endif
1373 }
1374
1375 static int
1376 compress_frag (struct z_stream_s *strm, const char *contents, int in_size,
1377                fragS **last_newf, struct obstack *ob)
1378 {
1379   int out_size;
1380   int total_out_size = 0;
1381   fragS *f = *last_newf;
1382   char *next_out;
1383   int avail_out;
1384
1385   /* Call the compression routine repeatedly until it has finished
1386      processing the frag.  */
1387   while (in_size > 0)
1388     {
1389       /* Reserve all the space available in the current chunk.
1390          If none is available, start a new frag.  */
1391       avail_out = obstack_room (ob);
1392       if (avail_out <= 0)
1393         {
1394           obstack_finish (ob);
1395           f = frag_alloc (ob);
1396           f->fr_type = rs_fill;
1397           (*last_newf)->fr_next = f;
1398           *last_newf = f;
1399           avail_out = obstack_room (ob);
1400         }
1401       if (avail_out <= 0)
1402         as_fatal (_("can't extend frag"));
1403       next_out = obstack_next_free (ob);
1404       obstack_blank_fast (ob, avail_out);
1405       out_size = compress_data (strm, &contents, &in_size,
1406                                 &next_out, &avail_out);
1407       if (out_size < 0)
1408         return -1;
1409
1410       f->fr_fix += out_size;
1411       total_out_size += out_size;
1412
1413       /* Return unused space.  */
1414       if (avail_out > 0)
1415         obstack_blank_fast (ob, -avail_out);
1416     }
1417
1418   return total_out_size;
1419 }
1420
1421 static void
1422 compress_debug (bfd *abfd, asection *sec, void *xxx ATTRIBUTE_UNUSED)
1423 {
1424   segment_info_type *seginfo = seg_info (sec);
1425   fragS *f;
1426   fragS *first_newf;
1427   fragS *last_newf;
1428   struct obstack *ob = &seginfo->frchainP->frch_obstack;
1429   bfd_size_type uncompressed_size = (bfd_size_type) sec->size;
1430   bfd_size_type compressed_size;
1431   const char *section_name;
1432   char *compressed_name;
1433   char *header;
1434   struct z_stream_s *strm;
1435   int x;
1436   flagword flags = bfd_get_section_flags (abfd, sec);
1437   unsigned int header_size, compression_header_size;
1438
1439   if (seginfo == NULL
1440       || sec->size < 32
1441       || (flags & (SEC_ALLOC | SEC_HAS_CONTENTS)) == SEC_ALLOC)
1442     return;
1443
1444   section_name = bfd_get_section_name (stdoutput, sec);
1445   if (strncmp (section_name, ".debug_", 7) != 0)
1446     return;
1447
1448   strm = compress_init ();
1449   if (strm == NULL)
1450     return;
1451
1452   if (flag_compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
1453     {
1454       compression_header_size
1455         = bfd_get_compression_header_size (stdoutput, NULL);
1456       header_size = compression_header_size;
1457     }
1458   else
1459     {
1460       compression_header_size = 0;
1461       header_size = 12;
1462     }
1463
1464   /* Create a new frag to contain the compression header.  */
1465   first_newf = frag_alloc (ob);
1466   if (obstack_room (ob) < header_size)
1467     first_newf = frag_alloc (ob);
1468   if (obstack_room (ob) < header_size)
1469     as_fatal (ngettext ("can't extend frag %lu char",
1470                         "can't extend frag %lu chars",
1471                         (unsigned long) header_size),
1472               (unsigned long) header_size);
1473   last_newf = first_newf;
1474   obstack_blank_fast (ob, header_size);
1475   last_newf->fr_type = rs_fill;
1476   last_newf->fr_fix = header_size;
1477   header = last_newf->fr_literal;
1478   compressed_size = header_size;
1479
1480   /* Stream the frags through the compression engine, adding new frags
1481      as necessary to accommodate the compressed output.  */
1482   for (f = seginfo->frchainP->frch_root;
1483        f;
1484        f = f->fr_next)
1485     {
1486       offsetT fill_size;
1487       char *fill_literal;
1488       offsetT count;
1489       int out_size;
1490
1491       gas_assert (f->fr_type == rs_fill);
1492       if (f->fr_fix)
1493         {
1494           out_size = compress_frag (strm, f->fr_literal, f->fr_fix,
1495                                     &last_newf, ob);
1496           if (out_size < 0)
1497             return;
1498           compressed_size += out_size;
1499         }
1500       fill_literal = f->fr_literal + f->fr_fix;
1501       fill_size = f->fr_var;
1502       count = f->fr_offset;
1503       gas_assert (count >= 0);
1504       if (fill_size && count)
1505         {
1506           while (count--)
1507             {
1508               out_size = compress_frag (strm, fill_literal, (int) fill_size,
1509                                         &last_newf, ob);
1510               if (out_size < 0)
1511                 return;
1512               compressed_size += out_size;
1513             }
1514         }
1515     }
1516
1517   /* Flush the compression state.  */
1518   for (;;)
1519     {
1520       int avail_out;
1521       char *next_out;
1522       int out_size;
1523
1524       /* Reserve all the space available in the current chunk.
1525          If none is available, start a new frag.  */
1526       avail_out = obstack_room (ob);
1527       if (avail_out <= 0)
1528         {
1529           fragS *newf;
1530
1531           obstack_finish (ob);
1532           newf = frag_alloc (ob);
1533           newf->fr_type = rs_fill;
1534           last_newf->fr_next = newf;
1535           last_newf = newf;
1536           avail_out = obstack_room (ob);
1537         }
1538       if (avail_out <= 0)
1539         as_fatal (_("can't extend frag"));
1540       next_out = obstack_next_free (ob);
1541       obstack_blank_fast (ob, avail_out);
1542       x = compress_finish (strm, &next_out, &avail_out, &out_size);
1543       if (x < 0)
1544         return;
1545
1546       last_newf->fr_fix += out_size;
1547       compressed_size += out_size;
1548
1549       /* Return unused space.  */
1550       if (avail_out > 0)
1551         obstack_blank_fast (ob, -avail_out);
1552
1553       if (x == 0)
1554         break;
1555     }
1556
1557   /* PR binutils/18087: If compression didn't make the section smaller,
1558      just keep it uncompressed.  */
1559   if (compressed_size >= uncompressed_size)
1560     return;
1561
1562   /* Replace the uncompressed frag list with the compressed frag list.  */
1563   seginfo->frchainP->frch_root = first_newf;
1564   seginfo->frchainP->frch_last = last_newf;
1565
1566   /* Update the section size and its name.  */
1567   bfd_update_compression_header (abfd, (bfd_byte *) header, sec);
1568   x = bfd_set_section_size (abfd, sec, compressed_size);
1569   gas_assert (x);
1570   if (!compression_header_size)
1571     {
1572       compressed_name = concat (".z", section_name + 1, (char *) NULL);
1573       bfd_section_name (stdoutput, sec) = compressed_name;
1574     }
1575 }
1576
1577 #ifndef md_generate_nops
1578 /* Genenerate COUNT bytes of no-op instructions to WHERE.  A target
1579    backend must override this with proper no-op instructions.   */
1580
1581 static void
1582 md_generate_nops (fragS *f ATTRIBUTE_UNUSED,
1583                   char *where ATTRIBUTE_UNUSED,
1584                   offsetT count ATTRIBUTE_UNUSED,
1585                   int control ATTRIBUTE_UNUSED)
1586 {
1587   as_bad (_("unimplemented .nops directive"));
1588 }
1589 #endif
1590
1591 static void
1592 write_contents (bfd *abfd ATTRIBUTE_UNUSED,
1593                 asection *sec,
1594                 void *xxx ATTRIBUTE_UNUSED)
1595 {
1596   segment_info_type *seginfo = seg_info (sec);
1597   addressT offset = 0;
1598   fragS *f;
1599
1600   /* Write out the frags.  */
1601   if (seginfo == NULL
1602       || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1603     return;
1604
1605   for (f = seginfo->frchainP->frch_root;
1606        f;
1607        f = f->fr_next)
1608     {
1609       int x;
1610       addressT fill_size;
1611       char *fill_literal;
1612       offsetT count;
1613
1614       gas_assert (f->fr_type == rs_fill || f->fr_type == rs_fill_nop);
1615       if (f->fr_fix)
1616         {
1617           x = bfd_set_section_contents (stdoutput, sec,
1618                                         f->fr_literal, (file_ptr) offset,
1619                                         (bfd_size_type) f->fr_fix);
1620           if (!x)
1621             as_fatal (ngettext ("can't write %ld byte "
1622                                 "to section %s of %s: '%s'",
1623                                 "can't write %ld bytes "
1624                                 "to section %s of %s: '%s'",
1625                                 (long) f->fr_fix),
1626                       (long) f->fr_fix,
1627                       sec->name, stdoutput->filename,
1628                       bfd_errmsg (bfd_get_error ()));
1629           offset += f->fr_fix;
1630         }
1631
1632       fill_size = f->fr_var;
1633       count = f->fr_offset;
1634       fill_literal = f->fr_literal + f->fr_fix;
1635
1636       if (f->fr_type == rs_fill_nop)
1637         {
1638           gas_assert (count >= 0 && fill_size == 1);
1639           if (count > 0)
1640             {
1641               char *buf = xmalloc (count);
1642               md_generate_nops (f, buf, count, *fill_literal);
1643               x = bfd_set_section_contents
1644                 (stdoutput, sec, buf, (file_ptr) offset,
1645                  (bfd_size_type) count);
1646               if (!x)
1647                 as_fatal (ngettext ("can't fill %ld byte "
1648                                     "in section %s of %s: '%s'",
1649                                     "can't fill %ld bytes "
1650                                     "in section %s of %s: '%s'",
1651                                     (long) count), (long) count,
1652                                     sec->name, stdoutput->filename,
1653                                     bfd_errmsg (bfd_get_error ()));
1654               offset += count;
1655               free (buf);
1656             }
1657           continue;
1658         }
1659
1660       gas_assert (count >= 0);
1661       if (fill_size && count)
1662         {
1663           char buf[256];
1664           if (fill_size > sizeof (buf))
1665             {
1666               /* Do it the old way. Can this ever happen?  */
1667               while (count--)
1668                 {
1669                   x = bfd_set_section_contents (stdoutput, sec,
1670                                                 fill_literal,
1671                                                 (file_ptr) offset,
1672                                                 (bfd_size_type) fill_size);
1673                   if (!x)
1674                     as_fatal (ngettext ("can't fill %ld byte "
1675                                         "in section %s of %s: '%s'",
1676                                         "can't fill %ld bytes "
1677                                         "in section %s of %s: '%s'",
1678                                         (long) fill_size),
1679                               (long) fill_size,
1680                               sec->name, stdoutput->filename,
1681                               bfd_errmsg (bfd_get_error ()));
1682                   offset += fill_size;
1683                 }
1684             }
1685           else
1686             {
1687               /* Build a buffer full of fill objects and output it as
1688                  often as necessary. This saves on the overhead of
1689                  potentially lots of bfd_set_section_contents calls.  */
1690               int n_per_buf, i;
1691               if (fill_size == 1)
1692                 {
1693                   n_per_buf = sizeof (buf);
1694                   memset (buf, *fill_literal, n_per_buf);
1695                 }
1696               else
1697                 {
1698                   char *bufp;
1699                   n_per_buf = sizeof (buf) / fill_size;
1700                   for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1701                     memcpy (bufp, fill_literal, fill_size);
1702                 }
1703               for (; count > 0; count -= n_per_buf)
1704                 {
1705                   n_per_buf = n_per_buf > count ? count : n_per_buf;
1706                   x = bfd_set_section_contents
1707                     (stdoutput, sec, buf, (file_ptr) offset,
1708                      (bfd_size_type) n_per_buf * fill_size);
1709                   if (!x)
1710                     as_fatal (ngettext ("can't fill %ld byte "
1711                                         "in section %s of %s: '%s'",
1712                                         "can't fill %ld bytes "
1713                                         "in section %s of %s: '%s'",
1714                                         (long) (n_per_buf * fill_size)),
1715                               (long) (n_per_buf * fill_size),
1716                               sec->name, stdoutput->filename,
1717                               bfd_errmsg (bfd_get_error ()));
1718                   offset += n_per_buf * fill_size;
1719                 }
1720             }
1721         }
1722     }
1723 }
1724
1725 static void
1726 merge_data_into_text (void)
1727 {
1728   seg_info (text_section)->frchainP->frch_last->fr_next =
1729     seg_info (data_section)->frchainP->frch_root;
1730   seg_info (text_section)->frchainP->frch_last =
1731     seg_info (data_section)->frchainP->frch_last;
1732   seg_info (data_section)->frchainP = 0;
1733 }
1734
1735 static void
1736 set_symtab (void)
1737 {
1738   int nsyms;
1739   asymbol **asympp;
1740   symbolS *symp;
1741   bfd_boolean result;
1742
1743   /* Count symbols.  We can't rely on a count made by the loop in
1744      write_object_file, because *_frob_file may add a new symbol or
1745      two.  */
1746   nsyms = 0;
1747   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1748     nsyms++;
1749
1750   if (nsyms)
1751     {
1752       int i;
1753       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1754
1755       asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1756       symp = symbol_rootP;
1757       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1758         {
1759           asympp[i] = symbol_get_bfdsym (symp);
1760           if (asympp[i]->flags != BSF_SECTION_SYM
1761               || !(bfd_is_const_section (asympp[i]->section)
1762                    && asympp[i]->section->symbol == asympp[i]))
1763             asympp[i]->flags |= BSF_KEEP;
1764           symbol_mark_written (symp);
1765         }
1766     }
1767   else
1768     asympp = 0;
1769   result = bfd_set_symtab (stdoutput, asympp, nsyms);
1770   gas_assert (result);
1771   symbol_table_frozen = 1;
1772 }
1773
1774 /* Finish the subsegments.  After every sub-segment, we fake an
1775    ".align ...".  This conforms to BSD4.2 brain-damage.  We then fake
1776    ".fill 0" because that is the kind of frag that requires least
1777    thought.  ".align" frags like to have a following frag since that
1778    makes calculating their intended length trivial.  */
1779
1780 #ifndef SUB_SEGMENT_ALIGN
1781 #ifdef HANDLE_ALIGN
1782 /* The last subsegment gets an alignment corresponding to the alignment
1783    of the section.  This allows proper nop-filling at the end of
1784    code-bearing sections.  */
1785 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
1786   (!(FRCHAIN)->frch_next && subseg_text_p (SEG)                         \
1787    && !do_not_pad_sections_to_alignment                                 \
1788    ? get_recorded_alignment (SEG)                                       \
1789    : 0)
1790 #else
1791 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1792 #endif
1793 #endif
1794
1795 static void
1796 subsegs_finish_section (asection *s)
1797 {
1798   struct frchain *frchainP;
1799   segment_info_type *seginfo = seg_info (s);
1800   if (!seginfo)
1801     return;
1802
1803   for (frchainP = seginfo->frchainP;
1804        frchainP != NULL;
1805        frchainP = frchainP->frch_next)
1806     {
1807       int alignment;
1808
1809       subseg_set (s, frchainP->frch_subseg);
1810
1811       /* This now gets called even if we had errors.  In that case,
1812          any alignment is meaningless, and, moreover, will look weird
1813          if we are generating a listing.  */
1814       if (had_errors ())
1815         do_not_pad_sections_to_alignment = 1;
1816
1817       alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1818       if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1819           && now_seg->entsize)
1820         {
1821           unsigned int entsize = now_seg->entsize;
1822           int entalign = 0;
1823
1824           while ((entsize & 1) == 0)
1825             {
1826               ++entalign;
1827               entsize >>= 1;
1828             }
1829
1830           if (entalign > alignment)
1831             alignment = entalign;
1832         }
1833
1834       if (subseg_text_p (now_seg))
1835         frag_align_code (alignment, 0);
1836       else
1837         frag_align (alignment, 0, 0);
1838
1839       /* frag_align will have left a new frag.
1840          Use this last frag for an empty ".fill".
1841
1842          For this segment ...
1843          Create a last frag. Do not leave a "being filled in frag".  */
1844       frag_wane (frag_now);
1845       frag_now->fr_fix = 0;
1846       know (frag_now->fr_next == NULL);
1847     }
1848 }
1849
1850 static void
1851 subsegs_finish (void)
1852 {
1853   asection *s;
1854
1855   for (s = stdoutput->sections; s; s = s->next)
1856     subsegs_finish_section (s);
1857 }
1858
1859 #ifdef OBJ_ELF
1860 static void
1861 create_obj_attrs_section (void)
1862 {
1863   segT s;
1864   char *p;
1865   offsetT size;
1866   const char *name;
1867
1868   size = bfd_elf_obj_attr_size (stdoutput);
1869   if (size == 0)
1870     return;
1871
1872   name = get_elf_backend_data (stdoutput)->obj_attrs_section;
1873   if (!name)
1874     name = ".gnu.attributes";
1875   s = subseg_new (name, 0);
1876   elf_section_type (s)
1877     = get_elf_backend_data (stdoutput)->obj_attrs_section_type;
1878   bfd_set_section_flags (stdoutput, s, SEC_READONLY | SEC_DATA);
1879   frag_now_fix ();
1880   p = frag_more (size);
1881   bfd_elf_set_obj_attr_contents (stdoutput, (bfd_byte *)p, size);
1882
1883   subsegs_finish_section (s);
1884   relax_segment (seg_info (s)->frchainP->frch_root, s, 0);
1885   size_seg (stdoutput, s, NULL);
1886 }
1887
1888 /* Create a relocation against an entry in a GNU Build attribute section.  */
1889
1890 static void
1891 create_note_reloc (segT           sec,
1892                    symbolS *      sym,
1893                    bfd_size_type  note_offset,
1894                    bfd_size_type  desc2_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     = note_offset + desc2_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[desc2_offset + 3] = addend;
1933           else
1934             note[desc2_offset + 7] = addend;
1935         }
1936       else
1937         note[desc2_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_tcbit)
3146     fprintf (stderr, " tcbit");
3147   if (fixp->fx_done)
3148     fprintf (stderr, " done");
3149   fprintf (stderr, "\n    size=%d frag=", fixp->fx_size);
3150   fprintf_vma (stderr, (bfd_vma) ((bfd_hostptr_t) fixp->fx_frag));
3151   fprintf (stderr, " where=%ld offset=%lx addnumber=%lx",
3152            (long) fixp->fx_where,
3153            (unsigned long) fixp->fx_offset,
3154            (unsigned long) fixp->fx_addnumber);
3155   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3156            fixp->fx_r_type);
3157   if (fixp->fx_addsy)
3158     {
3159       fprintf (stderr, "\n   +<");
3160       print_symbol_value_1 (stderr, fixp->fx_addsy);
3161       fprintf (stderr, ">");
3162     }
3163   if (fixp->fx_subsy)
3164     {
3165       fprintf (stderr, "\n   -<");
3166       print_symbol_value_1 (stderr, fixp->fx_subsy);
3167       fprintf (stderr, ">");
3168     }
3169   fprintf (stderr, "\n");
3170 #ifdef TC_FIX_DATA_PRINT
3171   TC_FIX_DATA_PRINT (stderr, fixp);
3172 #endif
3173 }