gas/config/obj-coff.c

   1 /* coff object file format
   2    Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to
  19    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "as.h"
  22 #include "obstack.h"
  23 #include "subsegs.h"
  24
  25 const char *s_get_name PARAMS ((symbolS * s));
  26 static symbolS *def_symbol_in_progress;
  27
  28 \f
  29 /* stack stuff */
  30 typedef struct
  31   {
  32     unsigned long chunk_size;
  33     unsigned long element_size;
  34     unsigned long size;
  35     char *data;
  36     unsigned long pointer;
  37   }
  38 stack;
  39
  40 static stack *
  41 stack_init (chunk_size, element_size)
  42      unsigned long chunk_size;
  43      unsigned long element_size;
  44 {
  45   stack *st;
  46
  47   st = (stack *) malloc (sizeof (stack));
  48   if (!st)
  49     return 0;
  50   st->data = malloc (chunk_size);
  51   if (!st->data)
  52     {
  53       free (st);
  54       return 0;
  55     }
  56   st->pointer = 0;
  57   st->size = chunk_size;
  58   st->chunk_size = chunk_size;
  59   st->element_size = element_size;
  60   return st;
  61 }
  62
  63 #if 0
  64 /* Not currently used.  */
  65 static void
  66 stack_delete (st)
  67      stack *st;
  68 {
  69   free (st->data);
  70   free (st);
  71 }
  72 #endif
  73
  74 static char *
  75 stack_push (st, element)
  76      stack *st;
  77      char *element;
  78 {
  79   if (st->pointer + st->element_size >= st->size)
  80     {
  81       st->size += st->chunk_size;
  82       if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
  83         return (char *) 0;
  84     }
  85   memcpy (st->data + st->pointer, element, st->element_size);
  86   st->pointer += st->element_size;
  87   return st->data + st->pointer;
  88 }
  89
  90 static char *
  91 stack_pop (st)
  92      stack *st;
  93 {
  94   if (st->pointer < st->element_size)
  95     {
  96       st->pointer = 0;
  97       return (char *) 0;
  98     }
  99   st->pointer -= st->element_size;
 100   return st->data + st->pointer;
 101 }
 102 \f
 103 /*
 104  * Maintain a list of the tagnames of the structres.
 105  */
 106
 107 static struct hash_control *tag_hash;
 108
 109 static void
 110 tag_init ()
 111 {
 112   tag_hash = hash_new ();
 113 }
 114
 115 static void
 116 tag_insert (name, symbolP)
 117      const char *name;
 118      symbolS *symbolP;
 119 {
 120   const char *error_string;
 121
 122   if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
 123     {
 124       as_fatal ("Inserting \"%s\" into structure table failed: %s",
 125                 name, error_string);
 126     }
 127 }
 128
 129 static symbolS *
 130 tag_find (name)
 131      char *name;
 132 {
 133 #ifdef STRIP_UNDERSCORE
 134   if (*name == '_')
 135     name++;
 136 #endif /* STRIP_UNDERSCORE */
 137   return (symbolS *) hash_find (tag_hash, name);
 138 }
 139
 140 static symbolS *
 141 tag_find_or_make (name)
 142      char *name;
 143 {
 144   symbolS *symbolP;
 145
 146   if ((symbolP = tag_find (name)) == NULL)
 147     {
 148       symbolP = symbol_new (name, undefined_section,
 149                             0, &zero_address_frag);
 150
 151       tag_insert (S_GET_NAME (symbolP), symbolP);
 152 #ifdef BFD_ASSEMBLER
 153       symbol_table_insert (symbolP);
 154 #endif
 155     }                           /* not found */
 156
 157   return symbolP;
 158 }
 159
 160
 161
 162 #ifdef BFD_ASSEMBLER
 163
 164 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
 165
 166 struct line_no {
 167   struct line_no *next;
 168   fragS *frag;
 169   alent l;
 170 };
 171
 172 #define GET_FILENAME_STRING(X) \
 173 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
 174
 175 /* @@ Ick.  */
 176 static segT
 177 fetch_coff_debug_section ()
 178 {
 179   static segT debug_section;
 180   if (!debug_section)
 181     {
 182       CONST asymbol *s;
 183       s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
 184       assert (s != 0);
 185       debug_section = s->section;
 186     }
 187   return debug_section;
 188 }
 189
 190 void
 191 SA_SET_SYM_ENDNDX (sym, val)
 192      symbolS *sym;
 193      symbolS *val;
 194 {
 195   combined_entry_type *entry, *p;
 196
 197   entry = &coffsymbol (sym->bsym)->native[1];
 198   p = coffsymbol (val->bsym)->native;
 199   entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
 200   entry->fix_end = 1;
 201 }
 202
 203 static void
 204 SA_SET_SYM_TAGNDX (sym, val)
 205      symbolS *sym;
 206      symbolS *val;
 207 {
 208   combined_entry_type *entry, *p;
 209
 210   entry = &coffsymbol (sym->bsym)->native[1];
 211   p = coffsymbol (val->bsym)->native;
 212   entry->u.auxent.x_sym.x_tagndx.p = p;
 213   entry->fix_tag = 1;
 214 }
 215
 216 static int
 217 S_GET_DATA_TYPE (sym)
 218      symbolS *sym;
 219 {
 220   return coffsymbol (sym->bsym)->native->u.syment.n_type;
 221 }
 222
 223 int
 224 S_SET_DATA_TYPE (sym, val)
 225      symbolS *sym;
 226      int val;
 227 {
 228   coffsymbol (sym->bsym)->native->u.syment.n_type = val;
 229   return val;
 230 }
 231
 232 int
 233 S_GET_STORAGE_CLASS (sym)
 234      symbolS *sym;
 235 {
 236   return coffsymbol (sym->bsym)->native->u.syment.n_sclass;
 237 }
 238
 239 int
 240 S_SET_STORAGE_CLASS (sym, val)
 241      symbolS *sym;
 242      int val;
 243 {
 244   coffsymbol (sym->bsym)->native->u.syment.n_sclass = val;
 245   return val;
 246 }
 247
 248 /* Merge a debug symbol containing debug information into a normal symbol. */
 249
 250 void
 251 c_symbol_merge (debug, normal)
 252      symbolS *debug;
 253      symbolS *normal;
 254 {
 255   S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
 256   S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
 257
 258   if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
 259     /* take the most we have */
 260     S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
 261
 262   if (S_GET_NUMBER_AUXILIARY (debug) > 0)
 263     {
 264       /* Move all the auxiliary information.  */
 265       /* @@ How many fields do we want to preserve?  Would it make more
 266          sense to pick and choose those we want to copy?  Should look
 267          into this further....  [raeburn:19920512.2209EST]  */
 268       alent *linenos;
 269       linenos = coffsymbol (normal->bsym)->lineno;
 270       memcpy ((char *) &coffsymbol (normal->bsym)->native,
 271               (char *) &coffsymbol (debug->bsym)->native,
 272               S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
 273       coffsymbol (normal->bsym)->lineno = linenos;
 274     }
 275
 276   /* Move the debug flags. */
 277   SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
 278 }
 279
 280 static symbolS *previous_file_symbol;
 281 void
 282 c_dot_file_symbol (filename)
 283      char *filename;
 284 {
 285   symbolS *symbolP;
 286
 287   symbolP = symbol_new (filename, &bfd_abs_section, 0,
 288                         &zero_address_frag);
 289
 290   S_SET_STORAGE_CLASS (symbolP, C_FILE);
 291   S_SET_NUMBER_AUXILIARY (symbolP, 1);
 292
 293   symbolP->bsym->flags = BSF_DEBUGGING;
 294
 295 #ifndef NO_LISTING
 296   {
 297     extern int listing;
 298     if (listing)
 299       {
 300         listing_source_file (filename);
 301       }
 302   }
 303 #endif
 304
 305   S_SET_VALUE (symbolP, (long) previous_file_symbol);
 306
 307   previous_file_symbol = symbolP;
 308
 309   /* Make sure that the symbol is first on the symbol chain */
 310   if (symbol_rootP != symbolP)
 311     {
 312       if (symbolP == symbol_lastP)
 313         {
 314           symbol_lastP = symbol_lastP->sy_previous;
 315         }                       /* if it was the last thing on the list */
 316
 317       symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
 318       symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
 319       symbol_rootP = symbolP;
 320     }                           /* if not first on the list */
 321 }
 322
 323 /*
 324  * Build a 'section static' symbol.
 325  */
 326
 327 char *
 328 c_section_symbol (name, value, length, nreloc, nlnno)
 329      char *name;
 330      long value;
 331      long length;
 332      unsigned short nreloc;
 333      unsigned short nlnno;
 334 {
 335   symbolS *symbolP;
 336
 337   symbolP = symbol_new (name,
 338                         (name[1] == 't'
 339                          ? text_section
 340                          : name[1] == 'd'
 341                          ? data_section
 342                          : bss_section),
 343                         value,
 344                         &zero_address_frag);
 345
 346   S_SET_STORAGE_CLASS (symbolP, C_STAT);
 347   S_SET_NUMBER_AUXILIARY (symbolP, 1);
 348
 349   SA_SET_SCN_SCNLEN (symbolP, length);
 350   SA_SET_SCN_NRELOC (symbolP, nreloc);
 351   SA_SET_SCN_NLINNO (symbolP, nlnno);
 352
 353   SF_SET_STATICS (symbolP);
 354
 355   return (char *) symbolP;
 356 }
 357
 358 /* Line number handling */
 359
 360 int coff_line_base;
 361
 362 /* Symbol of last function, which we should hang line#s off of.  */
 363 static symbolS *line_fsym;
 364
 365 #define in_function()           (line_fsym != 0)
 366 #define clear_function()        (line_fsym = 0)
 367 #define set_function(F)         (line_fsym = (F), coff_add_linesym (F))
 368
 369 \f
 370 void
 371 obj_symbol_new_hook (symbolP)
 372      symbolS *symbolP;
 373 {
 374   char underscore = 0;          /* Symbol has leading _ */
 375
 376   {
 377     long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
 378     char *s = (char *) bfd_alloc_by_size_t (stdoutput, sz);
 379     memset (s, 0, sz);
 380     coffsymbol (symbolP->bsym)->native = (combined_entry_type *) s;
 381   }
 382   S_SET_DATA_TYPE (symbolP, T_NULL);
 383   S_SET_STORAGE_CLASS (symbolP, 0);
 384   S_SET_NUMBER_AUXILIARY (symbolP, 0);
 385
 386   if (S_IS_STRING (symbolP))
 387     SF_SET_STRING (symbolP);
 388   if (!underscore && S_IS_LOCAL (symbolP))
 389     SF_SET_LOCAL (symbolP);
 390 }
 391
 392 \f
 393 /*
 394  * Handle .ln directives.
 395  */
 396
 397 static symbolS *current_lineno_sym;
 398 static struct line_no *line_nos;
 399
 400 static void
 401 add_lineno (frag, offset, num)
 402      fragS *frag;
 403      int offset;
 404      int num;
 405 {
 406   struct line_no *new_line = (struct line_no *) bfd_alloc_by_size_t (stdoutput,
 407                                                                      sizeof (struct line_no));
 408   if (!current_lineno_sym)
 409     {
 410       abort ();
 411     }
 412   new_line->next = line_nos;
 413   new_line->frag = frag;
 414   new_line->l.line_number = num;
 415   new_line->l.u.offset = offset;
 416   line_nos = new_line;
 417 }
 418
 419 void
 420 coff_add_linesym (sym)
 421      symbolS *sym;
 422 {
 423   if (line_nos)
 424     {
 425       add_lineno (0, 0, 0);
 426       coffsymbol (current_lineno_sym->bsym)->lineno = (alent *) line_nos;
 427       line_nos = 0;
 428     }
 429   current_lineno_sym = sym;
 430 }
 431
 432 static void
 433 obj_coff_ln (appline)
 434      int appline;
 435 {
 436   int l;
 437
 438   if (! appline && def_symbol_in_progress != NULL)
 439     {
 440       as_warn (".ln pseudo-op inside .def/.endef: ignored.");
 441       demand_empty_rest_of_line ();
 442       return;
 443     }
 444
 445   l = get_absolute_expression ();
 446   if (!appline)
 447     {
 448       add_lineno (frag_now, frag_now_fix (), l);
 449     }
 450
 451 #ifndef NO_LISTING
 452   {
 453     extern int listing;
 454
 455     if (listing)
 456       {
 457         if (! appline)
 458           l += coff_line_base - 1;
 459         listing_source_line (l);
 460       }
 461   }
 462 #endif
 463
 464   demand_empty_rest_of_line ();
 465 }
 466
 467 /*
 468  *                      def()
 469  *
 470  * Handle .def directives.
 471  *
 472  * One might ask : why can't we symbol_new if the symbol does not
 473  * already exist and fill it with debug information.  Because of
 474  * the C_EFCN special symbol. It would clobber the value of the
 475  * function symbol before we have a chance to notice that it is
 476  * a C_EFCN. And a second reason is that the code is more clear this
 477  * way. (at least I think it is :-).
 478  *
 479  */
 480
 481 #define SKIP_SEMI_COLON()       while (*input_line_pointer++ != ';')
 482 #define SKIP_WHITESPACES()      while (*input_line_pointer == ' ' || \
 483                                        *input_line_pointer == '\t') \
 484     input_line_pointer++;
 485
 486 static void
 487 obj_coff_def (what)
 488      int what;
 489 {
 490   char name_end;                /* Char after the end of name */
 491   char *symbol_name;            /* Name of the debug symbol */
 492   char *symbol_name_copy;       /* Temporary copy of the name */
 493   unsigned int symbol_name_length;
 494
 495   if (def_symbol_in_progress != NULL)
 496     {
 497       as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
 498       demand_empty_rest_of_line ();
 499       return;
 500     }                           /* if not inside .def/.endef */
 501
 502   SKIP_WHITESPACES ();
 503
 504   symbol_name = input_line_pointer;
 505 #ifdef STRIP_UNDERSCORE
 506   if (symbol_name[0] == '_' && symbol_name[1] != 0)
 507     symbol_name++;
 508 #endif /* STRIP_UNDERSCORE */
 509
 510   name_end = get_symbol_end ();
 511   symbol_name_length = strlen (symbol_name);
 512   symbol_name_copy = xmalloc (symbol_name_length + 1);
 513   strcpy (symbol_name_copy, symbol_name);
 514
 515   /* Initialize the new symbol */
 516   def_symbol_in_progress = symbol_make (symbol_name_copy);
 517   def_symbol_in_progress->sy_frag = &zero_address_frag;
 518   S_SET_VALUE (def_symbol_in_progress, 0);
 519
 520   if (S_IS_STRING (def_symbol_in_progress))
 521     SF_SET_STRING (def_symbol_in_progress);
 522
 523   *input_line_pointer = name_end;
 524
 525   demand_empty_rest_of_line ();
 526 }
 527
 528 unsigned int dim_index;
 529
 530 static void
 531 obj_coff_endef (ignore)
 532      int ignore;
 533 {
 534   symbolS *symbolP;
 535   /* DIM BUG FIX sac@cygnus.com */
 536   dim_index = 0;
 537   if (def_symbol_in_progress == NULL)
 538     {
 539       as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
 540       demand_empty_rest_of_line ();
 541       return;
 542     }                           /* if not inside .def/.endef */
 543
 544   /* Set the section number according to storage class. */
 545   switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
 546     {
 547     case C_STRTAG:
 548     case C_ENTAG:
 549     case C_UNTAG:
 550       SF_SET_TAG (def_symbol_in_progress);
 551       /* intentional fallthrough */
 552     case C_FILE:
 553     case C_TPDEF:
 554       SF_SET_DEBUG (def_symbol_in_progress);
 555       S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
 556       break;
 557
 558     case C_EFCN:
 559       SF_SET_LOCAL (def_symbol_in_progress);    /* Do not emit this symbol. */
 560       /* intentional fallthrough */
 561     case C_BLOCK:
 562       SF_SET_PROCESS (def_symbol_in_progress);  /* Will need processing before writing */
 563       /* intentional fallthrough */
 564     case C_FCN:
 565       {
 566         CONST char *name;
 567         S_SET_SEGMENT (def_symbol_in_progress, text_section);
 568
 569         name = bfd_asymbol_name (def_symbol_in_progress->bsym);
 570         if (name[1] == 'b' && name[2] == 'f')
 571           {
 572             if (! in_function ())
 573               as_warn ("`%s' symbol without preceding function", name);
 574 /*          SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
 575             /* Will need relocating */
 576             SF_SET_PROCESS (def_symbol_in_progress);
 577             clear_function ();
 578           }
 579       }
 580       break;
 581
 582 #ifdef C_AUTOARG
 583     case C_AUTOARG:
 584 #endif /* C_AUTOARG */
 585     case C_AUTO:
 586     case C_REG:
 587     case C_MOS:
 588     case C_MOE:
 589     case C_MOU:
 590     case C_ARG:
 591     case C_REGPARM:
 592     case C_FIELD:
 593     case C_EOS:
 594       SF_SET_DEBUG (def_symbol_in_progress);
 595       S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
 596       break;
 597
 598     case C_EXT:
 599     case C_STAT:
 600     case C_LABEL:
 601       /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
 602       break;
 603
 604     case C_USTATIC:
 605     case C_EXTDEF:
 606     case C_ULABEL:
 607       as_warn ("unexpected storage class %d",
 608                S_GET_STORAGE_CLASS (def_symbol_in_progress));
 609       break;
 610     }                           /* switch on storage class */
 611
 612   /* Now that we have built a debug symbol, try to find if we should
 613      merge with an existing symbol or not.  If a symbol is C_EFCN or
 614      SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
 615
 616   /* Two cases for functions.  Either debug followed by definition or
 617      definition followed by debug.  For definition first, we will
 618      merge the debug symbol into the definition.  For debug first, the
 619      lineno entry MUST point to the definition function or else it
 620      will point off into space when obj_crawl_symbol_chain() merges
 621      the debug symbol into the real symbol.  Therefor, let's presume
 622      the debug symbol is a real function reference. */
 623
 624   /* FIXME-SOON If for some reason the definition label/symbol is
 625      never seen, this will probably leave an undefined symbol at link
 626      time. */
 627
 628   if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
 629       || (!strcmp (bfd_get_section_name (stdoutput,
 630                                          S_GET_SEGMENT (def_symbol_in_progress)),
 631                    "*DEBUG*")
 632           && !SF_GET_TAG (def_symbol_in_progress))
 633       || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
 634       || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL)
 635     {
 636       if (def_symbol_in_progress != symbol_lastP)
 637         symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
 638                        &symbol_lastP);
 639     }
 640   else
 641     {
 642       /* This symbol already exists, merge the newly created symbol
 643          into the old one.  This is not mandatory. The linker can
 644          handle duplicate symbols correctly. But I guess that it save
 645          a *lot* of space if the assembly file defines a lot of
 646          symbols. [loic] */
 647
 648       /* The debug entry (def_symbol_in_progress) is merged into the
 649          previous definition. */
 650
 651       c_symbol_merge (def_symbol_in_progress, symbolP);
 652       /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
 653       def_symbol_in_progress = symbolP;
 654
 655       if (SF_GET_FUNCTION (def_symbol_in_progress)
 656           || SF_GET_TAG (def_symbol_in_progress))
 657         {
 658           /* For functions, and tags, the symbol *must* be where the
 659              debug symbol appears.  Move the existing symbol to the
 660              current place. */
 661           /* If it already is at the end of the symbol list, do nothing */
 662           if (def_symbol_in_progress != symbol_lastP)
 663             {
 664               symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
 665               symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
 666             }
 667         }
 668     }
 669
 670   if (SF_GET_TAG (def_symbol_in_progress)
 671       && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
 672     {
 673       tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
 674     }
 675
 676   if (SF_GET_FUNCTION (def_symbol_in_progress))
 677     {
 678       know (sizeof (def_symbol_in_progress) <= sizeof (long));
 679       set_function (def_symbol_in_progress);
 680       SF_SET_PROCESS (def_symbol_in_progress);
 681
 682       if (symbolP == NULL)
 683         {
 684           /* That is, if this is the first time we've seen the
 685              function... */
 686           symbol_table_insert (def_symbol_in_progress);
 687         } /* definition follows debug */
 688     } /* Create the line number entry pointing to the function being defined */
 689
 690   def_symbol_in_progress = NULL;
 691   demand_empty_rest_of_line ();
 692 }
 693
 694 static void
 695 obj_coff_dim (ignore)
 696      int ignore;
 697 {
 698   int dim_index;
 699
 700   if (def_symbol_in_progress == NULL)
 701     {
 702       as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
 703       demand_empty_rest_of_line ();
 704       return;
 705     }                           /* if not inside .def/.endef */
 706
 707   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 708
 709   for (dim_index = 0; dim_index < DIMNUM; dim_index++)
 710     {
 711       SKIP_WHITESPACES ();
 712       SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
 713                         get_absolute_expression ());
 714
 715       switch (*input_line_pointer)
 716         {
 717         case ',':
 718           input_line_pointer++;
 719           break;
 720
 721         default:
 722           as_warn ("badly formed .dim directive ignored");
 723           /* intentional fallthrough */
 724         case '\n':
 725         case ';':
 726           dim_index = DIMNUM;
 727           break;
 728         }
 729     }
 730
 731   demand_empty_rest_of_line ();
 732 }
 733
 734 static void
 735 obj_coff_line (ignore)
 736      int ignore;
 737 {
 738   int this_base;
 739
 740   if (def_symbol_in_progress == NULL)
 741     {
 742       /* Probably stabs-style line?  */
 743       obj_coff_ln (0);
 744       return;
 745     }
 746
 747   this_base = get_absolute_expression ();
 748   if (this_base > coff_line_base)
 749     coff_line_base = this_base;
 750
 751   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 752   SA_SET_SYM_LNNO (def_symbol_in_progress, coff_line_base);
 753
 754   demand_empty_rest_of_line ();
 755 }
 756
 757 static void
 758 obj_coff_size (ignore)
 759      int ignore;
 760 {
 761   if (def_symbol_in_progress == NULL)
 762     {
 763       as_warn (".size pseudo-op used outside of .def/.endef ignored.");
 764       demand_empty_rest_of_line ();
 765       return;
 766     }                           /* if not inside .def/.endef */
 767
 768   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 769   SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
 770   demand_empty_rest_of_line ();
 771 }
 772
 773 static void
 774 obj_coff_scl (ignore)
 775      int ignore;
 776 {
 777   if (def_symbol_in_progress == NULL)
 778     {
 779       as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
 780       demand_empty_rest_of_line ();
 781       return;
 782     }                           /* if not inside .def/.endef */
 783
 784   S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
 785   demand_empty_rest_of_line ();
 786 }
 787
 788 static void
 789 obj_coff_tag (ignore)
 790      int ignore;
 791 {
 792   char *symbol_name;
 793   char name_end;
 794
 795   if (def_symbol_in_progress == NULL)
 796     {
 797       as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
 798       demand_empty_rest_of_line ();
 799       return;
 800     }
 801
 802   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 803   symbol_name = input_line_pointer;
 804   name_end = get_symbol_end ();
 805
 806   /* Assume that the symbol referred to by .tag is always defined.
 807      This was a bad assumption.  I've added find_or_make. xoxorich. */
 808   SA_SET_SYM_TAGNDX (def_symbol_in_progress,
 809                      tag_find_or_make (symbol_name));
 810   if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
 811     {
 812       as_warn ("tag not found for .tag %s", symbol_name);
 813     }                           /* not defined */
 814
 815   SF_SET_TAGGED (def_symbol_in_progress);
 816   *input_line_pointer = name_end;
 817
 818   demand_empty_rest_of_line ();
 819 }
 820
 821 static void
 822 obj_coff_type (ignore)
 823      int ignore;
 824 {
 825   if (def_symbol_in_progress == NULL)
 826     {
 827       as_warn (".type pseudo-op used outside of .def/.endef ignored.");
 828       demand_empty_rest_of_line ();
 829       return;
 830     }                           /* if not inside .def/.endef */
 831
 832   S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
 833
 834   if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
 835       S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
 836     {
 837       SF_SET_FUNCTION (def_symbol_in_progress);
 838     }                           /* is a function */
 839
 840   demand_empty_rest_of_line ();
 841 }
 842
 843 static void
 844 obj_coff_val (ignore)
 845      int ignore;
 846 {
 847   if (def_symbol_in_progress == NULL)
 848     {
 849       as_warn (".val pseudo-op used outside of .def/.endef ignored.");
 850       demand_empty_rest_of_line ();
 851       return;
 852     }                           /* if not inside .def/.endef */
 853
 854   if (is_name_beginner (*input_line_pointer))
 855     {
 856       char *symbol_name = input_line_pointer;
 857       char name_end = get_symbol_end ();
 858
 859       if (!strcmp (symbol_name, "."))
 860         {
 861           def_symbol_in_progress->sy_frag = frag_now;
 862           S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
 863           /* If the .val is != from the .def (e.g. statics) */
 864         }
 865       else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
 866         {
 867           def_symbol_in_progress->sy_value.X_op = O_symbol;
 868           def_symbol_in_progress->sy_value.X_add_symbol =
 869             symbol_find_or_make (symbol_name);
 870           def_symbol_in_progress->sy_value.X_op_symbol = NULL;
 871           def_symbol_in_progress->sy_value.X_add_number = 0;
 872
 873           /* If the segment is undefined when the forward reference is
 874              resolved, then copy the segment id from the forward
 875              symbol.  */
 876           SF_SET_GET_SEGMENT (def_symbol_in_progress);
 877         }
 878       /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
 879       *input_line_pointer = name_end;
 880     }
 881   else
 882     {
 883       S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
 884     }                           /* if symbol based */
 885
 886   demand_empty_rest_of_line ();
 887 }
 888
 889 void
 890 obj_read_begin_hook ()
 891 {
 892   /* These had better be the same.  Usually 18 bytes. */
 893 #ifndef BFD_HEADERS
 894   know (sizeof (SYMENT) == sizeof (AUXENT));
 895   know (SYMESZ == AUXESZ);
 896 #endif
 897   tag_init ();
 898 }
 899
 900
 901 symbolS *coff_last_function;
 902
 903 void
 904 coff_frob_symbol (symp, punt)
 905      symbolS *symp;
 906      int *punt;
 907 {
 908   static symbolS *last_tagP;
 909   static stack *block_stack;
 910   static symbolS *set_end;
 911
 912   if (symp == &abs_symbol)
 913     {
 914       *punt = 1;
 915       return;
 916     }
 917
 918   if (current_lineno_sym)
 919     coff_add_linesym ((symbolS *) 0);
 920
 921   if (!block_stack)
 922     block_stack = stack_init (512, sizeof (symbolS*));
 923
 924   if (!S_IS_DEFINED (symp) && S_GET_STORAGE_CLASS (symp) != C_STAT)
 925     S_SET_STORAGE_CLASS (symp, C_EXT);
 926
 927   if (!SF_GET_DEBUG (symp))
 928     {
 929       symbolS *real;
 930       if (!SF_GET_LOCAL (symp)
 931           && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
 932           && real != symp)
 933         {
 934           c_symbol_merge (symp, real);
 935           *punt = 1;
 936         }
 937       if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
 938         {
 939           assert (S_GET_VALUE (symp) == 0);
 940           S_SET_EXTERNAL (symp);
 941         }
 942       else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
 943         {
 944           if (S_GET_SEGMENT (symp) == text_section
 945               && symp != seg_info (text_section)->sym)
 946             S_SET_STORAGE_CLASS (symp, C_LABEL);
 947           else
 948             S_SET_STORAGE_CLASS (symp, C_STAT);
 949         }
 950       if (SF_GET_PROCESS (symp))
 951         {
 952           if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
 953             {
 954               if (!strcmp (S_GET_NAME (symp), ".bb"))
 955                 stack_push (block_stack, (char *) &symp);
 956               else
 957                 {
 958                   symbolS *begin;
 959                   begin = *(symbolS **) stack_pop (block_stack);
 960                   if (begin == 0)
 961                     as_warn ("mismatched .eb");
 962                   else
 963                     set_end = begin;
 964                 }
 965             }
 966           if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
 967             {
 968               union internal_auxent *auxp;
 969               coff_last_function = symp;
 970               if (S_GET_NUMBER_AUXILIARY (symp) < 1)
 971                 S_SET_NUMBER_AUXILIARY (symp, 1);
 972               auxp = &coffsymbol (symp->bsym)->native[1].u.auxent;
 973               memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
 974                       sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
 975             }
 976           if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
 977             {
 978               if (coff_last_function == 0)
 979                 as_fatal ("C_EFCN symbol out of scope");
 980               SA_SET_SYM_FSIZE (coff_last_function,
 981                                 (long) (S_GET_VALUE (symp)
 982                                         - S_GET_VALUE (coff_last_function)));
 983               set_end = coff_last_function;
 984               coff_last_function = 0;
 985             }
 986         }
 987       else if (SF_GET_TAG (symp))
 988         last_tagP = symp;
 989       else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
 990         set_end = last_tagP;
 991       else if (S_GET_STORAGE_CLASS (symp) == C_FILE)
 992         {
 993           if (S_GET_VALUE (symp))
 994             {
 995               S_SET_VALUE ((symbolS *) S_GET_VALUE (symp), 0xdeadbeef);
 996               S_SET_VALUE (symp, 0);
 997             }
 998         }
 999       if (S_IS_EXTERNAL (symp))
1000         S_SET_STORAGE_CLASS (symp, C_EXT);
1001       else if (SF_GET_LOCAL (symp))
1002         *punt = 1;
1003       /* more ... */
1004     }
1005
1006   if (set_end != (symbolS *) NULL
1007       && ! *punt)
1008     {
1009       SA_SET_SYM_ENDNDX (set_end, symp);
1010       set_end = NULL;
1011     }
1012
1013   if (coffsymbol (symp->bsym)->lineno)
1014     {
1015       int i, n;
1016       struct line_no *lptr;
1017       alent *l;
1018
1019       lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1020       for (i = 0; lptr; lptr = lptr->next)
1021         i++;
1022       n = i + 1;
1023       lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1024       l = (alent *) bfd_alloc_by_size_t (stdoutput, n * sizeof (alent));
1025       coffsymbol (symp->bsym)->lineno = l;
1026       for (i = n - 1; i > 0; i--)
1027         {
1028           if (lptr->frag)
1029             lptr->l.u.offset += lptr->frag->fr_address;
1030           l[i] = lptr->l;
1031           lptr = lptr->next;
1032         }
1033     }
1034 }
1035
1036 /*
1037  * implement the .section pseudo op:
1038  *      .section name {, "flags"}
1039  *                ^         ^
1040  *                |         +--- optional flags: 'b' for bss
1041  *                |                              'i' for info
1042  *                +-- section name               'l' for lib
1043  *                                               'n' for noload
1044  *                                               'o' for over
1045  *                                               'w' for data
1046  *                                               'd' (apparently m88k for data)
1047  *                                               'x' for text
1048  * But if the argument is not a quoted string, treat it as a
1049  * subsegment number.
1050  */
1051
1052 void
1053 obj_coff_section (ignore)
1054      int ignore;
1055 {
1056   /* Strip out the section name */
1057   char *section_name;
1058   char c;
1059   char *name;
1060   unsigned int exp;
1061   flagword flags;
1062   asection *sec;
1063
1064   section_name = input_line_pointer;
1065   c = get_symbol_end ();
1066
1067   name = xmalloc (input_line_pointer - section_name + 1);
1068   strcpy (name, section_name);
1069
1070   *input_line_pointer = c;
1071
1072   SKIP_WHITESPACE ();
1073
1074   exp = 0;
1075   flags = SEC_NO_FLAGS;
1076
1077   if (*input_line_pointer == ',')
1078     {
1079       ++input_line_pointer;
1080       SKIP_WHITESPACE ();
1081       if (*input_line_pointer != '"')
1082         exp = get_absolute_expression ();
1083       else
1084         {
1085           ++input_line_pointer;
1086           while (*input_line_pointer != '"'
1087                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
1088             {
1089               switch (*input_line_pointer)
1090                 {
1091                 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1092                 case 'n': flags &=~ SEC_LOAD; break;
1093                 case 'd':
1094                 case 'w': flags &=~ SEC_READONLY; break;
1095                 case 'x': flags |= SEC_CODE; break;
1096
1097                 case 'i': /* STYP_INFO */
1098                 case 'l': /* STYP_LIB */
1099                 case 'o': /* STYP_OVER */
1100                   as_warn ("unsupported section attribute '%c'",
1101                            *input_line_pointer);
1102                   break;
1103
1104                 default:
1105                   as_warn("unknown section attribute '%c'",
1106                           *input_line_pointer);
1107                   break;
1108                 }
1109               ++input_line_pointer;
1110             }
1111           if (*input_line_pointer == '"')
1112             ++input_line_pointer;
1113         }
1114     }
1115
1116   sec = subseg_new (name, (subsegT) exp);
1117
1118   if (flags != SEC_NO_FLAGS)
1119     {
1120       if (! bfd_set_section_flags (stdoutput, sec, flags))
1121         as_warn ("error setting flags for \"%s\": %s",
1122                  bfd_section_name (stdoutput, sec),
1123                  bfd_errmsg (bfd_get_error ()));
1124     }
1125 }
1126
1127 void
1128 coff_adjust_symtab ()
1129 {
1130   if (symbol_rootP == NULL
1131       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1132     {
1133       assert (previous_file_symbol == 0);
1134       c_dot_file_symbol ("fake");
1135     }
1136 }
1137
1138 void
1139 coff_frob_section (sec)
1140      segT sec;
1141 {
1142   segT strsec;
1143   char *strname, *p;
1144   fragS *fragp;
1145   bfd_vma size, n_entries, mask;
1146
1147   /* The COFF back end in BFD requires that all section sizes be
1148      rounded up to multiples of the corresponding section alignments.
1149      Seems kinda silly to me, but that's the way it is.  */
1150   size = bfd_get_section_size_before_reloc (sec);
1151   assert (sec->alignment_power >= stdoutput->xvec->align_power_min);
1152   mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
1153   if (size & mask)
1154     bfd_set_section_size (stdoutput, sec, (size + mask) & ~mask);
1155
1156   /* @@ these should be in a "stabs.h" file, or maybe as.h */
1157 #ifndef STAB_SECTION_NAME
1158 #define STAB_SECTION_NAME ".stab"
1159 #endif
1160 #ifndef STAB_STRING_SECTION_NAME
1161 #define STAB_STRING_SECTION_NAME ".stabstr"
1162 #endif
1163   if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1164     return;
1165
1166   strsec = sec;
1167   sec = subseg_get (STAB_SECTION_NAME, 0);
1168   /* size is already rounded up, since other section will be listed first */
1169   size = bfd_get_section_size_before_reloc (strsec);
1170
1171   n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1172
1173   /* Find first non-empty frag.  It should be large enough.  */
1174   fragp = seg_info (sec)->frchainP->frch_root;
1175   while (fragp && fragp->fr_fix == 0)
1176     fragp = fragp->fr_next;
1177   assert (fragp != 0 && fragp->fr_fix >= 12);
1178
1179   /* Store the values.  */
1180   p = fragp->fr_literal;
1181   bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1182   bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1183 }
1184
1185 void
1186 obj_coff_init_stab_section (seg)
1187      segT seg;
1188 {
1189   char *file;
1190   char *p;
1191   char *stabstr_name;
1192   unsigned int stroff;
1193
1194   /* Make space for this first symbol. */
1195   p = frag_more (12);
1196   /* Zero it out. */
1197   memset (p, 0, 12);
1198   as_where (&file, (unsigned int *) NULL);
1199   stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1200   strcpy (stabstr_name, seg->name);
1201   strcat (stabstr_name, "str");
1202   stroff = get_stab_string_offset (file, stabstr_name);
1203   know (stroff == 1);
1204   md_number_to_chars (p, stroff, 4);
1205 }
1206
1207 #ifdef DEBUG
1208 /* for debugging */
1209 const char *
1210 s_get_name (s)
1211      symbolS *s;
1212 {
1213   return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1214 }
1215
1216 void
1217 symbol_dump ()
1218 {
1219   symbolS *symbolP;
1220
1221   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1222     {
1223       printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1224              (unsigned long) symbolP,
1225              S_GET_NAME(symbolP),
1226              (long) S_GET_DATA_TYPE(symbolP),
1227              S_GET_STORAGE_CLASS(symbolP),
1228              (int) S_GET_SEGMENT(symbolP));
1229     }
1230 }
1231
1232 #endif /* DEBUG */
1233
1234 #else /* not BFD_ASSEMBLER */
1235
1236 #include "frags.h"
1237 /* This is needed because we include internal bfd things. */
1238 #include <time.h>
1239 #include "../bfd/libbfd.h"
1240 #include "../bfd/libcoff.h"
1241
1242 /* The NOP_OPCODE is for the alignment fill value.  Fill with nop so
1243    that we can stick sections together without causing trouble.  */
1244 #ifndef NOP_OPCODE
1245 #define NOP_OPCODE 0x00
1246 #endif
1247
1248 /* The zeroes if symbol name is longer than 8 chars */
1249 #define S_SET_ZEROES(s,v)               ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1250
1251 #define MIN(a,b) ((a) < (b)? (a) : (b))
1252 /* This vector is used to turn an internal segment into a section #
1253    suitable for insertion into a coff symbol table
1254  */
1255
1256 const short seg_N_TYPE[] =
1257 {                               /* in: segT   out: N_TYPE bits */
1258   C_ABS_SECTION,
1259   1,
1260   2,
1261   3,
1262   4,
1263   5,
1264   6,
1265   7,
1266   8,
1267   9,
1268   10,
1269   C_UNDEF_SECTION,              /* SEG_UNKNOWN */
1270   C_UNDEF_SECTION,              /* SEG_GOOF */
1271   C_UNDEF_SECTION,              /* SEG_EXPR */
1272   C_DEBUG_SECTION,              /* SEG_DEBUG */
1273   C_NTV_SECTION,                /* SEG_NTV */
1274   C_PTV_SECTION,                /* SEG_PTV */
1275   C_REGISTER_SECTION,           /* SEG_REGISTER */
1276 };
1277
1278 int function_lineoff = -1;      /* Offset in line#s where the last function
1279                                    started (the odd entry for line #0) */
1280
1281 static symbolS *last_line_symbol;
1282
1283 /* Add 4 to the real value to get the index and compensate the
1284    negatives. This vector is used by S_GET_SEGMENT to turn a coff
1285    section number into a segment number
1286 */
1287 static symbolS *previous_file_symbol;
1288 void c_symbol_merge ();
1289 static int line_base;
1290
1291 symbolS *c_section_symbol ();
1292 bfd *abfd;
1293
1294 static void fixup_segment PARAMS ((segment_info_type *segP,
1295                                    segT this_segment_type));
1296
1297
1298 static void fixup_mdeps PARAMS ((fragS *,
1299                                  object_headers *,
1300                                  segT));
1301
1302
1303 static void fill_section PARAMS ((bfd * abfd,
1304                                   object_headers *,
1305                                   unsigned long *));
1306
1307
1308 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1309                                int line_number,
1310                                fragS * frag));
1311
1312
1313 static void w_symbols PARAMS ((bfd * abfd, char *where,
1314                                symbolS * symbol_rootP));
1315
1316 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1317
1318 static void obj_coff_lcomm PARAMS ((int));
1319 static void obj_coff_text PARAMS ((int));
1320 static void obj_coff_data PARAMS ((int));
1321 static void obj_coff_bss PARAMS ((int));
1322 static void obj_coff_ident PARAMS ((int));
1323 void obj_coff_section PARAMS ((int));
1324
1325 /* Section stuff
1326
1327    We allow more than just the standard 3 sections, infact, we allow
1328    10 sections, (though the usual three have to be there).
1329
1330    This structure performs the mappings for us:
1331
1332 */
1333
1334 #define N_SEG 32
1335 typedef struct
1336 {
1337   segT seg_t;
1338   int i;
1339 } seg_info_type;
1340
1341 static const seg_info_type seg_info_off_by_4[N_SEG] =
1342 {
1343  {SEG_PTV,  },
1344  {SEG_NTV,  },
1345  {SEG_DEBUG, },
1346  {SEG_ABSOLUTE,  },
1347  {SEG_UNKNOWN,   },
1348  {SEG_E0},
1349  {SEG_E1},
1350  {SEG_E2},
1351  {SEG_E3},
1352  {SEG_E4},
1353  {SEG_E5},
1354  {SEG_E6},
1355  {SEG_E7},
1356  {SEG_E8},
1357  {SEG_E9},
1358  {(segT)15},
1359  {(segT)16},
1360  {(segT)17},
1361  {(segT)18},
1362  {(segT)19},
1363  {(segT)20},
1364  {(segT)0},
1365  {(segT)0},
1366  {(segT)0},
1367  {SEG_REGISTER}
1368 };
1369
1370
1371
1372 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1373
1374 static relax_addressT
1375 relax_align (address, alignment)
1376      relax_addressT address;
1377      long alignment;
1378 {
1379   relax_addressT mask;
1380   relax_addressT new_address;
1381
1382   mask = ~((~0) << alignment);
1383   new_address = (address + mask) & (~mask);
1384   return (new_address - address);
1385 }
1386
1387
1388 segT
1389 s_get_segment (x)
1390      symbolS * x;
1391 {
1392   return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
1393 }
1394
1395
1396
1397 /* calculate the size of the frag chain and fill in the section header
1398    to contain all of it, also fill in the addr of the sections */
1399 static unsigned int
1400 size_section (abfd, idx)
1401      bfd * abfd;
1402      unsigned int idx;
1403 {
1404
1405   unsigned int size = 0;
1406   fragS *frag = segment_info[idx].frchainP->frch_root;
1407   while (frag)
1408     {
1409       size = frag->fr_address;
1410       if (frag->fr_address != size)
1411         {
1412           fprintf (stderr, "Out of step\n");
1413           size = frag->fr_address;
1414         }
1415
1416       switch (frag->fr_type)
1417         {
1418 #ifdef TC_COFF_SIZEMACHDEP
1419         case rs_machine_dependent:
1420           size += TC_COFF_SIZEMACHDEP (frag);
1421           break;
1422 #endif
1423         case rs_fill:
1424         case rs_org:
1425           size += frag->fr_fix;
1426           size += frag->fr_offset * frag->fr_var;
1427           break;
1428         case rs_align:
1429           size += frag->fr_fix;
1430           size += relax_align (size, frag->fr_offset);
1431           break;
1432         default:
1433           BAD_CASE (frag->fr_type);
1434           break;
1435         }
1436       frag = frag->fr_next;
1437     }
1438   segment_info[idx].scnhdr.s_size = size;
1439   return size;
1440 }
1441
1442
1443 static unsigned int
1444 count_entries_in_chain (idx)
1445      unsigned int idx;
1446 {
1447   unsigned int nrelocs;
1448   fixS *fixup_ptr;
1449
1450   /* Count the relocations */
1451   fixup_ptr = segment_info[idx].fix_root;
1452   nrelocs = 0;
1453   while (fixup_ptr != (fixS *) NULL)
1454     {
1455       if (TC_COUNT_RELOC (fixup_ptr))
1456         {
1457 #ifdef TC_A29K
1458           if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1459             nrelocs += 2;
1460           else
1461             nrelocs++;
1462 #else
1463           nrelocs++;
1464 #endif
1465         }
1466
1467       fixup_ptr = fixup_ptr->fx_next;
1468     }
1469   return nrelocs;
1470 }
1471
1472 /* output all the relocations for a section */
1473 void
1474 do_relocs_for (abfd, h, file_cursor)
1475      bfd * abfd;
1476      object_headers * h;
1477      unsigned long *file_cursor;
1478 {
1479   unsigned int nrelocs;
1480   unsigned int idx;
1481   unsigned long reloc_start = *file_cursor;
1482
1483   for (idx = SEG_E0; idx < SEG_E9; idx++)
1484     {
1485       if (segment_info[idx].scnhdr.s_name[0])
1486         {
1487           struct external_reloc *ext_ptr;
1488           struct external_reloc *external_reloc_vec;
1489           unsigned int external_reloc_size;
1490           unsigned int base = segment_info[idx].scnhdr.s_paddr;
1491           fixS *fix_ptr = segment_info[idx].fix_root;
1492           nrelocs = count_entries_in_chain (idx);
1493
1494           if (nrelocs)
1495             /* Bypass this stuff if no relocs.  This also incidentally
1496                avoids a SCO bug, where free(malloc(0)) tends to crash.  */
1497             {
1498               external_reloc_size = nrelocs * RELSZ;
1499               external_reloc_vec =
1500                 (struct external_reloc *) malloc (external_reloc_size);
1501
1502               ext_ptr = external_reloc_vec;
1503
1504               /* Fill in the internal coff style reloc struct from the
1505                  internal fix list.  */
1506               while (fix_ptr)
1507                 {
1508                   symbolS *symbol_ptr;
1509                   struct internal_reloc intr;
1510
1511                   /* Only output some of the relocations */
1512                   if (TC_COUNT_RELOC (fix_ptr))
1513                     {
1514 #ifdef TC_RELOC_MANGLE
1515                       TC_RELOC_MANGLE (fix_ptr, &intr, base);
1516
1517 #else
1518                       symbolS *dot;
1519                       symbol_ptr = fix_ptr->fx_addsy;
1520
1521                       intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1522                       intr.r_vaddr =
1523                         base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1524
1525 #ifdef TC_M88K
1526                       intr.r_offset = fix_ptr->fx_offset;
1527 #else
1528                       intr.r_offset = 0;
1529 #endif
1530
1531                       /* Turn the segment of the symbol into an offset.  */
1532                       if (symbol_ptr)
1533                         {
1534                           dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1535                           if (dot)
1536                             {
1537                               intr.r_symndx = dot->sy_number;
1538                             }
1539                           else
1540                             {
1541                               intr.r_symndx = symbol_ptr->sy_number;
1542                             }
1543
1544                         }
1545                       else
1546                         {
1547                           intr.r_symndx = -1;
1548                         }
1549 #endif
1550
1551                       (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1552                       ext_ptr++;
1553
1554 #if defined(TC_A29K)
1555
1556                       /* The 29k has a special kludge for the high 16 bit
1557                          reloc.  Two relocations are emited, R_IHIHALF,
1558                          and R_IHCONST. The second one doesn't contain a
1559                          symbol, but uses the value for offset.  */
1560
1561                       if (intr.r_type == R_IHIHALF)
1562                         {
1563                           /* now emit the second bit */
1564                           intr.r_type = R_IHCONST;
1565                           intr.r_symndx = fix_ptr->fx_addnumber;
1566                           (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1567                           ext_ptr++;
1568                         }
1569 #endif
1570                     }
1571
1572                   fix_ptr = fix_ptr->fx_next;
1573                 }
1574
1575               /* Write out the reloc table */
1576               bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1577                          abfd);
1578               free (external_reloc_vec);
1579
1580               /* Fill in section header info.  */
1581               segment_info[idx].scnhdr.s_relptr = *file_cursor;
1582               *file_cursor += external_reloc_size;
1583               segment_info[idx].scnhdr.s_nreloc = nrelocs;
1584             }
1585           else
1586             {
1587               /* No relocs */
1588               segment_info[idx].scnhdr.s_relptr = 0;
1589             }
1590         }
1591     }
1592   /* Set relocation_size field in file headers */
1593   H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1594 }
1595
1596
1597 /* run through a frag chain and write out the data to go with it, fill
1598    in the scnhdrs with the info on the file postions
1599 */
1600 static void
1601 fill_section (abfd, h, file_cursor)
1602      bfd * abfd;
1603      object_headers *h;
1604      unsigned long *file_cursor;
1605 {
1606
1607   unsigned int i;
1608   unsigned int paddr = 0;
1609
1610   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1611     {
1612       unsigned int offset = 0;
1613
1614       struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1615
1616       if (s->s_name[0])
1617         {
1618           fragS *frag = segment_info[i].frchainP->frch_root;
1619           char *buffer;
1620
1621           if (s->s_size == 0)
1622             s->s_scnptr = 0;
1623           else
1624             {
1625               buffer = xmalloc (s->s_size);
1626               s->s_scnptr = *file_cursor;
1627             }
1628           know (s->s_paddr == paddr);
1629
1630           if (strcmp (s->s_name, ".text") == 0)
1631             s->s_flags |= STYP_TEXT;
1632           else if (strcmp (s->s_name, ".data") == 0)
1633             s->s_flags |= STYP_DATA;
1634           else if (strcmp (s->s_name, ".bss") == 0)
1635             {
1636               s->s_scnptr = 0;
1637               s->s_flags |= STYP_BSS;
1638
1639               /* @@ Should make the i386 and a29k coff targets define
1640                  COFF_NOLOAD_PROBLEM, and have only one test here.  */
1641 #ifndef TC_I386
1642 #ifndef TC_A29K
1643 #ifndef COFF_NOLOAD_PROBLEM
1644               /* Apparently the SVR3 linker (and exec syscall) and UDI
1645                  mondfe progrem are confused by noload sections.  */
1646               s->s_flags |= STYP_NOLOAD;
1647 #endif
1648 #endif
1649 #endif
1650             }
1651           else if (strcmp (s->s_name, ".lit") == 0)
1652             s->s_flags = STYP_LIT | STYP_TEXT;
1653           else if (strcmp (s->s_name, ".init") == 0)
1654             s->s_flags |= STYP_TEXT;
1655           else if (strcmp (s->s_name, ".fini") == 0)
1656             s->s_flags |= STYP_TEXT;
1657           else if (strncmp (s->s_name, ".comment", 8) == 0)
1658             s->s_flags |= STYP_INFO;
1659
1660           while (frag)
1661             {
1662               unsigned int fill_size;
1663               switch (frag->fr_type)
1664                 {
1665                 case rs_machine_dependent:
1666                   if (frag->fr_fix)
1667                     {
1668                       memcpy (buffer + frag->fr_address,
1669                               frag->fr_literal,
1670                               (unsigned int) frag->fr_fix);
1671                       offset += frag->fr_fix;
1672                     }
1673
1674                   break;
1675                 case rs_fill:
1676                 case rs_align:
1677                 case rs_org:
1678                   if (frag->fr_fix)
1679                     {
1680                       memcpy (buffer + frag->fr_address,
1681                               frag->fr_literal,
1682                               (unsigned int) frag->fr_fix);
1683                       offset += frag->fr_fix;
1684                     }
1685
1686                   fill_size = frag->fr_var;
1687                   if (fill_size && frag->fr_offset > 0)
1688                     {
1689                       unsigned int count;
1690                       unsigned int off = frag->fr_fix;
1691                       for (count = frag->fr_offset; count; count--)
1692                         {
1693                           if (fill_size + frag->fr_address + off <= s->s_size)
1694                             {
1695                               memcpy (buffer + frag->fr_address + off,
1696                                       frag->fr_literal + frag->fr_fix,
1697                                       fill_size);
1698                               off += fill_size;
1699                               offset += fill_size;
1700                             }
1701                         }
1702                     }
1703                   break;
1704                 case rs_broken_word:
1705                   break;
1706                 default:
1707                   abort ();
1708                 }
1709               frag = frag->fr_next;
1710             }
1711
1712           if (s->s_size != 0)
1713             {
1714               if (s->s_scnptr != 0)
1715                 {
1716                   bfd_write (buffer, s->s_size, 1, abfd);
1717                   *file_cursor += s->s_size;
1718                 }
1719               free (buffer);
1720             }
1721           paddr += s->s_size;
1722         }
1723     }
1724 }
1725
1726 /* Coff file generation & utilities */
1727
1728 static void
1729 coff_header_append (abfd, h)
1730      bfd * abfd;
1731      object_headers * h;
1732 {
1733   unsigned int i;
1734   char buffer[1000];
1735   char buffero[1000];
1736
1737   bfd_seek (abfd, 0, 0);
1738
1739 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1740   H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1741   H_SET_VERSION_STAMP (h, 0);
1742   H_SET_ENTRY_POINT (h, 0);
1743   H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1744   H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1745   H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
1746                                                              buffero));
1747 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1748   H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
1749 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1750
1751   i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
1752
1753   bfd_write (buffer, i, 1, abfd);
1754   bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
1755
1756   for (i = SEG_E0; i < SEG_E9; i++)
1757     {
1758       if (segment_info[i].scnhdr.s_name[0])
1759         {
1760           unsigned int size =
1761           bfd_coff_swap_scnhdr_out (abfd,
1762                                     &(segment_info[i].scnhdr),
1763                                     buffer);
1764           bfd_write (buffer, size, 1, abfd);
1765         }
1766     }
1767 }
1768
1769
1770 char *
1771 symbol_to_chars (abfd, where, symbolP)
1772      bfd * abfd;
1773      char *where;
1774      symbolS * symbolP;
1775 {
1776   unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
1777   unsigned int i;
1778   valueT val;
1779
1780   /* Turn any symbols with register attributes into abs symbols */
1781   if (S_GET_SEGMENT (symbolP) == reg_section)
1782     {
1783       S_SET_SEGMENT (symbolP, absolute_section);
1784     }
1785   /* At the same time, relocate all symbols to their output value */
1786
1787   val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
1788          + S_GET_VALUE (symbolP));
1789
1790   S_SET_VALUE (symbolP, val);
1791
1792   symbolP->sy_symbol.ost_entry.n_value = val;
1793
1794   where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
1795                                   where);
1796
1797   for (i = 0; i < numaux; i++)
1798     {
1799       where += bfd_coff_swap_aux_out (abfd,
1800                                       &symbolP->sy_symbol.ost_auxent[i],
1801                                       S_GET_DATA_TYPE (symbolP),
1802                                       S_GET_STORAGE_CLASS (symbolP),
1803                                       i, numaux, where);
1804     }
1805   return where;
1806
1807 }
1808
1809 void
1810 obj_symbol_new_hook (symbolP)
1811      symbolS *symbolP;
1812 {
1813   char underscore = 0;          /* Symbol has leading _ */
1814
1815   /* Effective symbol */
1816   /* Store the pointer in the offset. */
1817   S_SET_ZEROES (symbolP, 0L);
1818   S_SET_DATA_TYPE (symbolP, T_NULL);
1819   S_SET_STORAGE_CLASS (symbolP, 0);
1820   S_SET_NUMBER_AUXILIARY (symbolP, 0);
1821   /* Additional information */
1822   symbolP->sy_symbol.ost_flags = 0;
1823   /* Auxiliary entries */
1824   memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
1825
1826   if (S_IS_STRING (symbolP))
1827     SF_SET_STRING (symbolP);
1828   if (!underscore && S_IS_LOCAL (symbolP))
1829     SF_SET_LOCAL (symbolP);
1830 }
1831
1832 /*
1833  * Handle .ln directives.
1834  */
1835
1836 static void
1837 obj_coff_ln (appline)
1838      int appline;
1839 {
1840   int l;
1841
1842   if (! appline && def_symbol_in_progress != NULL)
1843     {
1844       as_warn (".ln pseudo-op inside .def/.endef: ignored.");
1845       demand_empty_rest_of_line ();
1846       return;
1847     }                           /* wrong context */
1848
1849   c_line_new (0,
1850               obstack_next_free (&frags) - frag_now->fr_literal,
1851               l = get_absolute_expression (),
1852               frag_now);
1853 #ifndef NO_LISTING
1854   {
1855     extern int listing;
1856
1857     if (listing)
1858       {
1859         if (! appline)
1860           l += line_base - 1;
1861         listing_source_line ((unsigned int) l);
1862       }
1863
1864   }
1865 #endif
1866   demand_empty_rest_of_line ();
1867 }
1868
1869 /*
1870  *                      def()
1871  *
1872  * Handle .def directives.
1873  *
1874  * One might ask : why can't we symbol_new if the symbol does not
1875  * already exist and fill it with debug information.  Because of
1876  * the C_EFCN special symbol. It would clobber the value of the
1877  * function symbol before we have a chance to notice that it is
1878  * a C_EFCN. And a second reason is that the code is more clear this
1879  * way. (at least I think it is :-).
1880  *
1881  */
1882
1883 #define SKIP_SEMI_COLON()       while (*input_line_pointer++ != ';')
1884 #define SKIP_WHITESPACES()      while (*input_line_pointer == ' ' || \
1885                                       *input_line_pointer == '\t') \
1886                                          input_line_pointer++;
1887
1888 static void
1889 obj_coff_def (what)
1890      int what;
1891 {
1892   char name_end;                /* Char after the end of name */
1893   char *symbol_name;            /* Name of the debug symbol */
1894   char *symbol_name_copy;       /* Temporary copy of the name */
1895   unsigned int symbol_name_length;
1896
1897   if (def_symbol_in_progress != NULL)
1898     {
1899       as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
1900       demand_empty_rest_of_line ();
1901       return;
1902     }                           /* if not inside .def/.endef */
1903
1904   SKIP_WHITESPACES ();
1905
1906   def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
1907   memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
1908
1909   symbol_name = input_line_pointer;
1910   name_end = get_symbol_end ();
1911   symbol_name_length = strlen (symbol_name);
1912   symbol_name_copy = xmalloc (symbol_name_length + 1);
1913   strcpy (symbol_name_copy, symbol_name);
1914
1915   /* Initialize the new symbol */
1916 #ifdef STRIP_UNDERSCORE
1917   S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
1918                                        ? symbol_name_copy + 1
1919                                        : symbol_name_copy));
1920 #else /* STRIP_UNDERSCORE */
1921   S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
1922 #endif /* STRIP_UNDERSCORE */
1923   /* free(symbol_name_copy); */
1924   def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
1925   def_symbol_in_progress->sy_number = ~0;
1926   def_symbol_in_progress->sy_frag = &zero_address_frag;
1927   S_SET_VALUE (def_symbol_in_progress, 0);
1928
1929   if (S_IS_STRING (def_symbol_in_progress))
1930     SF_SET_STRING (def_symbol_in_progress);
1931
1932   *input_line_pointer = name_end;
1933
1934   demand_empty_rest_of_line ();
1935 }
1936
1937 unsigned int dim_index;
1938
1939
1940 static void
1941 obj_coff_endef (ignore)
1942      int ignore;
1943 {
1944   symbolS *symbolP = 0;
1945   /* DIM BUG FIX sac@cygnus.com */
1946   dim_index = 0;
1947   if (def_symbol_in_progress == NULL)
1948     {
1949       as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
1950       demand_empty_rest_of_line ();
1951       return;
1952     }                           /* if not inside .def/.endef */
1953
1954   /* Set the section number according to storage class. */
1955   switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
1956     {
1957     case C_STRTAG:
1958     case C_ENTAG:
1959     case C_UNTAG:
1960       SF_SET_TAG (def_symbol_in_progress);
1961       /* intentional fallthrough */
1962     case C_FILE:
1963     case C_TPDEF:
1964       SF_SET_DEBUG (def_symbol_in_progress);
1965       S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
1966       break;
1967
1968     case C_EFCN:
1969       SF_SET_LOCAL (def_symbol_in_progress);    /* Do not emit this symbol. */
1970       /* intentional fallthrough */
1971     case C_BLOCK:
1972       SF_SET_PROCESS (def_symbol_in_progress);  /* Will need processing before writing */
1973       /* intentional fallthrough */
1974     case C_FCN:
1975       S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
1976
1977       if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
1978         {                       /* .bf */
1979           if (function_lineoff < 0)
1980             {
1981               fprintf (stderr, "`.bf' symbol without preceding function\n");
1982             }                   /* missing function symbol */
1983           SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
1984
1985           SF_SET_PROCESS (last_line_symbol);
1986           function_lineoff = -1;
1987         }
1988       /* Value is always set to . */
1989       def_symbol_in_progress->sy_frag = frag_now;
1990       S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
1991       break;
1992
1993 #ifdef C_AUTOARG
1994     case C_AUTOARG:
1995 #endif /* C_AUTOARG */
1996     case C_AUTO:
1997     case C_REG:
1998     case C_MOS:
1999     case C_MOE:
2000     case C_MOU:
2001     case C_ARG:
2002     case C_REGPARM:
2003     case C_FIELD:
2004     case C_EOS:
2005       SF_SET_DEBUG (def_symbol_in_progress);
2006       S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2007       break;
2008
2009     case C_EXT:
2010     case C_STAT:
2011     case C_LABEL:
2012       /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2013       break;
2014
2015     case C_USTATIC:
2016     case C_EXTDEF:
2017     case C_ULABEL:
2018       as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
2019       break;
2020     }                           /* switch on storage class */
2021
2022   /* Now that we have built a debug symbol, try to find if we should
2023      merge with an existing symbol or not.  If a symbol is C_EFCN or
2024      absolute_section or untagged SEG_DEBUG it never merges.  We also
2025      don't merge labels, which are in a different namespace, nor
2026      symbols which have not yet been defined since they are typically
2027      unique, nor do we merge tags with non-tags.  */
2028
2029   /* Two cases for functions.  Either debug followed by definition or
2030      definition followed by debug.  For definition first, we will
2031      merge the debug symbol into the definition.  For debug first, the
2032      lineno entry MUST point to the definition function or else it
2033      will point off into space when crawl_symbols() merges the debug
2034      symbol into the real symbol.  Therefor, let's presume the debug
2035      symbol is a real function reference. */
2036
2037   /* FIXME-SOON If for some reason the definition label/symbol is
2038      never seen, this will probably leave an undefined symbol at link
2039      time. */
2040
2041   if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2042       || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2043       || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2044           && !SF_GET_TAG (def_symbol_in_progress))
2045       || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2046       || def_symbol_in_progress->sy_value.X_op != O_constant
2047       || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2048       || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2049     {
2050       symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2051                      &symbol_lastP);
2052     }
2053   else
2054     {
2055       /* This symbol already exists, merge the newly created symbol
2056          into the old one.  This is not mandatory. The linker can
2057          handle duplicate symbols correctly. But I guess that it save
2058          a *lot* of space if the assembly file defines a lot of
2059          symbols. [loic] */
2060
2061       /* The debug entry (def_symbol_in_progress) is merged into the
2062          previous definition.  */
2063
2064       c_symbol_merge (def_symbol_in_progress, symbolP);
2065       /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2066       def_symbol_in_progress = symbolP;
2067
2068       if (SF_GET_FUNCTION (def_symbol_in_progress)
2069           || SF_GET_TAG (def_symbol_in_progress))
2070         {
2071           /* For functions, and tags, the symbol *must* be where the
2072              debug symbol appears.  Move the existing symbol to the
2073              current place. */
2074           /* If it already is at the end of the symbol list, do nothing */
2075           if (def_symbol_in_progress != symbol_lastP)
2076             {
2077               symbol_remove (def_symbol_in_progress, &symbol_rootP,
2078                              &symbol_lastP);
2079               symbol_append (def_symbol_in_progress, symbol_lastP,
2080                              &symbol_rootP, &symbol_lastP);
2081             }                   /* if not already in place */
2082         }                       /* if function */
2083     }                           /* normal or mergable */
2084
2085   if (SF_GET_TAG (def_symbol_in_progress)
2086       && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
2087     {
2088       tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
2089     }
2090
2091   if (SF_GET_FUNCTION (def_symbol_in_progress))
2092     {
2093       know (sizeof (def_symbol_in_progress) <= sizeof (long));
2094       function_lineoff
2095         = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2096
2097       SF_SET_PROCESS (def_symbol_in_progress);
2098
2099       if (symbolP == NULL)
2100         {
2101           /* That is, if this is the first time we've seen the
2102              function... */
2103           symbol_table_insert (def_symbol_in_progress);
2104         }                       /* definition follows debug */
2105     }                           /* Create the line number entry pointing to the function being defined */
2106
2107   def_symbol_in_progress = NULL;
2108   demand_empty_rest_of_line ();
2109 }
2110
2111 static void
2112 obj_coff_dim (ignore)
2113      int ignore;
2114 {
2115   int dim_index;
2116
2117   if (def_symbol_in_progress == NULL)
2118     {
2119       as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2120       demand_empty_rest_of_line ();
2121       return;
2122     }                           /* if not inside .def/.endef */
2123
2124   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2125
2126   for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2127     {
2128       SKIP_WHITESPACES ();
2129       SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2130                         get_absolute_expression ());
2131
2132       switch (*input_line_pointer)
2133         {
2134         case ',':
2135           input_line_pointer++;
2136           break;
2137
2138         default:
2139           as_warn ("badly formed .dim directive ignored");
2140           /* intentional fallthrough */
2141         case '\n':
2142         case ';':
2143           dim_index = DIMNUM;
2144           break;
2145         }
2146     }
2147
2148   demand_empty_rest_of_line ();
2149 }
2150
2151 static void
2152 obj_coff_line (ignore)
2153      int ignore;
2154 {
2155   int this_base;
2156
2157   if (def_symbol_in_progress == NULL)
2158     {
2159       obj_coff_ln (0);
2160       return;
2161     }
2162
2163   this_base = get_absolute_expression ();
2164   if (this_base > line_base)
2165     {
2166       line_base = this_base;
2167     }
2168
2169 #ifndef NO_LISTING
2170   {
2171     extern int listing;
2172     if (listing && 0)
2173       {
2174         listing_source_line ((unsigned int) line_base);
2175       }
2176   }
2177 #endif
2178   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2179   SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2180
2181   demand_empty_rest_of_line ();
2182 }
2183
2184 static void
2185 obj_coff_size (ignore)
2186      int ignore;
2187 {
2188   if (def_symbol_in_progress == NULL)
2189     {
2190       as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2191       demand_empty_rest_of_line ();
2192       return;
2193     }                           /* if not inside .def/.endef */
2194
2195   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2196   SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2197   demand_empty_rest_of_line ();
2198 }
2199
2200 static void
2201 obj_coff_scl (ignore)
2202      int ignore;
2203 {
2204   if (def_symbol_in_progress == NULL)
2205     {
2206       as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2207       demand_empty_rest_of_line ();
2208       return;
2209     }                           /* if not inside .def/.endef */
2210
2211   S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2212   demand_empty_rest_of_line ();
2213 }
2214
2215 static void
2216 obj_coff_tag (ignore)
2217      int ignore;
2218 {
2219   char *symbol_name;
2220   char name_end;
2221
2222   if (def_symbol_in_progress == NULL)
2223     {
2224       as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2225       demand_empty_rest_of_line ();
2226       return;
2227     }
2228
2229   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2230   symbol_name = input_line_pointer;
2231   name_end = get_symbol_end ();
2232
2233   /* Assume that the symbol referred to by .tag is always defined.
2234      This was a bad assumption.  I've added find_or_make. xoxorich. */
2235   SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2236                      (long) tag_find_or_make (symbol_name));
2237   if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2238     {
2239       as_warn ("tag not found for .tag %s", symbol_name);
2240     }                           /* not defined */
2241
2242   SF_SET_TAGGED (def_symbol_in_progress);
2243   *input_line_pointer = name_end;
2244
2245   demand_empty_rest_of_line ();
2246 }
2247
2248 static void
2249 obj_coff_type (ignore)
2250      int ignore;
2251 {
2252   if (def_symbol_in_progress == NULL)
2253     {
2254       as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2255       demand_empty_rest_of_line ();
2256       return;
2257     }                           /* if not inside .def/.endef */
2258
2259   S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2260
2261   if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2262       S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2263     {
2264       SF_SET_FUNCTION (def_symbol_in_progress);
2265     }                           /* is a function */
2266
2267   demand_empty_rest_of_line ();
2268 }
2269
2270 static void
2271 obj_coff_val (ignore)
2272      int ignore;
2273 {
2274   if (def_symbol_in_progress == NULL)
2275     {
2276       as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2277       demand_empty_rest_of_line ();
2278       return;
2279     }                           /* if not inside .def/.endef */
2280
2281   if (is_name_beginner (*input_line_pointer))
2282     {
2283       char *symbol_name = input_line_pointer;
2284       char name_end = get_symbol_end ();
2285
2286       if (!strcmp (symbol_name, "."))
2287         {
2288           def_symbol_in_progress->sy_frag = frag_now;
2289           S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2290           /* If the .val is != from the .def (e.g. statics) */
2291         }
2292       else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2293         {
2294           def_symbol_in_progress->sy_value.X_op = O_symbol;
2295           def_symbol_in_progress->sy_value.X_add_symbol =
2296             symbol_find_or_make (symbol_name);
2297           def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2298           def_symbol_in_progress->sy_value.X_add_number = 0;
2299
2300           /* If the segment is undefined when the forward reference is
2301              resolved, then copy the segment id from the forward
2302              symbol.  */
2303           SF_SET_GET_SEGMENT (def_symbol_in_progress);
2304
2305           /* FIXME: gcc can generate address expressions
2306              here in unusual cases (search for "obscure"
2307              in sdbout.c).  We just ignore the offset
2308              here, thus generating incorrect debugging
2309              information.  We ignore the rest of the
2310              line just below.  */
2311         }
2312       /* Otherwise, it is the name of a non debug symbol and
2313          its value will be calculated later. */
2314       *input_line_pointer = name_end;
2315
2316       /* FIXME: this is to avoid an error message in the
2317          FIXME case mentioned just above.  */
2318       while (! is_end_of_line[(unsigned char) *input_line_pointer])
2319         ++input_line_pointer;
2320     }
2321   else
2322     {
2323       S_SET_VALUE (def_symbol_in_progress,
2324                    (valueT) get_absolute_expression ());
2325     }                           /* if symbol based */
2326
2327   demand_empty_rest_of_line ();
2328 }
2329
2330 void
2331 obj_read_begin_hook ()
2332 {
2333   /* These had better be the same.  Usually 18 bytes. */
2334 #ifndef BFD_HEADERS
2335   know (sizeof (SYMENT) == sizeof (AUXENT));
2336   know (SYMESZ == AUXESZ);
2337 #endif
2338   tag_init ();
2339 }
2340
2341 /* This function runs through the symbol table and puts all the
2342    externals onto another chain */
2343
2344 /* The chain of externals */
2345 symbolS *symbol_externP;
2346 symbolS *symbol_extern_lastP;
2347
2348 stack *block_stack;
2349 symbolS *last_functionP;
2350 symbolS *last_tagP;
2351
2352 static unsigned int
2353 yank_symbols ()
2354 {
2355   symbolS *symbolP;
2356   unsigned int symbol_number = 0;
2357   unsigned int last_file_symno = 0;
2358
2359   for (symbolP = symbol_rootP;
2360        symbolP;
2361        symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2362     {
2363       if (!SF_GET_DEBUG (symbolP))
2364         {
2365           /* Debug symbols do not need all this rubbish */
2366           symbolS *real_symbolP;
2367
2368           /* L* and C_EFCN symbols never merge. */
2369           if (!SF_GET_LOCAL (symbolP)
2370               && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2371               && symbolP->sy_value.X_op == O_constant
2372               && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2373               && real_symbolP != symbolP)
2374             {
2375               /* FIXME-SOON: where do dups come from?
2376                  Maybe tag references before definitions? xoxorich. */
2377               /* Move the debug data from the debug symbol to the
2378                  real symbol. Do NOT do the oposite (i.e. move from
2379                  real symbol to debug symbol and remove real symbol from the
2380                  list.) Because some pointers refer to the real symbol
2381                  whereas no pointers refer to the debug symbol. */
2382               c_symbol_merge (symbolP, real_symbolP);
2383               /* Replace the current symbol by the real one */
2384               /* The symbols will never be the last or the first
2385                  because : 1st symbol is .file and 3 last symbols are
2386                  .text, .data, .bss */
2387               symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2388               symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2389               symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2390               symbolP = real_symbolP;
2391             }                   /* if not local but dup'd */
2392
2393           if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2394             {
2395               S_SET_SEGMENT (symbolP, SEG_E0);
2396             }                   /* push data into text */
2397
2398           resolve_symbol_value (symbolP);
2399
2400           if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2401             {
2402               if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2403                 {
2404                   S_SET_EXTERNAL (symbolP);
2405                 }
2406               else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2407                 {
2408                   S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2409                 }
2410               else
2411                 {
2412                   S_SET_STORAGE_CLASS (symbolP, C_STAT);
2413                 }
2414             }
2415
2416           /* Mainly to speed up if not -g */
2417           if (SF_GET_PROCESS (symbolP))
2418             {
2419               /* Handle the nested blocks auxiliary info. */
2420               if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2421                 {
2422                   if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2423                     stack_push (block_stack, (char *) &symbolP);
2424                   else
2425                     {           /* .eb */
2426                       register symbolS *begin_symbolP;
2427                       begin_symbolP = *(symbolS **) stack_pop (block_stack);
2428                       if (begin_symbolP == (symbolS *) 0)
2429                         as_warn ("mismatched .eb");
2430                       else
2431                         SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2432                     }
2433                 }
2434               /* If we are able to identify the type of a function, and we
2435                are out of a function (last_functionP == 0) then, the
2436                function symbol will be associated with an auxiliary
2437                entry. */
2438               if (last_functionP == (symbolS *) 0 &&
2439                   SF_GET_FUNCTION (symbolP))
2440                 {
2441                   last_functionP = symbolP;
2442
2443                   if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2444                     {
2445                       S_SET_NUMBER_AUXILIARY (symbolP, 1);
2446                     }           /* make it at least 1 */
2447
2448                   /* Clobber possible stale .dim information. */
2449 #if 0
2450                   /* Iffed out by steve - this fries the lnnoptr info too */
2451                   bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2452                          sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2453 #endif
2454                 }
2455               /* The C_FCN doesn't need any additional information.  I
2456                  don't even know if this is needed for sdb. But the
2457                  standard assembler generates it, so...  */
2458               if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2459                 {
2460                   if (last_functionP == (symbolS *) 0)
2461                     as_fatal ("C_EFCN symbol out of scope");
2462                   SA_SET_SYM_FSIZE (last_functionP,
2463                                     (long) (S_GET_VALUE (symbolP) -
2464                                             S_GET_VALUE (last_functionP)));
2465                   SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2466                  last_functionP = (symbolS *) 0;
2467                 }
2468             }
2469         }
2470       else if (SF_GET_TAG (symbolP))
2471         {
2472           /* First descriptor of a structure must point to
2473                the first slot after the structure description. */
2474           last_tagP = symbolP;
2475
2476         }
2477       else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2478         {
2479           /* +2 take in account the current symbol */
2480           SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2481         }
2482       else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2483         {
2484           if (S_GET_VALUE (symbolP))
2485             {
2486               S_SET_VALUE (symbolP, last_file_symno);
2487               last_file_symno = symbol_number;
2488             }                   /* no one points at the first .file symbol */
2489         }                       /* if debug or tag or eos or file */
2490
2491       /* We must put the external symbols apart. The loader
2492          does not bomb if we do not. But the references in
2493          the endndx field for a .bb symbol are not corrected
2494          if an external symbol is removed between .bb and .be.
2495          I.e in the following case :
2496          [20] .bb endndx = 22
2497          [21] foo external
2498          [22] .be
2499          ld will move the symbol 21 to the end of the list but
2500          endndx will still be 22 instead of 21. */
2501
2502
2503       if (SF_GET_LOCAL (symbolP))
2504         {
2505           /* remove C_EFCN and LOCAL (L...) symbols */
2506           /* next pointer remains valid */
2507           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2508
2509         }
2510       else if (!S_IS_DEFINED (symbolP)
2511                && !S_IS_DEBUG (symbolP)
2512                && !SF_GET_STATICS (symbolP) &&
2513                S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2514         {                       /* C_EXT && !SF_GET_FUNCTION(symbolP))  */
2515           /* if external, Remove from the list */
2516           symbolS *hold = symbol_previous (symbolP);
2517
2518           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2519           symbol_clear_list_pointers (symbolP);
2520           symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2521           symbolP = hold;
2522         }
2523       else
2524         {
2525           if (SF_GET_STRING (symbolP))
2526             {
2527               symbolP->sy_name_offset = string_byte_count;
2528               string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2529             }
2530           else
2531             {
2532               symbolP->sy_name_offset = 0;
2533             }                   /* fix "long" names */
2534
2535           symbolP->sy_number = symbol_number;
2536           symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2537         }                       /* if local symbol */
2538     }                           /* traverse the symbol list */
2539   return symbol_number;
2540
2541 }
2542
2543
2544 static unsigned int
2545 glue_symbols ()
2546 {
2547   unsigned int symbol_number = 0;
2548   symbolS *symbolP;
2549   for (symbolP = symbol_externP; symbol_externP;)
2550     {
2551       symbolS *tmp = symbol_externP;
2552
2553       /* append */
2554       symbol_remove (tmp, &symbol_externP, &symbol_extern_lastP);
2555       symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2556
2557       /* and process */
2558       if (SF_GET_STRING (tmp))
2559         {
2560           tmp->sy_name_offset = string_byte_count;
2561           string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2562         }
2563       else
2564         {
2565           tmp->sy_name_offset = 0;
2566         }                       /* fix "long" names */
2567
2568       tmp->sy_number = symbol_number;
2569       symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2570     }                           /* append the entire extern chain */
2571   return symbol_number;
2572
2573 }
2574
2575 static unsigned int
2576 tie_tags ()
2577 {
2578   unsigned int symbol_number = 0;
2579
2580   symbolS *symbolP;
2581   for (symbolP = symbol_rootP; symbolP; symbolP =
2582        symbol_next (symbolP))
2583     {
2584       symbolP->sy_number = symbol_number;
2585
2586
2587
2588       if (SF_GET_TAGGED (symbolP))
2589         {
2590           SA_SET_SYM_TAGNDX
2591             (symbolP,
2592              ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2593         }
2594
2595       symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2596     }
2597   return symbol_number;
2598
2599 }
2600
2601 static void
2602 crawl_symbols (h, abfd)
2603      object_headers *h;
2604      bfd * abfd;
2605 {
2606   unsigned int i;
2607
2608   /* Initialize the stack used to keep track of the matching .bb .be */
2609
2610   block_stack = stack_init (512, sizeof (symbolS *));
2611
2612   /* The symbol list should be ordered according to the following sequence
2613    * order :
2614    * . .file symbol
2615    * . debug entries for functions
2616    * . fake symbols for the sections, including.text .data and .bss
2617    * . defined symbols
2618    * . undefined symbols
2619    * But this is not mandatory. The only important point is to put the
2620    * undefined symbols at the end of the list.
2621    */
2622
2623   if (symbol_rootP == NULL
2624       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
2625     {
2626       c_dot_file_symbol ("fake");
2627     }
2628   /* Is there a .file symbol ? If not insert one at the beginning. */
2629
2630   /*
2631    * Build up static symbols for the sections, they are filled in later
2632    */
2633
2634
2635   for (i = SEG_E0; i < SEG_E9; i++)
2636     {
2637       if (segment_info[i].scnhdr.s_name[0])
2638         {
2639           char name[9];
2640
2641           strncpy (name, segment_info[i].scnhdr.s_name, 8);
2642           name[8] = '\0';
2643           segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
2644         }
2645     }
2646
2647
2648   /* Take all the externals out and put them into another chain */
2649   H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
2650   /* Take the externals and glue them onto the end.*/
2651   H_SET_SYMBOL_TABLE_SIZE (h, H_GET_SYMBOL_COUNT (h) + glue_symbols ());
2652
2653   H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
2654   know (symbol_externP == NULL);
2655   know (symbol_extern_lastP == NULL);
2656 }
2657
2658 /*
2659  * Find strings by crawling along symbol table chain.
2660  */
2661
2662 void
2663 w_strings (where)
2664      char *where;
2665 {
2666   symbolS *symbolP;
2667
2668   /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2669   md_number_to_chars (where, (valueT) string_byte_count, 4);
2670   where += 4;
2671   for (symbolP = symbol_rootP;
2672        symbolP;
2673        symbolP = symbol_next (symbolP))
2674     {
2675       unsigned int size;
2676
2677       if (SF_GET_STRING (symbolP))
2678         {
2679           size = strlen (S_GET_NAME (symbolP)) + 1;
2680
2681           memcpy (where, S_GET_NAME (symbolP), size);
2682           where += size;
2683
2684         }
2685     }
2686 }
2687
2688 static void
2689 do_linenos_for (abfd, h, file_cursor)
2690      bfd * abfd;
2691      object_headers * h;
2692      unsigned long *file_cursor;
2693 {
2694   unsigned int idx;
2695   unsigned long start = *file_cursor;
2696
2697   for (idx = SEG_E0; idx < SEG_E9; idx++)
2698     {
2699       segment_info_type *s = segment_info + idx;
2700
2701
2702       if (s->scnhdr.s_nlnno != 0)
2703         {
2704           struct lineno_list *line_ptr;
2705
2706           struct external_lineno *buffer =
2707           (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
2708
2709           struct external_lineno *dst = buffer;
2710
2711           /* Run through the table we've built and turn it into its external
2712          form, take this chance to remove duplicates */
2713
2714           for (line_ptr = s->lineno_list_head;
2715                line_ptr != (struct lineno_list *) NULL;
2716                line_ptr = line_ptr->next)
2717             {
2718
2719               if (line_ptr->line.l_lnno == 0)
2720                 {
2721                   /* Turn a pointer to a symbol into the symbols' index */
2722                   line_ptr->line.l_addr.l_symndx =
2723                     ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
2724                 }
2725               else
2726                 {
2727                   line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
2728                 }
2729
2730
2731               (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
2732               dst++;
2733
2734             }
2735
2736           s->scnhdr.s_lnnoptr = *file_cursor;
2737
2738           bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
2739           free (buffer);
2740
2741           *file_cursor += s->scnhdr.s_nlnno * LINESZ;
2742         }
2743     }
2744   H_SET_LINENO_SIZE (h, *file_cursor - start);
2745 }
2746
2747
2748 /* Now we run through the list of frag chains in a segment and
2749    make all the subsegment frags appear at the end of the
2750    list, as if the seg 0 was extra long */
2751
2752 static void
2753 remove_subsegs ()
2754 {
2755   unsigned int i;
2756
2757   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2758     {
2759       frchainS *head = segment_info[i].frchainP;
2760       fragS dummy;
2761       fragS *prev_frag = &dummy;
2762
2763       while (head && head->frch_seg == i)
2764         {
2765           prev_frag->fr_next = head->frch_root;
2766           prev_frag = head->frch_last;
2767           head = head->frch_next;
2768         }
2769       prev_frag->fr_next = 0;
2770     }
2771 }
2772
2773 unsigned long machine;
2774 int coff_flags;
2775 extern void
2776 write_object_file ()
2777 {
2778   int i;
2779   char *name;
2780   struct frchain *frchain_ptr;
2781
2782   object_headers headers;
2783   unsigned long file_cursor;
2784   bfd *abfd;
2785   unsigned int addr;
2786   abfd = bfd_openw (out_file_name, TARGET_FORMAT);
2787
2788
2789   if (abfd == 0)
2790     {
2791       as_perror ("FATAL: Can't create %s", out_file_name);
2792       exit (42);
2793     }
2794   bfd_set_format (abfd, bfd_object);
2795   bfd_set_arch_mach (abfd, BFD_ARCH, machine);
2796
2797   string_byte_count = 4;
2798
2799   for (frchain_ptr = frchain_root;
2800        frchain_ptr != (struct frchain *) NULL;
2801        frchain_ptr = frchain_ptr->frch_next)
2802     {
2803       /* Run through all the sub-segments and align them up.  Also
2804          close any open frags.  We tack a .fill onto the end of the
2805          frag chain so that any .align's size can be worked by looking
2806          at the next frag.  */
2807
2808       subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
2809 #ifndef SUB_SEGMENT_ALIGN
2810 #define SUB_SEGMENT_ALIGN(SEG) 1
2811 #endif
2812       frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
2813       frag_wane (frag_now);
2814       frag_now->fr_fix = 0;
2815       know (frag_now->fr_next == NULL);
2816     }
2817
2818
2819   remove_subsegs ();
2820
2821
2822   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2823     {
2824       relax_segment (segment_info[i].frchainP->frch_root, i);
2825     }
2826
2827   H_SET_NUMBER_OF_SECTIONS (&headers, 0);
2828
2829   /* Find out how big the sections are, and set the addresses.  */
2830   addr = 0;
2831   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2832     {
2833       long size;
2834
2835       segment_info[i].scnhdr.s_paddr = addr;
2836       segment_info[i].scnhdr.s_vaddr = addr;
2837
2838       if (segment_info[i].scnhdr.s_name[0])
2839         {
2840           H_SET_NUMBER_OF_SECTIONS (&headers,
2841                                     H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
2842         }
2843
2844       size = size_section (abfd, (unsigned int) i);
2845       addr += size;
2846
2847       /* I think the section alignment is only used on the i960; the
2848          i960 needs it, and it should do no harm on other targets.  */
2849       segment_info[i].scnhdr.s_align = section_alignment[i];
2850
2851       if (i == SEG_E0)
2852         H_SET_TEXT_SIZE (&headers, size);
2853       else if (i == SEG_E1)
2854         H_SET_DATA_SIZE (&headers, size);
2855       else if (i == SEG_E2)
2856         H_SET_BSS_SIZE (&headers, size);
2857     }
2858
2859   /* Turn the gas native symbol table shape into a coff symbol table */
2860   crawl_symbols (&headers, abfd);
2861
2862   if (string_byte_count == 4)
2863     string_byte_count = 0;
2864
2865   H_SET_STRING_SIZE (&headers, string_byte_count);
2866
2867 #if !defined(TC_H8300) && !defined(TC_Z8K)
2868   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2869     {
2870       fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
2871       fixup_segment (&segment_info[i], i);
2872     }
2873 #endif
2874
2875   /* Look for ".stab" segments and fill in their initial symbols
2876      correctly. */
2877   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2878     {
2879       name = segment_info[i].scnhdr.s_name;
2880
2881       if (name != NULL
2882           && strncmp (".stab", name, 5) == 0
2883           && strncmp (".stabstr", name, 8) != 0)
2884         adjust_stab_section (abfd, i);
2885     }
2886
2887   file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
2888
2889   bfd_seek (abfd, (file_ptr) file_cursor, 0);
2890
2891   /* Plant the data */
2892
2893   fill_section (abfd, &headers, &file_cursor);
2894
2895   do_relocs_for (abfd, &headers, &file_cursor);
2896
2897   do_linenos_for (abfd, &headers, &file_cursor);
2898
2899   H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
2900 #ifndef OBJ_COFF_OMIT_TIMESTAMP
2901   H_SET_TIME_STAMP (&headers, (long)time((long*)0));
2902 #else
2903   H_SET_TIME_STAMP (&headers, 0);
2904 #endif
2905 #ifdef TC_COFF_SET_MACHINE
2906   TC_COFF_SET_MACHINE (&headers);
2907 #endif
2908
2909 #ifdef KEEP_RELOC_INFO
2910   H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
2911                           COFF_FLAGS | coff_flags));
2912 #else
2913   H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers)     ? 0 : F_LNNO)   |
2914                           (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
2915                           COFF_FLAGS | coff_flags));
2916 #endif
2917
2918   {
2919     unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
2920     char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
2921
2922     H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
2923     w_symbols (abfd, buffer1, symbol_rootP);
2924     if (string_byte_count > 0)
2925       w_strings (buffer1 + symtable_size);
2926     bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
2927     free (buffer1);
2928   }
2929
2930   coff_header_append (abfd, &headers);
2931 #if 0
2932   /* Recent changes to write need this, but where it should
2933      go is up to Ken.. */
2934   if (bfd_close_all_done (abfd) == false)
2935     as_fatal ("Can't close %s: %s", out_file_name,
2936               bfd_errmsg (bfd_get_error ()));
2937 #else
2938   {
2939     extern bfd *stdoutput;
2940     stdoutput = abfd;
2941   }
2942 #endif
2943
2944 }
2945
2946 /* Add a new segment.  This is called from subseg_new via the
2947    obj_new_segment macro.  */
2948
2949 segT
2950 obj_coff_add_segment (name)
2951      const char *name;
2952 {
2953   unsigned int len;
2954   unsigned int i;
2955
2956   /* Find out if we've already got a section of this name.  */
2957   len = strlen (name);
2958   if (len < sizeof (segment_info[i].scnhdr.s_name))
2959     ++len;
2960   else
2961     len = sizeof (segment_info[i].scnhdr.s_name);
2962   for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
2963     if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
2964         && (len == sizeof (segment_info[i].scnhdr.s_name)
2965             || segment_info[i].scnhdr.s_name[len] == '\0'))
2966       return (segT) i;
2967
2968   if (i == SEG_E9)
2969     {
2970       as_bad ("Too many new sections; can't add \"%s\"", name);
2971       return now_seg;
2972     }
2973
2974   /* Add a new section.  */
2975   strncpy (segment_info[i].scnhdr.s_name, name,
2976            sizeof (segment_info[i].scnhdr.s_name));
2977   segment_info[i].scnhdr.s_flags = STYP_REG;
2978
2979   return (segT) i;
2980 }
2981
2982 /*
2983  * implement the .section pseudo op:
2984  *      .section name {, "flags"}
2985  *                ^         ^
2986  *                |         +--- optional flags: 'b' for bss
2987  *                |                              'i' for info
2988  *                +-- section name               'l' for lib
2989  *                                               'n' for noload
2990  *                                               'o' for over
2991  *                                               'w' for data
2992  *                                               'd' (apparently m88k for data)
2993  *                                               'x' for text
2994  * But if the argument is not a quoted string, treat it as a
2995  * subsegment number.
2996  */
2997
2998 void
2999 obj_coff_section (ignore)
3000      int ignore;
3001 {
3002   /* Strip out the section name */
3003   char *section_name;
3004   char *section_name_end;
3005   char c;
3006   int argp;
3007   unsigned int len;
3008   unsigned int exp;
3009   long flags;
3010
3011   section_name = input_line_pointer;
3012   c = get_symbol_end ();
3013   section_name_end = input_line_pointer;
3014
3015   len = section_name_end - section_name;
3016   input_line_pointer++;
3017   SKIP_WHITESPACE ();
3018
3019   argp = 0;
3020   if (c == ',')
3021     argp = 1;
3022   else if (*input_line_pointer == ',')
3023     {
3024       argp = 1;
3025       ++input_line_pointer;
3026       SKIP_WHITESPACE ();
3027     }
3028
3029   exp = 0;
3030   flags = 0;
3031   if (argp)
3032     {
3033       if (*input_line_pointer != '"')
3034         exp = get_absolute_expression ();
3035       else
3036         {
3037           ++input_line_pointer;
3038           while (*input_line_pointer != '"'
3039                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
3040             {
3041               switch (*input_line_pointer)
3042                 {
3043                 case 'b': flags |= STYP_BSS;    break;
3044                 case 'i': flags |= STYP_INFO;   break;
3045                 case 'l': flags |= STYP_LIB;    break;
3046                 case 'n': flags |= STYP_NOLOAD; break;
3047                 case 'o': flags |= STYP_OVER;   break;
3048                 case 'd':
3049                 case 'w': flags |= STYP_DATA;   break;
3050                 case 'x': flags |= STYP_TEXT;   break;
3051                 default:
3052                   as_warn("unknown section attribute '%c'",
3053                           *input_line_pointer);
3054                   break;
3055                 }
3056               ++input_line_pointer;
3057             }
3058           if (*input_line_pointer == '"')
3059             ++input_line_pointer;
3060         }
3061     }
3062
3063   subseg_new (section_name, (subsegT) exp);
3064
3065   segment_info[now_seg].scnhdr.s_flags |= flags;
3066
3067   *section_name_end = c;
3068 }
3069
3070
3071 static void
3072 obj_coff_text (ignore)
3073      int ignore;
3074 {
3075   subseg_new (".text", get_absolute_expression ());
3076 }
3077
3078
3079 static void
3080 obj_coff_data (ignore)
3081      int ignore;
3082 {
3083   if (flag_readonly_data_in_text)
3084     subseg_new (".text", get_absolute_expression () + 1000);
3085   else
3086     subseg_new (".data", get_absolute_expression ());
3087 }
3088
3089 static void
3090 obj_coff_bss (ignore)
3091      int ignore;
3092 {
3093   if (*input_line_pointer == '\n')      /* .bss                 */
3094     subseg_new(".bss", get_absolute_expression());
3095   else                                  /* .bss id,expr         */
3096     obj_coff_lcomm(0);
3097 }
3098
3099 static void
3100 obj_coff_ident (ignore)
3101      int ignore;
3102 {
3103   segT current_seg = now_seg;           /* save current seg     */
3104   subsegT current_subseg = now_subseg;
3105   subseg_new (".comment", 0);           /* .comment seg         */
3106   stringer (1);                         /* read string          */
3107   subseg_set (current_seg, current_subseg);     /* restore current seg  */
3108 }
3109
3110 void
3111 c_symbol_merge (debug, normal)
3112      symbolS *debug;
3113      symbolS *normal;
3114 {
3115   S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3116   S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3117
3118   if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3119     {
3120       S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3121     }                           /* take the most we have */
3122
3123   if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3124     {
3125       memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3126               (char *) &debug->sy_symbol.ost_auxent[0],
3127               (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3128     }                           /* Move all the auxiliary information */
3129
3130   /* Move the debug flags. */
3131   SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3132 }                               /* c_symbol_merge() */
3133
3134 static int
3135 c_line_new (symbol, paddr, line_number, frag)
3136      symbolS * symbol;
3137      long paddr;
3138      int line_number;
3139      fragS * frag;
3140 {
3141   struct lineno_list *new_line =
3142   (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3143
3144   segment_info_type *s = segment_info + now_seg;
3145   new_line->line.l_lnno = line_number;
3146
3147   if (line_number == 0)
3148     {
3149       last_line_symbol = symbol;
3150       new_line->line.l_addr.l_symndx = (long) symbol;
3151     }
3152   else
3153     {
3154       new_line->line.l_addr.l_paddr = paddr;
3155     }
3156
3157   new_line->frag = (char *) frag;
3158   new_line->next = (struct lineno_list *) NULL;
3159
3160
3161   if (s->lineno_list_head == (struct lineno_list *) NULL)
3162     {
3163       s->lineno_list_head = new_line;
3164     }
3165   else
3166     {
3167       s->lineno_list_tail->next = new_line;
3168     }
3169   s->lineno_list_tail = new_line;
3170   return LINESZ * s->scnhdr.s_nlnno++;
3171 }
3172
3173 void
3174 c_dot_file_symbol (filename)
3175      char *filename;
3176 {
3177   symbolS *symbolP;
3178
3179   symbolP = symbol_new (".file",
3180                         SEG_DEBUG,
3181                         0,
3182                         &zero_address_frag);
3183
3184   S_SET_STORAGE_CLASS (symbolP, C_FILE);
3185   S_SET_NUMBER_AUXILIARY (symbolP, 1);
3186   SA_SET_FILE_FNAME (symbolP, filename);
3187 #ifndef NO_LISTING
3188   {
3189     extern int listing;
3190     if (listing)
3191       {
3192         listing_source_file (filename);
3193       }
3194
3195   }
3196
3197 #endif
3198   SF_SET_DEBUG (symbolP);
3199   S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3200
3201   previous_file_symbol = symbolP;
3202
3203   /* Make sure that the symbol is first on the symbol chain */
3204   if (symbol_rootP != symbolP)
3205     {
3206       if (symbolP == symbol_lastP)
3207         {
3208           symbol_lastP = symbol_lastP->sy_previous;
3209         }                       /* if it was the last thing on the list */
3210
3211       symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3212       symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3213       symbol_rootP = symbolP;
3214     }                           /* if not first on the list */
3215
3216 }                               /* c_dot_file_symbol() */
3217
3218 /*
3219  * Build a 'section static' symbol.
3220  */
3221
3222 symbolS *
3223 c_section_symbol (name, idx)
3224      char *name;
3225      int idx;
3226 {
3227   symbolS *symbolP;
3228
3229   symbolP = symbol_new (name, idx,
3230                         0,
3231                         &zero_address_frag);
3232
3233   S_SET_STORAGE_CLASS (symbolP, C_STAT);
3234   S_SET_NUMBER_AUXILIARY (symbolP, 1);
3235
3236   SF_SET_STATICS (symbolP);
3237
3238   return symbolP;
3239 }                               /* c_section_symbol() */
3240
3241 static void
3242 w_symbols (abfd, where, symbol_rootP)
3243      bfd * abfd;
3244      char *where;
3245      symbolS * symbol_rootP;
3246 {
3247   symbolS *symbolP;
3248   unsigned int i;
3249
3250   /* First fill in those values we have only just worked out */
3251   for (i = SEG_E0; i < SEG_E9; i++)
3252     {
3253       symbolP = segment_info[i].dot;
3254       if (symbolP)
3255         {
3256
3257           SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3258           SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3259           SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3260
3261         }
3262     }
3263
3264   /*
3265      * Emit all symbols left in the symbol chain.
3266      */
3267   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3268     {
3269       /* Used to save the offset of the name. It is used to point
3270                to the string in memory but must be a file offset. */
3271       register char *temp;
3272
3273       tc_coff_symbol_emit_hook (symbolP);
3274
3275       temp = S_GET_NAME (symbolP);
3276       if (SF_GET_STRING (symbolP))
3277         {
3278           S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3279           S_SET_ZEROES (symbolP, 0);
3280         }
3281       else
3282         {
3283           memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3284           strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3285         }
3286       where = symbol_to_chars (abfd, where, symbolP);
3287       S_SET_NAME (symbolP, temp);
3288     }
3289
3290 }                               /* w_symbols() */
3291
3292 static void
3293 obj_coff_lcomm (ignore)
3294      int ignore;
3295 {
3296   s_lcomm(0);
3297   return;
3298 #if 0
3299   char *name;
3300   char c;
3301   int temp;
3302   char *p;
3303
3304   symbolS *symbolP;
3305
3306   name = input_line_pointer;
3307
3308   c = get_symbol_end ();
3309   p = input_line_pointer;
3310   *p = c;
3311   SKIP_WHITESPACE ();
3312   if (*input_line_pointer != ',')
3313     {
3314       as_bad ("Expected comma after name");
3315       ignore_rest_of_line ();
3316       return;
3317     }
3318   if (*input_line_pointer == '\n')
3319     {
3320       as_bad ("Missing size expression");
3321       return;
3322     }
3323   input_line_pointer++;
3324   if ((temp = get_absolute_expression ()) < 0)
3325     {
3326       as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3327       ignore_rest_of_line ();
3328       return;
3329     }
3330   *p = 0;
3331
3332   symbolP = symbol_find_or_make(name);
3333
3334   if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3335       S_GET_VALUE(symbolP) == 0)
3336     {
3337       if (! need_pass_2)
3338         {
3339           char *p;
3340           segT current_seg = now_seg;   /* save current seg     */
3341           subsegT current_subseg = now_subseg;
3342
3343           subseg_set (SEG_E2, 1);
3344           symbolP->sy_frag = frag_now;
3345           p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3346                        temp, (char *)0);
3347           *p = 0;
3348           subseg_set (current_seg, current_subseg); /* restore current seg */
3349           S_SET_SEGMENT(symbolP, SEG_E2);
3350           S_SET_STORAGE_CLASS(symbolP, C_STAT);
3351         }
3352     }
3353   else
3354     as_bad("Symbol %s already defined", name);
3355
3356   demand_empty_rest_of_line();
3357 #endif
3358 }
3359
3360 static void
3361 fixup_mdeps (frags, h, this_segment)
3362      fragS * frags;
3363      object_headers * h;
3364      segT this_segment;
3365 {
3366   subseg_change (this_segment, 0);
3367   while (frags)
3368     {
3369       switch (frags->fr_type)
3370         {
3371         case rs_align:
3372         case rs_org:
3373           frags->fr_type = rs_fill;
3374           frags->fr_offset =
3375             (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3376           break;
3377         case rs_machine_dependent:
3378           md_convert_frag (h, frags);
3379           frag_wane (frags);
3380           break;
3381         default:
3382           ;
3383         }
3384       frags = frags->fr_next;
3385     }
3386 }
3387
3388 #if 1
3389 static void
3390 fixup_segment (segP, this_segment_type)
3391      segment_info_type * segP;
3392      segT this_segment_type;
3393 {
3394   register fixS * fixP;
3395   register symbolS *add_symbolP;
3396   register symbolS *sub_symbolP;
3397   register long add_number;
3398   register int size;
3399   register char *place;
3400   register long where;
3401   register char pcrel;
3402   register fragS *fragP;
3403   register segT add_symbol_segment = absolute_section;
3404
3405
3406   for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3407     {
3408       fragP = fixP->fx_frag;
3409       know (fragP);
3410       where = fixP->fx_where;
3411       place = fragP->fr_literal + where;
3412       size = fixP->fx_size;
3413       add_symbolP = fixP->fx_addsy;
3414 #ifdef TC_I960
3415       if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3416         {
3417           /* Relocation should be done via the associated 'bal' entry
3418              point symbol. */
3419
3420           if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3421             {
3422               as_bad_where (fixP->fx_file, fixP->fx_line,
3423                             "No 'bal' entry point for leafproc %s",
3424                             S_GET_NAME (add_symbolP));
3425               continue;
3426             }
3427           fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3428         }
3429 #endif
3430       sub_symbolP = fixP->fx_subsy;
3431       add_number = fixP->fx_offset;
3432       pcrel = fixP->fx_pcrel;
3433
3434       if (add_symbolP)
3435         {
3436           add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3437         }                       /* if there is an addend */
3438
3439       if (sub_symbolP)
3440         {
3441           if (!add_symbolP)
3442             {
3443               /* Its just -sym */
3444               if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
3445                 {
3446                   as_bad_where (fixP->fx_file, fixP->fx_line,
3447                                 "Negative of non-absolute symbol %s",
3448                                 S_GET_NAME (sub_symbolP));
3449                 }               /* not absolute */
3450
3451               add_number -= S_GET_VALUE (sub_symbolP);
3452               fixP->fx_subsy = 0;
3453
3454               /* if sub_symbol is in the same segment that add_symbol
3455                            and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3456             }
3457           else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
3458                    && (SEG_NORMAL (add_symbol_segment)
3459                        || (add_symbol_segment == absolute_section)))
3460             {
3461               /* Difference of 2 symbols from same segment.  Can't
3462                  make difference of 2 undefineds: 'value' means
3463                  something different for N_UNDF. */
3464 #ifdef TC_I960
3465               /* Makes no sense to use the difference of 2 arbitrary symbols
3466                  as the target of a call instruction.  */
3467               if (fixP->fx_tcbit)
3468                 {
3469                   as_bad_where (fixP->fx_file, fixP->fx_line,
3470                                 "callj to difference of 2 symbols");
3471                 }
3472 #endif /* TC_I960 */
3473               add_number += S_GET_VALUE (add_symbolP) -
3474                 S_GET_VALUE (sub_symbolP);
3475
3476               add_symbolP = NULL;
3477               fixP->fx_addsy = NULL;
3478               fixP->fx_subsy = NULL;
3479               fixP->fx_done = 1;
3480             }
3481           else
3482             {
3483               /* Different segments in subtraction. */
3484               know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3485
3486               if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3487                 {
3488                   add_number -= S_GET_VALUE (sub_symbolP);
3489                 }
3490 #ifdef DIFF_EXPR_OK
3491               else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3492 #if 0 /* Okay for 68k, at least... */
3493                        && !pcrel
3494 #endif
3495                        )
3496                 {
3497                   /* Make it pc-relative.  */
3498                   add_number += (md_pcrel_from (fixP)
3499                                  - S_GET_VALUE (sub_symbolP));
3500                   pcrel = 1;
3501                   fixP->fx_pcrel = 1;
3502                   sub_symbolP = 0;
3503                   fixP->fx_subsy = 0;
3504                 }
3505 #endif
3506               else
3507                 {
3508                   as_bad_where (fixP->fx_file, fixP->fx_line,
3509                                 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3510                                 segment_name (S_GET_SEGMENT (sub_symbolP)),
3511                                 S_GET_NAME (sub_symbolP),
3512                                 (long) (fragP->fr_address + where));
3513                 }               /* if absolute */
3514             }
3515         }                       /* if sub_symbolP */
3516
3517       if (add_symbolP)
3518         {
3519           if (add_symbol_segment == this_segment_type && pcrel)
3520             {
3521               /*
3522                * This fixup was made when the symbol's segment was
3523                * SEG_UNKNOWN, but it is now in the local segment.
3524                * So we know how to do the address without relocation.
3525                */
3526 #ifdef TC_I960
3527               /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3528                * in which cases it modifies *fixP as appropriate.  In the case
3529                * of a 'calls', no further work is required, and *fixP has been
3530                * set up to make the rest of the code below a no-op.
3531                */
3532               reloc_callj (fixP);
3533 #endif /* TC_I960 */
3534
3535               add_number += S_GET_VALUE (add_symbolP);
3536               add_number -= md_pcrel_from (fixP);
3537 #if defined (TC_I386) || defined (TE_LYNX)
3538               /* On the 386 we must adjust by the segment
3539                  vaddr as well.  Ian Taylor.  */
3540               add_number -= segP->scnhdr.s_vaddr;
3541 #endif
3542               pcrel = 0;        /* Lie. Don't want further pcrel processing. */
3543               fixP->fx_addsy = NULL;
3544               fixP->fx_done = 1;
3545             }
3546           else
3547             {
3548               switch (add_symbol_segment)
3549                 {
3550                 case absolute_section:
3551 #ifdef TC_I960
3552                   reloc_callj (fixP);   /* See comment about reloc_callj() above*/
3553 #endif /* TC_I960 */
3554                   add_number += S_GET_VALUE (add_symbolP);
3555                   fixP->fx_addsy = NULL;
3556                   fixP->fx_done = 1;
3557                   add_symbolP = NULL;
3558                   break;
3559                 default:
3560
3561 #ifdef TC_A29K
3562                   /* This really should be handled in the linker, but
3563                      backward compatibility forbids.  */
3564                   add_number += S_GET_VALUE (add_symbolP);
3565 #else
3566                   add_number += S_GET_VALUE (add_symbolP) +
3567                     segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3568 #endif
3569                   break;
3570
3571                 case SEG_UNKNOWN:
3572 #ifdef TC_I960
3573                   if ((int) fixP->fx_bit_fixP == 13)
3574                     {
3575                       /* This is a COBR instruction.  They have only a
3576                        * 13-bit displacement and are only to be used
3577                        * for local branches: flag as error, don't generate
3578                        * relocation.
3579                        */
3580                       as_bad_where (fixP->fx_file, fixP->fx_line,
3581                                     "can't use COBR format with external label");
3582                       fixP->fx_addsy = NULL;
3583                       fixP->fx_done = 1;
3584                       continue;
3585                     }           /* COBR */
3586 #endif /* TC_I960 */
3587 #if defined (TC_I386) || defined (TE_LYNX)
3588                   /* 386 COFF uses a peculiar format in
3589                      which the value of a common symbol is
3590                      stored in the .text segment (I've
3591                      checked this on SVR3.2 and SCO 3.2.2)
3592                      Ian Taylor <ian@cygnus.com>.  */
3593                   if (S_IS_COMMON (add_symbolP))
3594                     add_number += S_GET_VALUE (add_symbolP);
3595 #endif
3596                   break;
3597
3598
3599                 }               /* switch on symbol seg */
3600             }                   /* if not in local seg */
3601         }                       /* if there was a + symbol */
3602
3603       if (pcrel)
3604         {
3605 #ifndef TC_M88K
3606           /* This adjustment is not correct on the m88k, for which the
3607              linker does all the computation.  */
3608           add_number -= md_pcrel_from (fixP);
3609 #endif
3610           if (add_symbolP == 0)
3611             {
3612               fixP->fx_addsy = &abs_symbol;
3613             }                   /* if there's an add_symbol */
3614 #if defined (TC_I386) || defined (TE_LYNX)
3615           /* On the 386 we must adjust by the segment vaddr
3616              as well.  Ian Taylor.  */
3617           add_number -= segP->scnhdr.s_vaddr;
3618 #endif
3619         }                       /* if pcrel */
3620
3621       if (!fixP->fx_bit_fixP)
3622         {
3623 #ifndef TC_M88K
3624           /* The m88k uses the offset field of the reloc to get around
3625              this problem.  */
3626           if ((size == 1 &&
3627           (add_number & ~0xFF) && ((add_number & ~0xFF) != (-1 & ~0xFF))) ||
3628               (size == 2 &&
3629                (add_number & ~0xFFFF) && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3630             {
3631               as_bad_where (fixP->fx_file, fixP->fx_line,
3632                             "Value of %ld too large for field of %d bytes at 0x%lx",
3633                             (long) add_number, size,
3634                             (unsigned long) (fragP->fr_address + where));
3635             }                   /* generic error checking */
3636 #endif
3637 #ifdef WARN_SIGNED_OVERFLOW_WORD
3638           /* Warn if a .word value is too large when treated as
3639              a signed number.  We already know it is not too
3640              negative.  This is to catch over-large switches
3641              generated by gcc on the 68k.  */
3642           if (!flag_signed_overflow_ok
3643               && size == 2
3644               && add_number > 0x7fff)
3645             as_bad_where (fixP->fx_file, fixP->fx_line,
3646                           "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3647                           (long) add_number,
3648                           (unsigned long) (fragP->fr_address + where));
3649 #endif
3650         }                       /* not a bit fix */
3651       /* once this fix has been applied, we don't have to output anything
3652            nothing more need be done -*/
3653       md_apply_fix (fixP, add_number);
3654     }                           /* For each fixS in this segment. */
3655 }                               /* fixup_segment() */
3656
3657 #endif
3658
3659 /* The first entry in a .stab section is special.  */
3660
3661 void
3662 obj_coff_init_stab_section (seg)
3663      segT seg;
3664 {
3665   char *file;
3666   char *p;
3667   char *stabstr_name;
3668   unsigned int stroff;
3669
3670   /* Make space for this first symbol. */
3671   p = frag_more (12);
3672   /* Zero it out. */
3673   memset (p, 0, 12);
3674   as_where (&file, (unsigned int *) NULL);
3675   stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
3676   strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
3677   strcat (stabstr_name, "str");
3678   stroff = get_stab_string_offset (file, stabstr_name);
3679   know (stroff == 1);
3680   md_number_to_chars (p, stroff, 4);
3681 }
3682
3683 /* Fill in the counts in the first entry in a .stab section.  */
3684
3685 static void
3686 adjust_stab_section(abfd, seg)
3687      bfd *abfd;
3688      segT seg;
3689 {
3690   segT stabstrseg = SEG_UNKNOWN;
3691   char *secname, *name, *name2;
3692   char *p = NULL;
3693   int i, strsz = 0, nsyms;
3694   fragS *frag = segment_info[seg].frchainP->frch_root;
3695
3696   /* Look for the associated string table section. */
3697
3698   secname = segment_info[seg].scnhdr.s_name;
3699   name = (char *) alloca (strlen (secname) + 4);
3700   strcpy (name, secname);
3701   strcat (name, "str");
3702
3703   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3704     {
3705       name2 = segment_info[i].scnhdr.s_name;
3706       if (name2 != NULL && strncmp(name2, name, 8) == 0)
3707         {
3708           stabstrseg = i;
3709           break;
3710         }
3711     }
3712
3713   /* If we found the section, get its size. */
3714   if (stabstrseg != SEG_UNKNOWN)
3715     strsz = size_section (abfd, stabstrseg);
3716
3717   nsyms = size_section (abfd, seg) / 12 - 1;
3718
3719   /* Look for the first frag of sufficient size for the initial stab
3720      symbol, and collect a pointer to it. */
3721   while (frag && frag->fr_fix < 12)
3722     frag = frag->fr_next;
3723   assert (frag != 0);
3724   p = frag->fr_literal;
3725   assert (p != 0);
3726
3727   /* Write in the number of stab symbols and the size of the string
3728      table. */
3729   bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
3730   bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
3731 }
3732
3733 #endif /* not BFD_ASSEMBLER */
3734
3735 const pseudo_typeS obj_pseudo_table[] =
3736 {
3737   {"def", obj_coff_def, 0},
3738   {"dim", obj_coff_dim, 0},
3739   {"endef", obj_coff_endef, 0},
3740   {"line", obj_coff_line, 0},
3741   {"ln", obj_coff_ln, 0},
3742   {"appline", obj_coff_ln, 1},
3743   {"scl", obj_coff_scl, 0},
3744   {"size", obj_coff_size, 0},
3745   {"tag", obj_coff_tag, 0},
3746   {"type", obj_coff_type, 0},
3747   {"val", obj_coff_val, 0},
3748   {"section", obj_coff_section, 0},
3749 #ifndef BFD_ASSEMBLER
3750   {"use", obj_coff_section, 0},
3751   {"sect", obj_coff_section, 0},
3752   {"text", obj_coff_text, 0},
3753   {"data", obj_coff_data, 0},
3754   {"bss", obj_coff_bss, 0},
3755   {"lcomm", obj_coff_lcomm, 0},
3756   {"ident", obj_coff_ident, 0},
3757 #else
3758   {"optim", s_ignore, 0},       /* For sun386i cc (?) */
3759   {"ident", s_ignore, 0},       /* we don't yet handle this. */
3760 #endif
3761   {"ABORT", s_abort, 0},
3762 #ifdef TC_M88K
3763   /* The m88k uses sdef instead of def.  */
3764   {"sdef", obj_coff_def, 0},
3765 #endif
3766   {NULL}                        /* end sentinel */
3767 };                              /* obj_pseudo_table */