gas/config/obj-coffbfd.c

   1 /* coff object file format with bfd
   2    Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GAS.
   5
   6 GAS is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GAS is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GAS; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /*
  21
  22  How does this releate to the rest of GAS ?
  23
  24  Well, all the other files in gas are more or less a black box. It
  25  takes care of opening files, parsing command lines, stripping blanks
  26  etc etc. This module gets a chance to register what it wants to do by
  27  saying that it is interested in various pseduo ops. The other big
  28  change is write_object_file. This runs through all the data
  29  structures that gas builds, and outputs the file in the format of our
  30  choice.
  31
  32  Hacked for BFDness by steve chamberlain
  33
  34  This object module now supports the Hitachi H8/300 and the AMD 29k
  35
  36  sac@cygnus.com
  37 */
  38
  39 #include "as.h"
  40 #include "obstack.h"
  41 #include "subsegs.h"
  42 #include "frags.h"
  43 #include "../bfd/libbfd.h"
  44
  45
  46 /* This vector is used to turn an internal segment into a section #
  47    suitable for insertion into a coff symbol table
  48  */
  49
  50 const short seg_N_TYPE[] = { /* in: segT   out: N_TYPE bits */
  51         C_ABS_SECTION,
  52         1,
  53         2,
  54         3,
  55         4,
  56         5,
  57         6,
  58         7,
  59         8,
  60         9,
  61         10,
  62         C_UNDEF_SECTION,                /* SEG_UNKNOWN */
  63         C_UNDEF_SECTION,                /* SEG_ABSENT */
  64         C_UNDEF_SECTION,                /* SEG_PASS1 */
  65         C_UNDEF_SECTION,                /* SEG_GOOF */
  66         C_UNDEF_SECTION,                /* SEG_BIG */
  67         C_UNDEF_SECTION,                /* SEG_DIFFERENCE */
  68         C_DEBUG_SECTION,                /* SEG_DEBUG */
  69         C_NTV_SECTION,          /* SEG_NTV */
  70         C_PTV_SECTION,          /* SEG_PTV */
  71         C_REGISTER_SECTION,     /* SEG_REGISTER */
  72 };
  73
  74
  75 int function_lineoff = -1;      /* Offset in line#s where the last function
  76                                    started (the odd entry for line #0) */
  77
  78
  79 int had_lineno = 0;
  80 int had_reloc = 0;
  81
  82 static symbolS*last_line_symbol;
  83 /* Add 4 to the real value to get the index and compensate the
  84    negatives. This vector is used by S_GET_SEGMENT to turn a coff
  85    section number into a segment number
  86 */
  87 static symbolS *previous_file_symbol = NULL;
  88 void c_symbol_merge();
  89 static int line_base;
  90
  91 symbolS *c_section_symbol();
  92 bfd *abfd;
  93 void EXFUN(bfd_as_write_hook,(struct internal_filehdr *,
  94                               bfd *abfd));
  95
  96 static void EXFUN(fixup_segment,(fixS * fixP,
  97                   segT  this_segment_type));
  98
  99 static void EXFUN(fill_section,(bfd *abfd ,
 100                                 struct internal_filehdr *f, unsigned
 101                                 long *));
 102
 103
 104 char *EXFUN(s_get_name,(symbolS *s));
 105 static symbolS *EXFUN(tag_find_or_make,(char *name));
 106 static symbolS* EXFUN(tag_find,(char *name));
 107
 108
 109 static int
 110 EXFUN(c_line_new,(
 111       symbolS *symbol,
 112       long paddr,
 113       unsigned short line_number,
 114                   fragS* frag));
 115
 116
 117 static void EXFUN(w_symbols,
 118                   (bfd *abfd ,
 119                    char *where ,
 120                    symbolS *symbol_rootP));
 121
 122
 123
 124 static void EXFUN( obj_coff_def,(int what));
 125 static void EXFUN( obj_coff_lcomm,(void));
 126 static void EXFUN( obj_coff_dim,(void));
 127 static void EXFUN( obj_coff_text,(void));
 128 static void EXFUN( obj_coff_data,(void));
 129 static void EXFUN( obj_coff_endef,(void));
 130 static void EXFUN( obj_coff_line,(void));
 131 static void EXFUN( obj_coff_ln,(void));
 132 static void EXFUN( obj_coff_scl,(void));
 133 static void EXFUN( obj_coff_size,(void));
 134 static void EXFUN( obj_coff_tag,(void));
 135 static void EXFUN( obj_coff_type,(void));
 136 static void EXFUN( obj_coff_val,(void));
 137 static void EXFUN( obj_coff_section,(void));
 138 static void EXFUN( tag_init,(void));
 139 static void EXFUN( tag_insert,(char *name, symbolS *symbolP));
 140
 141
 142 static struct hash_control *tag_hash;
 143 static symbolS *def_symbol_in_progress = NULL;
 144
 145 const pseudo_typeS obj_pseudo_table[] = {
 146         { "def",        obj_coff_def,           0       },
 147         { "dim",        obj_coff_dim,           0       },
 148         { "endef",      obj_coff_endef,         0       },
 149         { "line",       obj_coff_line,          0       },
 150         { "ln",         obj_coff_ln,            0       },
 151         { "scl",        obj_coff_scl,           0       },
 152         { "size",       obj_coff_size,          0       },
 153         { "tag",        obj_coff_tag,           0       },
 154         { "type",       obj_coff_type,          0       },
 155         { "val",        obj_coff_val,           0       },
 156         { "section",    obj_coff_section,       0       },
 157         { "text",       obj_coff_text,          0       },
 158         { "data",       obj_coff_data,          0       },
 159         /* we don't yet handle this. */
 160         { "ident",      s_ignore,               0       },
 161         { "ABORT",      s_abort,                0 },
 162         { "lcomm",      obj_coff_lcomm, 0},
 163         { NULL} /* end sentinel */
 164 }; /* obj_pseudo_table */
 165
 166
 167
 168 /* Section stuff
 169
 170    We allow more than just the standard 3 sections, infact, we allow
 171    10 sections, (though the usual three have to be there).
 172
 173    This structure performs the mappings for us:
 174
 175 */
 176
 177 /* OBS stuff
 178 static struct internal_scnhdr bss_section_header;
 179 struct internal_scnhdr data_section_header;
 180 struct internal_scnhdr text_section_header;
 181
 182 const segT N_TYPE_seg [32] =
 183 {
 184
 185 };
 186
 187 */
 188
 189 #define N_SEG 32
 190 typedef struct
 191 {
 192   segT seg_t;
 193 int i;
 194 } seg_info_type;
 195
 196 seg_info_type seg_info_off_by_4[N_SEG] =
 197 {
 198 {SEG_PTV,  },
 199 {SEG_NTV,  },
 200 {SEG_DEBUG, },
 201 {SEG_ABSOLUTE,  },
 202 {SEG_UNKNOWN,    },
 203 {SEG_E0},
 204 {SEG_E1},
 205 {SEG_E2},
 206 {SEG_E3},
 207 {SEG_E4},
 208 {SEG_E5},
 209 {SEG_E6},
 210 {SEG_E7},
 211 {SEG_E8},
 212 {SEG_E9},
 213 {15},
 214 {16},
 215 {17},
 216 {18},
 217 {19},
 218 {20},
 219 {0},
 220 {0},
 221 {0},
 222 {SEG_REGISTER},0,0,0,0};
 223
 224 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
 225 #define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
 226
 227
 228  relax_addressT
 229 DEFUN(relax_align,(address, alignment),
 230 register relax_addressT address AND
 231 register long alignment )
 232 {
 233   relax_addressT        mask;
 234   relax_addressT        new_address;
 235
 236   mask = ~ ( (~0) << alignment );
 237   new_address = (address + mask) & (~ mask);
 238   return (new_address - address);
 239 } /* relax_align() */
 240
 241
 242 segT
 243 DEFUN(s_get_segment,(x) ,
 244 symbolS* x)
 245 {
 246   return SEG_INFO_FROM_SECTION_NUMBER(x->sy_symbol.ost_entry.n_scnum).seg_t;
 247 }
 248
 249
 250
 251 /* calculate the size of the frag chain and fill in the section header
 252    to contain all of it, also fill in the addr of the sections */
 253 static unsigned int  DEFUN(size_section,(abfd, idx),
 254                   bfd *abfd AND
 255                   unsigned int idx)
 256 {
 257
 258   unsigned int size = 0;
 259   fragS *frag = segment_info[idx].frchainP->frch_root;
 260   while (frag) {
 261       if (frag->fr_address != size) {
 262           printf("Out of step\n");
 263           size = frag->fr_address;
 264         }
 265       size += frag->fr_fix;
 266       switch (frag->fr_type) {
 267         case rs_fill:
 268         case rs_org:
 269           size  +=    frag->fr_offset * frag->fr_var;
 270           break;
 271         case rs_align:
 272           size  +=   relax_align(size, frag->fr_offset);
 273         }
 274       frag = frag->fr_next;
 275     }
 276   segment_info[idx].scnhdr.s_size = size;
 277   return size;
 278 }
 279
 280
 281 static unsigned int DEFUN(count_entries_in_chain,(idx),
 282                           unsigned int idx)
 283 {
 284     unsigned int nrelocs;
 285     fixS *fixup_ptr;
 286
 287     /* Count the relocations */
 288     fixup_ptr = segment_info[idx].fix_root;
 289     nrelocs = 0;
 290     while (fixup_ptr != (fixS *)NULL)
 291     {
 292         if (TC_COUNT_RELOC(fixup_ptr))
 293         {
 294
 295 #ifdef TC_A29K
 296
 297             if (fixup_ptr->fx_r_type == RELOC_CONSTH)
 298              nrelocs+=2;
 299             else
 300              nrelocs++;
 301 #else
 302             nrelocs++;
 303 #endif
 304         }
 305
 306         fixup_ptr = fixup_ptr->fx_next;
 307     }
 308     return nrelocs;
 309 }
 310
 311 /* output all the relocations for a section */
 312 void DEFUN(do_relocs_for,(abfd, file_cursor),
 313            bfd *abfd AND
 314            unsigned long *file_cursor)
 315 {
 316   unsigned int nrelocs;
 317   unsigned int idx;
 318
 319   for (idx = SEG_E0; idx < SEG_E9; idx++)
 320   {
 321     if (segment_info[idx].scnhdr.s_name[0])
 322     {
 323
 324       struct external_reloc *ext_ptr;
 325       struct external_reloc *external_reloc_vec;
 326       unsigned int external_reloc_size;
 327       unsigned int count = 0;
 328       unsigned int base  = segment_info[idx].scnhdr.s_paddr;
 329       fixS *   fix_ptr = segment_info[idx].fix_root;
 330       nrelocs = count_entries_in_chain(idx);
 331
 332       if (nrelocs)
 333        had_reloc = 1;
 334
 335       external_reloc_size = nrelocs * RELSZ;
 336       external_reloc_vec =
 337        (struct external_reloc*)malloc(external_reloc_size);
 338
 339
 340
 341       ext_ptr = external_reloc_vec;
 342
 343       /* Fill in the internal coff style reloc struct from the
 344          internal fix list */
 345       while (fix_ptr)
 346       {
 347         symbolS *symbol_ptr;
 348         struct internal_reloc intr;
 349
 350         /* Only output some of the relocations */
 351         if (TC_COUNT_RELOC(fix_ptr))
 352         {
 353 #ifdef TC_RELOC_MANGLE
 354           TC_RELOC_MANGLE(fix_ptr, &intr, base);
 355
 356 #else
 357           symbolS *dot;
 358           symbol_ptr = fix_ptr->fx_addsy;
 359
 360           intr.r_type = TC_COFF_FIX2RTYPE(fix_ptr);
 361           intr.r_vaddr =
 362            base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where ;
 363
 364           intr.r_offset = fix_ptr->fx_offset;
 365
 366           intr.r_offset = 0;
 367
 368           /* Turn the segment of the symbol into an offset
 369            */
 370           if (symbol_ptr)
 371           {
 372             dot = segment_info[S_GET_SEGMENT(symbol_ptr)].dot;
 373             if (dot)
 374             {
 375               intr.r_symndx = dot->sy_number;
 376             }
 377             else
 378             {
 379               intr.r_symndx = symbol_ptr->sy_number;
 380             }
 381
 382           }
 383           else
 384           {
 385             intr.r_symndx = -1;
 386
 387
 388           }
 389 #endif
 390
 391           (void)bfd_coff_swap_reloc_out(abfd, &intr, ext_ptr);
 392           ext_ptr++;
 393
 394 #if defined(TC_A29K)
 395           /* The 29k has a special kludge for the high 16 bit reloc.
 396              Two relocations are emmited, R_IHIHALF, and
 397              R_IHCONST. The second one doesn't contain a symbol,
 398              but uses the value for offset */
 399
 400           if (intr.r_type == R_IHIHALF)
 401           {
 402             /* now emit the second bit */
 403             intr.r_type = R_IHCONST;
 404             intr.r_symndx = fix_ptr->fx_addnumber;
 405             (void)bfd_coff_swap_reloc_out(abfd,&intr,ext_ptr);
 406             ext_ptr++;
 407           }
 408 #endif
 409         }
 410
 411         fix_ptr = fix_ptr->fx_next;
 412       }
 413
 414       /* Write out the reloc table */
 415       segment_info[idx].scnhdr.s_relptr = *file_cursor;
 416       segment_info[idx].scnhdr.s_nreloc = nrelocs;
 417       bfd_write((PTR)external_reloc_vec, 1, external_reloc_size, abfd);
 418       *file_cursor += external_reloc_size;
 419       free( external_reloc_vec);
 420     }
 421   }
 422 }
 423
 424
 425 /* run through a frag chain and write out the data to go with it, fill
 426    in the scnhdrs with the info on the file postions
 427 */
 428 static void DEFUN(fill_section,(abfd, filehdr, file_cursor),
 429                   bfd *abfd AND
 430                   struct internal_filehdr *filehdr AND
 431                   unsigned long *file_cursor)
 432 {
 433
 434     unsigned int i;
 435     unsigned int paddr = 0;
 436
 437     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
 438     {
 439         unsigned int offset = 0;
 440
 441         struct internal_scnhdr *s = &( segment_info[i].scnhdr);
 442
 443         if (s->s_name[0])
 444         {
 445           fragS *frag = segment_info[i].frchainP->frch_root;
 446           char *buffer =  malloc(s->s_size);
 447           if (s->s_size != 0)
 448           {
 449             s->s_scnptr = *file_cursor;
 450           s->s_paddr =  paddr;
 451           s->s_vaddr =  paddr;
 452
 453           }
 454           else
 455           {
 456             s->s_scnptr = 0;
 457           s->s_paddr =  0;
 458           s->s_vaddr =  0;
 459
 460           }
 461
 462
 463           s->s_flags = STYP_REG;
 464           if (strcmp(s->s_name,".text")==0)
 465            s->s_flags |= STYP_TEXT;
 466           else if (strcmp(s->s_name,".data")==0)
 467            s->s_flags |= STYP_DATA;
 468           else if (strcmp(s->s_name,".bss")==0)
 469            s->s_flags |= STYP_BSS | STYP_NOLOAD;
 470
 471           while (frag) {
 472               unsigned int fill_size;
 473               switch (frag->fr_type) {
 474
 475                 case rs_fill:
 476                 case rs_align:
 477                 case rs_org:
 478                   if(frag->fr_fix)
 479                   {
 480                     memcpy(buffer + frag->fr_address,
 481                            frag->fr_literal,
 482                            frag->fr_fix);
 483                     offset += frag->fr_fix;
 484                   }
 485
 486                   fill_size = frag->fr_var;
 487                   if (fill_size)
 488                   {
 489                     unsigned int count ;
 490                     unsigned int off = frag->fr_fix;
 491                     for (count = frag->fr_offset; count;  count--)
 492                     {
 493                       memcpy(buffer +  frag->fr_address  + off,
 494                              frag->fr_literal + frag->fr_fix,
 495                              fill_size);
 496                       off += fill_size;
 497                       offset += fill_size;
 498
 499                     }
 500
 501                   }
 502                   break;
 503                 default:
 504                   abort();
 505                 }
 506               frag = frag->fr_next;
 507             }
 508
 509
 510           bfd_write(buffer, s->s_size,1,abfd);
 511           free(buffer);
 512
 513           *file_cursor += s->s_size;
 514           paddr += s->s_size;
 515         }
 516     }
 517
 518 }
 519
 520
 521
 522 /* Coff file generation & utilities */
 523
 524
 525 static void
 526 DEFUN(coff_header_append,(abfd, filehdr, aouthdr),
 527       bfd *abfd AND
 528       struct internal_filehdr *filehdr AND
 529       struct internal_aouthdr *aouthdr)
 530 {
 531   unsigned int i;
 532   char buffer[1000];
 533   char buffero[1000];
 534
 535   bfd_seek(abfd, 0, 0);
 536 #if 0
 537   filehdr.f_opthdr = bfd_coff_swap_aouthdr_out(abfd, aouthdr,
 538                                                buffero);
 539 #else
 540   filehdr->f_opthdr = 0;
 541 #endif
 542   i = bfd_coff_swap_filehdr_out(abfd, filehdr, buffer);
 543
 544   bfd_write(buffer, i ,1, abfd);
 545   bfd_write(buffero, filehdr->f_opthdr, 1, abfd);
 546
 547   for (i = SEG_E0; i < SEG_E9; i++)
 548   {
 549     if (segment_info[i].scnhdr.s_name[0])
 550     {
 551       unsigned int size =
 552        bfd_coff_swap_scnhdr_out(abfd,
 553                                 &(segment_info[i].scnhdr),
 554                                 buffer);
 555       bfd_write(buffer, size, 1, abfd);
 556     }
 557   }
 558 }
 559
 560
 561 char *
 562 DEFUN(symbol_to_chars,(abfd, where, symbolP),
 563       bfd*abfd AND
 564       char *where AND
 565       symbolS *symbolP)
 566 {
 567     unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
 568     unsigned int i;
 569
 570     /* Turn any symbols with register attributes into abs symbols */
 571     if (S_GET_SEGMENT(symbolP) == SEG_REGISTER)
 572     {
 573         S_SET_SEGMENT(symbolP, SEG_ABSOLUTE);
 574     }
 575     /* At the same time, relocate all symbols to their output value */
 576
 577     S_SET_VALUE(symbolP,
 578                 segment_info[S_GET_SEGMENT(symbolP)].scnhdr.s_paddr
 579                 + S_GET_VALUE(symbolP));
 580
 581     where += bfd_coff_swap_sym_out(abfd, &symbolP->sy_symbol.ost_entry,
 582                                    where);
 583
 584     for (i = 0; i < numaux; i++)
 585     {
 586         where += bfd_coff_swap_aux_out(abfd,
 587                                        &symbolP->sy_symbol.ost_auxent[i],
 588                                        S_GET_DATA_TYPE(symbolP),
 589                                        S_GET_STORAGE_CLASS(symbolP),
 590                                        where);
 591     }
 592     return where;
 593
 594 }
 595
 596
 597
 598
 599 void obj_symbol_new_hook(symbolP)
 600 symbolS *symbolP;
 601 {
 602         char underscore = 0;      /* Symbol has leading _ */
 603
 604         /* Effective symbol */
 605         /* Store the pointer in the offset. */
 606         S_SET_ZEROES(symbolP, 0L);
 607         S_SET_DATA_TYPE(symbolP, T_NULL);
 608         S_SET_STORAGE_CLASS(symbolP, 0);
 609         S_SET_NUMBER_AUXILIARY(symbolP, 0);
 610         /* Additional information */
 611         symbolP->sy_symbol.ost_flags = 0;
 612         /* Auxiliary entries */
 613         bzero((char*)&symbolP->sy_symbol.ost_auxent[0], AUXESZ);
 614
 615 #ifdef STRIP_UNDERSCORE
 616         /* Remove leading underscore at the beginning of the symbol.
 617          * This is to be compatible with the standard librairies.
 618          */
 619         if (*S_GET_NAME(symbolP) == '_') {
 620                 underscore = 1;
 621                 S_SET_NAME(symbolP, S_GET_NAME(symbolP) + 1);
 622         } /* strip underscore */
 623 #endif /* STRIP_UNDERSCORE */
 624
 625         if (S_IS_STRING(symbolP))
 626             SF_SET_STRING(symbolP);
 627         if (!underscore && S_IS_LOCAL(symbolP))
 628             SF_SET_LOCAL(symbolP);
 629
 630         return;
 631 } /* obj_symbol_new_hook() */
 632
 633  /* stack stuff */
 634 stack* stack_init(chunk_size, element_size)
 635 unsigned long chunk_size;
 636 unsigned long element_size;
 637 {
 638         stack* st;
 639
 640         if ((st = (stack*)malloc(sizeof(stack))) == (stack*)0)
 641             return (stack*)0;
 642         if ((st->data = malloc(chunk_size)) == (char*)0) {
 643                 free(st);
 644                 return (stack*)0;
 645         }
 646         st->pointer = 0;
 647         st->size = chunk_size;
 648         st->chunk_size = chunk_size;
 649         st->element_size = element_size;
 650         return st;
 651 } /* stack_init() */
 652
 653 void stack_delete(st)
 654 stack* st;
 655 {
 656     free(st->data);
 657     free(st);
 658 }
 659
 660 char *stack_push(st, element)
 661 stack *st;
 662 char *element;
 663 {
 664         if (st->pointer + st->element_size >= st->size) {
 665                 st->size += st->chunk_size;
 666                 if ((st->data = xrealloc(st->data, st->size)) == (char*)0)
 667                     return (char*)0;
 668         }
 669         memcpy(st->data + st->pointer, element, st->element_size);
 670         st->pointer += st->element_size;
 671         return st->data + st->pointer;
 672 } /* stack_push() */
 673
 674 char* stack_pop(st)
 675 stack* st;
 676 {
 677     if ((st->pointer -= st->element_size) < 0) {
 678         st->pointer = 0;
 679         return (char*)0;
 680     }
 681
 682     return st->data + st->pointer;
 683 }
 684
 685 char* stack_top(st)
 686 stack* st;
 687 {
 688     return st->data + st->pointer - st->element_size;
 689 }
 690
 691
 692 /*
 693  * Handle .ln directives.
 694  */
 695
 696 static void obj_coff_ln()
 697 {
 698   int l;
 699
 700   if (def_symbol_in_progress != NULL) {
 701       as_warn(".ln pseudo-op inside .def/.endef: ignored.");
 702       demand_empty_rest_of_line();
 703       return;
 704     }                           /* wrong context */
 705
 706   c_line_new(0,
 707              obstack_next_free(&frags) - frag_now->fr_literal,
 708              l = get_absolute_expression(),
 709              frag_now);
 710 #ifndef NO_LISTING
 711 {
 712   extern int listing;
 713
 714   if (listing)
 715   {
 716     listing_source_line(l + line_base - 1);
 717   }
 718
 719 }
 720 #endif
 721   demand_empty_rest_of_line();
 722   return;
 723 }                               /* obj_coff_line() */
 724
 725 /*
 726  *                      def()
 727  *
 728  * Handle .def directives.
 729  *
 730  * One might ask : why can't we symbol_new if the symbol does not
 731  * already exist and fill it with debug information.  Because of
 732  * the C_EFCN special symbol. It would clobber the value of the
 733  * function symbol before we have a chance to notice that it is
 734  * a C_EFCN. And a second reason is that the code is more clear this
 735  * way. (at least I think it is :-).
 736  *
 737  */
 738
 739 #define SKIP_SEMI_COLON()       while (*input_line_pointer++ != ';')
 740 #define SKIP_WHITESPACES()      while (*input_line_pointer == ' ' || \
 741                                       *input_line_pointer == '\t') \
 742                                          input_line_pointer++;
 743
 744 static void
 745 DEFUN(obj_coff_def,(what),
 746       int what)
 747 {
 748     char name_end;              /* Char after the end of name */
 749     char *symbol_name;          /* Name of the debug symbol */
 750     char *symbol_name_copy;     /* Temporary copy of the name */
 751     unsigned int symbol_name_length;
 752     /*$char*    directiveP;$ */         /* Name of the pseudo opcode */
 753     /*$char directive[MAX_DIRECTIVE];$ */ /* Backup of the directive */
 754     /*$char end = 0;$ */ /* If 1, stop parsing */
 755
 756     if (def_symbol_in_progress != NULL) {
 757             as_warn(".def pseudo-op used inside of .def/.endef: ignored.");
 758             demand_empty_rest_of_line();
 759             return;
 760         }                       /* if not inside .def/.endef */
 761
 762     SKIP_WHITESPACES();
 763
 764     def_symbol_in_progress = (symbolS *) obstack_alloc(&notes, sizeof(*def_symbol_in_progress));
 765     bzero(def_symbol_in_progress, sizeof(*def_symbol_in_progress));
 766
 767     symbol_name = input_line_pointer;
 768     name_end = get_symbol_end();
 769     symbol_name_length = strlen(symbol_name);
 770     symbol_name_copy = xmalloc(symbol_name_length + 1);
 771     strcpy(symbol_name_copy, symbol_name);
 772
 773     /* Initialize the new symbol */
 774 #ifdef STRIP_UNDERSCORE
 775     S_SET_NAME(def_symbol_in_progress, (*symbol_name_copy == '_'
 776                                         ? symbol_name_copy + 1
 777                                         : symbol_name_copy));
 778 #else                           /* STRIP_UNDERSCORE */
 779     S_SET_NAME(def_symbol_in_progress, symbol_name_copy);
 780 #endif                          /* STRIP_UNDERSCORE */
 781     /* free(symbol_name_copy); */
 782     def_symbol_in_progress->sy_name_offset = ~0;
 783     def_symbol_in_progress->sy_number = ~0;
 784     def_symbol_in_progress->sy_frag = &zero_address_frag;
 785
 786     if (S_IS_STRING(def_symbol_in_progress)) {
 787             SF_SET_STRING(def_symbol_in_progress);
 788         }                       /* "long" name */
 789
 790     *input_line_pointer = name_end;
 791
 792     demand_empty_rest_of_line();
 793     return;
 794 }                               /* obj_coff_def() */
 795
 796 unsigned int dim_index;
 797 static void
 798 DEFUN_VOID(obj_coff_endef)
 799 {
 800     symbolS *symbolP = 0;
 801     /* DIM BUG FIX sac@cygnus.com */
 802     dim_index =0;
 803     if (def_symbol_in_progress == NULL) {
 804             as_warn(".endef pseudo-op used outside of .def/.endef: ignored.");
 805             demand_empty_rest_of_line();
 806             return;
 807         }                       /* if not inside .def/.endef */
 808
 809     /* Set the section number according to storage class. */
 810     switch (S_GET_STORAGE_CLASS(def_symbol_in_progress)) {
 811           case C_STRTAG:
 812           case C_ENTAG:
 813           case C_UNTAG:
 814             SF_SET_TAG(def_symbol_in_progress);
 815             /* intentional fallthrough */
 816           case C_FILE:
 817           case C_TPDEF:
 818             SF_SET_DEBUG(def_symbol_in_progress);
 819             S_SET_SEGMENT(def_symbol_in_progress, SEG_DEBUG);
 820             break;
 821
 822           case C_EFCN:
 823             SF_SET_LOCAL(def_symbol_in_progress); /* Do not emit this symbol. */
 824             /* intentional fallthrough */
 825           case C_BLOCK:
 826             SF_SET_PROCESS(def_symbol_in_progress); /* Will need processing before writing */
 827             /* intentional fallthrough */
 828           case C_FCN:
 829             S_SET_SEGMENT(def_symbol_in_progress, SEG_E0);
 830
 831             if (def_symbol_in_progress->sy_symbol.ost_entry._n._n_nptr[1][1] == 'b') { /* .bf */
 832                     if (function_lineoff < 0) {
 833                             fprintf(stderr, "`.bf' symbol without preceding function\n");
 834                         }       /* missing function symbol */
 835                     SA_GET_SYM_LNNOPTR(last_line_symbol) = function_lineoff;
 836
 837                     SF_SET_PROCESS(last_line_symbol);
 838                     function_lineoff = -1;
 839                 }
 840             break;
 841
 842 #ifdef C_AUTOARG
 843           case C_AUTOARG:
 844 #endif                          /* C_AUTOARG */
 845           case C_AUTO:
 846           case C_REG:
 847           case C_MOS:
 848           case C_MOE:
 849           case C_MOU:
 850           case C_ARG:
 851           case C_REGPARM:
 852           case C_FIELD:
 853           case C_EOS:
 854             SF_SET_DEBUG(def_symbol_in_progress);
 855             S_SET_SEGMENT(def_symbol_in_progress, SEG_ABSOLUTE);
 856             break;
 857
 858           case C_EXT:
 859           case C_STAT:
 860           case C_LABEL:
 861             /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
 862             break;
 863
 864           case C_USTATIC:
 865           case C_EXTDEF:
 866           case C_ULABEL:
 867             as_warn("unexpected storage class %d", S_GET_STORAGE_CLASS(def_symbol_in_progress));
 868             break;
 869         }                       /* switch on storage class */
 870
 871     /* Now that we have built a debug symbol, try to
 872        find if we should merge with an existing symbol
 873        or not.  If a symbol is C_EFCN or SEG_ABSOLUTE or
 874        untagged SEG_DEBUG it never merges. */
 875
 876     /* Two cases for functions.  Either debug followed
 877        by definition or definition followed by debug.
 878        For definition first, we will merge the debug
 879        symbol into the definition.  For debug first, the
 880        lineno entry MUST point to the definition
 881        function or else it will point off into space
 882        when crawl_symbols() merges the debug
 883        symbol into the real symbol.  Therefor, let's
 884        presume the debug symbol is a real function
 885        reference. */
 886
 887     /* FIXME-SOON If for some reason the definition
 888        label/symbol is never seen, this will probably
 889        leave an undefined symbol at link time. */
 890
 891     if (S_GET_STORAGE_CLASS(def_symbol_in_progress) == C_EFCN
 892         || (S_GET_SEGMENT(def_symbol_in_progress) == SEG_DEBUG
 893             && !SF_GET_TAG(def_symbol_in_progress))
 894         || S_GET_SEGMENT(def_symbol_in_progress) == SEG_ABSOLUTE
 895         || (symbolP = symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP)) == NULL) {
 896
 897             symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
 898
 899         } else {
 900                 /* This symbol already exists, merge the
 901                    newly created symbol into the old one.
 902                    This is not mandatory. The linker can
 903                    handle duplicate symbols correctly. But I
 904                    guess that it save a *lot* of space if
 905                    the assembly file defines a lot of
 906                    symbols. [loic] */
 907
 908                 /* The debug entry (def_symbol_in_progress)
 909                    is merged into the previous definition. */
 910
 911                 c_symbol_merge(def_symbol_in_progress, symbolP);
 912                 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
 913                 def_symbol_in_progress = symbolP;
 914
 915                 if (SF_GET_FUNCTION(def_symbol_in_progress)
 916                     || SF_GET_TAG(def_symbol_in_progress)) {
 917                         /* For functions, and tags, the symbol *must* be where the debug symbol
 918                            appears.  Move the existing symbol to the current place. */
 919                         /* If it already is at the end of the symbol list, do nothing */
 920                         if (def_symbol_in_progress != symbol_lastP) {
 921                                 symbol_remove(def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
 922                                 symbol_append(def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
 923                             }   /* if not already in place */
 924                     }           /* if function */
 925             }                   /* normal or mergable */
 926
 927     if (SF_GET_TAG(def_symbol_in_progress)
 928         && symbol_find_base(S_GET_NAME(def_symbol_in_progress), DO_NOT_STRIP) == NULL) {
 929             tag_insert(S_GET_NAME(def_symbol_in_progress), def_symbol_in_progress);
 930         }                       /* If symbol is a {structure,union} tag, associate symbol to its name. */
 931
 932     if (SF_GET_FUNCTION(def_symbol_in_progress)) {
 933             know(sizeof(def_symbol_in_progress) <= sizeof(long));
 934             function_lineoff
 935              = c_line_new(def_symbol_in_progress,0, 0, &zero_address_frag);
 936
 937
 938
 939             SF_SET_PROCESS(def_symbol_in_progress);
 940
 941             if (symbolP == NULL) {
 942                     /* That is, if this is the first
 943                        time we've seen the function... */
 944                     symbol_table_insert(def_symbol_in_progress);
 945                 }               /* definition follows debug */
 946         }                       /* Create the line number entry pointing to the function being defined */
 947
 948     def_symbol_in_progress = NULL;
 949     demand_empty_rest_of_line();
 950     return;
 951 }                               /* obj_coff_endef() */
 952
 953 static void
 954 DEFUN_VOID(obj_coff_dim)
 955 {
 956     register int dim_index;
 957
 958     if (def_symbol_in_progress == NULL)
 959     {
 960         as_warn(".dim pseudo-op used outside of .def/.endef: ignored.");
 961         demand_empty_rest_of_line();
 962         return;
 963     }                           /* if not inside .def/.endef */
 964
 965     S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
 966
 967     for (dim_index = 0; dim_index < DIMNUM; dim_index++)
 968     {
 969         SKIP_WHITESPACES();
 970         SA_SET_SYM_DIMEN(def_symbol_in_progress, dim_index, get_absolute_expression());
 971
 972         switch (*input_line_pointer)
 973         {
 974
 975           case ',':
 976             input_line_pointer++;
 977             break;
 978
 979           default:
 980             as_warn("badly formed .dim directive ignored");
 981             /* intentional fallthrough */
 982           case '\n':
 983           case ';':
 984             dim_index = DIMNUM;
 985             break;
 986         }                       /* switch on following character */
 987     }                           /* for each dimension */
 988
 989     demand_empty_rest_of_line();
 990     return;
 991 }                               /* obj_coff_dim() */
 992
 993 static void obj_coff_line()
 994 {
 995   int this_base;
 996
 997   if (def_symbol_in_progress == NULL) {
 998       obj_coff_ln();
 999       return;
1000     }                           /* if it looks like a stabs style line */
1001
1002   this_base = get_absolute_expression();
1003   if (this_base > line_base)
1004   {
1005     line_base = this_base;
1006   }
1007
1008
1009 #ifndef NO_LISTING
1010 {
1011   extern int listing;
1012   if (listing && 0) {
1013       listing_source_line(line_base);
1014     }
1015 }
1016 #endif
1017   S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
1018   SA_SET_SYM_LNNO(def_symbol_in_progress, line_base);
1019
1020   demand_empty_rest_of_line();
1021   return;
1022 }                               /* obj_coff_line() */
1023
1024 static void obj_coff_size() {
1025         if (def_symbol_in_progress == NULL) {
1026                 as_warn(".size pseudo-op used outside of .def/.endef ignored.");
1027                 demand_empty_rest_of_line();
1028                 return;
1029         } /* if not inside .def/.endef */
1030
1031         S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
1032         SA_SET_SYM_SIZE(def_symbol_in_progress, get_absolute_expression());
1033         demand_empty_rest_of_line();
1034         return;
1035 } /* obj_coff_size() */
1036
1037 static void obj_coff_scl() {
1038         if (def_symbol_in_progress == NULL) {
1039                 as_warn(".scl pseudo-op used outside of .def/.endef ignored.");
1040                 demand_empty_rest_of_line();
1041                 return;
1042         } /* if not inside .def/.endef */
1043
1044         S_SET_STORAGE_CLASS(def_symbol_in_progress, get_absolute_expression());
1045         demand_empty_rest_of_line();
1046         return;
1047 } /* obj_coff_scl() */
1048
1049 static void obj_coff_tag() {
1050         char *symbol_name;
1051         char name_end;
1052
1053         if (def_symbol_in_progress == NULL) {
1054                 as_warn(".tag pseudo-op used outside of .def/.endef ignored.");
1055                 demand_empty_rest_of_line();
1056                 return;
1057         } /* if not inside .def/.endef */
1058
1059         S_SET_NUMBER_AUXILIARY(def_symbol_in_progress, 1);
1060         symbol_name = input_line_pointer;
1061         name_end = get_symbol_end();
1062
1063         /* Assume that the symbol referred to by .tag is always defined. */
1064         /* This was a bad assumption.  I've added find_or_make. xoxorich. */
1065         SA_SET_SYM_TAGNDX(def_symbol_in_progress, (long) tag_find_or_make(symbol_name));
1066         if (SA_GET_SYM_TAGNDX(def_symbol_in_progress) == 0L) {
1067                 as_warn("tag not found for .tag %s", symbol_name);
1068         } /* not defined */
1069
1070         SF_SET_TAGGED(def_symbol_in_progress);
1071         *input_line_pointer = name_end;
1072
1073         demand_empty_rest_of_line();
1074         return;
1075 } /* obj_coff_tag() */
1076
1077 static void obj_coff_type() {
1078         if (def_symbol_in_progress == NULL) {
1079                 as_warn(".type pseudo-op used outside of .def/.endef ignored.");
1080                 demand_empty_rest_of_line();
1081                 return;
1082         } /* if not inside .def/.endef */
1083
1084         S_SET_DATA_TYPE(def_symbol_in_progress, get_absolute_expression());
1085
1086         if (ISFCN(S_GET_DATA_TYPE(def_symbol_in_progress)) &&
1087             S_GET_STORAGE_CLASS(def_symbol_in_progress) != C_TPDEF) {
1088                 SF_SET_FUNCTION(def_symbol_in_progress);
1089         } /* is a function */
1090
1091         demand_empty_rest_of_line();
1092         return;
1093 } /* obj_coff_type() */
1094
1095 static void obj_coff_val() {
1096         if (def_symbol_in_progress == NULL) {
1097                 as_warn(".val pseudo-op used outside of .def/.endef ignored.");
1098                 demand_empty_rest_of_line();
1099                 return;
1100         } /* if not inside .def/.endef */
1101
1102         if (is_name_beginner(*input_line_pointer)) {
1103                 char *symbol_name = input_line_pointer;
1104                 char name_end = get_symbol_end();
1105
1106                 if (!strcmp(symbol_name, ".")) {
1107                         def_symbol_in_progress->sy_frag = frag_now;
1108                         S_SET_VALUE(def_symbol_in_progress, obstack_next_free(&frags) - frag_now->fr_literal);
1109                         /* If the .val is != from the .def (e.g. statics) */
1110                 } else if (strcmp(S_GET_NAME(def_symbol_in_progress), symbol_name)) {
1111                         def_symbol_in_progress->sy_forward = symbol_find_or_make(symbol_name);
1112
1113                         /* If the segment is undefined when the forward
1114                            reference is solved, then copy the segment id
1115                            from the forward symbol. */
1116                         SF_SET_GET_SEGMENT(def_symbol_in_progress);
1117                 }
1118                 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
1119                 *input_line_pointer = name_end;
1120         } else {
1121                 S_SET_VALUE(def_symbol_in_progress, get_absolute_expression());
1122         } /* if symbol based */
1123
1124         demand_empty_rest_of_line();
1125         return;
1126 } /* obj_coff_val() */
1127
1128 /*
1129  * Maintain a list of the tagnames of the structres.
1130  */
1131
1132 static void tag_init() {
1133     tag_hash = hash_new();
1134     return ;
1135 } /* tag_init() */
1136
1137 static void tag_insert(name, symbolP)
1138 char *name;
1139 symbolS *symbolP;
1140 {
1141         register char * error_string;
1142
1143         if (*(error_string = hash_jam(tag_hash, name, (char *)symbolP))) {
1144                 as_fatal("Inserting \"%s\" into structure table failed: %s",
1145                          name, error_string);
1146         }
1147         return ;
1148 } /* tag_insert() */
1149
1150 static symbolS *tag_find_or_make(name)
1151 char *name;
1152 {
1153         symbolS *symbolP;
1154
1155         if ((symbolP = tag_find(name)) == NULL) {
1156                 symbolP = symbol_new(name,
1157                                      SEG_UNKNOWN,
1158                                      0,
1159                                      &zero_address_frag);
1160
1161                 tag_insert(S_GET_NAME(symbolP), symbolP);
1162                 symbol_table_insert(symbolP);
1163         } /* not found */
1164
1165         return(symbolP);
1166 } /* tag_find_or_make() */
1167
1168 static symbolS *tag_find(name)
1169 char *name;
1170 {
1171 #ifdef STRIP_UNDERSCORE
1172         if (*name == '_') name++;
1173 #endif /* STRIP_UNDERSCORE */
1174         return((symbolS*)hash_find(tag_hash, name));
1175 } /* tag_find() */
1176
1177 void obj_read_begin_hook() {
1178  /* These had better be the same.  Usually 18 bytes. */
1179 #ifndef BFD_HEADERS
1180         know(sizeof(SYMENT) == sizeof(AUXENT));
1181         know(SYMESZ == AUXESZ);
1182 #endif
1183         tag_init();
1184
1185         return;
1186 } /* obj_read_begin_hook() */
1187
1188 /* This function runs through the symbol table and puts all the
1189    externals onto another chain */
1190
1191 /* The chain of externals */
1192 symbolS *symbol_externP = NULL;
1193 symbolS *symbol_extern_lastP = NULL;
1194
1195 stack*block_stack;
1196   symbolS *last_functionP = NULL;
1197   symbolS *last_tagP;
1198
1199
1200 static unsigned int DEFUN_VOID(yank_symbols)
1201 {
1202   symbolS *symbolP;
1203   unsigned int symbol_number =0;
1204
1205   for (symbolP = symbol_rootP;
1206        symbolP;
1207        symbolP = symbolP ? symbol_next(symbolP) : symbol_rootP) {
1208       if (!SF_GET_DEBUG(symbolP)) {
1209           /* Debug symbols do not need all this rubbish */
1210           symbolS* real_symbolP;
1211
1212           /* L* and C_EFCN symbols never merge. */
1213           if (!SF_GET_LOCAL(symbolP)
1214               && (real_symbolP = symbol_find_base(S_GET_NAME(symbolP), DO_NOT_STRIP))
1215               && real_symbolP != symbolP) {
1216               /* FIXME-SOON: where do dups come from?
1217                  Maybe tag references before definitions? xoxorich. */
1218               /* Move the debug data from the debug symbol to the
1219                  real symbol. Do NOT do the oposite (i.e. move from
1220                  real symbol to debug symbol and remove real symbol from the
1221                  list.) Because some pointers refer to the real symbol
1222                  whereas no pointers refer to the debug symbol. */
1223               c_symbol_merge(symbolP, real_symbolP);
1224               /* Replace the current symbol by the real one */
1225               /* The symbols will never be the last or the first
1226                  because : 1st symbol is .file and 3 last symbols are
1227                  .text, .data, .bss */
1228               symbol_remove(real_symbolP, &symbol_rootP, &symbol_lastP);
1229               symbol_insert(real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
1230               symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
1231               symbolP = real_symbolP;
1232             }                   /* if not local but dup'd */
1233
1234           if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_E1)) {
1235               S_SET_SEGMENT(symbolP, SEG_E0);
1236             }                   /* push data into text */
1237
1238           S_SET_VALUE(symbolP,
1239                       S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
1240
1241           if (!S_IS_DEFINED(symbolP) && !SF_GET_LOCAL(symbolP))
1242           {
1243             S_SET_EXTERNAL(symbolP);
1244           }
1245           else if (S_GET_STORAGE_CLASS(symbolP) == C_NULL)
1246           {
1247             if (S_GET_SEGMENT(symbolP) == SEG_E0)
1248             {
1249               S_SET_STORAGE_CLASS(symbolP, C_LABEL);
1250             }
1251             else
1252             {
1253               S_SET_STORAGE_CLASS(symbolP, C_STAT);
1254             }
1255           }
1256
1257           /* Mainly to speed up if not -g */
1258           if (SF_GET_PROCESS(symbolP))
1259           {
1260             /* Handle the nested blocks auxiliary info. */
1261             if (S_GET_STORAGE_CLASS(symbolP) == C_BLOCK) {
1262                 if (!strcmp(S_GET_NAME(symbolP), ".bb"))
1263                  stack_push(block_stack, (char *) &symbolP);
1264                 else {          /* .eb */
1265                     register symbolS* begin_symbolP;
1266                     begin_symbolP = *(symbolS**)stack_pop(block_stack);
1267                     if (begin_symbolP == (symbolS*)0)
1268                      as_warn("mismatched .eb");
1269                     else
1270                      SA_SET_SYM_ENDNDX(begin_symbolP, symbol_number+2);
1271                   }
1272               }
1273             /* If we are able to identify the type of a function, and we
1274                are out of a function (last_functionP == 0) then, the
1275                function symbol will be associated with an auxiliary
1276                entry. */
1277             if (last_functionP == (symbolS*)0 &&
1278                 SF_GET_FUNCTION(symbolP)) {
1279                 last_functionP = symbolP;
1280
1281                 if (S_GET_NUMBER_AUXILIARY(symbolP) < 1) {
1282                     S_SET_NUMBER_AUXILIARY(symbolP, 1);
1283                   }             /* make it at least 1 */
1284
1285                 /* Clobber possible stale .dim information. */
1286 #if 0
1287 /* Iffed out by steve - this fries the lnnoptr info too */
1288                 bzero(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
1289                       sizeof(symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
1290 #endif
1291               }
1292             /* The C_FCN doesn't need any additional information.
1293                I don't even know if this is needed for sdb. But the
1294                standard assembler generates it, so...
1295                */
1296             if (S_GET_STORAGE_CLASS(symbolP) == C_EFCN) {
1297                 if (last_functionP == (symbolS*)0)
1298                  as_fatal("C_EFCN symbol out of scope");
1299                 SA_SET_SYM_FSIZE(last_functionP,
1300                                  (long)(S_GET_VALUE(symbolP) -
1301                                         S_GET_VALUE(last_functionP)));
1302                 SA_SET_SYM_ENDNDX(last_functionP, symbol_number);
1303                 last_functionP = (symbolS*)0;
1304               }
1305           }
1306         } else if (SF_GET_TAG(symbolP)) {
1307             /* First descriptor of a structure must point to
1308                the first slot after the structure description. */
1309             last_tagP = symbolP;
1310
1311           } else if (S_GET_STORAGE_CLASS(symbolP) == C_EOS) {
1312               /* +2 take in account the current symbol */
1313               SA_SET_SYM_ENDNDX(last_tagP, symbol_number + 2);
1314             } else if (S_GET_STORAGE_CLASS(symbolP) == C_FILE) {
1315                 if (S_GET_VALUE(symbolP)) {
1316                     S_SET_VALUE((symbolS *) S_GET_VALUE(symbolP), symbol_number);
1317                     S_SET_VALUE(symbolP, 0);
1318                   }             /* no one points at the first .file symbol */
1319               }                 /* if debug or tag or eos or file */
1320
1321       /* We must put the external symbols apart. The loader
1322          does not bomb if we do not. But the references in
1323          the endndx field for a .bb symbol are not corrected
1324          if an external symbol is removed between .bb and .be.
1325          I.e in the following case :
1326          [20] .bb endndx = 22
1327          [21] foo external
1328          [22] .be
1329          ld will move the symbol 21 to the end of the list but
1330          endndx will still be 22 instead of 21. */
1331
1332
1333       if (SF_GET_LOCAL(symbolP)) {
1334           /* remove C_EFCN and LOCAL (L...) symbols */
1335           /* next pointer remains valid */
1336           symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
1337
1338         }
1339       else if (!S_IS_DEFINED(symbolP)
1340                && !S_IS_DEBUG(symbolP)
1341                && !SF_GET_STATICS(symbolP) &&
1342                S_GET_STORAGE_CLASS(symbolP) == C_EXT)
1343       { /* C_EXT && !SF_GET_FUNCTION(symbolP))  */
1344             /* if external, Remove from the list */
1345             symbolS *hold = symbol_previous(symbolP);
1346
1347             symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
1348             symbol_clear_list_pointers(symbolP);
1349             symbol_append(symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
1350             symbolP = hold;
1351           } else {
1352               if (SF_GET_STRING(symbolP)) {
1353                   symbolP->sy_name_offset = string_byte_count;
1354                   string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
1355                 } else {
1356                     symbolP->sy_name_offset = 0;
1357                   }             /* fix "long" names */
1358
1359               symbolP->sy_number = symbol_number;
1360               symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
1361             }                   /* if local symbol */
1362     }                           /* traverse the symbol list */
1363   return symbol_number;
1364
1365 }
1366
1367
1368 static unsigned int DEFUN_VOID(glue_symbols)
1369 {
1370   unsigned int symbol_number = 0;
1371   symbolS *symbolP;
1372   for (symbolP = symbol_externP; symbol_externP;) {
1373       symbolS *tmp = symbol_externP;
1374
1375       /* append */
1376       symbol_remove(tmp, &symbol_externP, &symbol_extern_lastP);
1377       symbol_append(tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
1378
1379       /* and process */
1380       if (SF_GET_STRING(tmp)) {
1381           tmp->sy_name_offset = string_byte_count;
1382           string_byte_count += strlen(S_GET_NAME(tmp)) + 1;
1383         } else {
1384             tmp->sy_name_offset = 0;
1385           }                     /* fix "long" names */
1386
1387       tmp->sy_number = symbol_number;
1388       symbol_number += 1 + S_GET_NUMBER_AUXILIARY(tmp);
1389     }                           /* append the entire extern chain */
1390   return symbol_number;
1391
1392 }
1393
1394 static unsigned int DEFUN_VOID(tie_tags)
1395 {
1396   unsigned int symbol_number = 0;
1397
1398   symbolS*symbolP;
1399   for (symbolP = symbol_rootP; symbolP; symbolP =
1400        symbol_next(symbolP))
1401   {
1402     symbolP->sy_number = symbol_number;
1403
1404
1405
1406     if (SF_GET_TAGGED(symbolP))
1407     {
1408       SA_SET_SYM_TAGNDX
1409        (symbolP,
1410         ((symbolS*) SA_GET_SYM_TAGNDX(symbolP))->sy_number);
1411     }
1412
1413     symbol_number += 1 + S_GET_NUMBER_AUXILIARY(symbolP);
1414   }
1415   return symbol_number;
1416
1417 }
1418
1419 static void
1420 DEFUN(crawl_symbols,(headers, abfd),
1421       struct    internal_filehdr *headers AND
1422       bfd *abfd)
1423 {
1424
1425   unsigned int i;
1426   unsigned int ptr = 0;
1427
1428
1429   symbolS *symbolP;
1430
1431   /* Initialize the stack used to keep track of the matching .bb .be */
1432
1433   block_stack = stack_init(512, sizeof(symbolS*));
1434   /* JF deal with forward references first... */
1435   for (symbolP = symbol_rootP;
1436        symbolP;
1437        symbolP = symbol_next(symbolP))
1438   {
1439
1440     if (symbolP->sy_forward) {
1441         S_SET_VALUE(symbolP, (S_GET_VALUE(symbolP)
1442                               + S_GET_VALUE(symbolP->sy_forward)
1443                               + symbolP->sy_forward->sy_frag->fr_address));
1444
1445         if (SF_GET_GET_SEGMENT(symbolP)) {
1446             S_SET_SEGMENT(symbolP, S_GET_SEGMENT(symbolP->sy_forward));
1447           }                     /* forward segment also */
1448
1449         symbolP->sy_forward=0;
1450       }                         /* if it has a forward reference */
1451   }                             /* walk the symbol chain */
1452
1453
1454   /* The symbol list should be ordered according to the following sequence
1455    * order :
1456    * . .file symbol
1457    * . debug entries for functions
1458    * . fake symbols for the sections, including.text .data and .bss
1459    * . defined symbols
1460    * . undefined symbols
1461    * But this is not mandatory. The only important point is to put the
1462    * undefined symbols at the end of the list.
1463    */
1464
1465   if (symbol_rootP == NULL
1466       || S_GET_STORAGE_CLASS(symbol_rootP) != C_FILE) {
1467       c_dot_file_symbol("fake");
1468     }
1469   /* Is there a .file symbol ? If not insert one at the beginning. */
1470
1471   /*
1472    * Build up static symbols for the sections, they are filled in later
1473    */
1474
1475
1476   for (i = SEG_E0; i < SEG_E9; i++)
1477   {
1478     if (segment_info[i].scnhdr.s_name[0])
1479     {
1480       segment_info[i].dot =
1481        c_section_symbol(segment_info[i].scnhdr.s_name,
1482                         i-SEG_E0+1);
1483
1484     }
1485   }
1486
1487
1488   /* Take all the externals out and put them into another chain */
1489   headers->f_nsyms =   yank_symbols();
1490   /* Take the externals and glue them onto the end.*/
1491   headers->f_nsyms +=  glue_symbols();
1492
1493   headers->f_nsyms =   tie_tags();
1494   know(symbol_externP == NULL);
1495   know(symbol_extern_lastP  == NULL);
1496
1497   return;
1498 }
1499
1500 /*
1501  * Find strings by crawling along symbol table chain.
1502  */
1503
1504 void DEFUN(w_strings,(where),
1505            char *where)
1506 {
1507   symbolS *symbolP;
1508
1509   /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
1510   md_number_to_chars(where, string_byte_count, sizeof(string_byte_count));
1511   where += sizeof(string_byte_count);
1512   for (symbolP = symbol_rootP;
1513        symbolP;
1514        symbolP = symbol_next(symbolP))
1515   {
1516     unsigned int size;
1517
1518     if (SF_GET_STRING(symbolP)) {
1519         size = strlen(S_GET_NAME(symbolP)) + 1;
1520
1521         memcpy(where,  S_GET_NAME(symbolP),size);
1522         where += size;
1523
1524       }
1525   }
1526
1527 }
1528
1529
1530
1531
1532
1533 static void
1534 DEFUN(do_linenos_for,(abfd, file_cursor),
1535       bfd *abfd AND
1536       unsigned long *file_cursor)
1537 {
1538   unsigned int idx;
1539
1540   for (idx = SEG_E0;  idx < SEG_E9; idx++)
1541   {
1542     segment_info_type *s = segment_info + idx;
1543
1544
1545     if (s->scnhdr.s_nlnno != 0)
1546     {
1547       struct lineno_list *line_ptr ;
1548
1549       struct external_lineno *buffer =
1550        (struct external_lineno *)xmalloc(s->scnhdr.s_nlnno * LINESZ);
1551
1552       struct external_lineno *dst= buffer;
1553
1554       /* Run through the table we've built and turn it into its external
1555          form, take this chance to remove duplicates */
1556
1557       for (line_ptr = s->lineno_list_head;
1558            line_ptr != (struct lineno_list *)NULL;
1559            line_ptr = line_ptr->next)
1560       {
1561
1562         if (line_ptr->line.l_lnno == 0)
1563         {
1564           /* Turn a pointer to a symbol into the symbols' index */
1565           line_ptr->line.l_addr.l_symndx =
1566            ( (symbolS *)line_ptr->line.l_addr.l_symndx)->sy_number;
1567         }
1568         else
1569         {
1570           line_ptr->line.l_addr.l_paddr += ((struct frag * )(line_ptr->frag))->fr_address;
1571         }
1572
1573
1574         (void)  bfd_coff_swap_lineno_out(abfd, &(line_ptr->line), dst);
1575         dst++;
1576
1577       }
1578
1579       s->scnhdr.s_lnnoptr = *file_cursor;
1580
1581       bfd_write(buffer, 1, s->scnhdr.s_nlnno* LINESZ, abfd);
1582       free(buffer);
1583
1584       *file_cursor += s->scnhdr.s_nlnno * LINESZ;
1585     }
1586   }
1587 }
1588
1589
1590 /* Now we run through the list of frag chains in a segment and
1591    make all the subsegment frags appear at the end of the
1592    list, as if the seg 0 was extra long */
1593
1594 static void DEFUN_VOID(remove_subsegs)
1595 {
1596     unsigned int i;
1597
1598     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1599     {
1600         frchainS *head =  segment_info[i].frchainP;
1601         fragS dummy;
1602         fragS * prev_frag = &dummy;
1603
1604         while (head && head->frch_seg == i)
1605         {
1606             prev_frag->fr_next = head->frch_root;
1607             prev_frag = head->frch_last;
1608             head = head->frch_next;
1609         }
1610         prev_frag->fr_next = 0;
1611     }
1612 }
1613
1614
1615 extern void DEFUN_VOID(write_object_file)
1616 {
1617     int i;
1618     struct frchain *frchain_ptr;
1619
1620     struct internal_filehdr filehdr;
1621     struct internal_aouthdr aouthdr;
1622     unsigned long file_cursor;
1623     bfd *abfd;
1624       unsigned int addr = 0;
1625     abfd = bfd_openw(out_file_name, TARGET_FORMAT);
1626
1627
1628     if (abfd == 0) {
1629             as_perror ("FATAL: Can't create %s", out_file_name);
1630             exit(42);
1631         }
1632     bfd_set_format(abfd, bfd_object);
1633     bfd_set_arch_mach(abfd, BFD_ARCH, 0);
1634
1635
1636
1637     string_byte_count = 4;
1638
1639     for (frchain_ptr = frchain_root;
1640          frchain_ptr != (struct frchain *)NULL;
1641          frchain_ptr = frchain_ptr->frch_next) {
1642             /* Run through all the sub-segments and align them up. Also close any
1643                open frags. We tack a .fill onto the end of the frag chain so
1644                that any .align's size can be worked by looking at the next
1645                frag */
1646
1647             subseg_new(frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
1648 #define SUB_SEGMENT_ALIGN 1
1649             frag_align(SUB_SEGMENT_ALIGN,0);
1650             frag_wane(frag_now);
1651             frag_now->fr_fix = 0;
1652             know( frag_now->fr_next == NULL );
1653         }
1654
1655
1656     remove_subsegs();
1657
1658
1659     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1660     {
1661         relax_segment(segment_info[i].frchainP->frch_root, i);
1662     }
1663
1664
1665
1666
1667
1668       filehdr.f_nscns = 0;
1669
1670       /* Find out how big the sections are */
1671       for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1672       {
1673
1674         if (segment_info[i].scnhdr.s_name[0])
1675         {
1676           filehdr.f_nscns++;
1677         }
1678
1679         if (i == SEG_E2)
1680         {
1681           /* THis is a special case, we leave the size alone, which will have */
1682           /* been made up from all and any lcomms seen */
1683         }
1684         else {
1685             addr += size_section(abfd, i);
1686           }
1687       }
1688
1689
1690
1691     /* Turn the gas native symbol table shape into a coff symbol table */
1692     crawl_symbols(&filehdr, abfd);
1693 #ifndef TC_H8300
1694     for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1695     {
1696         fixup_segment(segment_info[i].fix_root, i);
1697     }
1698 #endif
1699
1700     file_cursor =   FILHSZ + SCNHSZ * filehdr.f_nscns ;
1701
1702     bfd_seek(abfd, file_cursor, 0);
1703
1704
1705     do_relocs_for(abfd, &file_cursor);
1706
1707     do_linenos_for(abfd, &file_cursor);
1708
1709
1710     /* Plant the data */
1711
1712     fill_section(abfd,&filehdr, &file_cursor);
1713
1714     filehdr.f_magic = COFF_MAGIC;
1715     filehdr.f_timdat = time(0);
1716     filehdr.f_flags = COFF_FLAGS ;
1717
1718     if (!had_lineno)
1719     {
1720       filehdr.f_flags |= F_LNNO;
1721     }
1722     if (!had_reloc)
1723     {
1724       filehdr.f_flags |= F_RELFLG;
1725     }
1726
1727
1728
1729
1730
1731
1732
1733   {
1734
1735       unsigned int   symtable_size = filehdr.f_nsyms * SYMESZ;
1736       char *buffer1 = malloc(symtable_size + string_byte_count + 4);
1737       char *ptr = buffer1;
1738       filehdr.f_symptr = bfd_tell(abfd);
1739       w_symbols(abfd, buffer1, symbol_rootP);
1740       w_strings(buffer1 + symtable_size);
1741       bfd_write(buffer1, 1,symtable_size +  string_byte_count + 4, abfd);
1742       free(buffer1);
1743
1744   }
1745     coff_header_append(abfd, &filehdr, &aouthdr);
1746
1747     bfd_close_all_done(abfd);
1748 }
1749
1750
1751 static void DEFUN(change_to_section,(name, len, exp),
1752  char *name AND
1753  unsigned int len AND
1754  unsigned int exp)
1755 {
1756   unsigned int i;
1757   /* Find out if we've already got a section of this name etc */
1758   for(i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0] ; i++)
1759   {
1760     if (strncmp(segment_info[i].scnhdr.s_name, name, len) == 0)
1761     {
1762       subseg_new(i, exp);
1763       return;
1764
1765     }
1766   }
1767   /* No section, add one */
1768   strncpy(segment_info[i].scnhdr.s_name, name, 8);
1769   subseg_new(i, exp);
1770 }
1771
1772 static void
1773 DEFUN_VOID(obj_coff_section)
1774 {
1775     /* Strip out the section name */
1776     char *section_name ;
1777     char *section_name_end;
1778     char c;
1779
1780     unsigned int len;
1781     unsigned int exp;
1782
1783     section_name =  input_line_pointer;
1784     c =   get_symbol_end();
1785     section_name_end =  input_line_pointer;
1786
1787     len = section_name_end - section_name ;
1788     input_line_pointer++;
1789     SKIP_WHITESPACE();
1790     if (c == ',')
1791     {
1792         exp = get_absolute_expression();
1793     }
1794     else if ( *input_line_pointer == ',')
1795     {
1796
1797         input_line_pointer++;
1798         exp = get_absolute_expression();
1799     }
1800     else
1801     {
1802         exp = 0;
1803     }
1804
1805     change_to_section(section_name, len,exp);
1806 *section_name_end = c;
1807
1808 }
1809
1810
1811 static void obj_coff_text()
1812 {
1813   change_to_section(".text",5, get_absolute_expression());
1814 }
1815
1816
1817 static void obj_coff_data()
1818 {
1819   change_to_section(".data",5, get_absolute_expression());
1820 }
1821
1822 void c_symbol_merge(debug, normal)
1823 symbolS *debug;
1824 symbolS *normal;
1825 {
1826         S_SET_DATA_TYPE(normal, S_GET_DATA_TYPE(debug));
1827         S_SET_STORAGE_CLASS(normal, S_GET_STORAGE_CLASS(debug));
1828
1829         if (S_GET_NUMBER_AUXILIARY(debug) > S_GET_NUMBER_AUXILIARY(normal)) {
1830                 S_SET_NUMBER_AUXILIARY(normal, S_GET_NUMBER_AUXILIARY(debug));
1831         } /* take the most we have */
1832
1833         if (S_GET_NUMBER_AUXILIARY(debug) > 0) {
1834                 memcpy((char*)&normal->sy_symbol.ost_auxent[0], (char*)&debug->sy_symbol.ost_auxent[0], S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
1835         } /* Move all the auxiliary information */
1836
1837         /* Move the debug flags. */
1838         SF_SET_DEBUG_FIELD(normal, SF_GET_DEBUG_FIELD(debug));
1839 } /* c_symbol_merge() */
1840
1841 static int
1842 DEFUN(c_line_new,(symbol, paddr, line_number, frag),
1843       symbolS *symbol AND
1844       long paddr AND
1845       unsigned short line_number AND
1846       fragS* frag)
1847 {
1848   struct lineno_list* new_line =
1849    (struct lineno_list *)xmalloc(sizeof(struct lineno_list));
1850
1851   segment_info_type *s =   segment_info + now_seg;
1852   new_line->line.l_lnno = line_number;
1853
1854   had_lineno = 1;
1855
1856   if (line_number == 0)
1857   {
1858 last_line_symbol = symbol;
1859     new_line->line.l_addr.l_symndx = (long)symbol;
1860   }
1861   else
1862   {
1863     new_line->line.l_addr.l_paddr = paddr;
1864   }
1865
1866   new_line->frag = (char*)frag;
1867   new_line->next = (struct lineno_list*)NULL;
1868
1869
1870   if (s->lineno_list_head == (struct lineno_list *)NULL)
1871   {
1872     s->lineno_list_head = new_line;
1873   }
1874   else
1875   {
1876     s->lineno_list_tail->next = new_line;
1877   }
1878    s->lineno_list_tail = new_line;
1879   return LINESZ * s->scnhdr.s_nlnno ++;
1880 }
1881
1882 void c_dot_file_symbol(filename)
1883 char *filename;
1884 {
1885     symbolS* symbolP;
1886
1887     symbolP = symbol_new(".file",
1888                          SEG_DEBUG,
1889                          0,
1890                          &zero_address_frag);
1891
1892     S_SET_STORAGE_CLASS(symbolP, C_FILE);
1893     S_SET_NUMBER_AUXILIARY(symbolP, 1);
1894     SA_SET_FILE_FNAME(symbolP, filename);
1895 #ifndef NO_LISTING
1896   {
1897     extern int listing;
1898     if (listing)
1899     {
1900       listing_source_file(filename);
1901     }
1902
1903   }
1904
1905 #endif
1906     SF_SET_DEBUG(symbolP);
1907     S_SET_VALUE(symbolP, (long) previous_file_symbol);
1908
1909     previous_file_symbol = symbolP;
1910
1911     /* Make sure that the symbol is first on the symbol chain */
1912     if (symbol_rootP != symbolP) {
1913             if (symbolP == symbol_lastP) {
1914                     symbol_lastP = symbol_lastP->sy_previous;
1915             } /* if it was the last thing on the list */
1916
1917             symbol_remove(symbolP, &symbol_rootP, &symbol_lastP);
1918             symbol_insert(symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
1919             symbol_rootP = symbolP;
1920     } /* if not first on the list */
1921
1922 } /* c_dot_file_symbol() */
1923
1924 /*
1925  * Build a 'section static' symbol.
1926  */
1927
1928 symbolS *c_section_symbol(name,idx)
1929 char *name;
1930 int idx;
1931 {
1932     symbolS *symbolP;
1933
1934     symbolP = symbol_new(name,idx,
1935                          0,
1936                          &zero_address_frag);
1937
1938     S_SET_STORAGE_CLASS(symbolP, C_STAT);
1939     S_SET_NUMBER_AUXILIARY(symbolP, 1);
1940
1941     SF_SET_STATICS(symbolP);
1942
1943     return symbolP;
1944 } /* c_section_symbol() */
1945
1946 static void
1947 DEFUN(w_symbols,(abfd, where, symbol_rootP),
1948 bfd *abfd AND
1949 char *where AND
1950 symbolS *symbol_rootP)
1951 {
1952     symbolS *symbolP;
1953     unsigned int i;
1954
1955     /* First fill in those values we have only just worked out */
1956     for (i = SEG_E0; i < SEG_E9; i++)
1957     {
1958         symbolP = segment_info[i].dot;
1959         if (symbolP)
1960         {
1961
1962             SA_SET_SCN_SCNLEN(symbolP, segment_info[i].scnhdr.s_size);
1963             SA_SET_SCN_NRELOC(symbolP, segment_info[i].scnhdr.s_nreloc);
1964             SA_SET_SCN_NLINNO(symbolP, segment_info[i].scnhdr.s_nlnno);
1965
1966         }
1967     }
1968
1969     /*
1970      * Emit all symbols left in the symbol chain.
1971      */
1972     for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
1973             /* Used to save the offset of the name. It is used to point
1974                to the string in memory but must be a file offset. */
1975             register char *     temp;
1976
1977             tc_coff_symbol_emit_hook(symbolP);
1978
1979             temp = S_GET_NAME(symbolP);
1980             if (SF_GET_STRING(symbolP)) {
1981                     S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
1982                     S_SET_ZEROES(symbolP, 0);
1983                 } else {
1984                         bzero(symbolP->sy_symbol.ost_entry.n_name, SYMNMLEN);
1985                         strncpy(symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
1986                     }
1987             where =  symbol_to_chars(abfd, where, symbolP);
1988             S_SET_NAME(symbolP,temp);
1989         }
1990
1991 }                               /* w_symbols() */
1992
1993 static void DEFUN_VOID(obj_coff_lcomm)
1994 {
1995     char *name;
1996     char c;
1997     int temp;
1998     char *p;
1999     symbolS *symbolP;
2000     name = input_line_pointer;
2001
2002
2003
2004     c = get_symbol_end();
2005     p = input_line_pointer;
2006     *p = c;
2007     SKIP_WHITESPACE();
2008     if (*input_line_pointer != ',') {
2009             as_bad("Expected comma after name");
2010             ignore_rest_of_line();
2011             return;
2012         }
2013     if (*input_line_pointer == '\n') {
2014             as_bad("Missing size expression");
2015             return;
2016         }
2017     input_line_pointer++;
2018     if ((temp = get_absolute_expression ()) < 0) {
2019             as_warn("lcomm length (%d.) <0! Ignored.", temp);
2020             ignore_rest_of_line();
2021             return;
2022         }
2023     *p = 0;
2024     symbolP = symbol_find_or_make(name);
2025     S_SET_VALUE(symbolP, segment_info[SEG_E2].scnhdr.s_size);
2026     S_SET_SEGMENT(symbolP, SEG_E2);
2027     segment_info[SEG_E2].scnhdr.s_size += temp;
2028     S_SET_STORAGE_CLASS(symbolP, C_STAT);
2029     demand_empty_rest_of_line();
2030 }
2031
2032
2033 #if 1
2034 static void DEFUN(fixup_segment,(fixP, this_segment_type),
2035 register fixS * fixP AND
2036 segT            this_segment_type)
2037 {
2038     register symbolS *add_symbolP;
2039     register symbolS *sub_symbolP;
2040     register long add_number;
2041     register int size;
2042     register char *place;
2043     register long where;
2044     register char pcrel;
2045     register fragS *fragP;
2046     register segT add_symbol_segment = SEG_ABSOLUTE;
2047
2048
2049     for ( ;  fixP;  fixP = fixP->fx_next)
2050     {
2051         fragP       = fixP->fx_frag;
2052         know(fragP);
2053         where     = fixP->fx_where;
2054         place       = fragP->fr_literal + where;
2055         size      = fixP->fx_size;
2056         add_symbolP = fixP->fx_addsy;
2057 #ifdef TC_I960
2058         if (fixP->fx_callj && TC_S_IS_CALLNAME(add_symbolP)) {
2059                 /* Relocation should be done via the
2060                    associated 'bal' entry point
2061                    symbol. */
2062
2063                 if (!TC_S_IS_BALNAME(tc_get_bal_of_call(add_symbolP))) {
2064                         as_bad("No 'bal' entry point for leafproc %s",
2065                                S_GET_NAME(add_symbolP));
2066                         continue;
2067                     }
2068                 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call(add_symbolP);
2069             }                   /* callj relocation */
2070 #endif
2071         sub_symbolP = fixP->fx_subsy;
2072         add_number  = fixP->fx_offset;
2073         pcrel     = fixP->fx_pcrel;
2074
2075         if (add_symbolP) {
2076                 add_symbol_segment = S_GET_SEGMENT(add_symbolP);
2077             }                   /* if there is an addend */
2078
2079         if (sub_symbolP) {
2080                 if (!add_symbolP) {
2081                         /* Its just -sym */
2082                         if (S_GET_SEGMENT(sub_symbolP) != SEG_ABSOLUTE) {
2083                                 as_bad("Negative of non-absolute symbol %s", S_GET_NAME(sub_symbolP));
2084                             }   /* not absolute */
2085
2086                         add_number -= S_GET_VALUE(sub_symbolP);
2087
2088                         /* if sub_symbol is in the same segment that add_symbol
2089                            and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
2090                     } else if ((S_GET_SEGMENT(sub_symbolP) == add_symbol_segment)
2091                                && (SEG_NORMAL(add_symbol_segment)
2092                                    || (add_symbol_segment == SEG_ABSOLUTE))) {
2093                             /* Difference of 2 symbols from same segment. */
2094                             /* Can't make difference of 2 undefineds: 'value' means */
2095                             /* something different for N_UNDF. */
2096 #ifdef TC_I960
2097                             /* Makes no sense to use the difference of 2 arbitrary symbols
2098                              * as the target of a call instruction.
2099                              */
2100                             if (fixP->fx_callj) {
2101                                     as_bad("callj to difference of 2 symbols");
2102                                 }
2103 #endif                          /* TC_I960 */
2104                             add_number += S_GET_VALUE(add_symbolP) -
2105                              S_GET_VALUE(sub_symbolP);
2106
2107                             add_symbolP = NULL;
2108                             fixP->fx_addsy = NULL;
2109                         } else {
2110                                 /* Different segments in subtraction. */
2111                                 know(!(S_IS_EXTERNAL(sub_symbolP) && (S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)));
2112
2113                                 if ((S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)) {
2114                                         add_number -= S_GET_VALUE(sub_symbolP);
2115                                     } else {
2116                                             as_bad("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
2117                                                    segment_name(S_GET_SEGMENT(sub_symbolP)),
2118                                                    S_GET_NAME(sub_symbolP), fragP->fr_address + where);
2119                                         } /* if absolute */
2120                             }
2121             }                   /* if sub_symbolP */
2122
2123         if (add_symbolP) {
2124                 if (add_symbol_segment == this_segment_type && pcrel) {
2125                         /*
2126                          * This fixup was made when the symbol's segment was
2127                          * SEG_UNKNOWN, but it is now in the local segment.
2128                          * So we know how to do the address without relocation.
2129                          */
2130 #ifdef TC_I960
2131                         /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
2132                          * in which cases it modifies *fixP as appropriate.  In the case
2133                          * of a 'calls', no further work is required, and *fixP has been
2134                          * set up to make the rest of the code below a no-op.
2135                          */
2136                         reloc_callj(fixP);
2137 #endif                          /* TC_I960 */
2138
2139                         add_number += S_GET_VALUE(add_symbolP);
2140                         add_number -= md_pcrel_from (fixP);
2141                         pcrel = 0; /* Lie. Don't want further pcrel processing. */
2142                         fixP->fx_addsy = NULL; /* No relocations please. */
2143                     } else
2144                     {
2145                         switch (add_symbol_segment)
2146                         {
2147                           case SEG_ABSOLUTE:
2148 #ifdef TC_I960
2149                             reloc_callj(fixP); /* See comment about reloc_callj() above*/
2150 #endif                          /* TC_I960 */
2151                             add_number += S_GET_VALUE(add_symbolP);
2152                             fixP->fx_addsy = NULL;
2153                             add_symbolP = NULL;
2154                             break;
2155                           default:
2156
2157                             add_number += S_GET_VALUE(add_symbolP) +
2158                 segment_info[S_GET_SEGMENT(add_symbolP)].scnhdr.s_paddr ;
2159                             break;
2160
2161                           case SEG_UNKNOWN:
2162 #ifdef TC_I960
2163                             if ((int)fixP->fx_bit_fixP == 13) {
2164                                     /* This is a COBR instruction.  They have only a
2165                                      * 13-bit displacement and are only to be used
2166                                      * for local branches: flag as error, don't generate
2167                                      * relocation.
2168                                      */
2169                                     as_bad("can't use COBR format with external label");
2170                                     fixP->fx_addsy = NULL; /* No relocations please. */
2171                                     continue;
2172                                 } /* COBR */
2173 #endif                          /* TC_I960 */
2174
2175
2176
2177                             break;
2178
2179
2180                         }       /* switch on symbol seg */
2181                     }           /* if not in local seg */
2182             }                   /* if there was a + symbol */
2183
2184         if (pcrel) {
2185                 add_number -= md_pcrel_from(fixP);
2186                 if (add_symbolP == 0) {
2187                         fixP->fx_addsy = & abs_symbol;
2188                     }           /* if there's an add_symbol */
2189             }                   /* if pcrel */
2190
2191         if (!fixP->fx_bit_fixP) {
2192                 if ((size==1 &&
2193                      (add_number& ~0xFF)   && (add_number&~0xFF!=(-1&~0xFF))) ||
2194                     (size==2 &&
2195                      (add_number& ~0xFFFF) && (add_number&~0xFFFF!=(-1&~0xFFFF)))) {
2196                         as_bad("Value of %d too large for field of %d bytes at 0x%x",
2197                                add_number, size, fragP->fr_address + where);
2198                     }           /* generic error checking */
2199             }                   /* not a bit fix */
2200         /* once this fix has been applied, we don't have to output anything
2201            nothing more need be done -*/
2202         md_apply_fix(fixP, add_number);
2203
2204     }                           /* For each fixS in this segment. */
2205
2206
2207 }                               /* fixup_segment() */
2208 #endif
2209
2210
2211
2212