gas/config/obj-coff.c

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