gas/config/obj-coff.c

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