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