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 BFD_ASSEMBLER
1754             to_addr -= symbol_get_frag (lie->sub)->fr_address;
1755 #endif
1756 #ifdef TC_CHECK_ADJUSTED_BROKEN_DOT_WORD
1757             TC_CHECK_ADJUSTED_BROKEN_DOT_WORD (to_addr, lie);
1758 #endif
1759             md_number_to_chars (lie->word_goes_here, to_addr, 2);
1760             for (untruth = lie->next_broken_word;
1761                  untruth && untruth->dispfrag == fragP;
1762                  untruth = untruth->next_broken_word)
1763               {
1764                 if (untruth->use_jump == lie)
1765                   md_number_to_chars (untruth->word_goes_here, to_addr, 2);
1766               }
1767
1768             /* Install the long jump.  */
1769             /* This is a long jump from table_ptr+0 to the final target.  */
1770             from_addr = table_addr;
1771             to_addr = S_GET_VALUE (lie->add) + lie->addnum;
1772 #ifdef BFD_ASSEMBLER
1773             to_addr += symbol_get_frag (lie->add)->fr_address;
1774 #endif
1775             md_create_long_jump (table_ptr, from_addr, to_addr, lie->dispfrag,
1776                                  lie->add);
1777             table_ptr += md_long_jump_size;
1778             table_addr += md_long_jump_size;
1779           }
1780       }
1781   }
1782 #endif /* not WORKING_DOT_WORD  */
1783
1784 #ifndef BFD_ASSEMBLER
1785 #ifndef OBJ_VMS
1786   {                             /* not vms  */
1787     char *the_object_file;
1788     long object_file_size;
1789     /* Scan every FixS performing fixups. We had to wait until now to
1790        do this because md_convert_frag() may have made some fixSs.  */
1791     int trsize, drsize;
1792
1793     subseg_change (SEG_TEXT, 0);
1794     trsize = md_reloc_size * fixup_segment (text_fix_root, SEG_TEXT);
1795     subseg_change (SEG_DATA, 0);
1796     drsize = md_reloc_size * fixup_segment (data_fix_root, SEG_DATA);
1797     H_SET_RELOCATION_SIZE (&headers, trsize, drsize);
1798
1799     /* FIXME: Move this stuff into the pre-write-hook.  */
1800     H_SET_MAGIC_NUMBER (&headers, magic_number_for_object_file);
1801     H_SET_ENTRY_POINT (&headers, 0);
1802
1803     obj_pre_write_hook (&headers);      /* Extra coff stuff.  */
1804
1805     object_file_size = H_GET_FILE_SIZE (&headers);
1806     next_object_file_charP = the_object_file = xmalloc (object_file_size);
1807
1808     output_file_create (out_file_name);
1809
1810     obj_header_append (&next_object_file_charP, &headers);
1811
1812     know ((next_object_file_charP - the_object_file)
1813           == H_GET_HEADER_SIZE (&headers));
1814
1815     /* Emit code.  */
1816     for (fragP = text_frag_root; fragP; fragP = fragP->fr_next)
1817       {
1818         register long count;
1819         register char *fill_literal;
1820         register long fill_size;
1821
1822         PROGRESS (1);
1823         know (fragP->fr_type == rs_fill);
1824         append (&next_object_file_charP, fragP->fr_literal,
1825                 (unsigned long) fragP->fr_fix);
1826         fill_literal = fragP->fr_literal + fragP->fr_fix;
1827         fill_size = fragP->fr_var;
1828         know (fragP->fr_offset >= 0);
1829
1830         for (count = fragP->fr_offset; count; count--)
1831           append (&next_object_file_charP, fill_literal,
1832                   (unsigned long) fill_size);
1833       }
1834
1835     know ((next_object_file_charP - the_object_file)
1836           == (H_GET_HEADER_SIZE (&headers)
1837               + H_GET_TEXT_SIZE (&headers)
1838               + H_GET_DATA_SIZE (&headers)));
1839
1840     /* Emit relocations.  */
1841     obj_emit_relocations (&next_object_file_charP, text_fix_root,
1842                           (relax_addressT) 0);
1843     know ((next_object_file_charP - the_object_file)
1844           == (H_GET_HEADER_SIZE (&headers)
1845               + H_GET_TEXT_SIZE (&headers)
1846               + H_GET_DATA_SIZE (&headers)
1847               + H_GET_TEXT_RELOCATION_SIZE (&headers)));
1848 #ifdef TC_I960
1849     /* Make addresses in data relocation directives relative to beginning of
1850        first data fragment, not end of last text fragment:  alignment of the
1851        start of the data segment may place a gap between the segments.  */
1852     obj_emit_relocations (&next_object_file_charP, data_fix_root,
1853                           data0_frchainP->frch_root->fr_address);
1854 #else /* TC_I960  */
1855     obj_emit_relocations (&next_object_file_charP, data_fix_root,
1856                           text_last_frag->fr_address);
1857 #endif /* TC_I960  */
1858
1859     know ((next_object_file_charP - the_object_file)
1860           == (H_GET_HEADER_SIZE (&headers)
1861               + H_GET_TEXT_SIZE (&headers)
1862               + H_GET_DATA_SIZE (&headers)
1863               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1864               + H_GET_DATA_RELOCATION_SIZE (&headers)));
1865
1866     /* Emit line number entries.  */
1867     OBJ_EMIT_LINENO (&next_object_file_charP, lineno_rootP, the_object_file);
1868     know ((next_object_file_charP - the_object_file)
1869           == (H_GET_HEADER_SIZE (&headers)
1870               + H_GET_TEXT_SIZE (&headers)
1871               + H_GET_DATA_SIZE (&headers)
1872               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1873               + H_GET_DATA_RELOCATION_SIZE (&headers)
1874               + H_GET_LINENO_SIZE (&headers)));
1875
1876     /* Emit symbols.  */
1877     obj_emit_symbols (&next_object_file_charP, symbol_rootP);
1878     know ((next_object_file_charP - the_object_file)
1879           == (H_GET_HEADER_SIZE (&headers)
1880               + H_GET_TEXT_SIZE (&headers)
1881               + H_GET_DATA_SIZE (&headers)
1882               + H_GET_TEXT_RELOCATION_SIZE (&headers)
1883               + H_GET_DATA_RELOCATION_SIZE (&headers)
1884               + H_GET_LINENO_SIZE (&headers)
1885               + H_GET_SYMBOL_TABLE_SIZE (&headers)));
1886
1887     /* Emit strings.  */
1888     if (string_byte_count > 0)
1889       obj_emit_strings (&next_object_file_charP);
1890
1891 #ifdef BFD_HEADERS
1892     bfd_seek (stdoutput, 0, 0);
1893     bfd_write (the_object_file, 1, object_file_size, stdoutput);
1894 #else
1895
1896     /* Write the data to the file.  */
1897     output_file_append (the_object_file, object_file_size, out_file_name);
1898     free (the_object_file);
1899 #endif
1900   }
1901 #else /* OBJ_VMS  */
1902   /* Now do the VMS-dependent part of writing the object file.  */
1903   vms_write_object_file (H_GET_TEXT_SIZE (&headers),
1904                          H_GET_DATA_SIZE (&headers),
1905                          H_GET_BSS_SIZE (&headers),
1906                          text_frag_root, data_frag_root);
1907 #endif /* OBJ_VMS  */
1908 #else /* BFD_ASSEMBLER  */
1909
1910   /* Resolve symbol values.  This needs to be done before processing
1911      the relocations.  */
1912   if (symbol_rootP)
1913     {
1914       symbolS *symp;
1915
1916       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1917         resolve_symbol_value (symp);
1918     }
1919   resolve_local_symbol_values ();
1920
1921   PROGRESS (1);
1922
1923 #ifdef tc_frob_file_before_adjust
1924   tc_frob_file_before_adjust ();
1925 #endif
1926 #ifdef obj_frob_file_before_adjust
1927   obj_frob_file_before_adjust ();
1928 #endif
1929
1930   bfd_map_over_sections (stdoutput, adjust_reloc_syms, (char *) 0);
1931
1932   /* Set up symbol table, and write it out.  */
1933   if (symbol_rootP)
1934     {
1935       symbolS *symp;
1936
1937       for (symp = symbol_rootP; symp; symp = symbol_next (symp))
1938         {
1939           int punt = 0;
1940           const char *name;
1941
1942           if (symbol_mri_common_p (symp))
1943             {
1944               if (S_IS_EXTERNAL (symp))
1945                 as_bad (_("%s: global symbols not supported in common sections"),
1946                         S_GET_NAME (symp));
1947               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1948               continue;
1949             }
1950
1951           name = S_GET_NAME (symp);
1952           if (name)
1953             {
1954               const char *name2 =
1955                 decode_local_label_name ((char *) S_GET_NAME (symp));
1956               /* They only differ if `name' is a fb or dollar local
1957                  label name.  */
1958               if (name2 != name && ! S_IS_DEFINED (symp))
1959                 as_bad (_("local label %s is not defined"), name2);
1960             }
1961
1962           /* Do it again, because adjust_reloc_syms might introduce
1963              more symbols.  They'll probably only be section symbols,
1964              but they'll still need to have the values computed.  */
1965           resolve_symbol_value (symp);
1966
1967           /* Skip symbols which were equated to undefined or common
1968              symbols.  */
1969           if (symbol_equated_p (symp)
1970               && (! S_IS_DEFINED (symp) || S_IS_COMMON (symp)))
1971             {
1972               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
1973               continue;
1974             }
1975
1976           /* So far, common symbols have been treated like undefined symbols.
1977              Put them in the common section now.  */
1978           if (S_IS_DEFINED (symp) == 0
1979               && S_GET_VALUE (symp) != 0)
1980             S_SET_SEGMENT (symp, bfd_com_section_ptr);
1981 #if 0
1982           printf ("symbol `%s'\n\t@%x: value=%d flags=%x seg=%s\n",
1983                   S_GET_NAME (symp), symp,
1984                   S_GET_VALUE (symp),
1985                   symbol_get_bfdsym (symp)->flags,
1986                   segment_name (S_GET_SEGMENT (symp)));
1987 #endif
1988
1989 #ifdef obj_frob_symbol
1990           obj_frob_symbol (symp, punt);
1991 #endif
1992 #ifdef tc_frob_symbol
1993           if (! punt || symbol_used_in_reloc_p (symp))
1994             tc_frob_symbol (symp, punt);
1995 #endif
1996
1997           /* If we don't want to keep this symbol, splice it out of
1998              the chain now.  If EMIT_SECTION_SYMBOLS is 0, we never
1999              want section symbols.  Otherwise, we skip local symbols
2000              and symbols that the frob_symbol macros told us to punt,
2001              but we keep such symbols if they are used in relocs.  */
2002           if ((! EMIT_SECTION_SYMBOLS
2003                && symbol_section_p (symp))
2004               /* Note that S_IS_EXTERN and S_IS_LOCAL are not always
2005                  opposites.  Sometimes the former checks flags and the
2006                  latter examines the name...  */
2007               || (!S_IS_EXTERN (symp)
2008                   && (S_IS_LOCAL (symp) || punt)
2009                   && ! symbol_used_in_reloc_p (symp)))
2010             {
2011               symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2012
2013               /* After symbol_remove, symbol_next(symp) still returns
2014                  the one that came after it in the chain.  So we don't
2015                  need to do any extra cleanup work here.  */
2016               continue;
2017             }
2018
2019           /* Make sure we really got a value for the symbol.  */
2020           if (! symbol_resolved_p (symp))
2021             {
2022               as_bad (_("can't resolve value for symbol \"%s\""),
2023                       S_GET_NAME (symp));
2024               symbol_mark_resolved (symp);
2025             }
2026
2027           /* Set the value into the BFD symbol.  Up til now the value
2028              has only been kept in the gas symbolS struct.  */
2029           symbol_get_bfdsym (symp)->value = S_GET_VALUE (symp);
2030         }
2031     }
2032
2033   PROGRESS (1);
2034
2035   /* Now do any format-specific adjustments to the symbol table, such
2036      as adding file symbols.  */
2037 #ifdef tc_adjust_symtab
2038   tc_adjust_symtab ();
2039 #endif
2040 #ifdef obj_adjust_symtab
2041   obj_adjust_symtab ();
2042 #endif
2043
2044   /* Now that all the sizes are known, and contents correct, we can
2045      start writing to the file.  */
2046   set_symtab ();
2047
2048   /* If *_frob_file changes the symbol value at this point, it is
2049      responsible for moving the changed value into symp->bsym->value
2050      as well.  Hopefully all symbol value changing can be done in
2051      *_frob_symbol.  */
2052 #ifdef tc_frob_file
2053   tc_frob_file ();
2054 #endif
2055 #ifdef obj_frob_file
2056   obj_frob_file ();
2057 #endif
2058
2059   bfd_map_over_sections (stdoutput, write_relocs, (char *) 0);
2060
2061 #ifdef tc_frob_file_after_relocs
2062   tc_frob_file_after_relocs ();
2063 #endif
2064 #ifdef obj_frob_file_after_relocs
2065   obj_frob_file_after_relocs ();
2066 #endif
2067
2068   bfd_map_over_sections (stdoutput, write_contents, (char *) 0);
2069 #endif /* BFD_ASSEMBLER  */
2070 }
2071 #endif /* ! BFD  */
2072
2073 #ifdef TC_GENERIC_RELAX_TABLE
2074
2075 /* Relax a fragment by scanning TC_GENERIC_RELAX_TABLE.  */
2076
2077 long
2078 relax_frag (segment, fragP, stretch)
2079      segT segment;
2080      fragS *fragP;
2081      long stretch;
2082 {
2083   const relax_typeS *this_type;
2084   const relax_typeS *start_type;
2085   relax_substateT next_state;
2086   relax_substateT this_state;
2087   long growth;
2088   offsetT aim;
2089   addressT target;
2090   addressT address;
2091   symbolS *symbolP;
2092   const relax_typeS *table;
2093
2094   target = fragP->fr_offset;
2095   address = fragP->fr_address;
2096   table = TC_GENERIC_RELAX_TABLE;
2097   this_state = fragP->fr_subtype;
2098   start_type = this_type = table + this_state;
2099   symbolP = fragP->fr_symbol;
2100
2101   if (symbolP)
2102     {
2103       fragS *sym_frag;
2104
2105       sym_frag = symbol_get_frag (symbolP);
2106
2107 #ifndef DIFF_EXPR_OK
2108 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2109       know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2110             || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2111             || (S_GET_SEGMENT (symbolP) == SEG_BSS)
2112             || (S_GET_SEGMENT (symbolP) == SEG_TEXT));
2113 #endif
2114       know (sym_frag != NULL);
2115 #endif
2116       know (!(S_GET_SEGMENT (symbolP) == absolute_section)
2117             || sym_frag == &zero_address_frag);
2118       target += S_GET_VALUE (symbolP) + sym_frag->fr_address;
2119
2120       /* If frag has yet to be reached on this pass,
2121          assume it will move by STRETCH just as we did.
2122          If this is not so, it will be because some frag
2123          between grows, and that will force another pass.  */
2124
2125       if (stretch != 0
2126           && sym_frag->relax_marker != fragP->relax_marker
2127           && S_GET_SEGMENT (symbolP) == segment)
2128         {
2129           target += stretch;
2130         }
2131     }
2132
2133   aim = target - address - fragP->fr_fix;
2134 #ifdef TC_PCREL_ADJUST
2135   /* Currently only the ns32k family needs this.  */
2136   aim += TC_PCREL_ADJUST (fragP);
2137 /* #else */
2138   /* This machine doesn't want to use pcrel_adjust.
2139      In that case, pcrel_adjust should be zero.  */
2140 #if 0
2141   assert (fragP->fr_targ.ns32k.pcrel_adjust == 0);
2142 #endif
2143 #endif
2144 #ifdef md_prepare_relax_scan /* formerly called M68K_AIM_KLUDGE  */
2145   md_prepare_relax_scan (fragP, address, aim, this_state, this_type);
2146 #endif
2147
2148   if (aim < 0)
2149     {
2150       /* Look backwards.  */
2151       for (next_state = this_type->rlx_more; next_state;)
2152         if (aim >= this_type->rlx_backward)
2153           next_state = 0;
2154         else
2155           {
2156             /* Grow to next state.  */
2157             this_state = next_state;
2158             this_type = table + this_state;
2159             next_state = this_type->rlx_more;
2160           }
2161     }
2162   else
2163     {
2164       /* Look forwards.  */
2165       for (next_state = this_type->rlx_more; next_state;)
2166         if (aim <= this_type->rlx_forward)
2167           next_state = 0;
2168         else
2169           {
2170             /* Grow to next state.  */
2171             this_state = next_state;
2172             this_type = table + this_state;
2173             next_state = this_type->rlx_more;
2174           }
2175     }
2176
2177   growth = this_type->rlx_length - start_type->rlx_length;
2178   if (growth != 0)
2179     fragP->fr_subtype = this_state;
2180   return growth;
2181 }
2182
2183 #endif /* defined (TC_GENERIC_RELAX_TABLE)  */
2184
2185 /* Relax_align. Advance location counter to next address that has 'alignment'
2186    lowest order bits all 0s, return size of adjustment made.  */
2187 static relax_addressT
2188 relax_align (address, alignment)
2189      register relax_addressT address;   /* Address now.  */
2190      register int alignment;    /* Alignment (binary).  */
2191 {
2192   relax_addressT mask;
2193   relax_addressT new_address;
2194
2195   mask = ~((~0) << alignment);
2196   new_address = (address + mask) & (~mask);
2197 #ifdef LINKER_RELAXING_SHRINKS_ONLY
2198   if (linkrelax)
2199     /* We must provide lots of padding, so the linker can discard it
2200        when needed.  The linker will not add extra space, ever.  */
2201     new_address += (1 << alignment);
2202 #endif
2203   return (new_address - address);
2204 }
2205
2206 /* Now we have a segment, not a crowd of sub-segments, we can make
2207    fr_address values.
2208
2209    Relax the frags.
2210
2211    After this, all frags in this segment have addresses that are correct
2212    within the segment. Since segments live in different file addresses,
2213    these frag addresses may not be the same as final object-file
2214    addresses.  */
2215
2216 int
2217 relax_segment (segment_frag_root, segment)
2218      struct frag *segment_frag_root;
2219      segT segment;
2220 {
2221   register struct frag *fragP;
2222   register relax_addressT address;
2223   int ret;
2224
2225 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2226   know (segment == SEG_DATA || segment == SEG_TEXT || segment == SEG_BSS);
2227 #endif
2228   /* In case md_estimate_size_before_relax() wants to make fixSs.  */
2229   subseg_change (segment, 0);
2230
2231   /* For each frag in segment: count and store  (a 1st guess of)
2232      fr_address.  */
2233   address = 0;
2234   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2235     {
2236       fragP->relax_marker = 0;
2237       fragP->fr_address = address;
2238       address += fragP->fr_fix;
2239
2240       switch (fragP->fr_type)
2241         {
2242         case rs_fill:
2243           address += fragP->fr_offset * fragP->fr_var;
2244           break;
2245
2246         case rs_align:
2247         case rs_align_code:
2248         case rs_align_test:
2249           {
2250             addressT offset = relax_align (address, (int) fragP->fr_offset);
2251
2252             if (fragP->fr_subtype != 0 && offset > fragP->fr_subtype)
2253               offset = 0;
2254
2255             if (offset % fragP->fr_var != 0)
2256               {
2257                 as_bad_where (fragP->fr_file, fragP->fr_line,
2258                               _("alignment padding (%lu bytes) not a multiple of %ld"),
2259                               (unsigned long) offset, (long) fragP->fr_var);
2260                 offset -= (offset % fragP->fr_var);
2261               }
2262
2263             address += offset;
2264           }
2265           break;
2266
2267         case rs_org:
2268         case rs_space:
2269           /* Assume .org is nugatory. It will grow with 1st relax.  */
2270           break;
2271
2272         case rs_machine_dependent:
2273           address += md_estimate_size_before_relax (fragP, segment);
2274           break;
2275
2276 #ifndef WORKING_DOT_WORD
2277           /* Broken words don't concern us yet.  */
2278         case rs_broken_word:
2279           break;
2280 #endif
2281
2282         case rs_leb128:
2283           /* Initial guess is always 1; doing otherwise can result in
2284              stable solutions that are larger than the minimum.  */
2285           address += fragP->fr_offset = 1;
2286           break;
2287
2288         case rs_cfa:
2289           address += eh_frame_estimate_size_before_relax (fragP);
2290           break;
2291
2292         case rs_dwarf2dbg:
2293           address += dwarf2dbg_estimate_size_before_relax (fragP);
2294           break;
2295
2296         default:
2297           BAD_CASE (fragP->fr_type);
2298           break;
2299         }
2300     }
2301
2302   /* Do relax().  */
2303   {
2304     long stretch;       /* May be any size, 0 or negative.  */
2305     /* Cumulative number of addresses we have relaxed this pass.
2306        We may have relaxed more than one address.  */
2307     int stretched;      /* Have we stretched on this pass?  */
2308     /* This is 'cuz stretch may be zero, when, in fact some piece of code
2309        grew, and another shrank.  If a branch instruction doesn't fit anymore,
2310        we could be scrod.  */
2311
2312     do
2313       {
2314         stretch = 0;
2315         stretched = 0;
2316
2317         for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2318           {
2319             long growth = 0;
2320             addressT was_address;
2321             offsetT offset;
2322             symbolS *symbolP;
2323
2324             fragP->relax_marker ^= 1;
2325             was_address = fragP->fr_address;
2326             address = fragP->fr_address += stretch;
2327             symbolP = fragP->fr_symbol;
2328             offset = fragP->fr_offset;
2329
2330             switch (fragP->fr_type)
2331               {
2332               case rs_fill:     /* .fill never relaxes.  */
2333                 growth = 0;
2334                 break;
2335
2336 #ifndef WORKING_DOT_WORD
2337                 /* JF:  This is RMS's idea.  I do *NOT* want to be blamed
2338                    for it I do not want to write it.  I do not want to have
2339                    anything to do with it.  This is not the proper way to
2340                    implement this misfeature.  */
2341               case rs_broken_word:
2342                 {
2343                   struct broken_word *lie;
2344                   struct broken_word *untruth;
2345
2346                   /* Yes this is ugly (storing the broken_word pointer
2347                      in the symbol slot).  Still, this whole chunk of
2348                      code is ugly, and I don't feel like doing anything
2349                      about it.  Think of it as stubbornness in action.  */
2350                   growth = 0;
2351                   for (lie = (struct broken_word *) (fragP->fr_symbol);
2352                        lie && lie->dispfrag == fragP;
2353                        lie = lie->next_broken_word)
2354                     {
2355
2356                       if (lie->added)
2357                         continue;
2358
2359                       offset = (symbol_get_frag (lie->add)->fr_address
2360                                 + S_GET_VALUE (lie->add)
2361                                 + lie->addnum
2362                                 - (symbol_get_frag (lie->sub)->fr_address
2363                                    + S_GET_VALUE (lie->sub)));
2364                       if (offset <= -32768 || offset >= 32767)
2365                         {
2366                           if (flag_warn_displacement)
2367                             {
2368                               char buf[50];
2369                               sprint_value (buf, (addressT) lie->addnum);
2370                               as_warn_where (fragP->fr_file, fragP->fr_line,
2371                                              _(".word %s-%s+%s didn't fit"),
2372                                              S_GET_NAME (lie->add),
2373                                              S_GET_NAME (lie->sub),
2374                                              buf);
2375                             }
2376                           lie->added = 1;
2377                           if (fragP->fr_subtype == 0)
2378                             {
2379                               fragP->fr_subtype++;
2380                               growth += md_short_jump_size;
2381                             }
2382                           for (untruth = lie->next_broken_word;
2383                                untruth && untruth->dispfrag == lie->dispfrag;
2384                                untruth = untruth->next_broken_word)
2385                             if ((symbol_get_frag (untruth->add)
2386                                  == symbol_get_frag (lie->add))
2387                                 && (S_GET_VALUE (untruth->add)
2388                                     == S_GET_VALUE (lie->add)))
2389                               {
2390                                 untruth->added = 2;
2391                                 untruth->use_jump = lie;
2392                               }
2393                           growth += md_long_jump_size;
2394                         }
2395                     }
2396
2397                   break;
2398                 }               /* case rs_broken_word  */
2399 #endif
2400               case rs_align:
2401               case rs_align_code:
2402               case rs_align_test:
2403                 {
2404                   addressT oldoff, newoff;
2405
2406                   oldoff = relax_align (was_address + fragP->fr_fix,
2407                                         (int) offset);
2408                   newoff = relax_align (address + fragP->fr_fix,
2409                                         (int) offset);
2410
2411                   if (fragP->fr_subtype != 0)
2412                     {
2413                       if (oldoff > fragP->fr_subtype)
2414                         oldoff = 0;
2415                       if (newoff > fragP->fr_subtype)
2416                         newoff = 0;
2417                     }
2418
2419                   growth = newoff - oldoff;
2420                 }
2421                 break;
2422
2423               case rs_org:
2424                 {
2425                   addressT target = offset;
2426                   addressT after;
2427
2428                   if (symbolP)
2429                     {
2430 #if !defined (MANY_SEGMENTS) && !defined (BFD_ASSEMBLER)
2431                       know ((S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2432                             || (S_GET_SEGMENT (symbolP) == SEG_DATA)
2433                             || (S_GET_SEGMENT (symbolP) == SEG_TEXT)
2434                             || S_GET_SEGMENT (symbolP) == SEG_BSS);
2435                       know (symbolP->sy_frag);
2436                       know (!(S_GET_SEGMENT (symbolP) == SEG_ABSOLUTE)
2437                             || (symbolP->sy_frag == &zero_address_frag));
2438 #endif
2439                       target += (S_GET_VALUE (symbolP)
2440                                  + symbol_get_frag (symbolP)->fr_address);
2441                     }           /* if we have a symbol  */
2442
2443                   know (fragP->fr_next);
2444                   after = fragP->fr_next->fr_address;
2445                   growth = target - after;
2446                   if (growth < 0)
2447                     {
2448                       /* Growth may be negative, but variable part of frag
2449                          cannot have fewer than 0 chars.  That is, we can't
2450                          .org backwards.  */
2451                       as_bad_where (fragP->fr_file, fragP->fr_line,
2452                                     _("attempt to .org backwards ignored"));
2453
2454                       /* We've issued an error message.  Change the
2455                          frag to avoid cascading errors.  */
2456                       fragP->fr_type = rs_align;
2457                       fragP->fr_subtype = 0;
2458                       fragP->fr_offset = 0;
2459                       fragP->fr_fix = after - address;
2460                       growth = stretch;
2461                     }
2462
2463                   /* This is an absolute growth factor  */
2464                   growth -= stretch;
2465                   break;
2466                 }
2467
2468               case rs_space:
2469                 growth = 0;
2470                 if (symbolP)
2471                   {
2472                     offsetT amount;
2473
2474                     amount = S_GET_VALUE (symbolP);
2475                     if (S_GET_SEGMENT (symbolP) != absolute_section
2476                         || S_IS_COMMON (symbolP)
2477                         || ! S_IS_DEFINED (symbolP))
2478                       {
2479                         as_bad_where (fragP->fr_file, fragP->fr_line,
2480                                       _(".space specifies non-absolute value"));
2481                         /* Prevent repeat of this error message.  */
2482                         fragP->fr_symbol = 0;
2483                       }
2484                     else if (amount < 0)
2485                       {
2486                         as_warn_where (fragP->fr_file, fragP->fr_line,
2487                                        _(".space or .fill with negative value, ignored"));
2488                         fragP->fr_symbol = 0;
2489                       }
2490                     else
2491                       growth = (was_address + amount
2492                                 - fragP->fr_next->fr_address);
2493                   }
2494                 break;
2495
2496               case rs_machine_dependent:
2497 #ifdef md_relax_frag
2498                 growth = md_relax_frag (segment, fragP, stretch);
2499 #else
2500 #ifdef TC_GENERIC_RELAX_TABLE
2501                 /* The default way to relax a frag is to look through
2502                    TC_GENERIC_RELAX_TABLE.  */
2503                 growth = relax_frag (segment, fragP, stretch);
2504 #endif /* TC_GENERIC_RELAX_TABLE  */
2505 #endif
2506                 break;
2507
2508               case rs_leb128:
2509                 {
2510                   valueT value;
2511                   int size;
2512
2513                   value = resolve_symbol_value (fragP->fr_symbol);
2514                   size = sizeof_leb128 (value, fragP->fr_subtype);
2515                   growth = size - fragP->fr_offset;
2516                   fragP->fr_offset = size;
2517                 }
2518                 break;
2519
2520               case rs_cfa:
2521                 growth = eh_frame_relax_frag (fragP);
2522                 break;
2523
2524               case rs_dwarf2dbg:
2525                 growth = dwarf2dbg_relax_frag (fragP);
2526                 break;
2527
2528               default:
2529                 BAD_CASE (fragP->fr_type);
2530                 break;
2531               }
2532             if (growth)
2533               {
2534                 stretch += growth;
2535                 stretched = 1;
2536               }
2537           }                     /* For each frag in the segment.  */
2538       }
2539     while (stretched);          /* Until nothing further to relax.  */
2540   }                             /* do_relax  */
2541
2542   ret = 0;
2543   for (fragP = segment_frag_root; fragP; fragP = fragP->fr_next)
2544     if (fragP->last_fr_address != fragP->fr_address)
2545       {
2546         fragP->last_fr_address = fragP->fr_address;
2547         ret = 1;
2548       }
2549   return ret;
2550 }
2551
2552 #if defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS))
2553
2554 #ifndef TC_RELOC_RTSYM_LOC_FIXUP
2555 #define TC_RELOC_RTSYM_LOC_FIXUP(X) (1)
2556 #endif
2557
2558 /* fixup_segment()
2559
2560    Go through all the fixS's in a segment and see which ones can be
2561    handled now.  (These consist of fixS where we have since discovered
2562    the value of a symbol, or the address of the frag involved.)
2563    For each one, call md_apply_fix to put the fix into the frag data.
2564
2565    Result is a count of how many relocation structs will be needed to
2566    handle the remaining fixS's that we couldn't completely handle here.
2567    These will be output later by emit_relocations().  */
2568
2569 static long
2570 fixup_segment (fixP, this_segment_type)
2571      register fixS *fixP;
2572      segT this_segment_type;    /* N_TYPE bits for segment.  */
2573 {
2574   long seg_reloc_count = 0;
2575   symbolS *add_symbolP;
2576   symbolS *sub_symbolP;
2577   valueT add_number;
2578   int size;
2579   char *place;
2580   long where;
2581   int pcrel, plt;
2582   fragS *fragP;
2583   segT add_symbol_segment = absolute_section;
2584
2585   /* If the linker is doing the relaxing, we must not do any fixups.
2586
2587      Well, strictly speaking that's not true -- we could do any that are
2588      PC-relative and don't cross regions that could change size.  And for the
2589      i960 (the only machine for which we've got a relaxing linker right now),
2590      we might be able to turn callx/callj into bal anyways in cases where we
2591      know the maximum displacement.  */
2592   if (linkrelax && TC_LINKRELAX_FIXUP (this_segment_type))
2593     {
2594       for (; fixP; fixP = fixP->fx_next)
2595         seg_reloc_count++;
2596       TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2597       return seg_reloc_count;
2598     }
2599
2600   for (; fixP; fixP = fixP->fx_next)
2601     {
2602 #ifdef DEBUG5
2603       fprintf (stderr, "\nprocessing fixup:\n");
2604       print_fixup (fixP);
2605 #endif
2606
2607       fragP = fixP->fx_frag;
2608       know (fragP);
2609       where = fixP->fx_where;
2610       place = fragP->fr_literal + where;
2611       size = fixP->fx_size;
2612       add_symbolP = fixP->fx_addsy;
2613 #ifdef TC_VALIDATE_FIX
2614       TC_VALIDATE_FIX (fixP, this_segment_type, skip);
2615 #endif
2616       sub_symbolP = fixP->fx_subsy;
2617       add_number = fixP->fx_offset;
2618       pcrel = fixP->fx_pcrel;
2619       plt = fixP->fx_plt;
2620
2621       if (add_symbolP != NULL
2622           && symbol_mri_common_p (add_symbolP))
2623         {
2624           know (add_symbolP->sy_value.X_op == O_symbol);
2625           add_number += S_GET_VALUE (add_symbolP);
2626           fixP->fx_offset = add_number;
2627           add_symbolP = fixP->fx_addsy =
2628             symbol_get_value_expression (add_symbolP)->X_add_symbol;
2629         }
2630
2631       if (add_symbolP)
2632         add_symbol_segment = S_GET_SEGMENT (add_symbolP);
2633
2634       if (sub_symbolP)
2635         {
2636           resolve_symbol_value (sub_symbolP);
2637           if (add_symbolP == NULL || add_symbol_segment == absolute_section)
2638             {
2639               if (add_symbolP != NULL)
2640                 {
2641                   add_number += S_GET_VALUE (add_symbolP);
2642                   add_symbolP = NULL;
2643                   fixP->fx_addsy = NULL;
2644                 }
2645
2646               /* It's just -sym.  */
2647               if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
2648                 {
2649                   add_number -= S_GET_VALUE (sub_symbolP);
2650                   fixP->fx_subsy = NULL;
2651                 }
2652               else if (pcrel
2653                        && S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2654                 {
2655                   /* Should try converting to a constant.  */
2656                   goto bad_sub_reloc;
2657                 }
2658               else
2659               bad_sub_reloc:
2660                 as_bad_where (fixP->fx_file, fixP->fx_line,
2661                               _("Negative of non-absolute symbol %s"),
2662                               S_GET_NAME (sub_symbolP));
2663             }
2664           else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
2665                    && SEG_NORMAL (add_symbol_segment))
2666             {
2667               /* Difference of 2 symbols from same segment.
2668                  Can't make difference of 2 undefineds: 'value' means
2669                  something different for N_UNDF.  */
2670 #ifdef TC_I960
2671               /* Makes no sense to use the difference of 2 arbitrary symbols
2672                  as the target of a call instruction.  */
2673               if (fixP->fx_tcbit)
2674                 as_bad_where (fixP->fx_file, fixP->fx_line,
2675                               _("callj to difference of 2 symbols"));
2676 #endif /* TC_I960  */
2677               add_number += (S_GET_VALUE (add_symbolP)
2678                              - S_GET_VALUE (sub_symbolP));
2679               if (1
2680 #ifdef TC_M68K
2681                   /* See the comment below about 68k weirdness.  */
2682                   && 0
2683 #endif
2684                   && pcrel)
2685                 add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2686
2687               add_symbolP = NULL;
2688               pcrel = 0;        /* No further pcrel processing.  */
2689
2690               /* Let the target machine make the final determination
2691                  as to whether or not a relocation will be needed to
2692                  handle this fixup.  */
2693               if (!TC_FORCE_RELOCATION_SECTION (fixP, this_segment_type))
2694                 {
2695                   fixP->fx_pcrel = 0;
2696                   fixP->fx_addsy = NULL;
2697                   fixP->fx_subsy = NULL;
2698                 }
2699             }
2700           else
2701             {
2702               /* Different segments in subtraction.  */
2703               know (!(S_IS_EXTERNAL (sub_symbolP)
2704                       && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
2705
2706               if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
2707                 add_number -= S_GET_VALUE (sub_symbolP);
2708
2709 #ifdef DIFF_EXPR_OK
2710               else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type)
2711                 {
2712                   /* Make it pc-relative.  */
2713                   if (0
2714 #ifdef TC_M68K
2715                       /* Do this for m68k even if it's already described
2716                          as pc-relative.  On the m68k, an operand of
2717                          "pc@(foo-.-2)" should address "foo" in a
2718                          pc-relative mode.  */
2719                       || 1
2720 #endif
2721                       || !pcrel)
2722                     {
2723                       add_number += MD_PCREL_FROM_SECTION (fixP,
2724                                                            this_segment_type);
2725                       pcrel = 1;
2726                       fixP->fx_pcrel = 1;
2727                     }
2728
2729                   add_number -= S_GET_VALUE (sub_symbolP);
2730                   sub_symbolP = 0;
2731                   fixP->fx_subsy = 0;
2732                 }
2733 #endif
2734 #ifdef UNDEFINED_DIFFERENCE_OK
2735               /* The PA needs this for PIC code generation.  We basically
2736                  don't want to do anything if we have the difference of two
2737                  symbols at this point.  */
2738               else if (1)
2739                 {
2740                   /* Leave it alone.  */
2741                 }
2742 #endif
2743 #ifdef BFD_ASSEMBLER
2744               else if (fixP->fx_r_type == BFD_RELOC_GPREL32
2745                        || fixP->fx_r_type == BFD_RELOC_GPREL16)
2746                 {
2747                   /* Leave it alone.  */
2748                 }
2749 #endif
2750               else
2751                 {
2752                   char buf[50];
2753                   sprint_value (buf, fragP->fr_address + where);
2754                   as_bad_where (fixP->fx_file, fixP->fx_line,
2755                                 _("Subtraction of two symbols in different sections \"%s\" {%s section} - \"%s\" {%s section} at file address %s."),
2756                                 S_GET_NAME (add_symbolP),
2757                                 segment_name (S_GET_SEGMENT (add_symbolP)),
2758                                 S_GET_NAME (sub_symbolP),
2759                                 segment_name (S_GET_SEGMENT (sub_symbolP)),
2760                                 buf);
2761                 }
2762             }
2763         }
2764
2765       if (add_symbolP)
2766         {
2767           if (add_symbol_segment == this_segment_type && pcrel && !plt
2768               && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
2769             {
2770               /* This fixup was made when the symbol's segment was
2771                  SEG_UNKNOWN, but it is now in the local segment.
2772                  So we know how to do the address without relocation.  */
2773 #ifdef TC_I960
2774               /* reloc_callj() may replace a 'call' with a 'calls' or a
2775                  'bal', in which cases it modifies *fixP as appropriate.
2776                  In the case of a 'calls', no further work is required,
2777                  and *fixP has been set up to make the rest of the code
2778                  below a no-op.  */
2779               reloc_callj (fixP);
2780 #endif /* TC_I960  */
2781
2782               add_number += S_GET_VALUE (add_symbolP);
2783               add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2784               /* Lie.  Don't want further pcrel processing.  */
2785               pcrel = 0;
2786
2787               /* Let the target machine make the final determination
2788                  as to whether or not a relocation will be needed to
2789                  handle this fixup.  */
2790               if (!TC_FORCE_RELOCATION (fixP))
2791                 {
2792                   fixP->fx_pcrel = 0;
2793                   fixP->fx_addsy = NULL;
2794                 }
2795             }
2796           else
2797             {
2798               if (add_symbol_segment == absolute_section
2799                   && ! pcrel)
2800                 {
2801 #ifdef TC_I960
2802                   /* See comment about reloc_callj() above.  */
2803                   reloc_callj (fixP);
2804 #endif /* TC_I960  */
2805                   add_number += S_GET_VALUE (add_symbolP);
2806
2807                   /* Let the target machine make the final determination
2808                      as to whether or not a relocation will be needed to
2809                      handle this fixup.  */
2810
2811                   if (!TC_FORCE_RELOCATION (fixP))
2812                     {
2813                       fixP->fx_addsy = NULL;
2814                       add_symbolP = NULL;
2815                     }
2816                 }
2817               else if (add_symbol_segment == undefined_section
2818 #ifdef BFD_ASSEMBLER
2819                        || bfd_is_com_section (add_symbol_segment)
2820 #endif
2821                        )
2822                 {
2823 #ifdef TC_I960
2824                   if ((int) fixP->fx_bit_fixP == 13)
2825                     {
2826                       /* This is a COBR instruction.  They have only a
2827                          13-bit displacement and are only to be used
2828                          for local branches: flag as error, don't generate
2829                          relocation.  */
2830                       as_bad_where (fixP->fx_file, fixP->fx_line,
2831                                     _("can't use COBR format with external label"));
2832                       fixP->fx_addsy = NULL;
2833                       fixP->fx_done = 1;
2834                       continue;
2835                     }           /* COBR.  */
2836 #endif /* TC_I960  */
2837
2838 #ifdef OBJ_COFF
2839 #ifdef TE_I386AIX
2840                   if (S_IS_COMMON (add_symbolP))
2841                     add_number += S_GET_VALUE (add_symbolP);
2842 #endif /* TE_I386AIX  */
2843 #endif /* OBJ_COFF  */
2844                   ++seg_reloc_count;
2845                 }
2846               else
2847                 {
2848                   seg_reloc_count++;
2849                   if (TC_FIX_ADJUSTABLE (fixP))
2850                     add_number += S_GET_VALUE (add_symbolP);
2851                 }
2852             }
2853         }
2854
2855       if (pcrel)
2856         {
2857           add_number -= MD_PCREL_FROM_SECTION (fixP, this_segment_type);
2858           if (add_symbolP == 0)
2859             {
2860 #ifndef BFD_ASSEMBLER
2861               fixP->fx_addsy = &abs_symbol;
2862 #else
2863               fixP->fx_addsy = section_symbol (absolute_section);
2864 #endif
2865               symbol_mark_used_in_reloc (fixP->fx_addsy);
2866               ++seg_reloc_count;
2867             }
2868         }
2869
2870       if (!fixP->fx_done)
2871         {
2872 #ifdef MD_APPLY_FIX3
2873           md_apply_fix3 (fixP, &add_number, this_segment_type);
2874 #else
2875 #ifdef BFD_ASSEMBLER
2876           md_apply_fix (fixP, &add_number);
2877 #else
2878           md_apply_fix (fixP, add_number);
2879 #endif
2880 #endif
2881
2882 #ifndef TC_HANDLES_FX_DONE
2883           /* If the tc-* files haven't been converted, assume it's handling
2884              it the old way, where a null fx_addsy means that the fix has
2885              been applied completely, and no further work is needed.  */
2886           if (fixP->fx_addsy == 0 && fixP->fx_pcrel == 0)
2887             fixP->fx_done = 1;
2888 #endif
2889         }
2890
2891       if (!fixP->fx_bit_fixP && !fixP->fx_no_overflow && size > 0)
2892         {
2893           if ((size_t) size < sizeof (valueT))
2894             {
2895               valueT mask;
2896
2897               mask = 0;
2898               mask--;           /* Set all bits to one.  */
2899               mask <<= size * 8 - (fixP->fx_signed ? 1 : 0);
2900               if ((add_number & mask) != 0 && (add_number & mask) != mask)
2901                 {
2902                   char buf[50], buf2[50];
2903                   sprint_value (buf, fragP->fr_address + where);
2904                   if (add_number > 1000)
2905                     sprint_value (buf2, add_number);
2906                   else
2907                     sprintf (buf2, "%ld", (long) add_number);
2908                   as_bad_where (fixP->fx_file, fixP->fx_line,
2909                                 _("Value of %s too large for field of %d bytes at %s"),
2910                                 buf2, size, buf);
2911                 } /* Generic error checking.  */
2912             }
2913 #ifdef WARN_SIGNED_OVERFLOW_WORD
2914           /* Warn if a .word value is too large when treated as a signed
2915              number.  We already know it is not too negative.  This is to
2916              catch over-large switches generated by gcc on the 68k.  */
2917           if (!flag_signed_overflow_ok
2918               && size == 2
2919               && add_number > 0x7fff)
2920             as_bad_where (fixP->fx_file, fixP->fx_line,
2921                           _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
2922                           (long) add_number,
2923                           (unsigned long) (fragP->fr_address + where));
2924 #endif
2925         }                       /* Not a bit fix.  */
2926
2927 #ifdef TC_VALIDATE_FIX
2928     skip:  ATTRIBUTE_UNUSED_LABEL
2929       ;
2930 #endif
2931 #ifdef DEBUG5
2932       fprintf (stderr, "result:\n");
2933       print_fixup (fixP);
2934 #endif
2935     }                           /* For each fixS in this segment.  */
2936
2937   TC_ADJUST_RELOC_COUNT (fixP, seg_reloc_count);
2938   return seg_reloc_count;
2939 }
2940
2941 #endif /* defined (BFD_ASSEMBLER) || (!defined (BFD) && !defined (OBJ_VMS)) */
2942
2943 void
2944 number_to_chars_bigendian (buf, val, n)
2945      char *buf;
2946      valueT val;
2947      int n;
2948 {
2949   if ((size_t) n > sizeof (val) || n <= 0)
2950     abort ();
2951   while (n--)
2952     {
2953       buf[n] = val & 0xff;
2954       val >>= 8;
2955     }
2956 }
2957
2958 void
2959 number_to_chars_littleendian (buf, val, n)
2960      char *buf;
2961      valueT val;
2962      int n;
2963 {
2964   if ((size_t) n > sizeof (val) || n <= 0)
2965     abort ();
2966   while (n--)
2967     {
2968       *buf++ = val & 0xff;
2969       val >>= 8;
2970     }
2971 }
2972
2973 void
2974 write_print_statistics (file)
2975      FILE *file;
2976 {
2977   fprintf (file, "fixups: %d\n", n_fixups);
2978 }
2979
2980 /* For debugging.  */
2981 extern int indent_level;
2982
2983 void
2984 print_fixup (fixp)
2985      fixS *fixp;
2986 {
2987   indent_level = 1;
2988   fprintf (stderr, "fix %lx %s:%d", (long) fixp, fixp->fx_file, fixp->fx_line);
2989   if (fixp->fx_pcrel)
2990     fprintf (stderr, " pcrel");
2991   if (fixp->fx_pcrel_adjust)
2992     fprintf (stderr, " pcrel_adjust=%d", fixp->fx_pcrel_adjust);
2993   if (fixp->fx_im_disp)
2994     {
2995 #ifdef TC_NS32K
2996       fprintf (stderr, " im_disp=%d", fixp->fx_im_disp);
2997 #else
2998       fprintf (stderr, " im_disp");
2999 #endif
3000     }
3001   if (fixp->fx_tcbit)
3002     fprintf (stderr, " tcbit");
3003   if (fixp->fx_done)
3004     fprintf (stderr, " done");
3005   fprintf (stderr, "\n    size=%d frag=%lx where=%ld offset=%lx addnumber=%lx",
3006            fixp->fx_size, (long) fixp->fx_frag, (long) fixp->fx_where,
3007            (long) fixp->fx_offset, (long) fixp->fx_addnumber);
3008 #ifdef BFD_ASSEMBLER
3009   fprintf (stderr, "\n    %s (%d)", bfd_get_reloc_code_name (fixp->fx_r_type),
3010            fixp->fx_r_type);
3011 #else
3012 #ifdef NEED_FX_R_TYPE
3013   fprintf (stderr, " r_type=%d", fixp->fx_r_type);
3014 #endif
3015 #endif
3016   if (fixp->fx_addsy)
3017     {
3018       fprintf (stderr, "\n   +<");
3019       print_symbol_value_1 (stderr, fixp->fx_addsy);
3020       fprintf (stderr, ">");
3021     }
3022   if (fixp->fx_subsy)
3023     {
3024       fprintf (stderr, "\n   -<");
3025       print_symbol_value_1 (stderr, fixp->fx_subsy);
3026       fprintf (stderr, ">");
3027     }
3028   fprintf (stderr, "\n");
3029 #ifdef TC_FIX_DATA_PRINT
3030   TC_FIX_DATA_PRINT (stderr, fixp);
3031 #endif
3032 }