gas/write.c

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