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