gas/write.c

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