gas/write.c

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