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