gas/config/obj-coff.c

   1 /* coff object file format
   2    Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #define OBJ_HEADER "obj-coff.h"
  24
  25 #include "as.h"
  26 #include "obstack.h"
  27 #include "subsegs.h"
  28
  29 /* I think this is probably always correct.  */
  30 #ifndef KEEP_RELOC_INFO
  31 #define KEEP_RELOC_INFO
  32 #endif
  33
  34 /* The BFD_ASSEMBLER version of obj_coff_section will use this macro to set
  35    a new section's attributes when a directive has no valid flags or the
  36    "w" flag is used. This default should be appropriate for most.  */
  37 #ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
  38 #define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
  39 #endif
  40
  41 /* This is used to hold the symbol built by a sequence of pseudo-ops
  42    from .def and .endef.  */
  43 static symbolS *def_symbol_in_progress;
  44
  45 typedef struct
  46   {
  47     unsigned long chunk_size;
  48     unsigned long element_size;
  49     unsigned long size;
  50     char *data;
  51     unsigned long pointer;
  52   }
  53 stack;
  54
  55 static stack *stack_init PARAMS ((unsigned long, unsigned long));
  56 static char *stack_push PARAMS ((stack *, char *));
  57 static char *stack_pop PARAMS ((stack *));
  58 static void tag_init PARAMS ((void));
  59 static void tag_insert PARAMS ((const char *, symbolS *));
  60 static symbolS *tag_find PARAMS ((char *));
  61 static symbolS *tag_find_or_make PARAMS ((char *));
  62 static void obj_coff_bss PARAMS ((int));
  63 static void obj_coff_weak PARAMS ((int));
  64 const char *s_get_name PARAMS ((symbolS * s));
  65 static void obj_coff_ln PARAMS ((int));
  66 static void obj_coff_def PARAMS ((int));
  67 static void obj_coff_endef PARAMS ((int));
  68 static void obj_coff_dim PARAMS ((int));
  69 static void obj_coff_line PARAMS ((int));
  70 static void obj_coff_size PARAMS ((int));
  71 static void obj_coff_scl PARAMS ((int));
  72 static void obj_coff_tag PARAMS ((int));
  73 static void obj_coff_val PARAMS ((int));
  74 static void obj_coff_type PARAMS ((int));
  75 static void obj_coff_ident PARAMS ((int));
  76 #ifdef BFD_ASSEMBLER
  77 static void obj_coff_loc PARAMS((int));
  78 #endif
  79 \f
  80 /* stack stuff */
  81
  82 static stack *
  83 stack_init (chunk_size, element_size)
  84      unsigned long chunk_size;
  85      unsigned long element_size;
  86 {
  87   stack *st;
  88
  89   st = (stack *) malloc (sizeof (stack));
  90   if (!st)
  91     return 0;
  92   st->data = malloc (chunk_size);
  93   if (!st->data)
  94     {
  95       free (st);
  96       return 0;
  97     }
  98   st->pointer = 0;
  99   st->size = chunk_size;
 100   st->chunk_size = chunk_size;
 101   st->element_size = element_size;
 102   return st;
 103 }
 104
 105 #if 0
 106 /* Not currently used.  */
 107 static void
 108 stack_delete (st)
 109      stack *st;
 110 {
 111   free (st->data);
 112   free (st);
 113 }
 114 #endif
 115
 116 static char *
 117 stack_push (st, element)
 118      stack *st;
 119      char *element;
 120 {
 121   if (st->pointer + st->element_size >= st->size)
 122     {
 123       st->size += st->chunk_size;
 124       if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
 125         return (char *) 0;
 126     }
 127   memcpy (st->data + st->pointer, element, st->element_size);
 128   st->pointer += st->element_size;
 129   return st->data + st->pointer;
 130 }
 131
 132 static char *
 133 stack_pop (st)
 134      stack *st;
 135 {
 136   if (st->pointer < st->element_size)
 137     {
 138       st->pointer = 0;
 139       return (char *) 0;
 140     }
 141   st->pointer -= st->element_size;
 142   return st->data + st->pointer;
 143 }
 144 \f
 145 /*
 146  * Maintain a list of the tagnames of the structres.
 147  */
 148
 149 static struct hash_control *tag_hash;
 150
 151 static void
 152 tag_init ()
 153 {
 154   tag_hash = hash_new ();
 155 }
 156
 157 static void
 158 tag_insert (name, symbolP)
 159      const char *name;
 160      symbolS *symbolP;
 161 {
 162   const char *error_string;
 163
 164   if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
 165     {
 166       as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
 167                 name, error_string);
 168     }
 169 }
 170
 171 static symbolS *
 172 tag_find (name)
 173      char *name;
 174 {
 175 #ifdef STRIP_UNDERSCORE
 176   if (*name == '_')
 177     name++;
 178 #endif /* STRIP_UNDERSCORE */
 179   return (symbolS *) hash_find (tag_hash, name);
 180 }
 181
 182 static symbolS *
 183 tag_find_or_make (name)
 184      char *name;
 185 {
 186   symbolS *symbolP;
 187
 188   if ((symbolP = tag_find (name)) == NULL)
 189     {
 190       symbolP = symbol_new (name, undefined_section,
 191                             0, &zero_address_frag);
 192
 193       tag_insert (S_GET_NAME (symbolP), symbolP);
 194 #ifdef BFD_ASSEMBLER
 195       symbol_table_insert (symbolP);
 196 #endif
 197     }                           /* not found */
 198
 199   return symbolP;
 200 }
 201
 202 /* We accept the .bss directive to set the section for backward
 203    compatibility with earlier versions of gas.  */
 204
 205 static void
 206 obj_coff_bss (ignore)
 207      int ignore ATTRIBUTE_UNUSED;
 208 {
 209   if (*input_line_pointer == '\n')
 210     subseg_new (".bss", get_absolute_expression ());
 211   else
 212     s_lcomm (0);
 213 }
 214
 215 /* Handle .weak.  This is a GNU extension.  */
 216
 217 static void
 218 obj_coff_weak (ignore)
 219      int ignore ATTRIBUTE_UNUSED;
 220 {
 221   char *name;
 222   int c;
 223   symbolS *symbolP;
 224
 225   do
 226     {
 227       name = input_line_pointer;
 228       c = get_symbol_end ();
 229       symbolP = symbol_find_or_make (name);
 230       *input_line_pointer = c;
 231       SKIP_WHITESPACE ();
 232
 233 #if defined BFD_ASSEMBLER || defined S_SET_WEAK
 234       S_SET_WEAK (symbolP);
 235 #endif
 236
 237 #ifdef TE_PE
 238       S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
 239 #else
 240       S_SET_STORAGE_CLASS (symbolP, C_WEAKEXT);
 241 #endif
 242
 243       if (c == ',')
 244         {
 245           input_line_pointer++;
 246           SKIP_WHITESPACE ();
 247           if (*input_line_pointer == '\n')
 248             c = '\n';
 249         }
 250     }
 251   while (c == ',');
 252
 253   demand_empty_rest_of_line ();
 254 }
 255
 256 #ifdef BFD_ASSEMBLER
 257
 258 static segT fetch_coff_debug_section PARAMS ((void));
 259 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
 260 static int S_GET_DATA_TYPE PARAMS ((symbolS *));
 261 void c_symbol_merge PARAMS ((symbolS *, symbolS *));
 262 static void add_lineno PARAMS ((fragS *, addressT, int));
 263
 264 #define GET_FILENAME_STRING(X) \
 265 ((char*) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
 266
 267 /* @@ Ick.  */
 268 static segT
 269 fetch_coff_debug_section ()
 270 {
 271   static segT debug_section;
 272   if (!debug_section)
 273     {
 274       CONST asymbol *s;
 275       s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
 276       assert (s != 0);
 277       debug_section = s->section;
 278     }
 279   return debug_section;
 280 }
 281
 282 void
 283 SA_SET_SYM_ENDNDX (sym, val)
 284      symbolS *sym;
 285      symbolS *val;
 286 {
 287   combined_entry_type *entry, *p;
 288
 289   entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
 290   p = coffsymbol (symbol_get_bfdsym (val))->native;
 291   entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
 292   entry->fix_end = 1;
 293 }
 294
 295 static void
 296 SA_SET_SYM_TAGNDX (sym, val)
 297      symbolS *sym;
 298      symbolS *val;
 299 {
 300   combined_entry_type *entry, *p;
 301
 302   entry = &coffsymbol (symbol_get_bfdsym (sym))->native[1];
 303   p = coffsymbol (symbol_get_bfdsym (val))->native;
 304   entry->u.auxent.x_sym.x_tagndx.p = p;
 305   entry->fix_tag = 1;
 306 }
 307
 308 static int
 309 S_GET_DATA_TYPE (sym)
 310      symbolS *sym;
 311 {
 312   return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
 313 }
 314
 315 int
 316 S_SET_DATA_TYPE (sym, val)
 317      symbolS *sym;
 318      int val;
 319 {
 320   coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
 321   return val;
 322 }
 323
 324 int
 325 S_GET_STORAGE_CLASS (sym)
 326      symbolS *sym;
 327 {
 328   return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
 329 }
 330
 331 int
 332 S_SET_STORAGE_CLASS (sym, val)
 333      symbolS *sym;
 334      int val;
 335 {
 336   coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
 337   return val;
 338 }
 339
 340 /* Merge a debug symbol containing debug information into a normal symbol.  */
 341
 342 void
 343 c_symbol_merge (debug, normal)
 344      symbolS *debug;
 345      symbolS *normal;
 346 {
 347   S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
 348   S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
 349
 350   if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
 351     {
 352       /* take the most we have */
 353       S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
 354     }
 355
 356   if (S_GET_NUMBER_AUXILIARY (debug) > 0)
 357     {
 358       /* Move all the auxiliary information.  */
 359       memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
 360               (S_GET_NUMBER_AUXILIARY (debug)
 361                * sizeof (*SYM_AUXINFO (debug))));
 362     }
 363
 364   /* Move the debug flags.  */
 365   SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
 366 }
 367
 368 void
 369 c_dot_file_symbol (filename)
 370      const char *filename;
 371 {
 372   symbolS *symbolP;
 373
 374   /* BFD converts filename to a .file symbol with an aux entry.  It
 375      also handles chaining.  */
 376   symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
 377
 378   S_SET_STORAGE_CLASS (symbolP, C_FILE);
 379   S_SET_NUMBER_AUXILIARY (symbolP, 1);
 380
 381   symbol_get_bfdsym (symbolP)->flags = BSF_DEBUGGING;
 382
 383 #ifndef NO_LISTING
 384   {
 385     extern int listing;
 386     if (listing)
 387       {
 388         listing_source_file (filename);
 389       }
 390   }
 391 #endif
 392
 393   /* Make sure that the symbol is first on the symbol chain */
 394   if (symbol_rootP != symbolP)
 395     {
 396       symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
 397       symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
 398     }                           /* if not first on the list */
 399 }
 400
 401 /* Line number handling */
 402
 403 struct line_no {
 404   struct line_no *next;
 405   fragS *frag;
 406   alent l;
 407 };
 408
 409 int coff_line_base;
 410
 411 /* Symbol of last function, which we should hang line#s off of.  */
 412 static symbolS *line_fsym;
 413
 414 #define in_function()           (line_fsym != 0)
 415 #define clear_function()        (line_fsym = 0)
 416 #define set_function(F)         (line_fsym = (F), coff_add_linesym (F))
 417
 418 \f
 419 void
 420 coff_obj_symbol_new_hook (symbolP)
 421      symbolS *symbolP;
 422 {
 423   long   sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
 424   char * s  = (char *) xmalloc (sz);
 425
 426   memset (s, 0, sz);
 427   coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;
 428
 429   S_SET_DATA_TYPE (symbolP, T_NULL);
 430   S_SET_STORAGE_CLASS (symbolP, 0);
 431   S_SET_NUMBER_AUXILIARY (symbolP, 0);
 432
 433   if (S_IS_STRING (symbolP))
 434     SF_SET_STRING (symbolP);
 435
 436   if (S_IS_LOCAL (symbolP))
 437     SF_SET_LOCAL (symbolP);
 438 }
 439
 440 \f
 441 /*
 442  * Handle .ln directives.
 443  */
 444
 445 static symbolS *current_lineno_sym;
 446 static struct line_no *line_nos;
 447 /* @@ Blindly assume all .ln directives will be in the .text section...  */
 448 int coff_n_line_nos;
 449
 450 static void
 451 add_lineno (frag, offset, num)
 452      fragS *frag;
 453      addressT offset;
 454      int num;
 455 {
 456   struct line_no *new_line =
 457     (struct line_no *) xmalloc (sizeof (struct line_no));
 458   if (!current_lineno_sym)
 459     {
 460       abort ();
 461     }
 462
 463 #ifndef OBJ_XCOFF
 464   /* The native aix assembler accepts negative line number */
 465
 466   if (num <= 0)
 467     {
 468       /* Zero is used as an end marker in the file.  */
 469       as_warn (_("Line numbers must be positive integers\n"));
 470       num = 1;
 471     }
 472 #endif /* OBJ_XCOFF */
 473   new_line->next = line_nos;
 474   new_line->frag = frag;
 475   new_line->l.line_number = num;
 476   new_line->l.u.offset = offset;
 477   line_nos = new_line;
 478   coff_n_line_nos++;
 479 }
 480
 481 void
 482 coff_add_linesym (sym)
 483      symbolS *sym;
 484 {
 485   if (line_nos)
 486     {
 487       coffsymbol (symbol_get_bfdsym (current_lineno_sym))->lineno =
 488         (alent *) line_nos;
 489       coff_n_line_nos++;
 490       line_nos = 0;
 491     }
 492   current_lineno_sym = sym;
 493 }
 494
 495 static void
 496 obj_coff_ln (appline)
 497      int appline;
 498 {
 499   int l;
 500
 501   if (! appline && def_symbol_in_progress != NULL)
 502     {
 503       as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
 504       demand_empty_rest_of_line ();
 505       return;
 506     }
 507
 508   l = get_absolute_expression ();
 509
 510   /* If there is no lineno symbol, treat a .ln
 511      directive as if it were a .appline directive.  */
 512   if (appline || current_lineno_sym == NULL)
 513     new_logical_line ((char *) NULL, l - 1);
 514   else
 515     add_lineno (frag_now, frag_now_fix (), l);
 516
 517 #ifndef NO_LISTING
 518   {
 519     extern int listing;
 520
 521     if (listing)
 522       {
 523         if (! appline)
 524           l += coff_line_base - 1;
 525         listing_source_line (l);
 526       }
 527   }
 528 #endif
 529
 530   demand_empty_rest_of_line ();
 531 }
 532
 533 /* .loc is essentially the same as .ln; parse it for assembler
 534    compatibility.  */
 535
 536 static void
 537 obj_coff_loc (ignore)
 538      int ignore ATTRIBUTE_UNUSED;
 539 {
 540   int lineno;
 541
 542   /* FIXME: Why do we need this check?  We need it for ECOFF, but why
 543      do we need it for COFF?  */
 544   if (now_seg != text_section)
 545     {
 546       as_warn (_(".loc outside of .text"));
 547       demand_empty_rest_of_line ();
 548       return;
 549     }
 550
 551   if (def_symbol_in_progress != NULL)
 552     {
 553       as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
 554       demand_empty_rest_of_line ();
 555       return;
 556     }
 557
 558   /* Skip the file number.  */
 559   SKIP_WHITESPACE ();
 560   get_absolute_expression ();
 561   SKIP_WHITESPACE ();
 562
 563   lineno = get_absolute_expression ();
 564
 565 #ifndef NO_LISTING
 566   {
 567     extern int listing;
 568
 569     if (listing)
 570       {
 571         lineno += coff_line_base - 1;
 572         listing_source_line (lineno);
 573       }
 574   }
 575 #endif
 576
 577   demand_empty_rest_of_line ();
 578
 579   add_lineno (frag_now, frag_now_fix (), lineno);
 580 }
 581
 582 /* Handle the .ident pseudo-op.  */
 583
 584 static void
 585 obj_coff_ident (ignore)
 586      int ignore ATTRIBUTE_UNUSED;
 587 {
 588   segT current_seg = now_seg;
 589   subsegT current_subseg = now_subseg;
 590
 591 #ifdef TE_PE
 592   {
 593     segT sec;
 594
 595     /* We could put it in .comment, but that creates an extra section
 596        that shouldn't be loaded into memory, which requires linker
 597        changes...  For now, until proven otherwise, use .rdata.  */
 598     sec = subseg_new (".rdata$zzz", 0);
 599     bfd_set_section_flags (stdoutput, sec,
 600                            ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA)
 601                             & bfd_applicable_section_flags (stdoutput)));
 602   }
 603 #else
 604   subseg_new (".comment", 0);
 605 #endif
 606
 607   stringer (1);
 608   subseg_set (current_seg, current_subseg);
 609 }
 610
 611 /*
 612  *                      def()
 613  *
 614  * Handle .def directives.
 615  *
 616  * One might ask : why can't we symbol_new if the symbol does not
 617  * already exist and fill it with debug information.  Because of
 618  * the C_EFCN special symbol. It would clobber the value of the
 619  * function symbol before we have a chance to notice that it is
 620  * a C_EFCN. And a second reason is that the code is more clear this
 621  * way. (at least I think it is :-).
 622  *
 623  */
 624
 625 #define SKIP_SEMI_COLON()       while (*input_line_pointer++ != ';')
 626 #define SKIP_WHITESPACES()      while (*input_line_pointer == ' ' || \
 627                                        *input_line_pointer == '\t') \
 628     input_line_pointer++;
 629
 630 static void
 631 obj_coff_def (what)
 632      int what ATTRIBUTE_UNUSED;
 633 {
 634   char name_end;                /* Char after the end of name */
 635   char *symbol_name;            /* Name of the debug symbol */
 636   char *symbol_name_copy;       /* Temporary copy of the name */
 637   unsigned int symbol_name_length;
 638
 639   if (def_symbol_in_progress != NULL)
 640     {
 641       as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
 642       demand_empty_rest_of_line ();
 643       return;
 644     }                           /* if not inside .def/.endef */
 645
 646   SKIP_WHITESPACES ();
 647
 648   symbol_name = input_line_pointer;
 649 #ifdef STRIP_UNDERSCORE
 650   if (symbol_name[0] == '_' && symbol_name[1] != 0)
 651     symbol_name++;
 652 #endif /* STRIP_UNDERSCORE */
 653
 654   name_end = get_symbol_end ();
 655   symbol_name_length = strlen (symbol_name);
 656   symbol_name_copy = xmalloc (symbol_name_length + 1);
 657   strcpy (symbol_name_copy, symbol_name);
 658 #ifdef tc_canonicalize_symbol_name
 659   symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
 660 #endif
 661
 662   /* Initialize the new symbol */
 663   def_symbol_in_progress = symbol_make (symbol_name_copy);
 664   symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
 665   S_SET_VALUE (def_symbol_in_progress, 0);
 666
 667   if (S_IS_STRING (def_symbol_in_progress))
 668     SF_SET_STRING (def_symbol_in_progress);
 669
 670   *input_line_pointer = name_end;
 671
 672   demand_empty_rest_of_line ();
 673 }
 674
 675 unsigned int dim_index;
 676
 677 static void
 678 obj_coff_endef (ignore)
 679      int ignore ATTRIBUTE_UNUSED;
 680 {
 681   symbolS *symbolP = NULL;
 682
 683   /* DIM BUG FIX sac@cygnus.com */
 684   dim_index = 0;
 685   if (def_symbol_in_progress == NULL)
 686     {
 687       as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
 688       demand_empty_rest_of_line ();
 689       return;
 690     }                           /* if not inside .def/.endef */
 691
 692   /* Set the section number according to storage class.  */
 693   switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
 694     {
 695     case C_STRTAG:
 696     case C_ENTAG:
 697     case C_UNTAG:
 698       SF_SET_TAG (def_symbol_in_progress);
 699       /* intentional fallthrough */
 700     case C_FILE:
 701     case C_TPDEF:
 702       SF_SET_DEBUG (def_symbol_in_progress);
 703       S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
 704       break;
 705
 706     case C_EFCN:
 707       SF_SET_LOCAL (def_symbol_in_progress);    /* Do not emit this symbol.  */
 708       /* intentional fallthrough */
 709     case C_BLOCK:
 710       SF_SET_PROCESS (def_symbol_in_progress);  /* Will need processing before writing */
 711       /* intentional fallthrough */
 712     case C_FCN:
 713       {
 714         CONST char *name;
 715         S_SET_SEGMENT (def_symbol_in_progress, text_section);
 716
 717         name = S_GET_NAME (def_symbol_in_progress);
 718         if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
 719           {
 720             switch (name[1])
 721               {
 722               case 'b':
 723                 /* .bf */
 724                 if (! in_function ())
 725                   as_warn (_("`%s' symbol without preceding function"), name);
 726                 /* Will need relocating.  */
 727                 SF_SET_PROCESS (def_symbol_in_progress);
 728                 clear_function ();
 729                 break;
 730 #ifdef TE_PE
 731               case 'e':
 732                 /* .ef */
 733                 /* The MS compilers output the actual endline, not the
 734                    function-relative one... we want to match without
 735                    changing the assembler input.  */
 736                 SA_SET_SYM_LNNO (def_symbol_in_progress,
 737                                  (SA_GET_SYM_LNNO (def_symbol_in_progress)
 738                                   + coff_line_base));
 739                 break;
 740 #endif
 741               }
 742           }
 743       }
 744       break;
 745
 746 #ifdef C_AUTOARG
 747     case C_AUTOARG:
 748 #endif /* C_AUTOARG */
 749     case C_AUTO:
 750     case C_REG:
 751     case C_ARG:
 752     case C_REGPARM:
 753     case C_FIELD:
 754
 755     /* According to the COFF documentation:
 756
 757        http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
 758
 759        A special section number (-2) marks symbolic debugging symbols,
 760        including structure/union/enumeration tag names, typedefs, and
 761        the name of the file. A section number of -1 indicates that the
 762        symbol has a value but is not relocatable. Examples of
 763        absolute-valued symbols include automatic and register variables,
 764        function arguments, and .eos symbols.
 765
 766        But from Ian Lance Taylor:
 767
 768        http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
 769
 770        the actual tools all marked them as section -1. So the GNU COFF
 771        assembler follows historical COFF assemblers.
 772
 773        However, it causes problems for djgpp
 774
 775        http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
 776
 777        By defining STRICTCOFF, a COFF port can make the assembler to
 778        follow the documented behavior.  */
 779 #ifdef STRICTCOFF
 780     case C_MOS:
 781     case C_MOE:
 782     case C_MOU:
 783     case C_EOS:
 784 #endif
 785       SF_SET_DEBUG (def_symbol_in_progress);
 786       S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
 787       break;
 788
 789 #ifndef STRICTCOFF
 790     case C_MOS:
 791     case C_MOE:
 792     case C_MOU:
 793     case C_EOS:
 794       S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
 795       break;
 796 #endif
 797
 798     case C_EXT:
 799     case C_WEAKEXT:
 800 #ifdef TE_PE
 801     case C_NT_WEAK:
 802 #endif
 803     case C_STAT:
 804     case C_LABEL:
 805       /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
 806       break;
 807
 808     default:
 809     case C_USTATIC:
 810     case C_EXTDEF:
 811     case C_ULABEL:
 812       as_warn (_("unexpected storage class %d"),
 813                S_GET_STORAGE_CLASS (def_symbol_in_progress));
 814       break;
 815     }                           /* switch on storage class */
 816
 817   /* Now that we have built a debug symbol, try to find if we should
 818      merge with an existing symbol or not.  If a symbol is C_EFCN or
 819      absolute_section or untagged SEG_DEBUG it never merges.  We also
 820      don't merge labels, which are in a different namespace, nor
 821      symbols which have not yet been defined since they are typically
 822      unique, nor do we merge tags with non-tags.  */
 823
 824   /* Two cases for functions.  Either debug followed by definition or
 825      definition followed by debug.  For definition first, we will
 826      merge the debug symbol into the definition.  For debug first, the
 827      lineno entry MUST point to the definition function or else it
 828      will point off into space when obj_crawl_symbol_chain() merges
 829      the debug symbol into the real symbol.  Therefor, let's presume
 830      the debug symbol is a real function reference.  */
 831
 832   /* FIXME-SOON If for some reason the definition label/symbol is
 833      never seen, this will probably leave an undefined symbol at link
 834      time.  */
 835
 836   if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
 837       || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
 838       || (!strcmp (bfd_get_section_name (stdoutput,
 839                                          S_GET_SEGMENT (def_symbol_in_progress)),
 840                    "*DEBUG*")
 841           && !SF_GET_TAG (def_symbol_in_progress))
 842       || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
 843       || ! symbol_constant_p (def_symbol_in_progress)
 844       || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
 845                                       DO_NOT_STRIP)) == NULL
 846       || SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
 847     {
 848       /* If it already is at the end of the symbol list, do nothing */
 849       if (def_symbol_in_progress != symbol_lastP)
 850         {
 851           symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
 852           symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
 853                          &symbol_lastP);
 854         }
 855     }
 856   else
 857     {
 858       /* This symbol already exists, merge the newly created symbol
 859          into the old one.  This is not mandatory. The linker can
 860          handle duplicate symbols correctly. But I guess that it save
 861          a *lot* of space if the assembly file defines a lot of
 862          symbols. [loic] */
 863
 864       /* The debug entry (def_symbol_in_progress) is merged into the
 865          previous definition.  */
 866
 867       c_symbol_merge (def_symbol_in_progress, symbolP);
 868       symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
 869
 870       def_symbol_in_progress = symbolP;
 871
 872       if (SF_GET_FUNCTION (def_symbol_in_progress)
 873           || SF_GET_TAG (def_symbol_in_progress)
 874           || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
 875         {
 876           /* For functions, and tags, and static symbols, the symbol
 877              *must* be where the debug symbol appears.  Move the
 878              existing symbol to the current place.  */
 879           /* If it already is at the end of the symbol list, do nothing */
 880           if (def_symbol_in_progress != symbol_lastP)
 881             {
 882               symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
 883               symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
 884             }
 885         }
 886     }
 887
 888   if (SF_GET_TAG (def_symbol_in_progress))
 889     {
 890       symbolS *oldtag;
 891
 892       oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
 893                                  DO_NOT_STRIP);
 894       if (oldtag == NULL || ! SF_GET_TAG (oldtag))
 895         tag_insert (S_GET_NAME (def_symbol_in_progress),
 896                     def_symbol_in_progress);
 897     }
 898
 899   if (SF_GET_FUNCTION (def_symbol_in_progress))
 900     {
 901       know (sizeof (def_symbol_in_progress) <= sizeof (long));
 902       set_function (def_symbol_in_progress);
 903       SF_SET_PROCESS (def_symbol_in_progress);
 904
 905       if (symbolP == NULL)
 906         {
 907           /* That is, if this is the first time we've seen the
 908              function...  */
 909           symbol_table_insert (def_symbol_in_progress);
 910         } /* definition follows debug */
 911     } /* Create the line number entry pointing to the function being defined */
 912
 913   def_symbol_in_progress = NULL;
 914   demand_empty_rest_of_line ();
 915 }
 916
 917 static void
 918 obj_coff_dim (ignore)
 919      int ignore ATTRIBUTE_UNUSED;
 920 {
 921   int dim_index;
 922
 923   if (def_symbol_in_progress == NULL)
 924     {
 925       as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
 926       demand_empty_rest_of_line ();
 927       return;
 928     }                           /* if not inside .def/.endef */
 929
 930   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 931
 932   for (dim_index = 0; dim_index < DIMNUM; dim_index++)
 933     {
 934       SKIP_WHITESPACES ();
 935       SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
 936                         get_absolute_expression ());
 937
 938       switch (*input_line_pointer)
 939         {
 940         case ',':
 941           input_line_pointer++;
 942           break;
 943
 944         default:
 945           as_warn (_("badly formed .dim directive ignored"));
 946           /* intentional fallthrough */
 947         case '\n':
 948         case ';':
 949           dim_index = DIMNUM;
 950           break;
 951         }
 952     }
 953
 954   demand_empty_rest_of_line ();
 955 }
 956
 957 static void
 958 obj_coff_line (ignore)
 959      int ignore ATTRIBUTE_UNUSED;
 960 {
 961   int this_base;
 962
 963   if (def_symbol_in_progress == NULL)
 964     {
 965       /* Probably stabs-style line?  */
 966       obj_coff_ln (0);
 967       return;
 968     }
 969
 970   this_base = get_absolute_expression ();
 971   if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
 972     coff_line_base = this_base;
 973
 974   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
 975   SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
 976
 977   demand_empty_rest_of_line ();
 978
 979 #ifndef NO_LISTING
 980   if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
 981     {
 982       extern int listing;
 983
 984       if (listing)
 985         listing_source_line ((unsigned int) this_base);
 986     }
 987 #endif
 988 }
 989
 990 static void
 991 obj_coff_size (ignore)
 992      int ignore ATTRIBUTE_UNUSED;
 993 {
 994   if (def_symbol_in_progress == NULL)
 995     {
 996       as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
 997       demand_empty_rest_of_line ();
 998       return;
 999     }                           /* if not inside .def/.endef */
1000
1001   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1002   SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
1003   demand_empty_rest_of_line ();
1004 }
1005
1006 static void
1007 obj_coff_scl (ignore)
1008      int ignore ATTRIBUTE_UNUSED;
1009 {
1010   if (def_symbol_in_progress == NULL)
1011     {
1012       as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
1013       demand_empty_rest_of_line ();
1014       return;
1015     }                           /* if not inside .def/.endef */
1016
1017   S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
1018   demand_empty_rest_of_line ();
1019 }
1020
1021 static void
1022 obj_coff_tag (ignore)
1023      int ignore ATTRIBUTE_UNUSED;
1024 {
1025   char *symbol_name;
1026   char name_end;
1027
1028   if (def_symbol_in_progress == NULL)
1029     {
1030       as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
1031       demand_empty_rest_of_line ();
1032       return;
1033     }
1034
1035   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
1036   symbol_name = input_line_pointer;
1037   name_end = get_symbol_end ();
1038
1039 #ifdef tc_canonicalize_symbol_name
1040   symbol_name = tc_canonicalize_symbol_name (symbol_name);
1041 #endif
1042
1043   /* Assume that the symbol referred to by .tag is always defined.
1044      This was a bad assumption.  I've added find_or_make. xoxorich.  */
1045   SA_SET_SYM_TAGNDX (def_symbol_in_progress,
1046                      tag_find_or_make (symbol_name));
1047   if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
1048     {
1049       as_warn (_("tag not found for .tag %s"), symbol_name);
1050     }                           /* not defined */
1051
1052   SF_SET_TAGGED (def_symbol_in_progress);
1053   *input_line_pointer = name_end;
1054
1055   demand_empty_rest_of_line ();
1056 }
1057
1058 static void
1059 obj_coff_type (ignore)
1060      int ignore ATTRIBUTE_UNUSED;
1061 {
1062   if (def_symbol_in_progress == NULL)
1063     {
1064       as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1065       demand_empty_rest_of_line ();
1066       return;
1067     }                           /* if not inside .def/.endef */
1068
1069   S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
1070
1071   if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
1072       S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
1073     {
1074       SF_SET_FUNCTION (def_symbol_in_progress);
1075     }                           /* is a function */
1076
1077   demand_empty_rest_of_line ();
1078 }
1079
1080 static void
1081 obj_coff_val (ignore)
1082      int ignore ATTRIBUTE_UNUSED;
1083 {
1084   if (def_symbol_in_progress == NULL)
1085     {
1086       as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1087       demand_empty_rest_of_line ();
1088       return;
1089     }                           /* if not inside .def/.endef */
1090
1091   if (is_name_beginner (*input_line_pointer))
1092     {
1093       char *symbol_name = input_line_pointer;
1094       char name_end = get_symbol_end ();
1095
1096 #ifdef tc_canonicalize_symbol_name
1097   symbol_name = tc_canonicalize_symbol_name (symbol_name);
1098 #endif
1099       if (!strcmp (symbol_name, "."))
1100         {
1101           symbol_set_frag (def_symbol_in_progress, frag_now);
1102           S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
1103           /* If the .val is != from the .def (e.g. statics) */
1104         }
1105       else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
1106         {
1107           expressionS exp;
1108
1109           exp.X_op = O_symbol;
1110           exp.X_add_symbol = symbol_find_or_make (symbol_name);
1111           exp.X_op_symbol = NULL;
1112           exp.X_add_number = 0;
1113           symbol_set_value_expression (def_symbol_in_progress, &exp);
1114
1115           /* If the segment is undefined when the forward reference is
1116              resolved, then copy the segment id from the forward
1117              symbol.  */
1118           SF_SET_GET_SEGMENT (def_symbol_in_progress);
1119
1120           /* FIXME: gcc can generate address expressions here in
1121              unusual cases (search for "obscure" in sdbout.c).  We
1122              just ignore the offset here, thus generating incorrect
1123              debugging information.  We ignore the rest of the line
1124              just below.  */
1125         }
1126       /* Otherwise, it is the name of a non debug symbol and its value
1127          will be calculated later.  */
1128       *input_line_pointer = name_end;
1129     }
1130   else
1131     {
1132       S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
1133     }                           /* if symbol based */
1134
1135   demand_empty_rest_of_line ();
1136 }
1137
1138 void
1139 coff_obj_read_begin_hook ()
1140 {
1141   /* These had better be the same.  Usually 18 bytes.  */
1142 #ifndef BFD_HEADERS
1143   know (sizeof (SYMENT) == sizeof (AUXENT));
1144   know (SYMESZ == AUXESZ);
1145 #endif
1146   tag_init ();
1147 }
1148
1149 symbolS *coff_last_function;
1150 static symbolS *coff_last_bf;
1151
1152 void
1153 coff_frob_symbol (symp, punt)
1154      symbolS *symp;
1155      int *punt;
1156 {
1157   static symbolS *last_tagP;
1158   static stack *block_stack;
1159   static symbolS *set_end;
1160   symbolS *next_set_end = NULL;
1161
1162   if (symp == &abs_symbol)
1163     {
1164       *punt = 1;
1165       return;
1166     }
1167
1168   if (current_lineno_sym)
1169     coff_add_linesym ((symbolS *) 0);
1170
1171   if (!block_stack)
1172     block_stack = stack_init (512, sizeof (symbolS*));
1173
1174   if (S_IS_WEAK (symp))
1175     {
1176 #ifdef TE_PE
1177       S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
1178 #else
1179       S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
1180 #endif
1181     }
1182
1183   if (!S_IS_DEFINED (symp)
1184       && !S_IS_WEAK (symp)
1185       && S_GET_STORAGE_CLASS (symp) != C_STAT)
1186     S_SET_STORAGE_CLASS (symp, C_EXT);
1187
1188   if (!SF_GET_DEBUG (symp))
1189     {
1190       symbolS * real;
1191
1192       if (!SF_GET_LOCAL (symp)
1193           && !SF_GET_STATICS (symp)
1194           && S_GET_STORAGE_CLASS (symp) != C_LABEL
1195           && symbol_constant_p(symp)
1196           && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
1197           && S_GET_STORAGE_CLASS (real) == C_NULL
1198           && real != symp)
1199         {
1200           c_symbol_merge (symp, real);
1201           *punt = 1;
1202           return;
1203         }
1204
1205       if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
1206         {
1207           assert (S_GET_VALUE (symp) == 0);
1208           S_SET_EXTERNAL (symp);
1209         }
1210       else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
1211         {
1212           if (S_GET_SEGMENT (symp) == text_section
1213               && symp != seg_info (text_section)->sym)
1214             S_SET_STORAGE_CLASS (symp, C_LABEL);
1215           else
1216             S_SET_STORAGE_CLASS (symp, C_STAT);
1217         }
1218
1219       if (SF_GET_PROCESS (symp))
1220         {
1221           if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
1222             {
1223               if (!strcmp (S_GET_NAME (symp), ".bb"))
1224                 stack_push (block_stack, (char *) &symp);
1225               else
1226                 {
1227                   symbolS *begin;
1228
1229                   begin = *(symbolS **) stack_pop (block_stack);
1230                   if (begin == 0)
1231                     as_warn (_("mismatched .eb"));
1232                   else
1233                     next_set_end = begin;
1234                 }
1235             }
1236
1237           if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
1238             {
1239               union internal_auxent *auxp;
1240
1241               coff_last_function = symp;
1242               if (S_GET_NUMBER_AUXILIARY (symp) < 1)
1243                 S_SET_NUMBER_AUXILIARY (symp, 1);
1244               auxp = SYM_AUXENT (symp);
1245               memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
1246                       sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
1247             }
1248
1249           if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
1250             {
1251               if (coff_last_function == 0)
1252                 as_fatal (_("C_EFCN symbol out of scope"));
1253               SA_SET_SYM_FSIZE (coff_last_function,
1254                                 (long) (S_GET_VALUE (symp)
1255                                         - S_GET_VALUE (coff_last_function)));
1256               next_set_end = coff_last_function;
1257               coff_last_function = 0;
1258             }
1259         }
1260
1261       if (S_IS_EXTERNAL (symp))
1262         S_SET_STORAGE_CLASS (symp, C_EXT);
1263       else if (SF_GET_LOCAL (symp))
1264         *punt = 1;
1265
1266       if (SF_GET_FUNCTION (symp))
1267         symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
1268
1269       /* more ...  */
1270     }
1271
1272   /* Double check weak symbols.  */
1273   if (S_IS_WEAK (symp) && S_IS_COMMON (symp))
1274     as_bad (_("Symbol `%s' can not be both weak and common"),
1275             S_GET_NAME (symp));
1276
1277   if (SF_GET_TAG (symp))
1278     last_tagP = symp;
1279   else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
1280     next_set_end = last_tagP;
1281
1282 #ifdef OBJ_XCOFF
1283   /* This is pretty horrible, but we have to set *punt correctly in
1284      order to call SA_SET_SYM_ENDNDX correctly.  */
1285   if (! symbol_used_in_reloc_p (symp)
1286       && ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
1287           || (! S_IS_EXTERNAL (symp)
1288               && ! symbol_get_tc (symp)->output
1289               && S_GET_STORAGE_CLASS (symp) != C_FILE)))
1290     *punt = 1;
1291 #endif
1292
1293   if (set_end != (symbolS *) NULL
1294       && ! *punt
1295       && ((symbol_get_bfdsym (symp)->flags & BSF_NOT_AT_END) != 0
1296           || (S_IS_DEFINED (symp)
1297               && ! S_IS_COMMON (symp)
1298               && (! S_IS_EXTERNAL (symp) || SF_GET_FUNCTION (symp)))))
1299     {
1300       SA_SET_SYM_ENDNDX (set_end, symp);
1301       set_end = NULL;
1302     }
1303
1304   if (next_set_end != NULL)
1305     {
1306       if (set_end != NULL)
1307         as_warn ("Warning: internal error: forgetting to set endndx of %s",
1308                  S_GET_NAME (set_end));
1309       set_end = next_set_end;
1310     }
1311
1312 #ifndef OBJ_XCOFF
1313   if (! *punt
1314       && S_GET_STORAGE_CLASS (symp) == C_FCN
1315       && strcmp (S_GET_NAME (symp), ".bf") == 0)
1316     {
1317       if (coff_last_bf != NULL)
1318         SA_SET_SYM_ENDNDX (coff_last_bf, symp);
1319       coff_last_bf = symp;
1320     }
1321 #endif
1322   if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
1323     {
1324       int i;
1325       struct line_no *lptr;
1326       alent *l;
1327
1328       lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1329       for (i = 0; lptr; lptr = lptr->next)
1330         i++;
1331       lptr = (struct line_no *) coffsymbol (symbol_get_bfdsym (symp))->lineno;
1332
1333       /* We need i entries for line numbers, plus 1 for the first
1334          entry which BFD will override, plus 1 for the last zero
1335          entry (a marker for BFD).  */
1336       l = (alent *) xmalloc ((i + 2) * sizeof (alent));
1337       coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
1338       l[i + 1].line_number = 0;
1339       l[i + 1].u.sym = NULL;
1340       for (; i > 0; i--)
1341         {
1342           if (lptr->frag)
1343             lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
1344           l[i] = lptr->l;
1345           lptr = lptr->next;
1346         }
1347     }
1348 }
1349
1350 void
1351 coff_adjust_section_syms (abfd, sec, x)
1352      bfd *abfd ATTRIBUTE_UNUSED;
1353      asection *sec;
1354      PTR x ATTRIBUTE_UNUSED;
1355 {
1356   symbolS *secsym;
1357   segment_info_type *seginfo = seg_info (sec);
1358   int nlnno, nrelocs = 0;
1359
1360   /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1361      tc-ppc.c.  Do not get confused by it.  */
1362   if (seginfo == NULL)
1363     return;
1364
1365   if (!strcmp (sec->name, ".text"))
1366     nlnno = coff_n_line_nos;
1367   else
1368     nlnno = 0;
1369   {
1370     /* @@ Hope that none of the fixups expand to more than one reloc
1371        entry...  */
1372     fixS *fixp = seginfo->fix_root;
1373     while (fixp)
1374       {
1375         if (! fixp->fx_done)
1376           nrelocs++;
1377         fixp = fixp->fx_next;
1378       }
1379   }
1380   if (bfd_get_section_size_before_reloc (sec) == 0
1381       && nrelocs == 0
1382       && nlnno == 0
1383       && sec != text_section
1384       && sec != data_section
1385       && sec != bss_section)
1386     return;
1387   secsym = section_symbol (sec);
1388   /* This is an estimate; we'll plug in the real value using
1389      SET_SECTION_RELOCS later */
1390   SA_SET_SCN_NRELOC (secsym, nrelocs);
1391   SA_SET_SCN_NLINNO (secsym, nlnno);
1392 }
1393
1394 void
1395 coff_frob_file_after_relocs ()
1396 {
1397   bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1398 }
1399
1400 /*
1401  * implement the .section pseudo op:
1402  *      .section name {, "flags"}
1403  *                ^         ^
1404  *                |         +--- optional flags: 'b' for bss
1405  *                |                              'i' for info
1406  *                +-- section name               'l' for lib
1407  *                                               'n' for noload
1408  *                                               'o' for over
1409  *                                               'w' for data
1410  *                                               'd' (apparently m88k for data)
1411  *                                               'x' for text
1412  *                                               'r' for read-only data
1413  *                                               's' for shared data (PE)
1414  * But if the argument is not a quoted string, treat it as a
1415  * subsegment number.
1416  */
1417
1418 void
1419 obj_coff_section (ignore)
1420      int ignore ATTRIBUTE_UNUSED;
1421 {
1422   /* Strip out the section name */
1423   char *section_name;
1424   char c;
1425   char *name;
1426   unsigned int exp;
1427   flagword flags, oldflags;
1428   asection *sec;
1429
1430   if (flag_mri)
1431     {
1432       char type;
1433
1434       s_mri_sect (&type);
1435       return;
1436     }
1437
1438   section_name = input_line_pointer;
1439   c = get_symbol_end ();
1440
1441   name = xmalloc (input_line_pointer - section_name + 1);
1442   strcpy (name, section_name);
1443
1444   *input_line_pointer = c;
1445
1446   SKIP_WHITESPACE ();
1447
1448   exp = 0;
1449   flags = SEC_NO_FLAGS;
1450
1451   if (*input_line_pointer == ',')
1452     {
1453       ++input_line_pointer;
1454       SKIP_WHITESPACE ();
1455       if (*input_line_pointer != '"')
1456         exp = get_absolute_expression ();
1457       else
1458         {
1459           ++input_line_pointer;
1460           while (*input_line_pointer != '"'
1461                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
1462             {
1463               switch (*input_line_pointer)
1464                 {
1465                 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1466                 case 'n': flags &=~ SEC_LOAD; flags |= SEC_NEVER_LOAD; break;
1467                 case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
1468                 case 'w': flags &=~ SEC_READONLY; break;
1469                 case 'x': flags |= SEC_CODE | SEC_LOAD; break;
1470                 case 'r': flags |= SEC_READONLY; break;
1471                 case 's': flags |= SEC_SHARED; break;
1472
1473                 case 'i': /* STYP_INFO */
1474                 case 'l': /* STYP_LIB */
1475                 case 'o': /* STYP_OVER */
1476                   as_warn (_("unsupported section attribute '%c'"),
1477                            *input_line_pointer);
1478                   break;
1479
1480                 default:
1481                   as_warn(_("unknown section attribute '%c'"),
1482                           *input_line_pointer);
1483                   break;
1484                 }
1485               ++input_line_pointer;
1486             }
1487           if (*input_line_pointer == '"')
1488             ++input_line_pointer;
1489         }
1490     }
1491
1492   sec = subseg_new (name, (subsegT) exp);
1493
1494   oldflags = bfd_get_section_flags (stdoutput, sec);
1495   if (oldflags == SEC_NO_FLAGS)
1496     {
1497       /* Set section flags for a new section just created by subseg_new.
1498          Provide a default if no flags were parsed.  */
1499       if (flags == SEC_NO_FLAGS)
1500         flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
1501
1502 #ifdef COFF_LONG_SECTION_NAMES
1503       /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1504          sections so adjust_reloc_syms in write.c will correctly handle
1505          relocs which refer to non-local symbols in these sections.  */
1506       if (strncmp (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1) == 0)
1507         flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1508 #endif
1509
1510       if (! bfd_set_section_flags (stdoutput, sec, flags))
1511         as_warn (_("error setting flags for \"%s\": %s"),
1512                  bfd_section_name (stdoutput, sec),
1513                  bfd_errmsg (bfd_get_error ()));
1514     }
1515   else if (flags != SEC_NO_FLAGS)
1516     {
1517       /* This section's attributes have already been set. Warn if the
1518          attributes don't match.  */
1519       flagword matchflags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
1520                              | SEC_DATA | SEC_SHARED | SEC_NEVER_LOAD);
1521       if ((flags ^ oldflags) & matchflags)
1522         as_warn (_("Ignoring changed section attributes for %s"), name);
1523     }
1524
1525   demand_empty_rest_of_line ();
1526 }
1527
1528 void
1529 coff_adjust_symtab ()
1530 {
1531   if (symbol_rootP == NULL
1532       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1533     c_dot_file_symbol ("fake");
1534 }
1535
1536 void
1537 coff_frob_section (sec)
1538      segT sec;
1539 {
1540   segT strsec;
1541   char *p;
1542   fragS *fragp;
1543   bfd_vma size, n_entries, mask;
1544   bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
1545
1546   /* The COFF back end in BFD requires that all section sizes be
1547      rounded up to multiples of the corresponding section alignments,
1548      supposedly because standard COFF has no other way of encoding alignment
1549      for sections.  If your COFF flavor has a different way of encoding
1550      section alignment, then skip this step, as TICOFF does.  */
1551   size = bfd_get_section_size_before_reloc (sec);
1552   mask = ((bfd_vma) 1 << align_power) - 1;
1553 #if !defined(TICOFF)
1554   if (size & mask)
1555     {
1556       bfd_vma new_size;
1557       fragS *last;
1558
1559       new_size = (size + mask) & ~mask;
1560       bfd_set_section_size (stdoutput, sec, new_size);
1561
1562       /* If the size had to be rounded up, add some padding in
1563          the last non-empty frag.  */
1564       fragp = seg_info (sec)->frchainP->frch_root;
1565       last = seg_info (sec)->frchainP->frch_last;
1566       while (fragp->fr_next != last)
1567         fragp = fragp->fr_next;
1568       last->fr_address = size;
1569       fragp->fr_offset += new_size - size;
1570     }
1571 #endif
1572
1573   /* If the section size is non-zero, the section symbol needs an aux
1574      entry associated with it, indicating the size.  We don't know
1575      all the values yet; coff_frob_symbol will fill them in later.  */
1576 #ifndef TICOFF
1577   if (size != 0
1578       || sec == text_section
1579       || sec == data_section
1580       || sec == bss_section)
1581 #endif
1582     {
1583       symbolS *secsym = section_symbol (sec);
1584
1585       S_SET_STORAGE_CLASS (secsym, C_STAT);
1586       S_SET_NUMBER_AUXILIARY (secsym, 1);
1587       SF_SET_STATICS (secsym);
1588       SA_SET_SCN_SCNLEN (secsym, size);
1589     }
1590
1591   /* @@ these should be in a "stabs.h" file, or maybe as.h */
1592 #ifndef STAB_SECTION_NAME
1593 #define STAB_SECTION_NAME ".stab"
1594 #endif
1595 #ifndef STAB_STRING_SECTION_NAME
1596 #define STAB_STRING_SECTION_NAME ".stabstr"
1597 #endif
1598   if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1599     return;
1600
1601   strsec = sec;
1602   sec = subseg_get (STAB_SECTION_NAME, 0);
1603   /* size is already rounded up, since other section will be listed first */
1604   size = bfd_get_section_size_before_reloc (strsec);
1605
1606   n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1607
1608   /* Find first non-empty frag.  It should be large enough.  */
1609   fragp = seg_info (sec)->frchainP->frch_root;
1610   while (fragp && fragp->fr_fix == 0)
1611     fragp = fragp->fr_next;
1612   assert (fragp != 0 && fragp->fr_fix >= 12);
1613
1614   /* Store the values.  */
1615   p = fragp->fr_literal;
1616   bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1617   bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1618 }
1619
1620 void
1621 obj_coff_init_stab_section (seg)
1622      segT seg;
1623 {
1624   char *file;
1625   char *p;
1626   char *stabstr_name;
1627   unsigned int stroff;
1628
1629   /* Make space for this first symbol.  */
1630   p = frag_more (12);
1631   /* Zero it out.  */
1632   memset (p, 0, 12);
1633   as_where (&file, (unsigned int *) NULL);
1634   stabstr_name = (char *) xmalloc (strlen (seg->name) + 4);
1635   strcpy (stabstr_name, seg->name);
1636   strcat (stabstr_name, "str");
1637   stroff = get_stab_string_offset (file, stabstr_name);
1638   know (stroff == 1);
1639   md_number_to_chars (p, stroff, 4);
1640 }
1641
1642 #ifdef DEBUG
1643 /* for debugging */
1644 const char *
1645 s_get_name (s)
1646      symbolS *s;
1647 {
1648   return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1649 }
1650
1651 void
1652 symbol_dump ()
1653 {
1654   symbolS *symbolP;
1655
1656   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1657     {
1658       printf (_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1659              (unsigned long) symbolP,
1660              S_GET_NAME(symbolP),
1661              (long) S_GET_DATA_TYPE(symbolP),
1662              S_GET_STORAGE_CLASS(symbolP),
1663              (int) S_GET_SEGMENT(symbolP));
1664     }
1665 }
1666
1667 #endif /* DEBUG */
1668
1669 #else /* not BFD_ASSEMBLER */
1670
1671 #include "frags.h"
1672 /* This is needed because we include internal bfd things.  */
1673 #include <time.h>
1674
1675 #include "libbfd.h"
1676 #include "libcoff.h"
1677
1678 #ifdef TE_PE
1679 #include "coff/pe.h"
1680 #endif
1681
1682 /* The NOP_OPCODE is for the alignment fill value.  Fill with nop so
1683    that we can stick sections together without causing trouble.  */
1684 #ifndef NOP_OPCODE
1685 #define NOP_OPCODE 0x00
1686 #endif
1687
1688 /* The zeroes if symbol name is longer than 8 chars */
1689 #define S_SET_ZEROES(s,v)               ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1690
1691 #define MIN(a,b) ((a) < (b)? (a) : (b))
1692
1693 /* This vector is used to turn a gas internal segment number into a
1694    section number suitable for insertion into a coff symbol table.
1695    This must correspond to seg_info_off_by_4.  */
1696
1697 const short seg_N_TYPE[] =
1698 {                               /* in: segT   out: N_TYPE bits */
1699   C_ABS_SECTION,
1700   1,    2,  3,   4,    5,   6,   7,   8,   9,  10,
1701   11,  12,  13,  14,  15,  16,  17,  18,  19,  20,
1702   21,  22,  23,  24,  25,  26,  27,  28,  29,  30,
1703   31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
1704   C_UNDEF_SECTION,              /* SEG_UNKNOWN */
1705   C_UNDEF_SECTION,              /* SEG_GOOF */
1706   C_UNDEF_SECTION,              /* SEG_EXPR */
1707   C_DEBUG_SECTION,              /* SEG_DEBUG */
1708   C_NTV_SECTION,                /* SEG_NTV */
1709   C_PTV_SECTION,                /* SEG_PTV */
1710   C_REGISTER_SECTION,           /* SEG_REGISTER */
1711 };
1712
1713 int function_lineoff = -1;      /* Offset in line#s where the last function
1714                                    started (the odd entry for line #0) */
1715
1716 /* Structure used to keep the filenames which
1717    are too long around so that we can stick them
1718    into the string table.  */
1719 struct filename_list
1720 {
1721   char *filename;
1722   struct filename_list *next;
1723 };
1724
1725 static struct filename_list *filename_list_head;
1726 static struct filename_list *filename_list_tail;
1727
1728 static symbolS *last_line_symbol;
1729
1730 /* Add 4 to the real value to get the index and compensate the
1731    negatives. This vector is used by S_GET_SEGMENT to turn a coff
1732    section number into a segment number.  */
1733
1734 bfd *abfd;
1735 static symbolS *previous_file_symbol;
1736 static int line_base;
1737
1738 void c_symbol_merge PARAMS ((symbolS *, symbolS *));
1739 symbolS *c_section_symbol PARAMS ((char *, int));
1740 void obj_coff_section PARAMS ((int));
1741 void do_relocs_for PARAMS ((bfd *, object_headers *, unsigned long *));
1742 char * symbol_to_chars PARAMS ((bfd *, char *, symbolS *));
1743 void w_strings PARAMS ((char *));
1744
1745 static void fixup_segment PARAMS ((segment_info_type *, segT));
1746 static void fixup_mdeps PARAMS ((fragS *, object_headers *, segT));
1747 static void fill_section PARAMS ((bfd *,  object_headers *, unsigned long *));
1748 static int c_line_new PARAMS ((symbolS *, long, int, fragS *));
1749 static void w_symbols PARAMS ((bfd *, char *, symbolS *));
1750 static void adjust_stab_section PARAMS ((bfd *, segT));
1751 static void obj_coff_lcomm PARAMS ((int));
1752 static void obj_coff_text PARAMS ((int));
1753 static void obj_coff_data PARAMS ((int));
1754 static unsigned int count_entries_in_chain PARAMS ((unsigned int));
1755 static void coff_header_append PARAMS ((bfd *, object_headers *));
1756 static unsigned int yank_symbols PARAMS ((void));
1757 static unsigned int glue_symbols PARAMS ((symbolS **, symbolS **));
1758 static unsigned int tie_tags PARAMS ((void));
1759 static void crawl_symbols PARAMS ((object_headers *, bfd *));
1760 static void do_linenos_for PARAMS ((bfd *, object_headers *, unsigned long *));
1761 static void remove_subsegs PARAMS ((void));
1762
1763
1764
1765 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1766
1767    This array maps a COFF section number into a gas section number.
1768    Because COFF uses negative section numbers, you must add 4 to the
1769    COFF section number when indexing into this array; this is done via
1770    the SEG_INFO_FROM_SECTION_NUMBER macro.  This must correspond to
1771    seg_N_TYPE.  */
1772
1773 static const segT seg_info_off_by_4[] =
1774 {
1775  SEG_PTV,
1776  SEG_NTV,
1777  SEG_DEBUG,
1778  SEG_ABSOLUTE,
1779  SEG_UNKNOWN,
1780  SEG_E0,  SEG_E1,  SEG_E2,  SEG_E3,  SEG_E4,
1781  SEG_E5,  SEG_E6,  SEG_E7,  SEG_E8,  SEG_E9,
1782  SEG_E10, SEG_E11, SEG_E12, SEG_E13, SEG_E14,
1783  SEG_E15, SEG_E16, SEG_E17, SEG_E18, SEG_E19,
1784  SEG_E20, SEG_E21, SEG_E22, SEG_E23, SEG_E24,
1785  SEG_E25, SEG_E26, SEG_E27, SEG_E28, SEG_E29,
1786  SEG_E30, SEG_E31, SEG_E32, SEG_E33, SEG_E34,
1787  SEG_E35, SEG_E36, SEG_E37, SEG_E38, SEG_E39,
1788  (segT) 40,
1789  (segT) 41,
1790  (segT) 42,
1791  (segT) 43,
1792  (segT) 44,
1793  (segT) 45,
1794  (segT) 0,
1795  (segT) 0,
1796  (segT) 0,
1797  SEG_REGISTER
1798 };
1799
1800 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1801
1802 static relax_addressT relax_align PARAMS ((relax_addressT, long));
1803
1804 static relax_addressT
1805 relax_align (address, alignment)
1806      relax_addressT address;
1807      long alignment;
1808 {
1809   relax_addressT mask;
1810   relax_addressT new_address;
1811
1812   mask = ~((~0) << alignment);
1813   new_address = (address + mask) & (~mask);
1814   return (new_address - address);
1815 }
1816
1817 segT
1818 s_get_segment (x)
1819      symbolS * x;
1820 {
1821   return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
1822 }
1823
1824 static unsigned int size_section PARAMS ((bfd *, unsigned int));
1825
1826 /* Calculate the size of the frag chain and fill in the section header
1827    to contain all of it, also fill in the addr of the sections.  */
1828
1829 static unsigned int
1830 size_section (abfd, idx)
1831      bfd *abfd ATTRIBUTE_UNUSED;
1832      unsigned int idx;
1833 {
1834
1835   unsigned int size = 0;
1836   fragS *frag = segment_info[idx].frchainP->frch_root;
1837
1838   while (frag)
1839     {
1840       size = frag->fr_address;
1841       if (frag->fr_address != size)
1842         {
1843           fprintf (stderr, _("Out of step\n"));
1844           size = frag->fr_address;
1845         }
1846
1847       switch (frag->fr_type)
1848         {
1849 #ifdef TC_COFF_SIZEMACHDEP
1850         case rs_machine_dependent:
1851           size += TC_COFF_SIZEMACHDEP (frag);
1852           break;
1853 #endif
1854         case rs_space:
1855         case rs_fill:
1856         case rs_org:
1857           size += frag->fr_fix;
1858           size += frag->fr_offset * frag->fr_var;
1859           break;
1860         case rs_align:
1861         case rs_align_code:
1862         case rs_align_test:
1863           {
1864             addressT off;
1865
1866             size += frag->fr_fix;
1867             off = relax_align (size, frag->fr_offset);
1868             if (frag->fr_subtype != 0 && off > frag->fr_subtype)
1869               off = 0;
1870             size += off;
1871           }
1872           break;
1873         default:
1874           BAD_CASE (frag->fr_type);
1875           break;
1876         }
1877       frag = frag->fr_next;
1878     }
1879   segment_info[idx].scnhdr.s_size = size;
1880   return size;
1881 }
1882
1883 static unsigned int
1884 count_entries_in_chain (idx)
1885      unsigned int idx;
1886 {
1887   unsigned int nrelocs;
1888   fixS *fixup_ptr;
1889
1890   /* Count the relocations.  */
1891   fixup_ptr = segment_info[idx].fix_root;
1892   nrelocs = 0;
1893   while (fixup_ptr != (fixS *) NULL)
1894     {
1895       if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
1896         {
1897 #if defined(TC_A29K) || defined(TC_OR32)
1898           if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1899             nrelocs += 2;
1900           else
1901             nrelocs++;
1902 #else
1903           nrelocs++;
1904 #endif
1905         }
1906
1907       fixup_ptr = fixup_ptr->fx_next;
1908     }
1909   return nrelocs;
1910 }
1911
1912 #ifdef TE_AUX
1913
1914 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1915
1916 /* AUX's ld expects relocations to be sorted.  */
1917
1918 static int
1919 compare_external_relocs (x, y)
1920      const PTR x;
1921      const PTR y;
1922 {
1923   struct external_reloc *a = (struct external_reloc *) x;
1924   struct external_reloc *b = (struct external_reloc *) y;
1925   bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1926   bfd_vma badr = bfd_getb32 (b->r_vaddr);
1927   return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1928 }
1929
1930 #endif
1931
1932 /* Output all the relocations for a section.  */
1933
1934 void
1935 do_relocs_for (abfd, h, file_cursor)
1936      bfd * abfd;
1937      object_headers * h;
1938      unsigned long *file_cursor;
1939 {
1940   unsigned int nrelocs;
1941   unsigned int idx;
1942   unsigned long reloc_start = *file_cursor;
1943
1944   for (idx = SEG_E0; idx < SEG_LAST; idx++)
1945     {
1946       if (segment_info[idx].scnhdr.s_name[0])
1947         {
1948           struct external_reloc *ext_ptr;
1949           struct external_reloc *external_reloc_vec;
1950           unsigned int external_reloc_size;
1951           unsigned int base = segment_info[idx].scnhdr.s_paddr;
1952           fixS *fix_ptr = segment_info[idx].fix_root;
1953           nrelocs = count_entries_in_chain (idx);
1954
1955           if (nrelocs)
1956             /* Bypass this stuff if no relocs.  This also incidentally
1957                avoids a SCO bug, where free(malloc(0)) tends to crash.  */
1958             {
1959               external_reloc_size = nrelocs * RELSZ;
1960               external_reloc_vec =
1961                 (struct external_reloc *) malloc (external_reloc_size);
1962
1963               ext_ptr = external_reloc_vec;
1964
1965               /* Fill in the internal coff style reloc struct from the
1966                  internal fix list.  */
1967               while (fix_ptr)
1968                 {
1969                   struct internal_reloc intr;
1970
1971                   /* Only output some of the relocations.  */
1972                   if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
1973                     {
1974 #ifdef TC_RELOC_MANGLE
1975                       TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1976                                        base);
1977 #else
1978                       symbolS *dot;
1979                       symbolS *symbol_ptr = fix_ptr->fx_addsy;
1980
1981                       intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1982                       intr.r_vaddr =
1983                         base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1984
1985 #ifdef TC_KEEP_FX_OFFSET
1986                       intr.r_offset = fix_ptr->fx_offset;
1987 #else
1988                       intr.r_offset = 0;
1989 #endif
1990
1991                       while (symbol_ptr->sy_value.X_op == O_symbol
1992                              && (! S_IS_DEFINED (symbol_ptr)
1993                                  || S_IS_COMMON (symbol_ptr)))
1994                         {
1995                           symbolS *n;
1996
1997                           /* We must avoid looping, as that can occur
1998                              with a badly written program.  */
1999                           n = symbol_ptr->sy_value.X_add_symbol;
2000                           if (n == symbol_ptr)
2001                             break;
2002                           symbol_ptr = n;
2003                         }
2004
2005                       /* Turn the segment of the symbol into an offset.  */
2006                       if (symbol_ptr)
2007                         {
2008                           resolve_symbol_value (symbol_ptr);
2009                           if (! symbol_ptr->sy_resolved)
2010                             {
2011                               char *file;
2012                               unsigned int line;
2013
2014                               if (expr_symbol_where (symbol_ptr, &file, &line))
2015                                 as_bad_where (file, line,
2016                                               _("unresolved relocation"));
2017                               else
2018                                 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
2019                                         S_GET_NAME (symbol_ptr));
2020                             }
2021
2022                           dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
2023                           if (dot)
2024                             intr.r_symndx = dot->sy_number;
2025                           else
2026                             intr.r_symndx = symbol_ptr->sy_number;
2027                         }
2028                       else
2029                         intr.r_symndx = -1;
2030 #endif
2031                       (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2032                       ext_ptr++;
2033 #if defined(TC_A29K)
2034                       /* The 29k has a special kludge for the high 16 bit
2035                          reloc.  Two relocations are emited, R_IHIHALF,
2036                          and R_IHCONST. The second one doesn't contain a
2037                          symbol, but uses the value for offset.  */
2038                       if (intr.r_type == R_IHIHALF)
2039                         {
2040                           /* Now emit the second bit.  */
2041                           intr.r_type = R_IHCONST;
2042                           intr.r_symndx = fix_ptr->fx_addnumber;
2043                           (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
2044                           ext_ptr++;
2045                         }
2046 #endif
2047 #if defined(TC_OR32)
2048                       /* The or32 has a special kludge for the high 16 bit
2049                          reloc.  Two relocations are emited, R_IHIHALF,
2050                          and R_IHCONST. The second one doesn't contain a
2051                          symbol, but uses the value for offset.  */
2052                       if (intr.r_type == R_IHIHALF)
2053                         {
2054                           /* Now emit the second bit.  */
2055                           intr.r_type = R_IHCONST;
2056                           intr.r_symndx = fix_ptr->fx_addnumber;
2057                           (void) bfd_coff_swap_reloc_out (abfd, & intr, ext_ptr);
2058                           ext_ptr ++;
2059                         }
2060 #endif
2061                     }
2062
2063                   fix_ptr = fix_ptr->fx_next;
2064                 }
2065 #ifdef TE_AUX
2066               /* Sort the reloc table.  */
2067               qsort ((PTR) external_reloc_vec, nrelocs,
2068                      sizeof (struct external_reloc), compare_external_relocs);
2069 #endif
2070               /* Write out the reloc table.  */
2071               bfd_bwrite ((PTR) external_reloc_vec,
2072                           (bfd_size_type) external_reloc_size, abfd);
2073               free (external_reloc_vec);
2074
2075               /* Fill in section header info.  */
2076               segment_info[idx].scnhdr.s_relptr = *file_cursor;
2077               *file_cursor += external_reloc_size;
2078               segment_info[idx].scnhdr.s_nreloc = nrelocs;
2079             }
2080           else
2081             {
2082               /* No relocs.  */
2083               segment_info[idx].scnhdr.s_relptr = 0;
2084             }
2085         }
2086     }
2087
2088   /* Set relocation_size field in file headers.  */
2089   H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
2090 }
2091
2092 /* Run through a frag chain and write out the data to go with it, fill
2093    in the scnhdrs with the info on the file postions.  */
2094
2095 static void
2096 fill_section (abfd, h, file_cursor)
2097      bfd * abfd;
2098      object_headers *h ATTRIBUTE_UNUSED;
2099      unsigned long *file_cursor;
2100 {
2101   unsigned int i;
2102   unsigned int paddr = 0;
2103
2104   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2105     {
2106       unsigned int offset = 0;
2107       struct internal_scnhdr *s = &(segment_info[i].scnhdr);
2108
2109       PROGRESS (1);
2110
2111       if (s->s_name[0])
2112         {
2113           fragS *frag = segment_info[i].frchainP->frch_root;
2114           char *buffer = NULL;
2115
2116           if (s->s_size == 0)
2117             s->s_scnptr = 0;
2118           else
2119             {
2120               buffer = xmalloc (s->s_size);
2121               s->s_scnptr = *file_cursor;
2122             }
2123           know (s->s_paddr == paddr);
2124
2125           if (strcmp (s->s_name, ".text") == 0)
2126             s->s_flags |= STYP_TEXT;
2127           else if (strcmp (s->s_name, ".data") == 0)
2128             s->s_flags |= STYP_DATA;
2129           else if (strcmp (s->s_name, ".bss") == 0)
2130             {
2131               s->s_scnptr = 0;
2132               s->s_flags |= STYP_BSS;
2133
2134               /* @@ Should make the i386 and a29k coff targets define
2135                  COFF_NOLOAD_PROBLEM, and have only one test here.  */
2136 #ifndef TC_I386
2137 #ifndef TC_A29K
2138 #ifndef TC_OR32
2139 #ifndef COFF_NOLOAD_PROBLEM
2140               /* Apparently the SVR3 linker (and exec syscall) and UDI
2141                  mondfe progrem are confused by noload sections.  */
2142               s->s_flags |= STYP_NOLOAD;
2143 #endif
2144 #endif
2145 #endif
2146 #endif
2147             }
2148           else if (strcmp (s->s_name, ".lit") == 0)
2149             s->s_flags = STYP_LIT | STYP_TEXT;
2150           else if (strcmp (s->s_name, ".init") == 0)
2151             s->s_flags |= STYP_TEXT;
2152           else if (strcmp (s->s_name, ".fini") == 0)
2153             s->s_flags |= STYP_TEXT;
2154           else if (strncmp (s->s_name, ".comment", 8) == 0)
2155             s->s_flags |= STYP_INFO;
2156
2157           while (frag)
2158             {
2159               unsigned int fill_size;
2160               switch (frag->fr_type)
2161                 {
2162                 case rs_machine_dependent:
2163                   if (frag->fr_fix)
2164                     {
2165                       memcpy (buffer + frag->fr_address,
2166                               frag->fr_literal,
2167                               (unsigned int) frag->fr_fix);
2168                       offset += frag->fr_fix;
2169                     }
2170
2171                   break;
2172                 case rs_space:
2173                 case rs_fill:
2174                 case rs_align:
2175                 case rs_align_code:
2176                 case rs_align_test:
2177                 case rs_org:
2178                   if (frag->fr_fix)
2179                     {
2180                       memcpy (buffer + frag->fr_address,
2181                               frag->fr_literal,
2182                               (unsigned int) frag->fr_fix);
2183                       offset += frag->fr_fix;
2184                     }
2185
2186                   fill_size = frag->fr_var;
2187                   if (fill_size && frag->fr_offset > 0)
2188                     {
2189                       unsigned int count;
2190                       unsigned int off = frag->fr_fix;
2191                       for (count = frag->fr_offset; count; count--)
2192                         {
2193                           if (fill_size + frag->fr_address + off <= s->s_size)
2194                             {
2195                               memcpy (buffer + frag->fr_address + off,
2196                                       frag->fr_literal + frag->fr_fix,
2197                                       fill_size);
2198                               off += fill_size;
2199                               offset += fill_size;
2200                             }
2201                         }
2202                     }
2203                   break;
2204                 case rs_broken_word:
2205                   break;
2206                 default:
2207                   abort ();
2208                 }
2209               frag = frag->fr_next;
2210             }
2211
2212           if (s->s_size != 0)
2213             {
2214               if (s->s_scnptr != 0)
2215                 {
2216                   bfd_bwrite (buffer, s->s_size, abfd);
2217                   *file_cursor += s->s_size;
2218                 }
2219               free (buffer);
2220             }
2221           paddr += s->s_size;
2222         }
2223     }
2224 }
2225
2226 /* Coff file generation & utilities.  */
2227
2228 static void
2229 coff_header_append (abfd, h)
2230      bfd * abfd;
2231      object_headers * h;
2232 {
2233   unsigned int i;
2234   char buffer[1000];
2235   char buffero[1000];
2236 #ifdef COFF_LONG_SECTION_NAMES
2237   unsigned long string_size = 4;
2238 #endif
2239
2240   bfd_seek (abfd, (file_ptr) 0, 0);
2241
2242 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2243   H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
2244   H_SET_VERSION_STAMP (h, 0);
2245   H_SET_ENTRY_POINT (h, 0);
2246   H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
2247   H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
2248   H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
2249                                                              buffero));
2250 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2251   H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
2252 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2253
2254   i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
2255
2256   bfd_bwrite (buffer, (bfd_size_type) i, abfd);
2257   bfd_bwrite (buffero, (bfd_size_type) H_GET_SIZEOF_OPTIONAL_HEADER (h), abfd);
2258
2259   for (i = SEG_E0; i < SEG_LAST; i++)
2260     {
2261       if (segment_info[i].scnhdr.s_name[0])
2262         {
2263           unsigned int size;
2264
2265 #ifdef COFF_LONG_SECTION_NAMES
2266           /* Support long section names as found in PE.  This code
2267              must coordinate with that in write_object_file and
2268              w_strings.  */
2269           if (strlen (segment_info[i].name) > SCNNMLEN)
2270             {
2271               memset (segment_info[i].scnhdr.s_name, 0, SCNNMLEN);
2272               sprintf (segment_info[i].scnhdr.s_name, "/%lu", string_size);
2273               string_size += strlen (segment_info[i].name) + 1;
2274             }
2275 #endif
2276           size = bfd_coff_swap_scnhdr_out (abfd,
2277                                            &(segment_info[i].scnhdr),
2278                                            buffer);
2279           if (size == 0)
2280             as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2281           bfd_bwrite (buffer, (bfd_size_type) size, abfd);
2282         }
2283     }
2284 }
2285
2286 char *
2287 symbol_to_chars (abfd, where, symbolP)
2288      bfd * abfd;
2289      char *where;
2290      symbolS * symbolP;
2291 {
2292   unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
2293   unsigned int i;
2294   valueT val;
2295
2296   /* Turn any symbols with register attributes into abs symbols.  */
2297   if (S_GET_SEGMENT (symbolP) == reg_section)
2298     S_SET_SEGMENT (symbolP, absolute_section);
2299
2300   /* At the same time, relocate all symbols to their output value.  */
2301 #ifndef TE_PE
2302   val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
2303          + S_GET_VALUE (symbolP));
2304 #else
2305   val = S_GET_VALUE (symbolP);
2306 #endif
2307
2308   S_SET_VALUE (symbolP, val);
2309
2310   symbolP->sy_symbol.ost_entry.n_value = val;
2311
2312   where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
2313                                   where);
2314
2315   for (i = 0; i < numaux; i++)
2316     {
2317       where += bfd_coff_swap_aux_out (abfd,
2318                                       &symbolP->sy_symbol.ost_auxent[i],
2319                                       S_GET_DATA_TYPE (symbolP),
2320                                       S_GET_STORAGE_CLASS (symbolP),
2321                                       i, numaux, where);
2322     }
2323
2324   return where;
2325 }
2326
2327 void
2328 coff_obj_symbol_new_hook (symbolP)
2329      symbolS *symbolP;
2330 {
2331   char underscore = 0;          /* Symbol has leading _  */
2332
2333   /* Effective symbol.  */
2334   /* Store the pointer in the offset.  */
2335   S_SET_ZEROES (symbolP, 0L);
2336   S_SET_DATA_TYPE (symbolP, T_NULL);
2337   S_SET_STORAGE_CLASS (symbolP, 0);
2338   S_SET_NUMBER_AUXILIARY (symbolP, 0);
2339   /* Additional information.  */
2340   symbolP->sy_symbol.ost_flags = 0;
2341   /* Auxiliary entries.  */
2342   memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
2343
2344   if (S_IS_STRING (symbolP))
2345     SF_SET_STRING (symbolP);
2346   if (!underscore && S_IS_LOCAL (symbolP))
2347     SF_SET_LOCAL (symbolP);
2348 }
2349
2350 /* Handle .ln directives.  */
2351
2352 static void
2353 obj_coff_ln (appline)
2354      int appline;
2355 {
2356   int l;
2357
2358   if (! appline && def_symbol_in_progress != NULL)
2359     {
2360       /* Wrong context.  */
2361       as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2362       demand_empty_rest_of_line ();
2363       return;
2364     }
2365
2366   l = get_absolute_expression ();
2367   c_line_new (0, frag_now_fix (), l, frag_now);
2368
2369   if (appline)
2370     new_logical_line ((char *) NULL, l - 1);
2371
2372 #ifndef NO_LISTING
2373   {
2374     extern int listing;
2375
2376     if (listing)
2377       {
2378         if (! appline)
2379           l += line_base - 1;
2380         listing_source_line ((unsigned int) l);
2381       }
2382
2383   }
2384 #endif
2385   demand_empty_rest_of_line ();
2386 }
2387
2388 /* Handle .def directives.
2389
2390   One might ask : why can't we symbol_new if the symbol does not
2391   already exist and fill it with debug information.  Because of
2392   the C_EFCN special symbol. It would clobber the value of the
2393   function symbol before we have a chance to notice that it is
2394   a C_EFCN. And a second reason is that the code is more clear this
2395   way. (at least I think it is :-).  */
2396
2397 #define SKIP_SEMI_COLON()       while (*input_line_pointer++ != ';')
2398 #define SKIP_WHITESPACES()      while (*input_line_pointer == ' ' || \
2399                                       *input_line_pointer == '\t') \
2400                                          input_line_pointer++;
2401
2402 static void
2403 obj_coff_def (what)
2404      int what ATTRIBUTE_UNUSED;
2405 {
2406   char name_end;                /* Char after the end of name.  */
2407   char *symbol_name;            /* Name of the debug symbol.  */
2408   char *symbol_name_copy;       /* Temporary copy of the name.  */
2409   unsigned int symbol_name_length;
2410
2411   if (def_symbol_in_progress != NULL)
2412     {
2413       as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2414       demand_empty_rest_of_line ();
2415       return;
2416     }
2417
2418   SKIP_WHITESPACES ();
2419
2420   def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
2421   memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2422
2423   symbol_name = input_line_pointer;
2424   name_end = get_symbol_end ();
2425   symbol_name_length = strlen (symbol_name);
2426   symbol_name_copy = xmalloc (symbol_name_length + 1);
2427   strcpy (symbol_name_copy, symbol_name);
2428 #ifdef tc_canonicalize_symbol_name
2429   symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
2430 #endif
2431
2432   /* Initialize the new symbol.  */
2433 #ifdef STRIP_UNDERSCORE
2434   S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2435                                        ? symbol_name_copy + 1
2436                                        : symbol_name_copy));
2437 #else /* STRIP_UNDERSCORE */
2438   S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2439 #endif /* STRIP_UNDERSCORE */
2440   /* free(symbol_name_copy); */
2441   def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2442   def_symbol_in_progress->sy_number = ~0;
2443   def_symbol_in_progress->sy_frag = &zero_address_frag;
2444   S_SET_VALUE (def_symbol_in_progress, 0);
2445
2446   if (S_IS_STRING (def_symbol_in_progress))
2447     SF_SET_STRING (def_symbol_in_progress);
2448
2449   *input_line_pointer = name_end;
2450
2451   demand_empty_rest_of_line ();
2452 }
2453
2454 unsigned int dim_index;
2455
2456 static void
2457 obj_coff_endef (ignore)
2458      int ignore ATTRIBUTE_UNUSED;
2459 {
2460   symbolS *symbolP = 0;
2461   /* DIM BUG FIX sac@cygnus.com */
2462   dim_index = 0;
2463   if (def_symbol_in_progress == NULL)
2464     {
2465       as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2466       demand_empty_rest_of_line ();
2467       return;
2468     }
2469
2470   /* Set the section number according to storage class.  */
2471   switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2472     {
2473     case C_STRTAG:
2474     case C_ENTAG:
2475     case C_UNTAG:
2476       SF_SET_TAG (def_symbol_in_progress);
2477       /* Intentional fallthrough.  */
2478
2479     case C_FILE:
2480     case C_TPDEF:
2481       SF_SET_DEBUG (def_symbol_in_progress);
2482       S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2483       break;
2484
2485     case C_EFCN:
2486       /* Do not emit this symbol.  */
2487       SF_SET_LOCAL (def_symbol_in_progress);
2488       /* Intentional fallthrough. */
2489
2490     case C_BLOCK:
2491       /* Will need processing before writing.  */
2492       SF_SET_PROCESS (def_symbol_in_progress);
2493       /* Intentional fallthrough.  */
2494
2495     case C_FCN:
2496       S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2497
2498       if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2499         {                       /* .bf */
2500           if (function_lineoff < 0)
2501             fprintf (stderr, _("`.bf' symbol without preceding function\n"));
2502
2503           SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2504
2505           SF_SET_PROCESS (last_line_symbol);
2506           SF_SET_ADJ_LNNOPTR (last_line_symbol);
2507           SF_SET_PROCESS (def_symbol_in_progress);
2508           function_lineoff = -1;
2509         }
2510
2511       /* Value is always set to .  */
2512       def_symbol_in_progress->sy_frag = frag_now;
2513       S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2514       break;
2515
2516 #ifdef C_AUTOARG
2517     case C_AUTOARG:
2518 #endif /* C_AUTOARG */
2519     case C_AUTO:
2520     case C_REG:
2521     case C_MOS:
2522     case C_MOE:
2523     case C_MOU:
2524     case C_ARG:
2525     case C_REGPARM:
2526     case C_FIELD:
2527     case C_EOS:
2528       SF_SET_DEBUG (def_symbol_in_progress);
2529       S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2530       break;
2531
2532     case C_EXT:
2533     case C_WEAKEXT:
2534 #ifdef TE_PE
2535     case C_NT_WEAK:
2536 #endif
2537     case C_STAT:
2538     case C_LABEL:
2539       /* Valid but set somewhere else (s_comm, s_lcomm, colon).  */
2540       break;
2541
2542     case C_USTATIC:
2543     case C_EXTDEF:
2544     case C_ULABEL:
2545       as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
2546       break;
2547     }
2548
2549   /* Now that we have built a debug symbol, try to find if we should
2550      merge with an existing symbol or not.  If a symbol is C_EFCN or
2551      absolute_section or untagged SEG_DEBUG it never merges.  We also
2552      don't merge labels, which are in a different namespace, nor
2553      symbols which have not yet been defined since they are typically
2554      unique, nor do we merge tags with non-tags.  */
2555
2556   /* Two cases for functions.  Either debug followed by definition or
2557      definition followed by debug.  For definition first, we will
2558      merge the debug symbol into the definition.  For debug first, the
2559      lineno entry MUST point to the definition function or else it
2560      will point off into space when crawl_symbols() merges the debug
2561      symbol into the real symbol.  Therefor, let's presume the debug
2562      symbol is a real function reference.  */
2563
2564   /* FIXME-SOON If for some reason the definition label/symbol is
2565      never seen, this will probably leave an undefined symbol at link
2566      time.  */
2567
2568   if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2569       || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2570       || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2571           && !SF_GET_TAG (def_symbol_in_progress))
2572       || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2573       || def_symbol_in_progress->sy_value.X_op != O_constant
2574       || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2575       || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2576     {
2577       symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2578                      &symbol_lastP);
2579     }
2580   else
2581     {
2582       /* This symbol already exists, merge the newly created symbol
2583          into the old one.  This is not mandatory. The linker can
2584          handle duplicate symbols correctly. But I guess that it save
2585          a *lot* of space if the assembly file defines a lot of
2586          symbols. [loic] */
2587
2588       /* The debug entry (def_symbol_in_progress) is merged into the
2589          previous definition.  */
2590
2591       c_symbol_merge (def_symbol_in_progress, symbolP);
2592       /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich.  */
2593       def_symbol_in_progress = symbolP;
2594
2595       if (SF_GET_FUNCTION (def_symbol_in_progress)
2596           || SF_GET_TAG (def_symbol_in_progress)
2597           || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_STAT)
2598         {
2599           /* For functions, and tags, and static symbols, the symbol
2600              *must* be where the debug symbol appears.  Move the
2601              existing symbol to the current place.  */
2602           /* If it already is at the end of the symbol list, do nothing.  */
2603           if (def_symbol_in_progress != symbol_lastP)
2604             {
2605               symbol_remove (def_symbol_in_progress, &symbol_rootP,
2606                              &symbol_lastP);
2607               symbol_append (def_symbol_in_progress, symbol_lastP,
2608                              &symbol_rootP, &symbol_lastP);
2609             }
2610         }
2611     }
2612
2613   if (SF_GET_TAG (def_symbol_in_progress))
2614     {
2615       symbolS *oldtag;
2616
2617       oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
2618                                  DO_NOT_STRIP);
2619       if (oldtag == NULL || ! SF_GET_TAG (oldtag))
2620         tag_insert (S_GET_NAME (def_symbol_in_progress),
2621                     def_symbol_in_progress);
2622     }
2623
2624   if (SF_GET_FUNCTION (def_symbol_in_progress))
2625     {
2626       know (sizeof (def_symbol_in_progress) <= sizeof (long));
2627       function_lineoff
2628         = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2629
2630       SF_SET_PROCESS (def_symbol_in_progress);
2631
2632       if (symbolP == NULL)
2633         {
2634           /* That is, if this is the first time we've seen the
2635              function...  */
2636           symbol_table_insert (def_symbol_in_progress);
2637         }
2638     }
2639
2640   def_symbol_in_progress = NULL;
2641   demand_empty_rest_of_line ();
2642 }
2643
2644 static void
2645 obj_coff_dim (ignore)
2646      int ignore ATTRIBUTE_UNUSED;
2647 {
2648   int dim_index;
2649
2650   if (def_symbol_in_progress == NULL)
2651     {
2652       as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2653       demand_empty_rest_of_line ();
2654       return;
2655     }
2656
2657   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2658
2659   for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2660     {
2661       SKIP_WHITESPACES ();
2662       SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2663                         get_absolute_expression ());
2664
2665       switch (*input_line_pointer)
2666         {
2667         case ',':
2668           input_line_pointer++;
2669           break;
2670
2671         default:
2672           as_warn (_("badly formed .dim directive ignored"));
2673           /* Intentional fallthrough.  */
2674
2675         case '\n':
2676         case ';':
2677           dim_index = DIMNUM;
2678           break;
2679         }
2680     }
2681
2682   demand_empty_rest_of_line ();
2683 }
2684
2685 static void
2686 obj_coff_line (ignore)
2687      int ignore ATTRIBUTE_UNUSED;
2688 {
2689   int this_base;
2690   const char *name;
2691
2692   if (def_symbol_in_progress == NULL)
2693     {
2694       obj_coff_ln (0);
2695       return;
2696     }
2697
2698   name = S_GET_NAME (def_symbol_in_progress);
2699   this_base = get_absolute_expression ();
2700
2701   /* Only .bf symbols indicate the use of a new base line number; the
2702      line numbers associated with .ef, .bb, .eb are relative to the
2703      start of the containing function.  */
2704   if (!strcmp (".bf", name))
2705     {
2706 #if 0 /* XXX Can we ever have line numbers going backwards?  */
2707       if (this_base > line_base)
2708 #endif
2709         line_base = this_base;
2710
2711 #ifndef NO_LISTING
2712       {
2713         extern int listing;
2714         if (listing)
2715           listing_source_line ((unsigned int) line_base);
2716       }
2717 #endif
2718     }
2719
2720   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2721   SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2722
2723   demand_empty_rest_of_line ();
2724 }
2725
2726 static void
2727 obj_coff_size (ignore)
2728      int ignore ATTRIBUTE_UNUSED;
2729 {
2730   if (def_symbol_in_progress == NULL)
2731     {
2732       as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2733       demand_empty_rest_of_line ();
2734       return;
2735     }
2736
2737   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2738   SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2739   demand_empty_rest_of_line ();
2740 }
2741
2742 static void
2743 obj_coff_scl (ignore)
2744      int ignore ATTRIBUTE_UNUSED;
2745 {
2746   if (def_symbol_in_progress == NULL)
2747     {
2748       as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2749       demand_empty_rest_of_line ();
2750       return;
2751     }
2752
2753   S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2754   demand_empty_rest_of_line ();
2755 }
2756
2757 static void
2758 obj_coff_tag (ignore)
2759      int ignore ATTRIBUTE_UNUSED;
2760 {
2761   char *symbol_name;
2762   char name_end;
2763
2764   if (def_symbol_in_progress == NULL)
2765     {
2766       as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2767       demand_empty_rest_of_line ();
2768       return;
2769     }
2770
2771   S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2772   symbol_name = input_line_pointer;
2773   name_end = get_symbol_end ();
2774 #ifdef tc_canonicalize_symbol_name
2775   symbol_name = tc_canonicalize_symbol_name (symbol_name);
2776 #endif
2777
2778   /* Assume that the symbol referred to by .tag is always defined.
2779      This was a bad assumption.  I've added find_or_make. xoxorich.  */
2780   SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2781                      (long) tag_find_or_make (symbol_name));
2782   if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2783     as_warn (_("tag not found for .tag %s"), symbol_name);
2784
2785   SF_SET_TAGGED (def_symbol_in_progress);
2786   *input_line_pointer = name_end;
2787
2788   demand_empty_rest_of_line ();
2789 }
2790
2791 static void
2792 obj_coff_type (ignore)
2793      int ignore ATTRIBUTE_UNUSED;
2794 {
2795   if (def_symbol_in_progress == NULL)
2796     {
2797       as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2798       demand_empty_rest_of_line ();
2799       return;
2800     }
2801
2802   S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2803
2804   if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2805       S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2806     SF_SET_FUNCTION (def_symbol_in_progress);
2807
2808   demand_empty_rest_of_line ();
2809 }
2810
2811 static void
2812 obj_coff_val (ignore)
2813      int ignore ATTRIBUTE_UNUSED;
2814 {
2815   if (def_symbol_in_progress == NULL)
2816     {
2817       as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2818       demand_empty_rest_of_line ();
2819       return;
2820     }
2821
2822   if (is_name_beginner (*input_line_pointer))
2823     {
2824       char *symbol_name = input_line_pointer;
2825       char name_end = get_symbol_end ();
2826
2827 #ifdef tc_canonicalize_symbol_name
2828   symbol_name = tc_canonicalize_symbol_name (symbol_name);
2829 #endif
2830
2831       if (!strcmp (symbol_name, "."))
2832         {
2833           def_symbol_in_progress->sy_frag = frag_now;
2834           S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2835           /* If the .val is != from the .def (e.g. statics).  */
2836         }
2837       else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2838         {
2839           def_symbol_in_progress->sy_value.X_op = O_symbol;
2840           def_symbol_in_progress->sy_value.X_add_symbol =
2841             symbol_find_or_make (symbol_name);
2842           def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2843           def_symbol_in_progress->sy_value.X_add_number = 0;
2844
2845           /* If the segment is undefined when the forward reference is
2846              resolved, then copy the segment id from the forward
2847              symbol.  */
2848           SF_SET_GET_SEGMENT (def_symbol_in_progress);
2849
2850           /* FIXME: gcc can generate address expressions here in
2851              unusual cases (search for "obscure" in sdbout.c).  We
2852              just ignore the offset here, thus generating incorrect
2853              debugging information.  We ignore the rest of the line
2854              just below.  */
2855         }
2856       /* Otherwise, it is the name of a non debug symbol and
2857          its value will be calculated later.  */
2858       *input_line_pointer = name_end;
2859
2860       /* FIXME: this is to avoid an error message in the
2861          FIXME case mentioned just above.  */
2862       while (! is_end_of_line[(unsigned char) *input_line_pointer])
2863         ++input_line_pointer;
2864     }
2865   else
2866     {
2867       S_SET_VALUE (def_symbol_in_progress,
2868                    (valueT) get_absolute_expression ());
2869     }                           /* if symbol based */
2870
2871   demand_empty_rest_of_line ();
2872 }
2873
2874 #ifdef TE_PE
2875
2876 /* Handle the .linkonce pseudo-op.  This is parsed by s_linkonce in
2877    read.c, which then calls this object file format specific routine.  */
2878
2879 void
2880 obj_coff_pe_handle_link_once (type)
2881      enum linkonce_type type;
2882 {
2883   seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
2884
2885   /* We store the type in the seg_info structure, and use it to set up
2886      the auxiliary entry for the section symbol in c_section_symbol.  */
2887   seg_info (now_seg)->linkonce = type;
2888 }
2889
2890 #endif /* TE_PE */
2891
2892 void
2893 coff_obj_read_begin_hook ()
2894 {
2895   /* These had better be the same.  Usually 18 bytes.  */
2896 #ifndef BFD_HEADERS
2897   know (sizeof (SYMENT) == sizeof (AUXENT));
2898   know (SYMESZ == AUXESZ);
2899 #endif
2900   tag_init ();
2901 }
2902
2903 /* This function runs through the symbol table and puts all the
2904    externals onto another chain.  */
2905
2906 /* The chain of globals.  */
2907 symbolS *symbol_globalP;
2908 symbolS *symbol_global_lastP;
2909
2910 /* The chain of externals.  */
2911 symbolS *symbol_externP;
2912 symbolS *symbol_extern_lastP;
2913
2914 stack *block_stack;
2915 symbolS *last_functionP;
2916 static symbolS *last_bfP;
2917 symbolS *last_tagP;
2918
2919 static unsigned int
2920 yank_symbols ()
2921 {
2922   symbolS *symbolP;
2923   unsigned int symbol_number = 0;
2924   unsigned int last_file_symno = 0;
2925
2926   struct filename_list *filename_list_scan = filename_list_head;
2927
2928   for (symbolP = symbol_rootP;
2929        symbolP;
2930        symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2931     {
2932       if (symbolP->sy_mri_common)
2933         {
2934           if (S_GET_STORAGE_CLASS (symbolP) == C_EXT
2935 #ifdef TE_PE
2936               || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
2937 #endif
2938               || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT)
2939             as_bad (_("%s: global symbols not supported in common sections"),
2940                     S_GET_NAME (symbolP));
2941           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2942           continue;
2943         }
2944
2945       if (!SF_GET_DEBUG (symbolP))
2946         {
2947           /* Debug symbols do not need all this rubbish.  */
2948           symbolS *real_symbolP;
2949
2950           /* L* and C_EFCN symbols never merge.  */
2951           if (!SF_GET_LOCAL (symbolP)
2952               && !SF_GET_STATICS (symbolP)
2953               && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2954               && symbolP->sy_value.X_op == O_constant
2955               && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2956               && real_symbolP != symbolP)
2957             {
2958               /* FIXME-SOON: where do dups come from?
2959                  Maybe tag references before definitions? xoxorich.  */
2960               /* Move the debug data from the debug symbol to the
2961                  real symbol. Do NOT do the oposite (i.e. move from
2962                  real symbol to debug symbol and remove real symbol from the
2963                  list.) Because some pointers refer to the real symbol
2964                  whereas no pointers refer to the debug symbol.  */
2965               c_symbol_merge (symbolP, real_symbolP);
2966               /* Replace the current symbol by the real one.  */
2967               /* The symbols will never be the last or the first
2968                  because : 1st symbol is .file and 3 last symbols are
2969                  .text, .data, .bss.  */
2970               symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2971               symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2972               symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2973               symbolP = real_symbolP;
2974             }
2975
2976           if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2977             S_SET_SEGMENT (symbolP, SEG_E0);
2978
2979           resolve_symbol_value (symbolP);
2980
2981           if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2982             {
2983               if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2984                 {
2985                   S_SET_EXTERNAL (symbolP);
2986                 }
2987
2988               else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2989                 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2990
2991               else
2992                 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2993             }
2994
2995           /* Mainly to speed up if not -g.  */
2996           if (SF_GET_PROCESS (symbolP))
2997             {
2998               /* Handle the nested blocks auxiliary info.  */
2999               if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
3000                 {
3001                   if (!strcmp (S_GET_NAME (symbolP), ".bb"))
3002                     stack_push (block_stack, (char *) &symbolP);
3003                   else
3004                     {
3005                       /* .eb */
3006                       symbolS *begin_symbolP;
3007
3008                       begin_symbolP = *(symbolS **) stack_pop (block_stack);
3009                       if (begin_symbolP == (symbolS *) 0)
3010                         as_warn (_("mismatched .eb"));
3011                       else
3012                         SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
3013                     }
3014                 }
3015               /* If we are able to identify the type of a function, and we
3016                are out of a function (last_functionP == 0) then, the
3017                function symbol will be associated with an auxiliary
3018                entry.  */
3019               if (last_functionP == (symbolS *) 0 &&
3020                   SF_GET_FUNCTION (symbolP))
3021                 {
3022                   last_functionP = symbolP;
3023
3024                   if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
3025                     S_SET_NUMBER_AUXILIARY (symbolP, 1);
3026
3027                   /* Clobber possible stale .dim information.  */
3028 #if 0
3029                   /* Iffed out by steve - this fries the lnnoptr info too.  */
3030                   bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
3031                          sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
3032 #endif
3033                 }
3034               if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
3035                 {
3036                   if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
3037                     {
3038                       if (last_bfP != NULL)
3039                         SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
3040                       last_bfP = symbolP;
3041                     }
3042                 }
3043               else if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
3044                 {
3045                   /* I don't even know if this is needed for sdb. But
3046                      the standard assembler generates it, so...  */
3047                   if (last_functionP == (symbolS *) 0)
3048                     as_fatal (_("C_EFCN symbol out of scope"));
3049                   SA_SET_SYM_FSIZE (last_functionP,
3050                                     (long) (S_GET_VALUE (symbolP) -
3051                                             S_GET_VALUE (last_functionP)));
3052                   SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
3053                  last_functionP = (symbolS *) 0;
3054                 }
3055             }
3056         }
3057       else if (SF_GET_TAG (symbolP))
3058         {
3059           /* First descriptor of a structure must point to
3060              the first slot after the structure description.  */
3061           last_tagP = symbolP;
3062
3063         }
3064       else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
3065         {
3066           /* +2 take in account the current symbol.  */
3067           SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
3068         }
3069       else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
3070         {
3071           /* If the filename was too long to fit in the
3072              auxent, put it in the string table.  */
3073           if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3074               && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3075             {
3076               SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
3077               string_byte_count += strlen (filename_list_scan->filename) + 1;
3078               filename_list_scan = filename_list_scan->next;
3079             }
3080           if (S_GET_VALUE (symbolP))
3081             {
3082               S_SET_VALUE (symbolP, last_file_symno);
3083               last_file_symno = symbol_number;
3084             }
3085         }
3086
3087 #ifdef tc_frob_coff_symbol
3088       tc_frob_coff_symbol (symbolP);
3089 #endif
3090
3091       /* We must put the external symbols apart. The loader
3092          does not bomb if we do not. But the references in
3093          the endndx field for a .bb symbol are not corrected
3094          if an external symbol is removed between .bb and .be.
3095          I.e in the following case :
3096          [20] .bb endndx = 22
3097          [21] foo external
3098          [22] .be
3099          ld will move the symbol 21 to the end of the list but
3100          endndx will still be 22 instead of 21.  */
3101
3102       if (SF_GET_LOCAL (symbolP))
3103         {
3104           /* Remove C_EFCN and LOCAL (L...) symbols.  */
3105           /* Next pointer remains valid.  */
3106           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3107
3108         }
3109       else if (symbolP->sy_value.X_op == O_symbol
3110                && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
3111         {
3112           /* Skip symbols which were equated to undefined or common
3113              symbols.  */
3114           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3115         }
3116       else if (!S_IS_DEFINED (symbolP)
3117                && !S_IS_DEBUG (symbolP)
3118                && !SF_GET_STATICS (symbolP)
3119                && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3120 #ifdef TE_PE
3121                    || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3122 #endif
3123                    || S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
3124         {
3125           /* If external, Remove from the list.  */
3126           symbolS *hold = symbol_previous (symbolP);
3127
3128           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3129           symbol_clear_list_pointers (symbolP);
3130           symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
3131           symbolP = hold;
3132         }
3133       else if (! S_IS_DEBUG (symbolP)
3134                && ! SF_GET_STATICS (symbolP)
3135                && ! SF_GET_FUNCTION (symbolP)
3136                && (S_GET_STORAGE_CLASS (symbolP) == C_EXT
3137 #ifdef TE_PE
3138                    || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK
3139 #endif
3140                    || S_GET_STORAGE_CLASS (symbolP) == C_NT_WEAK))
3141         {
3142           symbolS *hold = symbol_previous (symbolP);
3143
3144           /* The O'Reilly COFF book says that defined global symbols
3145              come at the end of the symbol table, just before
3146              undefined global symbols.  */
3147           symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3148           symbol_clear_list_pointers (symbolP);
3149           symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
3150                          &symbol_global_lastP);
3151           symbolP = hold;
3152         }
3153       else
3154         {
3155           if (SF_GET_STRING (symbolP))
3156             {
3157               symbolP->sy_name_offset = string_byte_count;
3158               string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
3159             }
3160           else
3161             {
3162               symbolP->sy_name_offset = 0;
3163             }
3164
3165           symbolP->sy_number = symbol_number;
3166           symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3167         }
3168     }
3169
3170   return symbol_number;
3171 }
3172
3173 static unsigned int
3174 glue_symbols (head, tail)
3175      symbolS **head;
3176      symbolS **tail;
3177 {
3178   unsigned int symbol_number = 0;
3179
3180   while (*head != NULL)
3181     {
3182       symbolS *tmp = *head;
3183
3184       /* Append.  */
3185       symbol_remove (tmp, head, tail);
3186       symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
3187
3188       /* Process.  */
3189       if (SF_GET_STRING (tmp))
3190         {
3191           tmp->sy_name_offset = string_byte_count;
3192           string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
3193         }
3194       else
3195         {
3196           /* Fix "long" names.  */
3197           tmp->sy_name_offset = 0;
3198         }
3199
3200       tmp->sy_number = symbol_number;
3201       symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
3202     }
3203
3204   return symbol_number;
3205 }
3206
3207 static unsigned int
3208 tie_tags ()
3209 {
3210   unsigned int symbol_number = 0;
3211   symbolS *symbolP;
3212
3213   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3214     {
3215       symbolP->sy_number = symbol_number;
3216
3217       if (SF_GET_TAGGED (symbolP))
3218         {
3219           SA_SET_SYM_TAGNDX
3220             (symbolP,
3221              ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
3222         }
3223
3224       symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
3225     }
3226
3227   return symbol_number;
3228 }
3229
3230
3231 static void
3232 crawl_symbols (h, abfd)
3233      object_headers *h;
3234      bfd *abfd ATTRIBUTE_UNUSED;
3235 {
3236   unsigned int i;
3237
3238   /* Initialize the stack used to keep track of the matching .bb .be.  */
3239
3240   block_stack = stack_init (512, sizeof (symbolS *));
3241
3242   /* The symbol list should be ordered according to the following sequence
3243      order :
3244      . .file symbol
3245      . debug entries for functions
3246      . fake symbols for the sections, including .text .data and .bss
3247      . defined symbols
3248      . undefined symbols
3249      But this is not mandatory. The only important point is to put the
3250      undefined symbols at the end of the list.  */
3251
3252   /* Is there a .file symbol ? If not insert one at the beginning.  */
3253   if (symbol_rootP == NULL
3254       || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
3255     c_dot_file_symbol ("fake");
3256
3257   /* Build up static symbols for the sections, they are filled in later.  */
3258
3259   for (i = SEG_E0; i < SEG_LAST; i++)
3260     if (segment_info[i].scnhdr.s_name[0])
3261       segment_info[i].dot = c_section_symbol ((char *) segment_info[i].name,
3262                                               i - SEG_E0 + 1);
3263
3264   /* Take all the externals out and put them into another chain.  */
3265   H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
3266   /* Take the externals and glue them onto the end.  */
3267   H_SET_SYMBOL_TABLE_SIZE (h,
3268                            (H_GET_SYMBOL_COUNT (h)
3269                             + glue_symbols (&symbol_globalP,
3270                                             &symbol_global_lastP)
3271                             + glue_symbols (&symbol_externP,
3272                                             &symbol_extern_lastP)));
3273
3274   H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
3275   know (symbol_globalP == NULL);
3276   know (symbol_global_lastP == NULL);
3277   know (symbol_externP == NULL);
3278   know (symbol_extern_lastP == NULL);
3279 }
3280
3281 /* Find strings by crawling along symbol table chain.  */
3282
3283 void
3284 w_strings (where)
3285      char *where;
3286 {
3287   symbolS *symbolP;
3288   struct filename_list *filename_list_scan = filename_list_head;
3289
3290   /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK.  */
3291   md_number_to_chars (where, (valueT) string_byte_count, 4);
3292   where += 4;
3293
3294 #ifdef COFF_LONG_SECTION_NAMES
3295   /* Support long section names as found in PE.  This code must
3296      coordinate with that in coff_header_append and write_object_file.  */
3297   {
3298     unsigned int i;
3299
3300     for (i = SEG_E0; i < SEG_LAST; i++)
3301       {
3302         if (segment_info[i].scnhdr.s_name[0]
3303             && strlen (segment_info[i].name) > SCNNMLEN)
3304           {
3305             unsigned int size;
3306
3307             size = strlen (segment_info[i].name) + 1;
3308             memcpy (where, segment_info[i].name, size);
3309             where += size;
3310           }
3311       }
3312   }
3313 #endif /* COFF_LONG_SECTION_NAMES */
3314
3315   for (symbolP = symbol_rootP;
3316        symbolP;
3317        symbolP = symbol_next (symbolP))
3318     {
3319       unsigned int size;
3320
3321       if (SF_GET_STRING (symbolP))
3322         {
3323           size = strlen (S_GET_NAME (symbolP)) + 1;
3324           memcpy (where, S_GET_NAME (symbolP), size);
3325           where += size;
3326         }
3327       if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
3328           && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
3329           && SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
3330         {
3331           size = strlen (filename_list_scan->filename) + 1;
3332           memcpy (where, filename_list_scan->filename, size);
3333           filename_list_scan = filename_list_scan ->next;
3334           where += size;
3335         }
3336     }
3337 }
3338
3339 static void
3340 do_linenos_for (abfd, h, file_cursor)
3341      bfd * abfd;
3342      object_headers * h;
3343      unsigned long *file_cursor;
3344 {
3345   unsigned int idx;
3346   unsigned long start = *file_cursor;
3347
3348   for (idx = SEG_E0; idx < SEG_LAST; idx++)
3349     {
3350       segment_info_type *s = segment_info + idx;
3351
3352       if (s->scnhdr.s_nlnno != 0)
3353         {
3354           struct lineno_list *line_ptr;
3355
3356           struct external_lineno *buffer =
3357           (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
3358
3359           struct external_lineno *dst = buffer;
3360
3361           /* Run through the table we've built and turn it into its external
3362              form, take this chance to remove duplicates.  */
3363
3364           for (line_ptr = s->lineno_list_head;
3365                line_ptr != (struct lineno_list *) NULL;
3366                line_ptr = line_ptr->next)
3367             {
3368               if (line_ptr->line.l_lnno == 0)
3369                 {
3370                   /* Turn a pointer to a symbol into the symbols' index,
3371                      provided that it has been initialised.  */
3372                   if (line_ptr->line.l_addr.l_symndx)
3373                     line_ptr->line.l_addr.l_symndx =
3374                       ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
3375                 }
3376               else
3377                 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
3378
3379               (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
3380               dst++;
3381             }
3382
3383           s->scnhdr.s_lnnoptr = *file_cursor;
3384
3385           bfd_bwrite (buffer, (bfd_size_type) s->scnhdr.s_nlnno * LINESZ, abfd);
3386           free (buffer);
3387
3388           *file_cursor += s->scnhdr.s_nlnno * LINESZ;
3389         }
3390     }
3391
3392   H_SET_LINENO_SIZE (h, *file_cursor - start);
3393 }
3394
3395 /* Now we run through the list of frag chains in a segment and
3396    make all the subsegment frags appear at the end of the
3397    list, as if the seg 0 was extra long.  */
3398
3399 static void
3400 remove_subsegs ()
3401 {
3402   unsigned int i;
3403
3404   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3405     {
3406       frchainS *head = segment_info[i].frchainP;
3407       fragS dummy;
3408       fragS *prev_frag = &dummy;
3409
3410       while (head && head->frch_seg == i)
3411         {
3412           prev_frag->fr_next = head->frch_root;
3413           prev_frag = head->frch_last;
3414           head = head->frch_next;
3415         }
3416       prev_frag->fr_next = 0;
3417     }
3418 }
3419
3420 unsigned long machine;
3421 int coff_flags;
3422
3423 #ifndef SUB_SEGMENT_ALIGN
3424 #ifdef HANDLE_ALIGN
3425 /* The last subsegment gets an aligment corresponding to the alignment
3426    of the section.  This allows proper nop-filling at the end of
3427    code-bearing sections.  */
3428 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN)                                 \
3429   (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG)     \
3430    ? get_recorded_alignment (SEG) : 0)
3431 #else
3432 #define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 1
3433 #endif
3434 #endif
3435
3436 extern void
3437 write_object_file ()
3438 {
3439   int i;
3440   const char *name;
3441   struct frchain *frchain_ptr;
3442
3443   object_headers headers;
3444   unsigned long file_cursor;
3445   bfd *abfd;
3446   unsigned int addr;
3447   abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3448
3449   if (abfd == 0)
3450     {
3451       as_perror (_("FATAL: Can't create %s"), out_file_name);
3452       exit (EXIT_FAILURE);
3453     }
3454   bfd_set_format (abfd, bfd_object);
3455   bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3456
3457   string_byte_count = 4;
3458
3459   /* Run through all the sub-segments and align them up.  Also
3460      close any open frags.  We tack a .fill onto the end of the
3461      frag chain so that any .align's size can be worked by looking
3462      at the next frag.  */
3463   for (frchain_ptr = frchain_root;
3464        frchain_ptr != (struct frchain *) NULL;
3465        frchain_ptr = frchain_ptr->frch_next)
3466     {
3467       int alignment;
3468
3469       subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3470
3471       alignment = SUB_SEGMENT_ALIGN (now_seg, frchain_ptr)
3472
3473 #ifdef md_do_align
3474       md_do_align (alignment, (char *) NULL, 0, 0, alignment_done);
3475 #endif
3476       if (subseg_text_p (now_seg))
3477         frag_align_code (alignment, 0);
3478       else
3479         frag_align (alignment, 0, 0);
3480
3481 #ifdef md_do_align
3482     alignment_done:
3483 #endif
3484
3485       frag_wane (frag_now);
3486       frag_now->fr_fix = 0;
3487       know (frag_now->fr_next == NULL);
3488     }
3489
3490   remove_subsegs ();
3491
3492   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3493     relax_segment (segment_info[i].frchainP->frch_root, i);
3494
3495   /* Relaxation has completed.  Freeze all syms.  */
3496   finalize_syms = 1;
3497
3498   H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3499
3500   /* Find out how big the sections are, and set the addresses.  */
3501   addr = 0;
3502   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3503     {
3504       long size;
3505
3506       segment_info[i].scnhdr.s_paddr = addr;
3507       segment_info[i].scnhdr.s_vaddr = addr;
3508
3509       if (segment_info[i].scnhdr.s_name[0])
3510         {
3511           H_SET_NUMBER_OF_SECTIONS (&headers,
3512                                     H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3513
3514 #ifdef COFF_LONG_SECTION_NAMES
3515           /* Support long section names as found in PE.  This code
3516              must coordinate with that in coff_header_append and
3517              w_strings.  */
3518           {
3519             unsigned int len;
3520
3521             len = strlen (segment_info[i].name);
3522             if (len > SCNNMLEN)
3523               string_byte_count += len + 1;
3524           }
3525 #endif /* COFF_LONG_SECTION_NAMES */
3526         }
3527
3528       size = size_section (abfd, (unsigned int) i);
3529       addr += size;
3530
3531       /* I think the section alignment is only used on the i960; the
3532          i960 needs it, and it should do no harm on other targets.  */
3533 #ifdef ALIGNMENT_IN_S_FLAGS
3534       segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
3535 #else
3536       segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3537 #endif
3538
3539       if (i == SEG_E0)
3540         H_SET_TEXT_SIZE (&headers, size);
3541       else if (i == SEG_E1)
3542         H_SET_DATA_SIZE (&headers, size);
3543       else if (i == SEG_E2)
3544         H_SET_BSS_SIZE (&headers, size);
3545     }
3546
3547   /* Turn the gas native symbol table shape into a coff symbol table.  */
3548   crawl_symbols (&headers, abfd);
3549
3550   if (string_byte_count == 4)
3551     string_byte_count = 0;
3552
3553   H_SET_STRING_SIZE (&headers, string_byte_count);
3554
3555 #ifdef tc_frob_file
3556   tc_frob_file ();
3557 #endif
3558
3559   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3560     {
3561       fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3562       fixup_segment (&segment_info[i], i);
3563     }
3564
3565   /* Look for ".stab" segments and fill in their initial symbols
3566      correctly.  */
3567   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3568     {
3569       name = segment_info[i].name;
3570
3571       if (name != NULL
3572           && strncmp (".stab", name, 5) == 0
3573           && strncmp (".stabstr", name, 8) != 0)
3574         adjust_stab_section (abfd, i);
3575     }
3576
3577   file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3578
3579   bfd_seek (abfd, (file_ptr) file_cursor, 0);
3580
3581   /* Plant the data.  */
3582   fill_section (abfd, &headers, &file_cursor);
3583
3584   do_relocs_for (abfd, &headers, &file_cursor);
3585
3586   do_linenos_for (abfd, &headers, &file_cursor);
3587
3588   H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3589 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3590   H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3591 #else
3592   H_SET_TIME_STAMP (&headers, 0);
3593 #endif
3594 #ifdef TC_COFF_SET_MACHINE
3595   TC_COFF_SET_MACHINE (&headers);
3596 #endif
3597
3598 #ifndef COFF_FLAGS
3599 #define COFF_FLAGS 0
3600 #endif
3601
3602 #ifdef KEEP_RELOC_INFO
3603   H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3604                           COFF_FLAGS | coff_flags));
3605 #else
3606   H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers)     ? 0 : F_LNNO)   |
3607                           (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3608                           COFF_FLAGS | coff_flags));
3609 #endif
3610
3611   {
3612     unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3613     char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3614
3615     H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3616     w_symbols (abfd, buffer1, symbol_rootP);
3617     if (string_byte_count > 0)
3618       w_strings (buffer1 + symtable_size);
3619     bfd_bwrite (buffer1, (bfd_size_type) symtable_size + string_byte_count,
3620                 abfd);
3621     free (buffer1);
3622   }
3623
3624   coff_header_append (abfd, &headers);
3625 #if 0
3626   /* Recent changes to write need this, but where it should
3627      go is up to Ken..  */
3628   if (bfd_close_all_done (abfd) == false)
3629     as_fatal (_("Can't close %s: %s"), out_file_name,
3630               bfd_errmsg (bfd_get_error ()));
3631 #else
3632   {
3633     extern bfd *stdoutput;
3634     stdoutput = abfd;
3635   }
3636 #endif
3637
3638 }
3639
3640 /* Add a new segment.  This is called from subseg_new via the
3641    obj_new_segment macro.  */
3642
3643 segT
3644 obj_coff_add_segment (name)
3645      const char *name;
3646 {
3647   unsigned int i;
3648
3649 #ifndef COFF_LONG_SECTION_NAMES
3650   char buf[SCNNMLEN + 1];
3651
3652   strncpy (buf, name, SCNNMLEN);
3653   buf[SCNNMLEN] = '\0';
3654   name = buf;
3655 #endif
3656
3657   for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
3658     if (strcmp (name, segment_info[i].name) == 0)
3659       return (segT) i;
3660
3661   if (i == SEG_LAST)
3662     {
3663       as_bad (_("Too many new sections; can't add \"%s\""), name);
3664       return now_seg;
3665     }
3666
3667   /* Add a new section.  */
3668   strncpy (segment_info[i].scnhdr.s_name, name,
3669            sizeof (segment_info[i].scnhdr.s_name));
3670   segment_info[i].scnhdr.s_flags = STYP_REG;
3671   segment_info[i].name = xstrdup (name);
3672
3673   return (segT) i;
3674 }
3675
3676 /* Implement the .section pseudo op:
3677         .section name {, "flags"}
3678                   ^         ^
3679                   |         +--- optional flags: 'b' for bss
3680                   |                              'i' for info
3681                   +-- section name               'l' for lib
3682                                                  'n' for noload
3683                                                  'o' for over
3684                                                  'w' for data
3685                                                  'd' (apparently m88k for data)
3686                                                  'x' for text
3687                                                  'r' for read-only data
3688    But if the argument is not a quoted string, treat it as a
3689    subsegment number.  */
3690
3691 void
3692 obj_coff_section (ignore)
3693      int ignore ATTRIBUTE_UNUSED;
3694 {
3695   /* Strip out the section name.  */
3696   char *section_name, *name;
3697   char c;
3698   unsigned int exp;
3699   long flags;
3700
3701   if (flag_mri)
3702     {
3703       char type;
3704
3705       s_mri_sect (&type);
3706       flags = 0;
3707       if (type == 'C')
3708         flags = STYP_TEXT;
3709       else if (type == 'D')
3710         flags = STYP_DATA;
3711       segment_info[now_seg].scnhdr.s_flags |= flags;
3712
3713       return;
3714     }
3715
3716   section_name = input_line_pointer;
3717   c = get_symbol_end ();
3718
3719   name = xmalloc (input_line_pointer - section_name + 1);
3720   strcpy (name, section_name);
3721
3722   *input_line_pointer = c;
3723
3724   exp = 0;
3725   flags = 0;
3726
3727   SKIP_WHITESPACE ();
3728   if (*input_line_pointer == ',')
3729     {
3730       ++input_line_pointer;
3731       SKIP_WHITESPACE ();
3732
3733       if (*input_line_pointer != '"')
3734         exp = get_absolute_expression ();
3735       else
3736         {
3737           ++input_line_pointer;
3738           while (*input_line_pointer != '"'
3739                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
3740             {
3741               switch (*input_line_pointer)
3742                 {
3743                 case 'b': flags |= STYP_BSS;    break;
3744                 case 'i': flags |= STYP_INFO;   break;
3745                 case 'l': flags |= STYP_LIB;    break;
3746                 case 'n': flags |= STYP_NOLOAD; break;
3747                 case 'o': flags |= STYP_OVER;   break;
3748                 case 'd':
3749                 case 'w': flags |= STYP_DATA;   break;
3750                 case 'x': flags |= STYP_TEXT;   break;
3751                 case 'r': flags |= STYP_LIT;    break;
3752                 default:
3753                   as_warn(_("unknown section attribute '%c'"),
3754                           *input_line_pointer);
3755                   break;
3756                 }
3757               ++input_line_pointer;
3758             }
3759           if (*input_line_pointer == '"')
3760             ++input_line_pointer;
3761         }
3762     }
3763
3764   subseg_new (name, (subsegT) exp);
3765
3766   segment_info[now_seg].scnhdr.s_flags |= flags;
3767
3768   demand_empty_rest_of_line ();
3769 }
3770
3771 static void
3772 obj_coff_text (ignore)
3773      int ignore ATTRIBUTE_UNUSED;
3774 {
3775   subseg_new (".text", get_absolute_expression ());
3776 }
3777
3778 static void
3779 obj_coff_data (ignore)
3780      int ignore ATTRIBUTE_UNUSED;
3781 {
3782   if (flag_readonly_data_in_text)
3783     subseg_new (".text", get_absolute_expression () + 1000);
3784   else
3785     subseg_new (".data", get_absolute_expression ());
3786 }
3787
3788 static void
3789 obj_coff_ident (ignore)
3790      int ignore ATTRIBUTE_UNUSED;
3791 {
3792   segT current_seg = now_seg;           /* Save current seg.  */
3793   subsegT current_subseg = now_subseg;
3794
3795   subseg_new (".comment", 0);           /* .comment seg.  */
3796   stringer (1);                         /* Read string.  */
3797   subseg_set (current_seg, current_subseg);     /* Restore current seg.  */
3798 }
3799
3800 void
3801 c_symbol_merge (debug, normal)
3802      symbolS *debug;
3803      symbolS *normal;
3804 {
3805   S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3806   S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3807
3808   if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3809     S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3810
3811   if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3812     memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3813             (char *) &debug->sy_symbol.ost_auxent[0],
3814             (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3815
3816   /* Move the debug flags.  */
3817   SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3818 }
3819
3820 static int
3821 c_line_new (symbol, paddr, line_number, frag)
3822      symbolS * symbol;
3823      long paddr;
3824      int line_number;
3825      fragS * frag;
3826 {
3827   struct lineno_list *new_line =
3828   (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3829
3830   segment_info_type *s = segment_info + now_seg;
3831   new_line->line.l_lnno = line_number;
3832
3833   if (line_number == 0)
3834     {
3835       last_line_symbol = symbol;
3836       new_line->line.l_addr.l_symndx = (long) symbol;
3837     }
3838   else
3839     {
3840       new_line->line.l_addr.l_paddr = paddr;
3841     }
3842
3843   new_line->frag = (char *) frag;
3844   new_line->next = (struct lineno_list *) NULL;
3845
3846   if (s->lineno_list_head == (struct lineno_list *) NULL)
3847     s->lineno_list_head = new_line;
3848   else
3849     s->lineno_list_tail->next = new_line;
3850
3851   s->lineno_list_tail = new_line;
3852   return LINESZ * s->scnhdr.s_nlnno++;
3853 }
3854
3855 void
3856 c_dot_file_symbol (filename)
3857      char *filename;
3858 {
3859   symbolS *symbolP;
3860
3861   symbolP = symbol_new (".file",
3862                         SEG_DEBUG,
3863                         0,
3864                         &zero_address_frag);
3865
3866   S_SET_STORAGE_CLASS (symbolP, C_FILE);
3867   S_SET_NUMBER_AUXILIARY (symbolP, 1);
3868
3869   if (strlen (filename) > FILNMLEN)
3870     {
3871       /* Filename is too long to fit into an auxent,
3872          we stick it into the string table instead.  We keep
3873          a linked list of the filenames we find so we can emit
3874          them later.  */
3875       struct filename_list *f = ((struct filename_list *)
3876                                  xmalloc (sizeof (struct filename_list)));
3877
3878       f->filename = filename;
3879       f->next = 0;
3880
3881       SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3882       SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
3883
3884       if (filename_list_tail)
3885         filename_list_tail->next = f;
3886       else
3887         filename_list_head = f;
3888       filename_list_tail = f;
3889     }
3890   else
3891     {
3892       SA_SET_FILE_FNAME (symbolP, filename);
3893     }
3894 #ifndef NO_LISTING
3895   {
3896     extern int listing;
3897     if (listing)
3898       listing_source_file (filename);
3899   }
3900 #endif
3901   SF_SET_DEBUG (symbolP);
3902   S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3903
3904   previous_file_symbol = symbolP;
3905
3906   /* Make sure that the symbol is first on the symbol chain.  */
3907   if (symbol_rootP != symbolP)
3908     {
3909       symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3910       symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3911     }
3912 }
3913
3914 /* Build a 'section static' symbol.  */
3915
3916 symbolS *
3917 c_section_symbol (name, idx)
3918      char *name;
3919      int idx;
3920 {
3921   symbolS *symbolP;
3922
3923   symbolP = symbol_find_base (name, DO_NOT_STRIP);
3924   if (symbolP == NULL)
3925     symbolP = symbol_new (name, idx, 0, &zero_address_frag);
3926   else
3927     {
3928       /* Mmmm.  I just love violating interfaces.  Makes me feel...dirty.  */
3929       S_SET_SEGMENT (symbolP, idx);
3930       symbolP->sy_frag = &zero_address_frag;
3931     }
3932
3933   S_SET_STORAGE_CLASS (symbolP, C_STAT);
3934   S_SET_NUMBER_AUXILIARY (symbolP, 1);
3935
3936   SF_SET_STATICS (symbolP);
3937
3938 #ifdef TE_DELTA
3939   /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3940      which is set by the new definition of LOCAL_LABEL in tc-m68k.h.  */
3941   SF_CLEAR_LOCAL (symbolP);
3942 #endif
3943 #ifdef TE_PE
3944   /* If the .linkonce pseudo-op was used for this section, we must
3945      store the information in the auxiliary entry for the section
3946      symbol.  */
3947   if (segment_info[idx].linkonce != LINKONCE_UNSET)
3948     {
3949       int type;
3950
3951       switch (segment_info[idx].linkonce)
3952         {
3953         default:
3954           abort ();
3955         case LINKONCE_DISCARD:
3956           type = IMAGE_COMDAT_SELECT_ANY;
3957           break;
3958         case LINKONCE_ONE_ONLY:
3959           type = IMAGE_COMDAT_SELECT_NODUPLICATES;
3960           break;
3961         case LINKONCE_SAME_SIZE:
3962           type = IMAGE_COMDAT_SELECT_SAME_SIZE;
3963           break;
3964         case LINKONCE_SAME_CONTENTS:
3965           type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
3966           break;
3967         }
3968
3969       SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
3970     }
3971 #endif /* TE_PE */
3972
3973   return symbolP;
3974 }
3975
3976 static void
3977 w_symbols (abfd, where, symbol_rootP)
3978      bfd * abfd;
3979      char *where;
3980      symbolS * symbol_rootP;
3981 {
3982   symbolS *symbolP;
3983   unsigned int i;
3984
3985   /* First fill in those values we have only just worked out.  */
3986   for (i = SEG_E0; i < SEG_LAST; i++)
3987     {
3988       symbolP = segment_info[i].dot;
3989       if (symbolP)
3990         {
3991           SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3992           SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3993           SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3994         }
3995     }
3996
3997   /* Emit all symbols left in the symbol chain.  */
3998   for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3999     {
4000       /* Used to save the offset of the name. It is used to point
4001          to the string in memory but must be a file offset.  */
4002       char *temp;
4003
4004       /* We can't fix the lnnoptr field in yank_symbols with the other
4005          adjustments, because we have to wait until we know where they
4006          go in the file.  */
4007       if (SF_GET_ADJ_LNNOPTR (symbolP))
4008         SA_GET_SYM_LNNOPTR (symbolP) +=
4009           segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
4010
4011       tc_coff_symbol_emit_hook (symbolP);
4012
4013       temp = S_GET_NAME (symbolP);
4014       if (SF_GET_STRING (symbolP))
4015         {
4016           S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
4017           S_SET_ZEROES (symbolP, 0);
4018         }
4019       else
4020         {
4021           memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
4022           strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
4023         }
4024       where = symbol_to_chars (abfd, where, symbolP);
4025       S_SET_NAME (symbolP, temp);
4026     }
4027 }
4028
4029 static void
4030 obj_coff_lcomm (ignore)
4031      int ignore ATTRIBUTE_UNUSED;
4032 {
4033   s_lcomm(0);
4034   return;
4035 #if 0
4036   char *name;
4037   char c;
4038   int temp;
4039   char *p;
4040
4041   symbolS *symbolP;
4042
4043   name = input_line_pointer;
4044
4045   c = get_symbol_end ();
4046   p = input_line_pointer;
4047   *p = c;
4048   SKIP_WHITESPACE ();
4049   if (*input_line_pointer != ',')
4050     {
4051       as_bad (_("Expected comma after name"));
4052       ignore_rest_of_line ();
4053       return;
4054     }
4055   if (*input_line_pointer == '\n')
4056     {
4057       as_bad (_("Missing size expression"));
4058       return;
4059     }
4060   input_line_pointer++;
4061   if ((temp = get_absolute_expression ()) < 0)
4062     {
4063       as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
4064       ignore_rest_of_line ();
4065       return;
4066     }
4067   *p = 0;
4068
4069   symbolP = symbol_find_or_make (name);
4070
4071   if (S_GET_SEGMENT (symbolP) == SEG_UNKNOWN &&
4072       S_GET_VALUE (symbolP) == 0)
4073     {
4074       if (! need_pass_2)
4075         {
4076           char *p;
4077           segT current_seg = now_seg;   /* Save current seg.  */
4078           subsegT current_subseg = now_subseg;
4079
4080           subseg_set (SEG_E2, 1);
4081           symbolP->sy_frag = frag_now;
4082           p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
4083                        (offsetT) temp, (char *) 0);
4084           *p = 0;
4085           subseg_set (current_seg, current_subseg); /* Restore current seg.  */
4086           S_SET_SEGMENT (symbolP, SEG_E2);
4087           S_SET_STORAGE_CLASS (symbolP, C_STAT);
4088         }
4089     }
4090   else
4091     as_bad (_("Symbol %s already defined"), name);
4092
4093   demand_empty_rest_of_line ();
4094 #endif
4095 }
4096
4097 static void
4098 fixup_mdeps (frags, h, this_segment)
4099      fragS * frags;
4100      object_headers * h;
4101      segT this_segment;
4102 {
4103   subseg_change (this_segment, 0);
4104
4105   while (frags)
4106     {
4107       switch (frags->fr_type)
4108         {
4109         case rs_align:
4110         case rs_align_code:
4111         case rs_align_test:
4112         case rs_org:
4113 #ifdef HANDLE_ALIGN
4114           HANDLE_ALIGN (frags);
4115 #endif
4116           frags->fr_type = rs_fill;
4117           frags->fr_offset =
4118             ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
4119              / frags->fr_var);
4120           break;
4121         case rs_machine_dependent:
4122           md_convert_frag (h, this_segment, frags);
4123           frag_wane (frags);
4124           break;
4125         default:
4126           ;
4127         }
4128       frags = frags->fr_next;
4129     }
4130 }
4131
4132 #if 1
4133
4134 #ifndef TC_FORCE_RELOCATION
4135 #define TC_FORCE_RELOCATION(fix) 0
4136 #endif
4137
4138 static void
4139 fixup_segment (segP, this_segment_type)
4140      segment_info_type * segP;
4141      segT this_segment_type;
4142 {
4143   fixS * fixP;
4144   symbolS *add_symbolP;
4145   symbolS *sub_symbolP;
4146   long add_number;
4147   int size;
4148   char *place;
4149   long where;
4150   char pcrel;
4151   fragS *fragP;
4152   segT add_symbol_segment = absolute_section;
4153
4154   for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
4155     {
4156       fragP = fixP->fx_frag;
4157       know (fragP);
4158       where = fixP->fx_where;
4159       place = fragP->fr_literal + where;
4160       size = fixP->fx_size;
4161       add_symbolP = fixP->fx_addsy;
4162       sub_symbolP = fixP->fx_subsy;
4163       add_number = fixP->fx_offset;
4164       pcrel = fixP->fx_pcrel;
4165
4166       /* We want function-relative stabs to work on systems which
4167          may use a relaxing linker; thus we must handle the sym1-sym2
4168          fixups function-relative stabs generates.
4169
4170          Of course, if you actually enable relaxing in the linker, the
4171          line and block scoping information is going to be incorrect
4172          in some cases.  The only way to really fix this is to support
4173          a reloc involving the difference of two symbols.  */
4174       if (linkrelax
4175           && (!sub_symbolP || pcrel))
4176         continue;
4177
4178 #ifdef TC_I960
4179       if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
4180         {
4181           /* Relocation should be done via the associated 'bal' entry
4182              point symbol.  */
4183
4184           if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
4185             {
4186               as_bad_where (fixP->fx_file, fixP->fx_line,
4187                             _("No 'bal' entry point for leafproc %s"),
4188                             S_GET_NAME (add_symbolP));
4189               continue;
4190             }
4191           fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
4192         }
4193 #endif
4194
4195       /* Make sure the symbols have been resolved; this may not have
4196          happened if these are expression symbols.  */
4197       if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
4198         resolve_symbol_value (add_symbolP);
4199
4200       if (add_symbolP != NULL)
4201         {
4202           /* If this fixup is against a symbol which has been equated
4203              to another symbol, convert it to the other symbol.  */
4204           if (add_symbolP->sy_value.X_op == O_symbol
4205               && (! S_IS_DEFINED (add_symbolP)
4206                   || S_IS_COMMON (add_symbolP)))
4207             {
4208               while (add_symbolP->sy_value.X_op == O_symbol
4209                      && (! S_IS_DEFINED (add_symbolP)
4210                          || S_IS_COMMON (add_symbolP)))
4211                 {
4212                   symbolS *n;
4213
4214                   /* We must avoid looping, as that can occur with a
4215                      badly written program.  */
4216                   n = add_symbolP->sy_value.X_add_symbol;
4217                   if (n == add_symbolP)
4218                     break;
4219                   add_number += add_symbolP->sy_value.X_add_number;
4220                   add_symbolP = n;
4221                 }
4222               fixP->fx_addsy = add_symbolP;
4223               fixP->fx_offset = add_number;
4224             }
4225         }
4226
4227       if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
4228         resolve_symbol_value (sub_symbolP);
4229
4230       if (add_symbolP != NULL
4231           && add_symbolP->sy_mri_common)
4232         {
4233           know (add_symbolP->sy_value.X_op == O_symbol);
4234           add_number += S_GET_VALUE (add_symbolP);
4235           fixP->fx_offset = add_number;
4236           add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
4237         }
4238
4239       if (add_symbolP)
4240         add_symbol_segment = S_GET_SEGMENT (add_symbolP);
4241
4242       if (sub_symbolP)
4243         {
4244           if (add_symbolP == NULL || add_symbol_segment == absolute_section)
4245             {
4246               if (add_symbolP != NULL)
4247                 {
4248                   add_number += S_GET_VALUE (add_symbolP);
4249                   add_symbolP = NULL;
4250                   fixP->fx_addsy = NULL;
4251                 }
4252
4253               /* It's just -sym.  */
4254               if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
4255                 {
4256                   add_number -= S_GET_VALUE (sub_symbolP);
4257                   fixP->fx_subsy = 0;
4258                   fixP->fx_done = 1;
4259                 }
4260               else
4261                 {
4262 #ifndef TC_M68K
4263                   as_bad_where (fixP->fx_file, fixP->fx_line,
4264                                 _("Negative of non-absolute symbol %s"),
4265                                 S_GET_NAME (sub_symbolP));
4266 #endif
4267                   add_number -= S_GET_VALUE (sub_symbolP);
4268                 }               /* not absolute */
4269
4270               /* if sub_symbol is in the same segment that add_symbol
4271                  and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE.  */
4272             }
4273           else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
4274                    && SEG_NORMAL (add_symbol_segment))
4275             {
4276               /* Difference of 2 symbols from same segment.  Can't
4277                  make difference of 2 undefineds: 'value' means
4278                  something different for N_UNDF.  */
4279 #ifdef TC_I960
4280               /* Makes no sense to use the difference of 2 arbitrary symbols
4281                  as the target of a call instruction.  */
4282               if (fixP->fx_tcbit)
4283                 as_bad_where (fixP->fx_file, fixP->fx_line,
4284                               _("callj to difference of 2 symbols"));
4285 #endif /* TC_I960 */
4286               add_number += S_GET_VALUE (add_symbolP) -
4287                 S_GET_VALUE (sub_symbolP);
4288               add_symbolP = NULL;
4289
4290               if (!TC_FORCE_RELOCATION (fixP))
4291                 {
4292                   fixP->fx_addsy = NULL;
4293                   fixP->fx_subsy = NULL;
4294                   fixP->fx_done = 1;
4295 #ifdef TC_M68K /* is this right? */
4296                   pcrel = 0;
4297                   fixP->fx_pcrel = 0;
4298 #endif
4299                 }
4300             }
4301           else
4302             {
4303               /* Different segments in subtraction.  */
4304               know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
4305
4306               if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
4307                 add_number -= S_GET_VALUE (sub_symbolP);
4308
4309 #ifdef DIFF_EXPR_OK
4310               else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
4311 #if 0 /* Okay for 68k, at least...  */
4312                        && !pcrel
4313 #endif
4314                        )
4315                 {
4316                   /* Make it pc-relative.  */
4317                   add_number += (md_pcrel_from (fixP)
4318                                  - S_GET_VALUE (sub_symbolP));
4319                   pcrel = 1;
4320                   fixP->fx_pcrel = 1;
4321                   sub_symbolP = 0;
4322                   fixP->fx_subsy = 0;
4323                 }
4324 #endif
4325               else
4326                 {
4327                   as_bad_where (fixP->fx_file, fixP->fx_line,
4328                                 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4329                                 segment_name (S_GET_SEGMENT (sub_symbolP)),
4330                                 S_GET_NAME (sub_symbolP),
4331                                 (long) (fragP->fr_address + where));
4332                 }
4333             }
4334         }
4335
4336       if (add_symbolP)
4337         {
4338           if (add_symbol_segment == this_segment_type && pcrel)
4339             {
4340               /* This fixup was made when the symbol's segment was
4341                  SEG_UNKNOWN, but it is now in the local segment.
4342                  So we know how to do the address without relocation.  */
4343 #ifdef TC_I960
4344               /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4345                  in which cases it modifies *fixP as appropriate.  In the case
4346                  of a 'calls', no further work is required, and *fixP has been
4347                  set up to make the rest of the code below a no-op.  */
4348               reloc_callj (fixP);
4349 #endif /* TC_I960 */
4350
4351               add_number += S_GET_VALUE (add_symbolP);
4352               add_number -= md_pcrel_from (fixP);
4353
4354               /* We used to do
4355                    add_number -= segP->scnhdr.s_vaddr;
4356                  if defined (TC_I386) || defined (TE_LYNX).  I now
4357                  think that was an error propagated from the case when
4358                  we are going to emit the relocation.  If we are not
4359                  going to emit the relocation, then we just want to
4360                  set add_number to the difference between the symbols.
4361                  This is a case that would only arise when there is a
4362                  PC relative reference from a section other than .text
4363                  to a symbol defined in the same section, and the
4364                  reference is not relaxed.  Since jump instructions on
4365                  the i386 are relaxed, this could only arise with a
4366                  call instruction.  */
4367
4368               pcrel = 0;        /* Lie. Don't want further pcrel processing.  */
4369               if (!TC_FORCE_RELOCATION (fixP))
4370                 {
4371                   fixP->fx_addsy = NULL;
4372                   fixP->fx_done = 1;
4373                 }
4374             }
4375           else
4376             {
4377               switch (add_symbol_segment)
4378                 {
4379                 case absolute_section:
4380 #ifdef TC_I960
4381                   /* See comment about reloc_callj() above.  */
4382                   reloc_callj (fixP);
4383 #endif /* TC_I960 */
4384                   add_number += S_GET_VALUE (add_symbolP);
4385                   add_symbolP = NULL;
4386
4387                   if (!TC_FORCE_RELOCATION (fixP))
4388                     {
4389                       fixP->fx_addsy = NULL;
4390                       fixP->fx_done = 1;
4391                     }
4392                   break;
4393                 default:
4394
4395 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K) || defined(TC_OR32)
4396                   /* This really should be handled in the linker, but
4397                      backward compatibility forbids.  */
4398                   add_number += S_GET_VALUE (add_symbolP);
4399 #else
4400                   add_number += S_GET_VALUE (add_symbolP) +
4401                     segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
4402 #endif
4403                   break;
4404
4405                 case SEG_UNKNOWN:
4406 #ifdef TC_I960
4407                   if ((int) fixP->fx_bit_fixP == 13)
4408                     {
4409                       /* This is a COBR instruction.  They have only a
4410                          13-bit displacement and are only to be used
4411                          for local branches: flag as error, don't generate
4412                          relocation.  */
4413                       as_bad_where (fixP->fx_file, fixP->fx_line,
4414                                     _("can't use COBR format with external label"));
4415                       fixP->fx_addsy = NULL;
4416                       fixP->fx_done = 1;
4417                       continue;
4418                     }
4419 #endif /* TC_I960 */
4420 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4421                   /* 386 COFF uses a peculiar format in which the
4422                      value of a common symbol is stored in the .text
4423                      segment (I've checked this on SVR3.2 and SCO
4424                      3.2.2) Ian Taylor <ian@cygnus.com>.  */
4425                   /* This is also true for 68k COFF on sysv machines
4426                      (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4427                      UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4428                      Philippe De Muyter <phdm@info.ucl.ac.be>.  */
4429                   if (S_IS_COMMON (add_symbolP))
4430                     add_number += S_GET_VALUE (add_symbolP);
4431 #endif
4432                   break;
4433
4434                 }
4435             }
4436         }
4437
4438       if (pcrel)
4439         {
4440 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K) && !defined(TC_OR32)
4441           /* This adjustment is not correct on the m88k, for which the
4442              linker does all the computation.  */
4443           add_number -= md_pcrel_from (fixP);
4444 #endif
4445           if (add_symbolP == 0)
4446             fixP->fx_addsy = &abs_symbol;
4447 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4448           /* On the 386 we must adjust by the segment vaddr as well.
4449              Ian Taylor.
4450
4451              I changed the i960 to work this way as well.  This is
4452              compatible with the current GNU linker behaviour.  I do
4453              not know what other i960 COFF assemblers do.  This is not
4454              a common case: normally, only assembler code will contain
4455              a PC relative reloc, and only branches which do not
4456              originate in the .text section will have a non-zero
4457              address.
4458
4459              I changed the m68k to work this way as well.  This will
4460              break existing PC relative relocs from sections which do
4461              not start at address 0, but it will make ld -r work.
4462              Ian Taylor, 4 Oct 96.  */
4463
4464           add_number -= segP->scnhdr.s_vaddr;
4465 #endif
4466         }
4467
4468       md_apply_fix3 (fixP, (valueT *) & add_number, this_segment_type);
4469
4470       if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
4471         {
4472 #ifndef TC_M88K
4473           /* The m88k uses the offset field of the reloc to get around
4474              this problem.  */
4475           if ((size == 1
4476                && ((add_number & ~0xFF)
4477                    || (fixP->fx_signed && (add_number & 0x80)))
4478                && ((add_number & ~0xFF) != (-1 & ~0xFF)
4479                    || (add_number & 0x80) == 0))
4480               || (size == 2
4481                   && ((add_number & ~0xFFFF)
4482                       || (fixP->fx_signed && (add_number & 0x8000)))
4483                   && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
4484                       || (add_number & 0x8000) == 0)))
4485             {
4486               as_bad_where (fixP->fx_file, fixP->fx_line,
4487                             _("Value of %ld too large for field of %d bytes at 0x%lx"),
4488                             (long) add_number, size,
4489                             (unsigned long) (fragP->fr_address + where));
4490             }
4491 #endif
4492 #ifdef WARN_SIGNED_OVERFLOW_WORD
4493           /* Warn if a .word value is too large when treated as a
4494              signed number.  We already know it is not too negative.
4495              This is to catch over-large switches generated by gcc on
4496              the 68k.  */
4497           if (!flag_signed_overflow_ok
4498               && size == 2
4499               && add_number > 0x7fff)
4500             as_bad_where (fixP->fx_file, fixP->fx_line,
4501                           _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4502                           (long) add_number,
4503                           (unsigned long) (fragP->fr_address + where));
4504 #endif
4505         }
4506     }
4507 }
4508
4509 #endif
4510
4511 /* The first entry in a .stab section is special.  */
4512
4513 void
4514 obj_coff_init_stab_section (seg)
4515      segT seg;
4516 {
4517   char *file;
4518   char *p;
4519   char *stabstr_name;
4520   unsigned int stroff;
4521
4522   /* Make space for this first symbol.  */
4523   p = frag_more (12);
4524   /* Zero it out.  */
4525   memset (p, 0, 12);
4526   as_where (&file, (unsigned int *) NULL);
4527   stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
4528   strcpy (stabstr_name, segment_info[seg].name);
4529   strcat (stabstr_name, "str");
4530   stroff = get_stab_string_offset (file, stabstr_name);
4531   know (stroff == 1);
4532   md_number_to_chars (p, stroff, 4);
4533 }
4534
4535 /* Fill in the counts in the first entry in a .stab section.  */
4536
4537 static void
4538 adjust_stab_section(abfd, seg)
4539      bfd *abfd;
4540      segT seg;
4541 {
4542   segT stabstrseg = SEG_UNKNOWN;
4543   const char *secname, *name2;
4544   char *name;
4545   char *p = NULL;
4546   int i, strsz = 0, nsyms;
4547   fragS *frag = segment_info[seg].frchainP->frch_root;
4548
4549   /* Look for the associated string table section.  */
4550
4551   secname = segment_info[seg].name;
4552   name = (char *) alloca (strlen (secname) + 4);
4553   strcpy (name, secname);
4554   strcat (name, "str");
4555
4556   for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4557     {
4558       name2 = segment_info[i].name;
4559       if (name2 != NULL && strncmp(name2, name, 8) == 0)
4560         {
4561           stabstrseg = i;
4562           break;
4563         }
4564     }
4565
4566   /* If we found the section, get its size.  */
4567   if (stabstrseg != SEG_UNKNOWN)
4568     strsz = size_section (abfd, stabstrseg);
4569
4570   nsyms = size_section (abfd, seg) / 12 - 1;
4571
4572   /* Look for the first frag of sufficient size for the initial stab
4573      symbol, and collect a pointer to it.  */
4574   while (frag && frag->fr_fix < 12)
4575     frag = frag->fr_next;
4576   assert (frag != 0);
4577   p = frag->fr_literal;
4578   assert (p != 0);
4579
4580   /* Write in the number of stab symbols and the size of the string
4581      table.  */
4582   bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4583   bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4584 }
4585
4586 #endif /* not BFD_ASSEMBLER */
4587
4588 const pseudo_typeS coff_pseudo_table[] =
4589 {
4590   {"def", obj_coff_def, 0},
4591   {"dim", obj_coff_dim, 0},
4592   {"endef", obj_coff_endef, 0},
4593   {"line", obj_coff_line, 0},
4594   {"ln", obj_coff_ln, 0},
4595 #ifdef BFD_ASSEMBLER
4596   {"loc", obj_coff_loc, 0},
4597 #endif
4598   {"appline", obj_coff_ln, 1},
4599   {"scl", obj_coff_scl, 0},
4600   {"size", obj_coff_size, 0},
4601   {"tag", obj_coff_tag, 0},
4602   {"type", obj_coff_type, 0},
4603   {"val", obj_coff_val, 0},
4604   {"section", obj_coff_section, 0},
4605   {"sect", obj_coff_section, 0},
4606   /* FIXME: We ignore the MRI short attribute.  */
4607   {"section.s", obj_coff_section, 0},
4608   {"sect.s", obj_coff_section, 0},
4609   /* We accept the .bss directive for backward compatibility with
4610      earlier versions of gas.  */
4611   {"bss", obj_coff_bss, 0},
4612   {"weak", obj_coff_weak, 0},
4613   {"ident", obj_coff_ident, 0},
4614 #ifndef BFD_ASSEMBLER
4615   {"use", obj_coff_section, 0},
4616   {"text", obj_coff_text, 0},
4617   {"data", obj_coff_data, 0},
4618   {"lcomm", obj_coff_lcomm, 0},
4619 #else
4620   {"optim", s_ignore, 0},       /* For sun386i cc (?) */
4621 #endif
4622   {"version", s_ignore, 0},
4623   {"ABORT", s_abort, 0},
4624 #ifdef TC_M88K
4625   /* The m88k uses sdef instead of def.  */
4626   {"sdef", obj_coff_def, 0},
4627 #endif
4628   {NULL, NULL, 0}               /* end sentinel */
4629 };                              /* coff_pseudo_table */
4630 \f
4631 #ifdef BFD_ASSEMBLER
4632
4633 /* Support for a COFF emulation.  */
4634
4635 static void coff_pop_insert PARAMS ((void));
4636 static int coff_separate_stab_sections PARAMS ((void));
4637
4638 static void
4639 coff_pop_insert ()
4640 {
4641   pop_insert (coff_pseudo_table);
4642 }
4643
4644 static int
4645 coff_separate_stab_sections ()
4646 {
4647   return 1;
4648 }
4649
4650 const struct format_ops coff_format_ops =
4651 {
4652   bfd_target_coff_flavour,
4653   0,    /* dfl_leading_underscore */
4654   1,    /* emit_section_symbols */
4655   0,    /* begin */
4656   c_dot_file_symbol,
4657   coff_frob_symbol,
4658   0,    /* frob_file */
4659   0,    /* frob_file_before_adjust */
4660   coff_frob_file_after_relocs,
4661   0,    /* s_get_size */
4662   0,    /* s_set_size */
4663   0,    /* s_get_align */
4664   0,    /* s_set_align */
4665   0,    /* s_get_other */
4666   0,    /* s_set_other */
4667   0,    /* s_get_desc */
4668   0,    /* s_set_desc */
4669   0,    /* s_get_type */
4670   0,    /* s_set_type */
4671   0,    /* copy_symbol_attributes */
4672   0,    /* generate_asm_lineno */
4673   0,    /* process_stab */
4674   coff_separate_stab_sections,
4675   obj_coff_init_stab_section,
4676   0,    /* sec_sym_ok_for_reloc */
4677   coff_pop_insert,
4678   0,    /* ecoff_set_ext */
4679   coff_obj_read_begin_hook,
4680   coff_obj_symbol_new_hook
4681 };
4682
4683 #endif