gas/write.c

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