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