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