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