gas/write.c

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