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) || TC_FORCE_RELOCATION (FIX))
  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 **) xmalloc (n * sizeof (arelent *));
 942   memset ((char *) relocs, 0, n * sizeof (arelent *));
 943
 944   i = 0;
 945   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
 946     {
 947       arelent *reloc;
 948       bfd_reloc_status_type s;
 949       symbolS *sym;
 950
 951       if (fixp->fx_done)
 952         {
 953           n--;
 954           continue;
 955         }
 956
 957       /* If this is an undefined symbol which was equated to another
 958          symbol, then generate the reloc against the latter symbol
 959          rather than the former.  */
 960       sym = fixp->fx_addsy;
 961       while (symbol_equated_reloc_p (sym))
 962         {
 963           symbolS *n;
 964
 965           /* We must avoid looping, as that can occur with a badly
 966              written program.  */
 967           n = symbol_get_value_expression (sym)->X_add_symbol;
 968           if (n == sym)
 969             break;
 970           fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
 971           sym = n;
 972         }
 973       fixp->fx_addsy = sym;
 974
 975       reloc = tc_gen_reloc (sec, fixp);
 976       if (!reloc)
 977         {
 978           n--;
 979           continue;
 980         }
 981
 982 #if 0
 983       /* This test is triggered inappropriately for the SH.  */
 984       if (fixp->fx_where + fixp->fx_size
 985           > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
 986         abort ();
 987 #endif
 988
 989       s = bfd_install_relocation (stdoutput, reloc,
 990                                   fixp->fx_frag->fr_literal,
 991                                   fixp->fx_frag->fr_address,
 992                                   sec, &err);
 993       switch (s)
 994         {
 995         case bfd_reloc_ok:
 996           break;
 997         case bfd_reloc_overflow:
 998           as_bad_where (fixp->fx_file, fixp->fx_line,
 999                         _("relocation overflow"));
1000           break;
1001         case bfd_reloc_outofrange:
1002           as_bad_where (fixp->fx_file, fixp->fx_line,
1003                         _("relocation out of range"));
1004           break;
1005         default:
1006           as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1007                     fixp->fx_file, fixp->fx_line, s);
1008         }
1009       relocs[i++] = reloc;
1010     }
1011 #else
1012   n = n * MAX_RELOC_EXPANSION;
1013   /* Set up reloc information as well.  */
1014   relocs = (arelent **) xmalloc (n * sizeof (arelent *));
1015
1016   i = 0;
1017   for (fixp = seginfo->fix_root; fixp != (fixS *) NULL; fixp = fixp->fx_next)
1018     {
1019       arelent **reloc;
1020       char *data;
1021       bfd_reloc_status_type s;
1022       symbolS *sym;
1023       int j;
1024
1025       if (fixp->fx_done)
1026         {
1027           n--;
1028           continue;
1029         }
1030
1031       /* If this is an undefined symbol which was equated to another
1032          symbol, then generate the reloc against the latter symbol
1033          rather than the former.  */
1034       sym = fixp->fx_addsy;
1035       while (symbol_equated_reloc_p (sym))
1036         {
1037           symbolS *n;
1038
1039           /* We must avoid looping, as that can occur with a badly
1040              written program.  */
1041           n = symbol_get_value_expression (sym)->X_add_symbol;
1042           if (n == sym)
1043             break;
1044           fixp->fx_offset += symbol_get_value_expression (sym)->X_add_number;
1045           sym = n;
1046         }
1047       fixp->fx_addsy = sym;
1048
1049       reloc = tc_gen_reloc (sec, fixp);
1050
1051       for (j = 0; reloc[j]; j++)
1052         {
1053           relocs[i++] = reloc[j];
1054           assert (i <= n);
1055         }
1056       data = fixp->fx_frag->fr_literal + fixp->fx_where;
1057       if (fixp->fx_where + fixp->fx_size
1058           > fixp->fx_frag->fr_fix + fixp->fx_frag->fr_offset)
1059         as_bad_where (fixp->fx_file, fixp->fx_line,
1060                       _("internal error: fixup not contained within frag"));
1061       for (j = 0; reloc[j]; j++)
1062         {
1063           s = bfd_install_relocation (stdoutput, reloc[j],
1064                                       fixp->fx_frag->fr_literal,
1065                                       fixp->fx_frag->fr_address,
1066                                       sec, &err);
1067           switch (s)
1068             {
1069             case bfd_reloc_ok:
1070               break;
1071             case bfd_reloc_overflow:
1072               as_bad_where (fixp->fx_file, fixp->fx_line,
1073                             _("relocation overflow"));
1074               break;
1075             case bfd_reloc_outofrange:
1076               as_bad_where (fixp->fx_file, fixp->fx_line,
1077                             _("relocation out of range"));
1078               break;
1079             default:
1080               as_fatal (_("%s:%u: bad return from bfd_install_relocation: %x"),
1081                         fixp->fx_file, fixp->fx_line, s);
1082             }
1083         }
1084     }
1085   n = i;
1086 #endif
1087
1088 #ifdef DEBUG4
1089   {
1090     int i, j, nsyms;
1091     asymbol **sympp;
1092     sympp = bfd_get_outsymbols (stdoutput);
1093     nsyms = bfd_get_symcount (stdoutput);
1094     for (i = 0; i < n; i++)
1095       if (((*relocs[i]->sym_ptr_ptr)->flags & BSF_SECTION_SYM) == 0)
1096         {
1097           for (j = 0; j < nsyms; j++)
1098             if (sympp[j] == *relocs[i]->sym_ptr_ptr)
1099               break;
1100           if (j == nsyms)
1101             abort ();
1102         }
1103   }
1104 #endif
1105
1106   if (n)
1107     bfd_set_reloc (stdoutput, sec, relocs, n);
1108   else
1109     bfd_set_section_flags (abfd, sec,
1110                            (bfd_get_section_flags (abfd, sec)
1111                             & (flagword) ~SEC_RELOC));
1112
1113 #ifdef SET_SECTION_RELOCS
1114   SET_SECTION_RELOCS (sec, relocs, n);
1115 #endif
1116
1117 #ifdef DEBUG3
1118   {
1119     int i;
1120     arelent *r;
1121     asymbol *s;
1122     fprintf (stderr, "relocs for sec %s\n", sec->name);
1123     for (i = 0; i < n; i++)
1124       {
1125         r = relocs[i];
1126         s = *r->sym_ptr_ptr;
1127         fprintf (stderr, "  reloc %2d @%08x off %4x : sym %-10s addend %x\n",
1128                  i, r, r->address, s->name, r->addend);
1129       }
1130   }
1131 #endif
1132 }
1133
1134 static void
1135 write_contents (abfd, sec, xxx)
1136      bfd *abfd ATTRIBUTE_UNUSED;
1137      asection *sec;
1138      PTR xxx ATTRIBUTE_UNUSED;
1139 {
1140   segment_info_type *seginfo = seg_info (sec);
1141   unsigned long offset = 0;
1142   fragS *f;
1143
1144   /* Write out the frags.  */
1145   if (seginfo == NULL
1146       || !(bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS))
1147     return;
1148
1149   for (f = seginfo->frchainP->frch_root;
1150        f;
1151        f = f->fr_next)
1152     {
1153       int x;
1154       unsigned long fill_size;
1155       char *fill_literal;
1156       long count;
1157
1158       assert (f->fr_type == rs_fill);
1159       if (f->fr_fix)
1160         {
1161           x = bfd_set_section_contents (stdoutput, sec,
1162                                         f->fr_literal, (file_ptr) offset,
1163                                         (bfd_size_type) f->fr_fix);
1164           if (!x)
1165             {
1166               bfd_perror (stdoutput->filename);
1167               as_perror (_("FATAL: Can't write %s"), stdoutput->filename);
1168               exit (EXIT_FAILURE);
1169             }
1170           offset += f->fr_fix;
1171         }
1172       fill_literal = f->fr_literal + f->fr_fix;
1173       fill_size = f->fr_var;
1174       count = f->fr_offset;
1175       assert (count >= 0);
1176       if (fill_size && count)
1177         {
1178           char buf[256];
1179           if (fill_size > sizeof (buf))
1180             {
1181               /* Do it the old way. Can this ever happen?  */
1182               while (count--)
1183                 {
1184                   x = bfd_set_section_contents (stdoutput, sec,
1185                                                 fill_literal,
1186                                                 (file_ptr) offset,
1187                                                 (bfd_size_type) fill_size);
1188                   if (!x)
1189                     {
1190                       bfd_perror (stdoutput->filename);
1191                       as_perror (_("FATAL: Can't write %s"),
1192                                  stdoutput->filename);
1193                       exit (EXIT_FAILURE);
1194                     }
1195                   offset += fill_size;
1196                 }
1197             }
1198           else
1199             {
1200               /* Build a buffer full of fill objects and output it as
1201                  often as necessary. This saves on the overhead of
1202                  potentially lots of bfd_set_section_contents calls.  */
1203               int n_per_buf, i;
1204               if (fill_size == 1)
1205                 {
1206                   n_per_buf = sizeof (buf);
1207                   memset (buf, *fill_literal, n_per_buf);
1208                 }
1209               else
1210                 {
1211                   char *bufp;
1212                   n_per_buf = sizeof (buf) / fill_size;
1213                   for (i = n_per_buf, bufp = buf; i; i--, bufp += fill_size)
1214                     memcpy (bufp, fill_literal, fill_size);
1215                 }
1216               for (; count > 0; count -= n_per_buf)
1217                 {
1218                   n_per_buf = n_per_buf > count ? count : n_per_buf;
1219                   x = bfd_set_section_contents
1220                     (stdoutput, sec, buf, (file_ptr) offset,
1221                      (bfd_size_type) n_per_buf * fill_size);
1222                   if (!x)
1223                     as_fatal (_("cannot write to output file"));
1224                   offset += n_per_buf * fill_size;
1225                 }
1226             }
1227         }
1228     }
1229 }
1230 #endif
1231
1232 #if defined(BFD_ASSEMBLER) || (!defined (BFD) && !defined(OBJ_AOUT))
1233 static void
1234 merge_data_into_text ()
1235 {
1236 #if defined(BFD_ASSEMBLER) || defined(MANY_SEGMENTS)
1237   seg_info (text_section)->frchainP->frch_last->fr_next =
1238     seg_info (data_section)->frchainP->frch_root;
1239   seg_info (text_section)->frchainP->frch_last =
1240     seg_info (data_section)->frchainP->frch_last;
1241   seg_info (data_section)->frchainP = 0;
1242 #else
1243   fixS *tmp;
1244
1245   text_last_frag->fr_next = data_frag_root;
1246   text_last_frag = data_last_frag;
1247   data_last_frag = NULL;
1248   data_frag_root = NULL;
1249   if (text_fix_root)
1250     {
1251       for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next);;
1252       tmp->fx_next = data_fix_root;
1253       text_fix_tail = data_fix_tail;
1254     }
1255   else
1256     text_fix_root = data_fix_root;
1257   data_fix_root = NULL;
1258 #endif
1259 }
1260 #endif /* BFD_ASSEMBLER || (! BFD && ! OBJ_AOUT)  */
1261
1262 #if !defined (BFD_ASSEMBLER) && !defined (BFD)
1263 static void
1264 relax_and_size_all_segments ()
1265 {
1266   fragS *fragP;
1267
1268   relax_segment (text_frag_root, SEG_TEXT);
1269   relax_segment (data_frag_root, SEG_DATA);
1270   relax_segment (bss_frag_root, SEG_BSS);
1271
1272   /* Now the addresses of frags are correct within the segment.  */
1273   know (text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
1274   H_SET_TEXT_SIZE (&headers, text_last_frag->fr_address);
1275   text_last_frag->fr_address = H_GET_TEXT_SIZE (&headers);
1276
1277   /* Join the 2 segments into 1 huge segment.
1278      To do this, re-compute every rn_address in the SEG_DATA frags.
1279      Then join the data frags after the text frags.
1280
1281      Determine a_data [length of data segment].  */
1282   if (data_frag_root)
1283     {
1284       register relax_addressT slide;
1285
1286       know ((text_last_frag->fr_type == rs_fill)
1287             && (text_last_frag->fr_offset == 0));
1288
1289       H_SET_DATA_SIZE (&headers, data_last_frag->fr_address);
1290       data_last_frag->fr_address = H_GET_DATA_SIZE (&headers);
1291       slide = H_GET_TEXT_SIZE (&headers);       /* & in file of the data segment.  */
1292 #ifdef OBJ_BOUT
1293 #define RoundUp(N,S) (((N)+(S)-1)&-(S))
1294       /* For b.out: If the data section has a strict alignment
1295          requirement, its load address in the .o file will be
1296          rounded up from the size of the text section.  These
1297          two values are *not* the same!  Similarly for the bss
1298          section....  */
1299       slide = RoundUp (slide, 1 << section_alignment[SEG_DATA]);
1300 #endif
1301
1302       for (fragP = data_frag_root; fragP; fragP = fragP->fr_next)
1303         fragP->fr_address += slide;
1304
1305       know (text_last_frag != 0);
1306       text_last_frag->fr_next = data_frag_root;
1307     }
1308   else
1309     {
1310       H_SET_DATA_SIZE (&headers, 0);
1311     }
1312
1313 #ifdef OBJ_BOUT
1314   /* See above comments on b.out data section address.  */
1315   {
1316     long bss_vma;
1317     if (data_last_frag == 0)
1318       bss_vma = H_GET_TEXT_SIZE (&headers);
1319     else
1320       bss_vma = data_last_frag->fr_address;
1321     bss_vma = RoundUp (bss_vma, 1 << section_alignment[SEG_BSS]);
1322     bss_address_frag.fr_address = bss_vma;
1323   }
1324 #else /* ! OBJ_BOUT  */
1325   bss_address_frag.fr_address = (H_GET_TEXT_SIZE (&headers) +
1326                                  H_GET_DATA_SIZE (&headers));
1327
1328 #endif /* ! OBJ_BOUT  */
1329
1330   /* Slide all the frags.  */
1331   if (bss_frag_root)
1332     {
1333       relax_addressT slide = bss_address_frag.fr_address;
1334
1335       for (fragP = bss_frag_root; fragP; fragP = fragP->fr_next)
1336         fragP->fr_address += slide;
1337     }
1338
1339   if (bss_last_frag)
1340     H_SET_BSS_SIZE (&headers,
1341                     bss_last_frag->fr_address - bss_frag_root->fr_address);
1342   else
1343     H_SET_BSS_SIZE (&headers, 0);
1344 }
1345 #endif /* ! BFD_ASSEMBLER && ! BFD  */
1346
1347 #if defined (BFD_ASSEMBLER) || !defined (BFD)
1348
1349 #ifdef BFD_ASSEMBLER
1350 static void
1351 set_symtab ()
1352 {
1353   int nsyms;
1354   asymbol **asympp;
1355   symbolS *symp;
1356   bfd_boolean result;
1357   extern PTR bfd_alloc PARAMS ((bfd *, bfd_size_type));
1358
1359   /* Count symbols.  We can't rely on a count made by the loop in
1360      write_object_file, because *_frob_file may add a new symbol or
1361      two.  */
1362   nsyms = 0;
1363   for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1364     nsyms++;
1365
1366   if (nsyms)
1367     {
1368       int i;
1369       bfd_size_type amt = (bfd_size_type) nsyms * sizeof (asymbol *);
1370
1371       asympp = (asymbol **) bfd_alloc (stdoutput, amt);
1372       symp = symbol_rootP;
1373       for (i = 0; i < nsyms; i++, symp = symbol_next (symp))
1374         {
1375           asympp[i] = symbol_get_bfdsym (symp);
1376           symbol_mark_written (symp);
1377         }
1378     }
1379   else
1380     asympp = 0;
1381   result = bfd_set_symtab (stdoutput, asympp, nsyms);
1382   assert (result);
1383   symbol_table_frozen = 1;
1384 }
1385 #endif
1386
1387 /* Finish the subsegments.  After every sub-segment, we fake an
1388    ".align ...".  This conforms to BSD4.2 brane-damage.  We then fake
1389    ".fill 0" because that is the kind of frag that requires least
1390    thought.  ".align" frags like to have a following frag since that
1391    makes calculating their intended length trivial.  */
1392
1393 #ifndef SUB_SEGMENT_ALIGN
1394 #ifdef HANDLE_ALIGN
1395 /* The last subsegment gets an aligment corresponding to the alignment
1396    of the section.  This allows proper nop-filling at the end of
1397    code-bearing sections.  */
1398 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
1399   (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG)     \
1400    ? get_recorded_alignment (SEG) : 0)
1401 #else
1402 #ifdef BFD_ASSEMBLER
1403 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 0
1404 #else
1405 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 2
1406 #endif
1407 #endif
1408 #endif
1409
1410 void
1411 subsegs_finish ()
1412 {
1413   struct frchain *frchainP;
1414
1415   for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next)
1416     {
1417       int alignment = 0;
1418
1419       subseg_set (frchainP->frch_seg, frchainP->frch_subseg);
1420
1421       /* This now gets called even if we had errors.  In that case,
1422          any alignment is meaningless, and, moreover, will look weird
1423          if we are generating a listing.  */
1424       if (!had_errors ())
1425         {
1426           alignment = SUB_SEGMENT_ALIGN (now_seg, frchainP);
1427 #ifdef BFD_ASSEMBLER
1428           if ((bfd_get_section_flags (now_seg->owner, now_seg) & SEC_MERGE)
1429               && now_seg->entsize)
1430             {
1431               unsigned int entsize = now_seg->entsize;
1432               int entalign = 0;
1433
1434               while ((entsize & 1) == 0)
1435                 {
1436                   ++entalign;
1437                   entsize >>= 1;
1438                 }
1439               if (entalign > alignment)
1440                 alignment = entalign;
1441             }
1442 #endif
1443         }
1444
1445       if (subseg_text_p (now_seg))
1446         frag_align_code (alignment, 0);
1447       else
1448         frag_align (alignment, 0, 0);
1449
1450       /* frag_align will have left a new frag.
1451          Use this last frag for an empty ".fill".
1452
1453          For this segment ...
1454          Create a last frag. Do not leave a "being filled in frag".  */
1455       frag_wane (frag_now);
1456       frag_now->fr_fix = 0;
1457       know (frag_now->fr_next == NULL);
1458     }
1459 }
1460
1461 /* Write the object file.  */
1462
1463 void
1464 write_object_file ()
1465 {
1466 #if ! defined (BFD_ASSEMBLER) || ! defined (WORKING_DOT_WORD)
1467   fragS *fragP;                 /* Track along all frags.  */
1468 #endif
1469
1470   /* Do we really want to write it?  */
1471   {
1472     int n_warns, n_errs;
1473     n_warns = had_warnings ();
1474     n_errs = had_errors ();
1475     /* The -Z flag indicates that an object file should be generated,
1476        regardless of warnings and errors.  */
1477     if (flag_always_generate_output)
1478       {
1479         if (n_warns || n_errs)
1480           as_warn (_("%d error%s, %d warning%s, generating bad object file"),
1481                    n_errs, n_errs == 1 ? "" : "s",
1482                    n_warns, n_warns == 1 ? "" : "s");
1483       }
1484     else
1485       {
1486         if (n_errs)
1487           as_fatal (_("%d error%s, %d warning%s, no object file generated"),
1488                     n_errs, n_errs == 1 ? "" : "s",
1489                     n_warns, n_warns == 1 ? "" : "s");
1490       }
1491   }
1492
1493 #ifdef  OBJ_VMS
1494   /* Under VMS we try to be compatible with VAX-11 "C".  Thus, we call
1495      a routine to check for the definition of the procedure "_main",
1496      and if so -- fix it up so that it can be program entry point.  */
1497   vms_check_for_main ();
1498 #endif /* OBJ_VMS  */
1499
1500   /* From now on, we don't care about sub-segments.  Build one frag chain
1501      for each segment. Linked thru fr_next.  */
1502
1503 #ifdef BFD_ASSEMBLER
1504   /* Remove the sections created by gas for its own purposes.  */
1505   {
1506     asection **seclist;
1507     int i;
1508
1509     seclist = &stdoutput->sections;
1510     while (*seclist)
1511       {
1512         if (*seclist == reg_section || *seclist == expr_section)
1513           {
1514             bfd_section_list_remove (stdoutput, seclist);
1515             stdoutput->section_count--;
1516           }
1517         else
1518           seclist = &(*seclist)->next;
1519       }
1520     i = 0;
1521     bfd_map_over_sections (stdoutput, renumber_sections, &i);
1522   }
1523
1524   bfd_map_over_sections (stdoutput, chain_frchains_together, (char *) 0);
1525 #else
1526   remove_subsegs (frchain_root, SEG_TEXT, &text_frag_root, &text_last_frag);
1527   remove_subsegs (data0_frchainP, SEG_DATA, &data_frag_root, &data_last_frag);
1528   remove_subsegs (bss0_frchainP, SEG_BSS, &bss_frag_root, &bss_last_frag);
1529 #endif
1530
1531   /* We have two segments. If user gave -R flag, then we must put the
1532      data frags into the text segment. Do this before relaxing so
1533      we know to take advantage of -R and make shorter addresses.  */
1534 #if !defined (OBJ_AOUT) || defined (BFD_ASSEMBLER)
1535   if (flag_readonly_data_in_text)
1536     {
1537       merge_data_into_text ();
1538     }
1539 #endif
1540
1541 #ifdef BFD_ASSEMBLER
1542   while (1)
1543     {
1544       int changed;
1545
1546 #ifndef WORKING_DOT_WORD
1547       /* We need to reset the markers in the broken word list and
1548          associated frags between calls to relax_segment (via
1549          relax_seg).  Since the broken word list is global, we do it
1550          once per round, rather than locally in relax_segment for each
1551          segment.  */
1552       struct broken_word *brokp;
1553
1554       for (brokp = broken_words;
1555            brokp != (struct broken_word *) NULL;
1556            brokp = brokp->next_broken_word)
1557         {
1558           brokp->added = 0;
1559
1560           if (brokp->dispfrag != (fragS *) NULL
1561               && brokp->dispfrag->fr_type == rs_broken_word)
1562             brokp->dispfrag->fr_subtype = 0;
1563         }
1564 #endif
1565
1566       changed = 0;
1567       bfd_map_over_sections (stdoutput, relax_seg, &changed);
1568       if (!changed)
1569         break;
1570     }
1571
1572   /* Note - Most ports will use the default value of
1573      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG, which 1.  This will force
1574      local symbols to be resolved, removing their frag information.
1575      Some ports however, will not have finished relaxing all of
1576      their frags and will still need the local symbol frag
1577      information.  These ports can set
1578      TC_FINALIZE_SYMS_BEFORE_SIZE_SEG to 0.  */
1579   finalize_syms = TC_FINALIZE_SYMS_BEFORE_SIZE_SEG;
1580
1581   bfd_map_over_sections (stdoutput, size_seg, (char *) 0);
1582 #else
1583   relax_and_size_all_segments ();
1584 #endif /* BFD_ASSEMBLER  */
1585
1586   /* Relaxation has completed.  Freeze all syms.  */
1587   finalize_syms = 1;
1588
1589 #ifndef BFD_ASSEMBLER
1590   /* Crawl the symbol chain.
1591
1592      For each symbol whose value depends on a frag, take the address of
1593      that frag and subsume it into the value of the symbol.
1594      After this, there is just one way to lookup a symbol value.
1595      Values are left in their final state for object file emission.
1596      We adjust the values of 'L' local symbols, even if we do
1597      not intend to emit them to the object file, because their values
1598      are needed for fix-ups.
1599
1600      Unless we saw a -L flag, remove all symbols that begin with 'L'
1601      from the symbol chain.  (They are still pointed to by the fixes.)
1602
1603      Count the remaining symbols.
1604      Assign a symbol number to each symbol.
1605      Count the number of string-table chars we will emit.
1606      Put this info into the headers as appropriate.  */
1607   know (zero_address_frag.fr_address == 0);
1608   string_byte_count = sizeof (string_byte_count);
1609
1610   obj_crawl_symbol_chain (&headers);
1611
1612   if (string_byte_count == sizeof (string_byte_count))
1613     string_byte_count = 0;
1614
1615   H_SET_STRING_SIZE (&headers, string_byte_count);
1616
1617   /* Addresses of frags now reflect addresses we use in the object file.
1618      Symbol values are correct.
1619      Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
1620      Also converting any machine-dependent frags using md_convert_frag();  */
1621   subseg_change (SEG_TEXT, 0);
1622
1623   for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1624     {
1625       /* At this point we have linked all the frags into a single
1626          chain.  However, cvt_frag_to_fill may call md_convert_frag
1627          which may call fix_new.  We need to ensure that fix_new adds
1628          the fixup to the right section.  */
1629       if (fragP == data_frag_root)
1630         subseg_change (SEG_DATA, 0);
1631
1632       cvt_frag_to_fill (&headers, SEG_TEXT, fragP);
1633
1634       /* Some assert macros don't work with # directives mixed in.  */
1635 #ifndef NDEBUG
1636       if (!(fragP->fr_next == NULL
1637 #ifdef OBJ_BOUT
1638             || fragP->fr_next == data_frag_root
1639 #endif
1640             || ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1641                 == (fragP->fr_fix + fragP->fr_offset * fragP->fr_var))))
1642         abort ();
1643 #endif
1644     }
1645 #endif /* ! BFD_ASSEMBLER  */
1646
1647 #ifndef WORKING_DOT_WORD
1648   {
1649     struct broken_word *lie;
1650     struct broken_word **prevP;
1651
1652     prevP = &broken_words;
1653     for (lie = broken_words; lie; lie = lie->next_broken_word)
1654       if (!lie->added)
1655         {
1656           expressionS exp;
1657
1658           subseg_change (lie->seg, lie->subseg);
1659           exp.X_op = O_subtract;
1660           exp.X_add_symbol = lie->add;
1661           exp.X_op_symbol = lie->sub;
1662           exp.X_add_number = lie->addnum;
1663 #ifdef BFD_ASSEMBLER
1664 #ifdef TC_CONS_FIX_NEW
1665           TC_CONS_FIX_NEW (lie->frag,
1666                            lie->word_goes_here - lie->frag->fr_literal,
1667                            2, &exp);
1668 #else
1669           fix_new_exp (lie->frag,
1670                        lie->word_goes_here - lie->frag->fr_literal,
1671                        2, &exp, 0, BFD_RELOC_16);
1672 #endif
1673 #else
1674 #if defined(TC_SPARC) || defined(TC_A29K) || defined(NEED_FX_R_TYPE)
1675           fix_new_exp (lie->frag,
1676                        lie->word_goes_here - lie->frag->fr_literal,
1677                        2, &exp, 0, NO_RELOC);
1678 #else
1679 #ifdef TC_NS32K
1680           fix_new_ns32k_exp (lie->frag,
1681                              lie->word_goes_here - lie->frag->fr_literal,
1682                              2, &exp, 0, 0, 2, 0, 0);
1683 #else
1684           fix_new_exp (lie->frag,
1685                        lie->word_goes_here - lie->frag->fr_literal,
1686                        2, &exp, 0, 0);
1687 #endif /* TC_NS32K  */
1688 #endif /* TC_SPARC|TC_A29K|NEED_FX_R_TYPE  */
1689 #endif /* BFD_ASSEMBLER  */
1690           *prevP = lie->next_broken_word;
1691         }
1692       else
1693         prevP = &(lie->next_broken_word);
1694
1695     for (lie = broken_words; lie;)
1696       {
1697         struct broken_word *untruth;
1698         char *table_ptr;
1699         addressT table_addr;
1700         addressT from_addr, to_addr;
1701         int n, m;
1702
1703         subseg_change (lie->seg, lie->subseg);
1704         fragP = lie->dispfrag;
1705
1706         /* Find out how many broken_words go here.  */
1707         n = 0;
1708         for (untruth = lie;
1709              untruth && untruth->dispfrag == fragP;
1710              untruth = untruth->next_broken_word)
1711           if (untruth->added == 1)
1712             n++;
1713
1714         table_ptr = lie->dispfrag->fr_opcode;
1715         table_addr = (lie->dispfrag->fr_address
1716                       + (table_ptr - lie->dispfrag->fr_literal));
1717         /* Create the jump around the long jumps.  This is a short
1718            jump from table_ptr+0 to table_ptr+n*long_jump_size.  */
1719         from_addr = table_addr;
1720         to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
1721         md_create_short_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1722                               lie->add);
1723         table_ptr += md_short_jump_size;
1724         table_addr += md_short_jump_size;
1725
1726         for (m = 0;
1727              lie && lie->dispfrag == fragP;
1728              m++, lie = lie->next_broken_word)
1729           {
1730             if (lie->added == 2)
1731               continue;
1732             /* Patch the jump table.  */
1733             /* This is the offset from ??? to table_ptr+0.  */
1734             to_addr = table_addr - S_GET_VALUE (lie->sub);
1735 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1736             TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1737 #endif
1738             md_number_to_chars (lie->word_goes_here, to_addr, 2);
1739             for (untruth = lie->next_broken_word;
1740                  untruth && untruth->dispfrag == fragP;
1741                  untruth = untruth->next_broken_word)
1742               {
1743                 if (untruth->use_jump == lie)
1744                   md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1745               }
1746
1747             /* Install the long jump.  */
1748             /* This is a long jump from table_ptr+0 to the final target.  */
1749             from_addr = table_addr;
1750             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1751             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1752                                  lie->add);
1753             table_ptr += md_long_jump_size;
1754             table_addr += md_long_jump_size;
1755           }
1756       }
1757   }
1758 #endif /* not WORKING_DOT_WORD  */
1759
1760 #ifndef BFD_ASSEMBLER
1761 #ifndef OBJ_VMS
1762   {                             /* not vms  */
1763     char *the_object_file;
1764     long object_file_size;
1765     /* Scan every FixS performing fixups. We had to wait until now to
1766        do this because md_convert_frag() may have made some fixSs.  */
1767     int trsize, drsize;
1768
1769     subseg_change (SEG_TEXT, 0);
1770     trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1771     subseg_change (SEG_DATA, 0);
1772     drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1773     H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1774
1775     /* FIXME: Move this stuff into the pre-write-hook.  */
1776     H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1777     H_SET_ENTRY_POINT (&headers, 0);
1778
1779     obj_pre_write_hook (&headers);      /* Extra coff stuff.  */
1780
1781     object_file_size = H_GET_FILE_SIZE (&headers);
1782     next_object_file_charP = the_object_file = xmalloc (object_file_size);
1783
1784     output_file_create (out_file_name);
1785
1786     obj_header_append (&next_object_file_charP, &headers);
1787
1788     know ((next_object_file_charP - the_object_file)
1789           == H_GET_HEADER_SIZE (&headers));
1790
1791     /* Emit code.  */
1792     for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1793       {
1794         register long count;
1795         register char *fill_literal;
1796         register long fill_size;
1797
1798         PROGRESS (1);
1799         know (fragP->fr_type == rs_fill);
1800         append (&next_object_file_charP, fragP->fr_literal,
1801                 (unsigned long) fragP->fr_fix);
1802         fill_literal = fragP->fr_literal + fragP->fr_fix;
1803         fill_size = fragP->fr_var;
1804         know (fragP->fr_offset >= 0);
1805
1806         for (count = fragP->fr_offset; count; count--)
1807           append (&next_object_file_charP, fill_literal,
1808                   (unsigned long) fill_size);
1809       }
1810
1811     know ((next_object_file_charP - the_object_file)
1812           == (H_GET_HEADER_SIZE (&headers)
1813               + H_GET_TEXT_SIZE (&headers)
1814               + H_GET_DATA_SIZE (&headers)));
1815
1816     /* Emit relocations.  */
1817     obj_emit_relocations (&next_object_file_charP, text_fix_root,
1818                           (relax_addressT) 0);
1819     know ((next_object_file_charP - the_object_file)
1820           == (H_GET_HEADER_SIZE (&headers)
1821               + H_GET_TEXT_SIZE (&headers)
1822               + H_GET_DATA_SIZE (&headers)
1823               + H_GET_TEXT_RELOCATION_SIZE (&headers)));
1824 #ifdef TC_I960
1825     /* Make addresses in data relocation directives relative to beginning of
1826        first data fragment, not end of last text fragment:  alignment of the
1827        start of the data segment may place a gap between the segments.  */
1828     obj_emit_relocations (&next_object_file_charP, data_fix_root,
1829                           data0_frchainP->frch_root->fr_address);
1830 #else /* TC_I960  */
1831     obj_emit_relocations (&next_object_file_charP, data_fix_root,
1832                           text_last_frag->fr_address);
1833 #endif /* TC_I960  */
1834
1835     know ((next_object_file_charP - the_object_file)
1836           == (H_GET_HEADER_SIZE (&headers)
1837               + H_GET_TEXT_SIZE (&headers)
1838               + H_GET_DATA_SIZE (&headers)
1839               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1840               + H_GET_DATA_RELOCATION_SIZE (&headers)));
1841
1842     /* Emit line number entries.  */
1843     OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1844     know ((next_object_file_charP - the_object_file)
1845           == (H_GET_HEADER_SIZE (&headers)
1846               + H_GET_TEXT_SIZE (&headers)
1847               + H_GET_DATA_SIZE (&headers)
1848               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1849               + H_GET_DATA_RELOCATION_SIZE (&headers)
1850               + H_GET_LINENO_SIZE (&headers)));
1851
1852     /* Emit symbols.  */
1853     obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1854     know ((next_object_file_charP - the_object_file)
1855           == (H_GET_HEADER_SIZE (&headers)
1856               + H_GET_TEXT_SIZE (&headers)
1857               + H_GET_DATA_SIZE (&headers)
1858               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1859               + H_GET_DATA_RELOCATION_SIZE (&headers)
1860               + H_GET_LINENO_SIZE (&headers)
1861               + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1862
1863     /* Emit strings.  */
1864     if (string_byte_count > 0)
1865       obj_emit_strings (&next_object_file_charP);
1866
1867 #ifdef BFD_HEADERS
1868     bfd_seek (stdoutput, (file_ptr) 0, 0);
1869     bfd_bwrite (the_object_file, (bfd_size_type) object_file_size, stdoutput);
1870 #else
1871
1872     /* Write the data to the file.  */
1873     output_file_append (the_object_file, object_file_size, out_file_name);
1874     free (the_object_file);
1875 #endif
1876   }
1877 #else /* OBJ_VMS  */
1878   /* Now do the VMS-dependent part of writing the object file.  */
1879   vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1880                          H_GET_DATA_SIZE (&headers),
1881                          H_GET_BSS_SIZE (&headers),
1882                          text_frag_root, data_frag_root);
1883 #endif /* OBJ_VMS  */
1884 #else /* BFD_ASSEMBLER  */
1885
1886   /* Resolve symbol values.  This needs to be done before processing
1887      the relocations.  */
1888   if (symbol_rootP)
1889     {
1890       symbolS *symp;
1891
1892       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1893         resolve_symbol_value (symp);
1894     }
1895   resolve_local_symbol_values ();
1896
1897   PROGRESS (1);
1898
1899 #ifdef tc_frob_file_before_adjust
1900   tc_frob_file_before_adjust ();
1901 #endif
1902 #ifdef obj_frob_file_before_adjust
1903   obj_frob_file_before_adjust ();
1904 #endif
1905
1906   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1907
1908 #ifdef tc_frob_file_before_fix
1909   tc_frob_file_before_fix ();
1910 #endif
1911 #ifdef obj_frob_file_before_fix
1912   obj_frob_file_before_fix ();
1913 #endif
1914
1915   bfd_map_over_sections (stdoutput, fix_segment, (char *) 0);
1916
1917   /* Set up symbol table, and write it out.  */
1918   if (symbol_rootP)
1919     {
1920       symbolS *symp;
1921
1922       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1923         {
1924           int punt = 0;
1925           const char *name;
1926
1927           if (symbol_mri_common_p (symp))
1928             {
1929               if (S_IS_EXTERNAL (symp))
1930                 as_bad (_("%s: global symbols not supported in common sections"),
1931                         S_GET_NAME (symp));
1932               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1933               continue;
1934             }
1935
1936           name = S_GET_NAME (symp);
1937           if (name)
1938             {
1939               const char *name2 =
1940                 decode_local_label_name ((char *) S_GET_NAME (symp));
1941               /* They only differ if `name' is a fb or dollar local
1942                  label name.  */
1943               if (name2 != name && ! S_IS_DEFINED (symp))
1944                 as_bad (_("local label `%s' is not defined"), name2);
1945             }
1946
1947           /* Do it again, because adjust_reloc_syms might introduce
1948              more symbols.  They'll probably only be section symbols,
1949              but they'll still need to have the values computed.  */
1950           resolve_symbol_value (symp);
1951
1952           /* Skip symbols which were equated to undefined or common
1953              symbols.  */
1954           if (symbol_equated_reloc_p (symp))
1955             {
1956               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1957               continue;
1958             }
1959
1960           /* So far, common symbols have been treated like undefined symbols.
1961              Put them in the common section now.  */
1962           if (S_IS_DEFINED (symp) == 0
1963               && S_GET_VALUE (symp) != 0)
1964             S_SET_SEGMENT (symp, bfd_com_section_ptr);
1965 #if 0
1966           printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1967                   S_GET_NAME (symp), symp,
1968                   S_GET_VALUE (symp),
1969                   symbol_get_bfdsym (symp)->flags,
1970                   segment_name (S_GET_SEGMENT (symp)));
1971 #endif
1972
1973 #ifdef obj_frob_symbol
1974           obj_frob_symbol (symp, punt);
1975 #endif
1976 #ifdef tc_frob_symbol
1977           if (! punt || symbol_used_in_reloc_p (symp))
1978             tc_frob_symbol (symp, punt);
1979 #endif
1980
1981           /* If we don't want to keep this symbol, splice it out of
1982              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
1983              want section symbols.  Otherwise, we skip local symbols
1984              and symbols that the frob_symbol macros told us to punt,
1985              but we keep such symbols if they are used in relocs.  */
1986           if (symp == abs_section_sym
1987               || (! EMIT_SECTION_SYMBOLS
1988                   && symbol_section_p (symp))
1989               /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
1990                  opposites.  Sometimes the former checks flags and the
1991                  latter examines the name...  */
1992               || (!S_IS_EXTERN (symp)
1993                   && (punt || S_IS_LOCAL (symp))
1994                   && ! symbol_used_in_reloc_p (symp)))
1995             {
1996               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1997
1998               /* After symbol_remove, symbol_next(symp) still returns
1999                  the one that came after it in the chain.  So we don't
2000                  need to do any extra cleanup work here.  */
2001               continue;
2002             }
2003
2004           /* Make sure we really got a value for the symbol.  */
2005           if (! symbol_resolved_p (symp))
2006             {
2007               as_bad (_("can't resolve value for symbol `%s'"),
2008                       S_GET_NAME (symp));
2009               symbol_mark_resolved (symp);
2010             }
2011
2012           /* Set the value into the BFD symbol.  Up til now the value
2013              has only been kept in the gas symbolS struct.  */
2014           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2015         }
2016     }
2017
2018   PROGRESS (1);
2019
2020   /* Now do any format-specific adjustments to the symbol table, such
2021      as adding file symbols.  */
2022 #ifdef tc_adjust_symtab
2023   tc_adjust_symtab ();
2024 #endif
2025 #ifdef obj_adjust_symtab
2026   obj_adjust_symtab ();
2027 #endif
2028
2029   /* Now that all the sizes are known, and contents correct, we can
2030      start writing to the file.  */
2031   set_symtab ();
2032
2033   /* If *_frob_file changes the symbol value at this point, it is
2034      responsible for moving the changed value into symp->bsym->value
2035      as well.  Hopefully all symbol value changing can be done in
2036      *_frob_symbol.  */
2037 #ifdef tc_frob_file
2038   tc_frob_file ();
2039 #endif
2040 #ifdef obj_frob_file
2041   obj_frob_file ();
2042 #endif
2043
2044   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2045
2046 #ifdef tc_frob_file_after_relocs
2047   tc_frob_file_after_relocs ();
2048 #endif
2049 #ifdef obj_frob_file_after_relocs
2050   obj_frob_file_after_relocs ();
2051 #endif
2052
2053   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2054 #endif /* BFD_ASSEMBLER  */
2055 }
2056 #endif /* ! BFD  */
2057
2058 #ifdef TC_GENERIC_RELAX_TABLE
2059
2060 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2061
2062 long
2063 relax_frag (segment, fragP, stretch)
2064      segT segment;
2065      fragS *fragP;
2066      long stretch;
2067 {
2068   const relax_typeS *this_type;
2069   const relax_typeS *start_type;
2070   relax_substateT next_state;
2071   relax_substateT this_state;
2072   long growth;
2073   offsetT aim;
2074   addressT target;
2075   addressT address;
2076   symbolS *symbolP;
2077   const relax_typeS *table;
2078
2079   target = fragP->fr_offset;
2080   address = fragP->fr_address;
2081   table = TC_GENERIC_RELAX_TABLE;
2082   this_state = fragP->fr_subtype;
2083   start_type = this_type = table + this_state;
2084   symbolP = fragP->fr_symbol;
2085
2086   if (symbolP)
2087     {
2088       fragS *sym_frag;
2089
2090       sym_frag = symbol_get_frag (symbolP);
2091
2092 #ifndef DIFF_EXPR_OK
2093 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2094       know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2095             || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2096             || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2097             || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2098 #endif
2099       know (sym_frag != NULL);
2100 #endif
2101       know (S_GET_SEGMENT (symbolP) != absolute_section
2102             || sym_frag == &zero_address_frag);
2103       target += S_GET_VALUE (symbolP);
2104
2105       /* If frag has yet to be reached on this pass,
2106          assume it will move by STRETCH just as we did.
2107          If this is not so, it will be because some frag
2108          between grows, and that will force another pass.  */
2109
2110       if (stretch != 0
2111           && sym_frag->relax_marker != fragP->relax_marker
2112           && S_GET_SEGMENT (symbolP) == segment)
2113         {
2114           target += stretch;
2115         }
2116     }
2117
2118   aim = target - address - fragP->fr_fix;
2119 #ifdef TC_PCREL_ADJUST
2120   /* Currently only the ns32k family needs this.  */
2121   aim += TC_PCREL_ADJUST (fragP);
2122 /* #else */
2123   /* This machine doesn't want to use pcrel_adjust.
2124      In that case, pcrel_adjust should be zero.  */
2125 #if 0
2126   assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
2127 #endif
2128 #endif
2129 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE  */
2130   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2131 #endif
2132
2133   if (aim < 0)
2134     {
2135       /* Look backwards.  */
2136       for (next_state = this_type->rlx_more; next_state;)
2137         if (aim >= this_type->rlx_backward)
2138           next_state = 0;
2139         else
2140           {
2141             /* Grow to next state.  */
2142             this_state = next_state;
2143             this_type = table + this_state;
2144             next_state = this_type->rlx_more;
2145           }
2146     }
2147   else
2148     {
2149       /* Look forwards.  */
2150       for (next_state = this_type->rlx_more; next_state;)
2151         if (aim <= this_type->rlx_forward)
2152           next_state = 0;
2153         else
2154           {
2155             /* Grow to next state.  */
2156             this_state = next_state;
2157             this_type = table + this_state;
2158             next_state = this_type->rlx_more;
2159           }
2160     }
2161
2162   growth = this_type->rlx_length - start_type->rlx_length;
2163   if (growth != 0)
2164     fragP->fr_subtype = this_state;
2165   return growth;
2166 }
2167
2168 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2169
2170 /* Relax_align. Advance location counter to next address that has 'alignment'
2171    lowest order bits all 0s, return size of adjustment made.  */
2172 static relax_addressT
2173 relax_align (address, alignment)
2174      register relax_addressT address;   /* Address now.  */
2175      register int alignment;    /* Alignment (binary).  */
2176 {
2177   relax_addressT mask;
2178   relax_addressT new_address;
2179
2180   mask = ~((~0) << alignment);
2181   new_address = (address + mask) & (~mask);
2182 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2183   if (linkrelax)
2184     /* We must provide lots of padding, so the linker can discard it
2185        when needed.  The linker will not add extra space, ever.  */
2186     new_address += (1 << alignment);
2187 #endif
2188   return (new_address - address);
2189 }
2190
2191 /* Now we have a segment, not a crowd of sub-segments, we can make
2192    fr_address values.
2193
2194    Relax the frags.
2195
2196    After this, all frags in this segment have addresses that are correct
2197    within the segment. Since segments live in different file addresses,
2198    these frag addresses may not be the same as final object-file
2199    addresses.  */
2200
2201 int
2202 relax_segment (segment_frag_root, segment)
2203      struct frag *segment_frag_root;
2204      segT segment;
2205 {
2206   register struct frag *fragP;
2207   register relax_addressT address;
2208   int ret;
2209
2210 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2211   know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2212 #endif
2213   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2214   subseg_change (segment, 0);
2215
2216   /* For each frag in segment: count and store  (a 1st guess of)
2217      fr_address.  */
2218   address = 0;
2219   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2220     {
2221       fragP->relax_marker = 0;
2222       fragP->fr_address = address;
2223       address += fragP->fr_fix;
2224
2225       switch (fragP->fr_type)
2226         {
2227         case rs_fill:
2228           address += fragP->fr_offset * fragP->fr_var;
2229           break;
2230
2231         case rs_align:
2232         case rs_align_code:
2233         case rs_align_test:
2234           {
2235             addressT offset = relax_align (address, (int) fragP->fr_offset);
2236
2237             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2238               offset = 0;
2239
2240             if (offset % fragP->fr_var != 0)
2241               {
2242                 as_bad_where (fragP->fr_file, fragP->fr_line,
2243                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2244                               (unsigned long) offset, (long) fragP->fr_var);
2245                 offset -= (offset % fragP->fr_var);
2246               }
2247
2248             address += offset;
2249           }
2250           break;
2251
2252         case rs_org:
2253         case rs_space:
2254           /* Assume .org is nugatory. It will grow with 1st relax.  */
2255           break;
2256
2257         case rs_machine_dependent:
2258           /* If fr_symbol is an expression, this call to
2259              resolve_symbol_value sets up the correct segment, which will
2260              likely be needed in md_estimate_size_before_relax.  */
2261           if (fragP->fr_symbol)
2262             resolve_symbol_value (fragP->fr_symbol);
2263
2264           address += md_estimate_size_before_relax (fragP, segment);
2265           break;
2266
2267 #ifndef WORKING_DOT_WORD
2268           /* Broken words don't concern us yet.  */
2269         case rs_broken_word:
2270           break;
2271 #endif
2272
2273         case rs_leb128:
2274           /* Initial guess is always 1; doing otherwise can result in
2275              stable solutions that are larger than the minimum.  */
2276           address += fragP->fr_offset = 1;
2277           break;
2278
2279         case rs_cfa:
2280           address += eh_frame_estimate_size_before_relax (fragP);
2281           break;
2282
2283         case rs_dwarf2dbg:
2284           address += dwarf2dbg_estimate_size_before_relax (fragP);
2285           break;
2286
2287         default:
2288           BAD_CASE (fragP->fr_type);
2289           break;
2290         }
2291     }
2292
2293   /* Do relax().  */
2294   {
2295     long stretch;       /* May be any size, 0 or negative.  */
2296     /* Cumulative number of addresses we have relaxed this pass.
2297        We may have relaxed more than one address.  */
2298     int stretched;      /* Have we stretched on this pass?  */
2299     /* This is 'cuz stretch may be zero, when, in fact some piece of code
2300        grew, and another shrank.  If a branch instruction doesn't fit anymore,
2301        we could be scrod.  */
2302
2303     do
2304       {
2305         stretch = 0;
2306         stretched = 0;
2307
2308         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2309           {
2310             long growth = 0;
2311             addressT was_address;
2312             offsetT offset;
2313             symbolS *symbolP;
2314
2315             fragP->relax_marker ^= 1;
2316             was_address = fragP->fr_address;
2317             address = fragP->fr_address += stretch;
2318             symbolP = fragP->fr_symbol;
2319             offset = fragP->fr_offset;
2320
2321             switch (fragP->fr_type)
2322               {
2323               case rs_fill:     /* .fill never relaxes.  */
2324                 growth = 0;
2325                 break;
2326
2327 #ifndef WORKING_DOT_WORD
2328                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2329                    for it I do not want to write it.  I do not want to have
2330                    anything to do with it.  This is not the proper way to
2331                    implement this misfeature.  */
2332               case rs_broken_word:
2333                 {
2334                   struct broken_word *lie;
2335                   struct broken_word *untruth;
2336
2337                   /* Yes this is ugly (storing the broken_word pointer
2338                      in the symbol slot).  Still, this whole chunk of
2339                      code is ugly, and I don't feel like doing anything
2340                      about it.  Think of it as stubbornness in action.  */
2341                   growth = 0;
2342                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2343                        lie && lie->dispfrag == fragP;
2344                        lie = lie->next_broken_word)
2345                     {
2346
2347                       if (lie->added)
2348                         continue;
2349
2350                       offset = (S_GET_VALUE (lie->add)
2351                                 + lie->addnum
2352                                 - S_GET_VALUE (lie->sub));
2353                       if (offset <= -32768 || offset >= 32767)
2354                         {
2355                           if (flag_warn_displacement)
2356                             {
2357                               char buf[50];
2358                               sprint_value (buf, (addressT) lie->addnum);
2359                               as_warn_where (fragP->fr_file, fragP->fr_line,
2360                                              _(".word %s-%s+%s didn't fit"),
2361                                              S_GET_NAME (lie->add),
2362                                              S_GET_NAME (lie->sub),
2363                                              buf);
2364                             }
2365                           lie->added = 1;
2366                           if (fragP->fr_subtype == 0)
2367                             {
2368                               fragP->fr_subtype++;
2369                               growth += md_short_jump_size;
2370                             }
2371                           for (untruth = lie->next_broken_word;
2372                                untruth && untruth->dispfrag == lie->dispfrag;
2373                                untruth = untruth->next_broken_word)
2374                             if ((symbol_get_frag (untruth->add)
2375                                  == symbol_get_frag (lie->add))
2376                                 && (S_GET_VALUE (untruth->add)
2377                                     == S_GET_VALUE (lie->add)))
2378                               {
2379                                 untruth->added = 2;
2380                                 untruth->use_jump = lie;
2381                               }
2382                           growth += md_long_jump_size;
2383                         }
2384                     }
2385
2386                   break;
2387                 }               /* case rs_broken_word  */
2388 #endif
2389               case rs_align:
2390               case rs_align_code:
2391               case rs_align_test:
2392                 {
2393                   addressT oldoff, newoff;
2394
2395                   oldoff = relax_align (was_address + fragP->fr_fix,
2396                                         (int) offset);
2397                   newoff = relax_align (address + fragP->fr_fix,
2398                                         (int) offset);
2399
2400                   if (fragP->fr_subtype != 0)
2401                     {
2402                       if (oldoff > fragP->fr_subtype)
2403                         oldoff = 0;
2404                       if (newoff > fragP->fr_subtype)
2405                         newoff = 0;
2406                     }
2407
2408                   growth = newoff - oldoff;
2409                 }
2410                 break;
2411
2412               case rs_org:
2413                 {
2414                   addressT target = offset;
2415                   addressT after;
2416
2417                   if (symbolP)
2418                     {
2419 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2420                       know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2421                             || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2422                             || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2423                             || S_GET_SEGMENT (symbolP) == SEG_BSS);
2424                       know (symbolP->sy_frag);
2425                       know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2426                             || (symbolP->sy_frag == &zero_address_frag));
2427 #endif
2428                       /* Convert from an actual address to an octet offset
2429                          into the section.  Here it is assumed that the
2430                          section's VMA is zero, and can omit subtracting it
2431                          from the symbol's value to get the address offset.  */
2432                       know (S_GET_SECTION (symbolP)->vma == 0);
2433                       target += S_GET_VALUE (symbolP) * OCTETS_PER_BYTE;
2434                     }
2435
2436                   know (fragP->fr_next);
2437                   after = fragP->fr_next->fr_address;
2438                   growth = target - after;
2439                   if (growth < 0)
2440                     {
2441                       /* Growth may be negative, but variable part of frag
2442                          cannot have fewer than 0 chars.  That is, we can't
2443                          .org backwards.  */
2444                       as_bad_where (fragP->fr_file, fragP->fr_line,
2445                                     _("attempt to .org backwards"));
2446
2447                       /* We've issued an error message.  Change the
2448                          frag to avoid cascading errors.  */
2449                       fragP->fr_type = rs_align;
2450                       fragP->fr_subtype = 0;
2451                       fragP->fr_offset = 0;
2452                       fragP->fr_fix = after - address;
2453                       growth = stretch;
2454                     }
2455
2456                   /* This is an absolute growth factor  */
2457                   growth -= stretch;
2458                   break;
2459                 }
2460
2461               case rs_space:
2462                 growth = 0;
2463                 if (symbolP)
2464                   {
2465                     offsetT amount;
2466
2467                     amount = S_GET_VALUE (symbolP);
2468                     if (S_GET_SEGMENT (symbolP) != absolute_section
2469                         || S_IS_COMMON (symbolP)
2470                         || ! S_IS_DEFINED (symbolP))
2471                       {
2472                         as_bad_where (fragP->fr_file, fragP->fr_line,
2473                                       _(".space specifies non-absolute value"));
2474                         /* Prevent repeat of this error message.  */
2475                         fragP->fr_symbol = 0;
2476                       }
2477                     else if (amount < 0)
2478                       {
2479                         as_warn_where (fragP->fr_file, fragP->fr_line,
2480                                        _(".space or .fill with negative value, ignored"));
2481                         fragP->fr_symbol = 0;
2482                       }
2483                     else
2484                       growth = (was_address + fragP->fr_fix + amount
2485                                 - fragP->fr_next->fr_address);
2486                   }
2487                 break;
2488
2489               case rs_machine_dependent:
2490 #ifdef md_relax_frag
2491                 growth = md_relax_frag (segment, fragP, stretch);
2492 #else
2493 #ifdef TC_GENERIC_RELAX_TABLE
2494                 /* The default way to relax a frag is to look through
2495                    TC_GENERIC_RELAX_TABLE.  */
2496                 growth = relax_frag (segment, fragP, stretch);
2497 #endif /* TC_GENERIC_RELAX_TABLE  */
2498 #endif
2499                 break;
2500
2501               case rs_leb128:
2502                 {
2503                   valueT value;
2504                   int size;
2505
2506                   value = resolve_symbol_value (fragP->fr_symbol);
2507                   size = sizeof_leb128 (value, fragP->fr_subtype);
2508                   growth = size - fragP->fr_offset;
2509                   fragP->fr_offset = size;
2510                 }
2511                 break;
2512
2513               case rs_cfa:
2514                 growth = eh_frame_relax_frag (fragP);
2515                 break;
2516
2517               case rs_dwarf2dbg:
2518                 growth = dwarf2dbg_relax_frag (fragP);
2519                 break;
2520
2521               default:
2522                 BAD_CASE (fragP->fr_type);
2523                 break;
2524               }
2525             if (growth)
2526               {
2527                 stretch += growth;
2528                 stretched = 1;
2529               }
2530           }                     /* For each frag in the segment.  */
2531       }
2532     while (stretched);          /* Until nothing further to relax.  */
2533   }                             /* do_relax  */
2534
2535   ret = 0;
2536   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2537     if (fragP->last_fr_address != fragP->fr_address)
2538       {
2539         fragP->last_fr_address = fragP->fr_address;
2540         ret = 1;
2541       }
2542   return ret;
2543 }
2544
2545 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2546
2547 /* fixup_segment()
2548
2549    Go through all the fixS's in a segment and see which ones can be
2550    handled now.  (These consist of fixS where we have since discovered
2551    the value of a symbol, or the address of the frag involved.)
2552    For each one, call md_apply_fix3 to put the fix into the frag data.
2553
2554    Result is a count of how many relocation structs will be needed to
2555    handle the remaining fixS's that we couldn't completely handle here.
2556    These will be output later by emit_relocations().  */
2557
2558 static long
2559 fixup_segment (fixP, this_segment)
2560      fixS *fixP;
2561      segT this_segment;
2562 {
2563   long seg_reloc_count = 0;
2564   valueT add_number;
2565   fragS *fragP;
2566   segT add_symbol_segment = absolute_section;
2567
2568   if (fixP != NULL && abs_section_sym == NULL)
2569     {
2570 #ifndef BFD_ASSEMBLER
2571       abs_section_sym = &abs_symbol;
2572 #else
2573       abs_section_sym = section_symbol (absolute_section);
2574 #endif
2575     }
2576
2577   /* If the linker is doing the relaxing, we must not do any fixups.
2578
2579      Well, strictly speaking that's not true -- we could do any that
2580      are PC-relative and don't cross regions that could change size.
2581      And for the i960 we might be able to turn callx/callj into bal
2582      anyways in cases where we know the maximum displacement.  */
2583   if (linkrelax && TC_LINKRELAX_FIXUP (this_segment))
2584     {
2585       for (; fixP; fixP = fixP->fx_next)
2586         if (!fixP->fx_done)
2587           {
2588             if (fixP->fx_addsy == NULL)
2589               {
2590                 /* There was no symbol required by this relocation.
2591                    However, BFD doesn't really handle relocations
2592                    without symbols well. So fake up a local symbol in
2593                    the absolute section.  */
2594                 fixP->fx_addsy = abs_section_sym;
2595               }
2596             symbol_mark_used_in_reloc (fixP->fx_addsy);
2597             if (fixP->fx_subsy != NULL)
2598               symbol_mark_used_in_reloc (fixP->fx_subsy);
2599             seg_reloc_count++;
2600           }
2601       TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2602       return seg_reloc_count;
2603     }
2604
2605   for (; fixP; fixP = fixP->fx_next)
2606     {
2607 #ifdef DEBUG5
2608       fprintf (stderr, "\nprocessing fixup:\n");
2609       print_fixup (fixP);
2610 #endif
2611
2612       fragP = fixP->fx_frag;
2613       know (fragP);
2614 #ifdef TC_VALIDATE_FIX
2615       TC_VALIDATE_FIX (fixP, this_segment, skip);
2616 #endif
2617       add_number = fixP->fx_offset;
2618
2619       if (fixP->fx_addsy != NULL
2620           && symbol_mri_common_p (fixP->fx_addsy))
2621         {
2622           know (fixP->fx_addsy->sy_value.X_op == O_symbol);
2623           add_number += S_GET_VALUE (fixP->fx_addsy);
2624           fixP->fx_offset = add_number;
2625           fixP->fx_addsy
2626             = symbol_get_value_expression (fixP->fx_addsy)->X_add_symbol;
2627         }
2628
2629       if (fixP->fx_addsy != NULL)
2630         add_symbol_segment = S_GET_SEGMENT (fixP->fx_addsy);
2631
2632       if (fixP->fx_subsy != NULL)
2633         {
2634           segT sub_symbol_segment;
2635           resolve_symbol_value (fixP->fx_subsy);
2636           sub_symbol_segment = S_GET_SEGMENT (fixP->fx_subsy);
2637           if (fixP->fx_addsy != NULL
2638               && sub_symbol_segment == add_symbol_segment
2639               && !TC_FORCE_RELOCATION_SUB_SAME (fixP, add_symbol_segment))
2640             {
2641               add_number += S_GET_VALUE (fixP->fx_addsy);
2642               add_number -= S_GET_VALUE (fixP->fx_subsy);
2643               fixP->fx_offset = add_number;
2644               /* If the back-end code has selected a pc-relative
2645                  reloc, adjust the value to be pc-relative.  */
2646               if (1
2647 #ifdef TC_M68K
2648                   /* See the comment below about 68k weirdness.  */
2649                   && 0
2650 #endif
2651                   && fixP->fx_pcrel)
2652                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2653               fixP->fx_addsy = NULL;
2654               fixP->fx_subsy = NULL;
2655               fixP->fx_pcrel = 0;
2656             }
2657           else if (sub_symbol_segment == absolute_section
2658                    && !TC_FORCE_RELOCATION_SUB_ABS (fixP))
2659             {
2660               add_number -= S_GET_VALUE (fixP->fx_subsy);
2661               fixP->fx_offset = add_number;
2662               fixP->fx_subsy = NULL;
2663             }
2664           else if (sub_symbol_segment == this_segment
2665                    && !TC_FORCE_RELOCATION_SUB_LOCAL (fixP))
2666             {
2667               add_number -= S_GET_VALUE (fixP->fx_subsy);
2668               fixP->fx_offset = (add_number + fixP->fx_dot_value
2669                                  + fixP->fx_frag->fr_address);
2670
2671               /* Make it pc-relative.  If the back-end code has not
2672                  selected a pc-relative reloc, cancel the adjustment
2673                  we do later on all pc-relative relocs.  */
2674               if (0
2675 #ifdef TC_M68K
2676                   /* Do this for m68k even if it's already described
2677                      as pc-relative.  On the m68k, an operand of
2678                      "pc@(foo-.-2)" should address "foo" in a
2679                      pc-relative mode.  */
2680                   || 1
2681 #endif
2682                   || !fixP->fx_pcrel)
2683                 add_number += MD_PCREL_FROM_SECTION (fixP, this_segment);
2684               fixP->fx_subsy = NULL;
2685               fixP->fx_pcrel = 1;
2686             }
2687           else if (!TC_VALIDATE_FIX_SUB (fixP))
2688             {
2689               as_bad_where (fixP->fx_file, fixP->fx_line,
2690                             _("can't resolve `%s' {%s section} - `%s' {%s section}"),
2691                             fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : "0",
2692                             segment_name (add_symbol_segment),
2693                             S_GET_NAME (fixP->fx_subsy),
2694                             segment_name (sub_symbol_segment));
2695             }
2696         }
2697
2698       if (fixP->fx_addsy)
2699         {
2700           if (add_symbol_segment == this_segment
2701               && !TC_FORCE_RELOCATION_LOCAL (fixP))
2702             {
2703               /* This fixup was made when the symbol's segment was
2704                  SEG_UNKNOWN, but it is now in the local segment.
2705                  So we know how to do the address without relocation.  */
2706               add_number += S_GET_VALUE (fixP->fx_addsy);
2707               fixP->fx_offset = add_number;
2708               if (fixP->fx_pcrel)
2709                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2710               fixP->fx_addsy = NULL;
2711               fixP->fx_pcrel = 0;
2712             }
2713           else if (add_symbol_segment == absolute_section
2714                    && !TC_FORCE_RELOCATION_ABS (fixP))
2715             {
2716               add_number += S_GET_VALUE (fixP->fx_addsy);
2717               fixP->fx_offset = add_number;
2718               fixP->fx_addsy = NULL;
2719             }
2720           else if (add_symbol_segment != undefined_section
2721 #ifdef BFD_ASSEMBLER
2722                    && ! bfd_is_com_section (add_symbol_segment)
2723 #endif
2724                    && MD_APPLY_SYM_VALUE (fixP))
2725             add_number += S_GET_VALUE (fixP->fx_addsy);
2726         }
2727
2728       if (fixP->fx_pcrel)
2729         {
2730           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment);
2731           if (!fixP->fx_done && fixP->fx_addsy == NULL)
2732             {
2733               /* There was no symbol required by this relocation.
2734                  However, BFD doesn't really handle relocations
2735                  without symbols well. So fake up a local symbol in
2736                  the absolute section.  */
2737               fixP->fx_addsy = abs_section_sym;
2738             }
2739         }
2740
2741       if (!fixP->fx_done)
2742         md_apply_fix3 (fixP, &add_number, this_segment);
2743
2744       if (!fixP->fx_done)
2745         {
2746           ++seg_reloc_count;
2747           if (fixP->fx_addsy == NULL)
2748             fixP->fx_addsy = abs_section_sym;
2749           symbol_mark_used_in_reloc (fixP->fx_addsy);
2750           if (fixP->fx_subsy != NULL)
2751             symbol_mark_used_in_reloc (fixP->fx_subsy);
2752         }
2753
2754       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && fixP->fx_size != 0)
2755         {
2756           if (fixP->fx_size < sizeof (valueT))
2757             {
2758               valueT mask;
2759
2760               mask = 0;
2761               mask--;           /* Set all bits to one.  */
2762               mask <<= fixP->fx_size * 8 - (fixP->fx_signed ? 1 : 0);
2763               if ((add_number & mask) != 0 && (add_number & mask) != mask)
2764                 {
2765                   char buf[50], buf2[50];
2766                   sprint_value (buf, fragP->fr_address + fixP->fx_where);
2767                   if (add_number > 1000)
2768                     sprint_value (buf2, add_number);
2769                   else
2770                     sprintf (buf2, "%ld", (long) add_number);
2771                   as_bad_where (fixP->fx_file, fixP->fx_line,
2772                                 _("value of %s too large for field of %d bytes at %s"),
2773                                 buf2, fixP->fx_size, buf);
2774                 } /* Generic error checking.  */
2775             }
2776 #ifdef WARN_SIGNED_OVERFLOW_WORD
2777           /* Warn if a .word value is too large when treated as a signed
2778              number.  We already know it is not too negative.  This is to
2779              catch over-large switches generated by gcc on the 68k.  */
2780           if (!flag_signed_overflow_ok
2781               && fixP->fx_size == 2
2782               && add_number > 0x7fff)
2783             as_bad_where (fixP->fx_file, fixP->fx_line,
2784                           _("signed .word overflow; switch may be too large; %ld at 0x%lx"),
2785                           (long) add_number,
2786                           (long) (fragP->fr_address + fixP->fx_where));
2787 #endif
2788         }                       /* Not a bit fix.  */
2789
2790 #ifdef TC_VALIDATE_FIX
2791     skip:  ATTRIBUTE_UNUSED_LABEL
2792       ;
2793 #endif
2794 #ifdef DEBUG5
2795       fprintf (stderr, "result:\n");
2796       print_fixup (fixP);
2797 #endif
2798     }                           /* For each fixS in this segment.  */
2799
2800   TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2801   return seg_reloc_count;
2802 }
2803
2804 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2805
2806 void
2807 number_to_chars_bigendian (buf, val, n)
2808      char *buf;
2809      valueT val;
2810      int n;
2811 {
2812   if (n <= 0)
2813     abort ();
2814   while (n--)
2815     {
2816       buf[n] = val & 0xff;
2817       val >>= 8;
2818     }
2819 }
2820
2821 void
2822 number_to_chars_littleendian (buf, val, n)
2823      char *buf;
2824      valueT val;
2825      int n;
2826 {
2827   if (n <= 0)
2828     abort ();
2829   while (n--)
2830     {
2831       *buf++ = val & 0xff;
2832       val >>= 8;
2833     }
2834 }
2835
2836 void
2837 write_print_statistics (file)
2838      FILE *file;
2839 {
2840   fprintf (file, "fixups: %d\n", n_fixups);
2841 }
2842
2843 /* For debugging.  */
2844 extern int indent_level;
2845
2846 void
2847 print_fixup (fixp)
2848      fixS *fixp;
2849 {
2850   indent_level = 1;
2851   fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2852   if (fixp->fx_pcrel)
2853     fprintf (stderr, " pcrel");
2854   if (fixp->fx_pcrel_adjust)
2855     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2856   if (fixp->fx_im_disp)
2857     {
2858 #ifdef TC_NS32K
2859       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2860 #else
2861       fprintf (stderr, " im_disp");
2862 #endif
2863     }
2864   if (fixp->fx_tcbit)
2865     fprintf (stderr, " tcbit");
2866   if (fixp->fx_done)
2867     fprintf (stderr, " done");
2868   fprintf (stderr, "\n    size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
2869            fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
2870            (long) fixp->fx_offset, (long) fixp->fx_addnumber);
2871 #ifdef BFD_ASSEMBLER
2872   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
2873            fixp->fx_r_type);
2874 #else
2875 #ifdef NEED_FX_R_TYPE
2876   fprintf (stderr, " r_type=%d", fixp->fx_r_type);
2877 #endif
2878 #endif
2879   if (fixp->fx_addsy)
2880     {
2881       fprintf (stderr, "\n   +<");
2882       print_symbol_value_1 (stderr, fixp->fx_addsy);
2883       fprintf (stderr, ">");
2884     }
2885   if (fixp->fx_subsy)
2886     {
2887       fprintf (stderr, "\n   -<");
2888       print_symbol_value_1 (stderr, fixp->fx_subsy);
2889       fprintf (stderr, ">");
2890     }
2891   fprintf (stderr, "\n");
2892 #ifdef TC_FIX_DATA_PRINT
2893   TC_FIX_DATA_PRINT (stderr, fixp);
2894 #endif
2895 }