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