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