read.c (s_align_bytes): Properly record alignment.

[deliverable/binutils-gdb.git] / gas / config / obj-elf.c

/* ELF object file format
   Copyright (C) 1992, 1993 Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2,
   or (at your option) any later version.

   GAS is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
   the GNU General Public License for more details.

   You should have received a copy of the GNU General Public
   License along with GAS; see the file COPYING.  If not, write
   to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

/* HP PA-RISC support was contributed by the Center for Software Science
   at the University of Utah.  */

#include "as.h"
#include "aout/stab_gnu.h"
#include "obstack.h"

static void obj_elf_stab PARAMS ((int what));
static void obj_elf_line PARAMS ((void));
static void obj_elf_desc PARAMS ((void));
static void obj_elf_version PARAMS ((void));
static void obj_elf_section PARAMS ((int));
static void obj_elf_size PARAMS ((void));
static void obj_elf_type PARAMS ((void));
static void obj_elf_ident PARAMS ((void));

const pseudo_typeS obj_pseudo_table[] = {
  { "ident",    obj_elf_ident,          0 },
  { "section",  obj_elf_section,        0 },
  { "size",     obj_elf_size,           0 },
  { "type",     obj_elf_type,           0 },
  { "version",  obj_elf_version,        0 },

  /* These are used for stabs-in-elf configurations.  */
  { "desc",     obj_elf_desc,           0       },
  { "line",     obj_elf_line,           0       },
  { "stabd",    obj_elf_stab,           'd'     },
  { "stabn",    obj_elf_stab,           'n'     },
  { "stabs",    obj_elf_stab,           's'     },
  /* This is used on Solaris 2.x on SPARC, but not supported yet.  */
  { "xstabs",   s_ignore,               0       },

  { NULL}       /* end sentinel */
};

static void
obj_elf_section (xxx)
     int xxx;
{
  char *string;
  asection *sec;

  /* Initialize this with inclusive-or of all flags that can be cleared
     by attributes, but not set by them.  Also include flags that won't
     get set properly in the assembler, but which the user/compiler
     shouldn't be expected to set.  */
  flagword flags = SEC_READONLY | SEC_ALLOC | SEC_RELOC;
  /* Initialize this with the default flags to be used if none are
     specified.  */
  flagword default_flags = SEC_ALLOC | SEC_RELOC;

  string = demand_copy_C_string (&xxx);
  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    flags = default_flags;
  while (*input_line_pointer == ',')
    {
      flagword bit;
      int len, inv;
      char *p, oldp;

      input_line_pointer++;
      if (*input_line_pointer != '#')
        {
          as_bad ("unrecognized syntax in .section command");
          ignore_rest_of_line ();
          break;
        }
      input_line_pointer++;

#define CHECK(X,BIT,NEG)        \
      if (!strncmp(X,input_line_pointer,len = sizeof(X) - 1)) { \
        bit = BIT; inv = NEG; goto match; }

      CHECK ("write", SEC_READONLY, 1);
      CHECK ("alloc", SEC_ALLOC, 0);
#undef CHECK

      p = input_line_pointer;
      while (!is_end_of_line[*p] && *p != 0 && *p != ',')
        p++;
      *p = 0;
      oldp = *p;
      as_bad ("unrecognized section attribute `%s' ignored",
              input_line_pointer);
      *p = oldp;
      continue;

    match:
      if (inv)
        flags &= ~bit;
      else
        flags |= bit;
      input_line_pointer += len;
    }
  demand_empty_rest_of_line ();

  sec = bfd_get_section_by_name (stdoutput, string);
  if (sec == 0)
    {
      sec = bfd_make_section_old_way (stdoutput, string);
      bfd_set_section_flags (stdoutput, sec,
                             /* @@ What should the flags be??  */
                             flags);
      sec->output_section = sec;
    }
  subseg_change (sec, 0);
}

#if 0
/* pa-spaces.c -- Space/subspace support for the HP PA-RISC version of GAS */

/* for space, subspace, and symbol maintenance on HP 9000 Series 800 */

space_dict_chainS *space_dict_root;
space_dict_chainS *space_dict_last;

space_dict_chainS *current_space;
subspace_dict_chainS *current_subspace;
#endif

symbolS *start_symbol_root;
symbolS *start_symbol_last;

#if 0 /* I really don't think this belongs in this file.  */
void pa_spaces_begin()
{
  space_dict_chainS *space;
  int i;
  subsegT now_subseg    = now_subseg;

  space_dict_root = NULL;
  space_dict_last = NULL;

  start_symbol_root = NULL;
  start_symbol_last = NULL;

  /* create default space and subspace dictionaries */

  i = 0;
  while ( pa_def_spaces[i].name ) {
          if ( pa_def_spaces[i].alias )
              pa_def_spaces[i].segment = subseg_new(pa_def_spaces[i].alias,0);
          else
              pa_def_spaces[i].segment = bfd_make_section_old_way(stdoutput,pa_def_spaces[i].name);

          create_new_space(pa_def_spaces[i].name,pa_def_spaces[i].spnum,
                           pa_def_spaces[i].loadable,pa_def_spaces[i].defined,
                           pa_def_spaces[i].private,pa_def_spaces[i].sort,0,
                           pa_def_spaces[i].segment);
          i++;
  }

  i = 0;
  while ( pa_def_subspaces[i].name ) {
          space = pa_segment_to_space(pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
          if ( space ) {
                  create_new_subspace(space,
                                      pa_def_subspaces[i].name,pa_def_subspaces[i].defined,
                                      pa_def_subspaces[i].loadable,
                                      pa_def_subspaces[i].code_only,pa_def_subspaces[i].common,
                                      pa_def_subspaces[i].dup_common,pa_def_subspaces[i].zero,
                                      pa_def_subspaces[i].sort,pa_def_subspaces[i].access,
                                      pa_def_subspaces[i].space_index,
                                      pa_def_subspaces[i].alignment,
                                      pa_def_subspaces[i].quadrant,
                                      pa_def_spaces[pa_def_subspaces[i].def_space_index].segment);
                  subseg_new(pa_def_subspaces[i].name,pa_def_subspaces[i].subsegment);
          }
          else
              as_fatal("Internal error: space missing for subspace \"%s\"\n",
                       pa_def_subspaces[i].name);
          i++;
  }
}

space_dict_chainS *create_new_space(name,spnum,loadable,defined,private,sort,defined_in_file,seg)
     char *name;
     int spnum;
     char loadable;
     char defined;
     char private;
     char sort;
     char defined_in_file;
     asection * seg;

{
  Elf_Internal_Shdr *new_space;
  space_dict_chainS *chain_entry;

  new_space = (Elf_Internal_Shdr *)xmalloc(sizeof(Elf_Internal_Shdr));
  if ( !new_space )
    as_fatal("Out of memory: could not allocate new Elf_Internal_Shdr: %s\n",name);

  /*
  new_space->space_number = spnum;
  new_space->is_loadable = loadable & 1;
  new_space->is_defined = defined & 1;
  new_space->is_private = private & 1;
  new_space->sort_key = sort & 0xff;

  new_space->loader_fix_index = ~0;
  new_space->loader_fix_quantity = 0;
  new_space->init_pointer_index = ~0;
  new_space->init_pointer_quantity = 0;
  new_space->subspace_quantity = 0;
  */

  chain_entry = (space_dict_chainS *)xmalloc(sizeof(space_dict_chainS));
  if ( !chain_entry )
    as_fatal("Out of memory: could not allocate new space chain entry: %s\n",name);

  SPACE_NAME(chain_entry) = (char *)xmalloc(strlen(name)+1);
  strcpy(SPACE_NAME(chain_entry),name);

  chain_entry->sd_entry = new_space;
  chain_entry->sd_defined = defined_in_file;
  chain_entry->sd_seg = seg;
  chain_entry->sd_last_subseg = -1;
  chain_entry->sd_next = NULL;

  SPACE_SPNUM(chain_entry) = spnum;
  SPACE_LOADABLE(chain_entry) = loadable & 1;
  SPACE_DEFINED(chain_entry) = defined & 1;
  SPACE_PRIVATE(chain_entry) = private & 1;
  SPACE_SORT(chain_entry) = sort & 0xff;

  /* find spot for the new space based on its sort key */

  if ( !space_dict_last )
    space_dict_last = chain_entry;

  if ( space_dict_root == NULL )        /* if root is null, it is very easy */
    space_dict_root = chain_entry;
  else
    {
      space_dict_chainS *sdcP;
      space_dict_chainS *last_sdcP;

      sdcP = space_dict_root;
      last_sdcP = NULL;

      while ( sdcP ) {
        if ( SPACE_SORT(sdcP) < SPACE_SORT(chain_entry) ) {
          last_sdcP = sdcP;
          sdcP = sdcP->sd_next;
        }
        else if ( SPACE_SORT(sdcP) == SPACE_SORT(chain_entry) ) {
          last_sdcP = sdcP;
          sdcP = sdcP->sd_next;
        }
        else if ( SPACE_SORT(sdcP) > SPACE_SORT(chain_entry) ) {
          break;
        }       
      }

      if ( last_sdcP ) {
        chain_entry->sd_next = sdcP;
        last_sdcP->sd_next = chain_entry;
      }
      else {
        space_dict_root = chain_entry;
        chain_entry->sd_next = sdcP;
      }

      if ( chain_entry->sd_next  == NULL )
        space_dict_last = chain_entry;
    }

  return chain_entry;
}

subspace_dict_chainS
*create_new_subspace(space,name,defined,loadable,code_only,common,dup_common,
                     is_zero,sort,access,space_index,alignment,quadrant,seg)
     space_dict_chainS *space;
     char *name;
     char defined,loadable,code_only,common,dup_common,is_zero;
     char sort;
     int access;
     int space_index;
     int alignment;
     int quadrant;
     asection * seg;
{
  Elf_Internal_Shdr * new_subspace;
  subspace_dict_chainS * chain_entry;
  symbolS * start_symbol;

  new_subspace = (Elf_Internal_Shdr *)xmalloc(sizeof(Elf_Internal_Shdr));
  if ( !new_subspace )
    as_fatal("Out of memory: could not allocate new Elf_Internal_Shdr: %s\n",
            name);

  /*
  new_subspace->space_index = space_index;
  new_subspace->fixup_request_index = ~0;
  */

  chain_entry = (subspace_dict_chainS *)xmalloc(sizeof(subspace_dict_chainS));
  if ( !chain_entry )
    as_fatal("Out of memory: could not allocate new subspace chain entry: %s\n",name);

  chain_entry->ssd_entry = new_subspace;
  SUBSPACE_NAME(chain_entry) = (char *)xmalloc(strlen(name)+1);
  strcpy(SUBSPACE_NAME(chain_entry),name);

  SUBSPACE_ACCESS(chain_entry) = access & 0x7f;
  SUBSPACE_LOADABLE(chain_entry) = loadable & 1;
  SUBSPACE_COMMON(chain_entry) = common & 1;
  SUBSPACE_DUP_COMM(chain_entry) = dup_common & 1;
  SUBSPACE_SORT(chain_entry) = sort & 0xff;
  SET_SUBSPACE_CODE_ONLY(chain_entry,code_only & 1);
  SUBSPACE_ALIGN(chain_entry) = alignment & 0xffff;
  SUBSPACE_QUADRANT(chain_entry) = quadrant & 0x3;
  SUBSPACE_SUBSPACE_START(chain_entry) = pa_subspace_start(space,quadrant);

  chain_entry->ssd_defined = defined;
  chain_entry->ssd_space_number = space_index;
  chain_entry->ssd_subseg = pa_next_subseg(space);
  chain_entry->ssd_seg = seg;
  SUBSPACE_ZERO(chain_entry) = is_zero;
  chain_entry->ssd_last_align = 1;
  chain_entry->ssd_next = NULL;

  /* find spot for the new subspace based on its sort key */

  if ( space->sd_subspaces == NULL )        /* if root is null, it is very easy */
    space->sd_subspaces = chain_entry;
  else
    {
      subspace_dict_chainS *ssdcP;
      subspace_dict_chainS *last_ssdcP;

      ssdcP = space->sd_subspaces;
      last_ssdcP = NULL;

      while ( ssdcP ) {
        if ( SUBSPACE_SORT(ssdcP) < SUBSPACE_SORT(chain_entry) ) {
          last_ssdcP = ssdcP;
          ssdcP = ssdcP->ssd_next;
        }
        else if ( SUBSPACE_SORT(ssdcP) == SUBSPACE_SORT(chain_entry) ) {
          last_ssdcP = ssdcP;
          ssdcP = ssdcP->ssd_next;
        }
        else if ( SUBSPACE_SORT(ssdcP) > SUBSPACE_SORT(chain_entry) ) {
          break;
        }       
      }

      if ( last_ssdcP ) {
        chain_entry->ssd_next = ssdcP;
        last_ssdcP->ssd_next = chain_entry;
      }
      else {
        space->sd_subspaces = chain_entry;
        chain_entry->ssd_next = ssdcP;
      }
    }

  start_symbol = pa_set_start_symbol(seg,space->sd_last_subseg);
  chain_entry->ssd_start_sym = start_symbol;
  return chain_entry;

}

subspace_dict_chainS
*update_subspace(name,defined,loadable,code_only,common,dup_common,sort,zero,
                 access,space_index,alignment,quadrant,subseg)
     char *name;
     char defined,loadable,code_only,common,dup_common,zero;
     char sort;
     int access;
     int space_index;
     int alignment;
     int quadrant;
     subsegT subseg;
{
  subspace_dict_chainS *chain_entry;
  subspace_dict_chainS *is_defined_subspace();

  if ( (chain_entry = is_defined_subspace(name,subseg)) ) {

    SUBSPACE_ACCESS(chain_entry) = access & 0x7f;
    SUBSPACE_LOADABLE(chain_entry) = loadable & 1;
    SUBSPACE_COMMON(chain_entry) = common & 1;
    SUBSPACE_DUP_COMM(chain_entry) = dup_common & 1;
    SET_SUBSPACE_CODE_ONLY(chain_entry,code_only & 1);
    SUBSPACE_SORT(chain_entry) = sort & 0xff;
    /* chain_entry->ssd_entry->space_index = space_index; */
    SUBSPACE_ALIGN(chain_entry) = alignment & 0xffff;
    SUBSPACE_QUADRANT(chain_entry) = quadrant & 0x3;

    chain_entry->ssd_defined = defined;
    chain_entry->ssd_space_number = space_index;
    SUBSPACE_ZERO(chain_entry) = zero;
  }
  else
    chain_entry = NULL;

  return chain_entry;

}

space_dict_chainS *is_defined_space(name)
     char *name;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root;spaceCh;spaceCh=spaceCh->sd_next ) {
    if ( strcmp(SPACE_NAME(spaceCh),name) == 0 ) {
      return spaceCh;
    }
  }

  return NULL;
}

space_dict_chainS *pa_segment_to_space(seg)
     asection * seg;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root;spaceCh;spaceCh=spaceCh->sd_next ) {
    if ( spaceCh->sd_seg == seg ) {
      return spaceCh;
    }
  }

  return NULL;
}

subspace_dict_chainS *is_defined_subspace(name,subseg)
     char *name;
     subsegT subseg;
{
  space_dict_chainS *spaceCh;
  subspace_dict_chainS *subspCh;

  for ( spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next ) {
    for ( subspCh = spaceCh->sd_subspaces; subspCh; subspCh=subspCh->ssd_next ) {
      /*
        if ( strcmp(SUBSPACE_NAME(subspCh),name) == 0 &&
            subspCh->ssd_subseg == subseg ) {
       */
        if ( strcmp(SUBSPACE_NAME(subspCh),name) == 0 ) {
          return subspCh;
        }
    }
  }
  return NULL;
}

subspace_dict_chainS *pa_subsegment_to_subspace(seg,subseg)
    asection * seg;
    subsegT subseg;
{
  space_dict_chainS *spaceCh;
  subspace_dict_chainS *subspCh;

  for ( spaceCh = space_dict_root; spaceCh; spaceCh = spaceCh->sd_next ) {
    if ( spaceCh->sd_seg == seg ) {
      for (subspCh = spaceCh->sd_subspaces;subspCh;subspCh=subspCh->ssd_next ) {
        if ( subspCh->ssd_subseg == (int)subseg ) {
          return subspCh;
        }
      }
    }
  }

  return NULL;
}

space_dict_chainS *pa_find_space_by_number(number)
     int number;
{
  space_dict_chainS *spaceCh;

  for (spaceCh = space_dict_root;spaceCh;spaceCh=spaceCh->sd_next ) {
    if ( SPACE_SPNUM(spaceCh) == number ) {
      return spaceCh;
    }
  }

  return NULL;
}

unsigned int pa_subspace_start(space,quadrant)
     space_dict_chainS *space;
     int quadrant;
{
  if ( (strcasecmp(SPACE_NAME(space),"$PRIVATE$") == 0) &&
       quadrant == 1 ) {
    return 0x40000000;
  }
  else if ( space->sd_seg == data_section && quadrant == 1 ) {  /* in case name is */
                                                            /* already converted */
                                                            /* to a space dict- */
                                                            /* ionary index */
    return 0x40000000;
  }
  else
    return 0;
}

int pa_next_subseg(space)
     space_dict_chainS *space;
{

  space->sd_last_subseg++;
  return space->sd_last_subseg;
}

int is_last_defined_subspace(ssd)
     subspace_dict_chainS *ssd;
{

  for ( ;ssd; ssd = ssd->ssd_next ) {
    if ( ssd->ssd_defined )
      return FALSE;
  }

  return TRUE;
}

symbolS *pa_get_start_symbol(seg,subseg)
     asection * seg;
     subsegT subseg;
{
  symbolS *start_symbol;
  subspace_dict_chainS *ssd;

  start_symbol = NULL;

  /* each time a new space is created, build a symbol called LS$START_seg_subseg$ */
  /* where <space-name> is the name of the space */
  /* the start symbol will be SS_LOCAL and ST_CODE */

  if ( seg == bfd_make_section_old_way ( stdoutput, ".text" ) ||
       seg == bfd_make_section_old_way ( stdoutput, ".data" ) ||
       seg == bfd_make_section_old_way ( stdoutput, GDB_DEBUG_SPACE_NAME ) ) {
          ssd = pa_subsegment_to_subspace(seg,subseg);
          if ( ssd ) {
                  start_symbol = ssd->ssd_start_sym;
          }
          else
              as_fatal("Internal error: missing subspace for (seg,subseg)=('%s',%d)",
                       seg->name,subseg);
  }
  else
      as_fatal("Internal error: attempt to find start symbol for unloadable segment: '%s'",
               seg->name);

  return start_symbol;
}

/*
  Function to define a symbol whose address is the beginning of a subspace.
  This function assumes the symbol is to be defined for the current subspace.
 */

symbolS *pa_set_start_symbol(seg,subseg)
     asection * seg;
     subsegT subseg;
{
  symbolS *start_symbol;
  subspace_dict_chainS *ssd;
  char *symbol_name;

  symbol_name = (char *)xmalloc(strlen("LS$START__000000$")+strlen(seg->name)+1);

  sprintf(symbol_name,"LS$START_%s_%03d$",seg->name,subseg);

  start_symbol
      = symbol_new(symbol_name,seg,0,frag_now); /* XXX: not sure if value s.b. 0 or frag s.b. NULL */

  start_symbol->bsym->flags     = BSF_LOCAL;    /* XXX: isn't there a macro defined for this? */

  /* each time a new space is created, build a symbol called LS$START_seg_subseg$ */
  /* where <space-name> is the name of the space */
  /* the start symbol will be SS_LOCAL and ST_CODE */
  /* This function assumes that (seg,subseg) is a new subsegment(subspace) */

  if ( seg == bfd_make_section_old_way ( stdoutput, ".text" ) ||
       seg == bfd_make_section_old_way ( stdoutput, ".data" ) ||
       seg == bfd_make_section_old_way ( stdoutput, GDB_DEBUG_SPACE_NAME ) ) {
          ssd = pa_subsegment_to_subspace(seg,subseg);
          if ( ssd ) {
                  ssd->ssd_start_sym = start_symbol;
          }
          else
              as_fatal("Internal error: missing subspace for (seg,subseg)=('%s',%d)",
                       seg,subseg);
  }
  else
      as_fatal("Internal error: attempt to define start symbol for unloadable segment: '%s'",
               seg->name);

  return start_symbol;
}
#endif

int
obj_elf_frob_symbol (sym, punt)
     symbolS *sym;
     int *punt;
{

        /* If this is a local symbol, are there any relocations for */
        /* which need this symbol?      */

        /* To find this out, we examine all relocations in all bfd */
        /* sections that have relocations.  If there is one that */
        /* references this symbol, we need to keep this symbol.  In */
        /* this case, we return a true status.  In all other cases, we */
        /* return a false status.       */

        if ( S_IS_LOCAL(sym) ) {
                asymbol *bsym = sym->bsym;      
                bfd *abfd = bsym->the_bfd;
                asection *bsec;

                for ( bsec = abfd->sections; bsec; bsec = bsec->next ) {
                        struct reloc_cache_entry **rlocs = bsec->orelocation;
                        int rcnt = bsec->reloc_count;

                        if ( rlocs ) {
                                int i;

                                for ( i = 0; i < rcnt; i++ ) {
                                        if ( rlocs[i]->sym_ptr_ptr
                                            && rlocs[i]->sym_ptr_ptr[0] == bsym )
                                                return 1;
                                }
                        }
                }
        }
        return 0;
}

static void obj_elf_line() {
        /* Assume delimiter is part of expression.
           BSD4.2 as fails with delightful bug, so we
           are not being incompatible here. */
        new_logical_line((char *)NULL, (int)(get_absolute_expression()));
        demand_empty_rest_of_line();
} /* obj_elf_line() */

/*
 *                      stab()
 *
 * Handle .stabX directives, which used to be open-coded.
 * So much creeping featurism overloaded the semantics that we decided
 * to put all .stabX thinking in one place. Here.
 *
 * We try to make any .stabX directive legal. Other people's AS will often
 * do assembly-time consistency checks: eg assigning meaning to n_type bits
 * and "protecting" you from setting them to certain values. (They also zero
 * certain bits before emitting symbols. Tut tut.)
 *
 * If an expression is not absolute we either gripe or use the relocation
 * information. Other people's assemblers silently forget information they
 * don't need and invent information they need that you didn't supply.
 *
 * .stabX directives always make a symbol table entry. It may be junk if
 * the rest of your .stabX directive is malformed.
 */

/*
 *                      pa_stab_symbol_string()
 *
 * Build a string dictionary entry for a .stabX symbol.
 * The symbol is added to the .stabstr section.
 *
 */

static unsigned int gdb_string_index = 0;

static unsigned int
elf_stab_symbol_string(string)
     char *string;
{
  asection *save_seg;
  asection *seg;
  subsegT save_subseg;
  unsigned int length;
  unsigned int old_gdb_string_index;
  char *clengthP;
  int i;
  char c;

  old_gdb_string_index = 0;
  length = strlen(string);
  clengthP = (char *)&length;
  if ( length > 0 ) {                   /* Ordinary case. */
    save_seg = now_seg;
    save_subseg = now_subseg;

    /* Create the stab sections, if they are not already created. */
    seg = bfd_get_section_by_name(stdoutput,".stabstr");
    if ( seg == 0 ) {
            seg = bfd_make_section_old_way(stdoutput,".stabstr");
            bfd_set_section_flags (stdoutput,
                                   seg,
                                   SEC_READONLY | SEC_ALLOC | SEC_LOAD );
    }
    subseg_new((char *) seg->name,save_subseg);
    old_gdb_string_index = gdb_string_index;
    i = 0;
    while ( (c = *string++) )
      {
        i++;
        gdb_string_index++;
        FRAG_APPEND_1_CHAR( c );
      }
    {
      FRAG_APPEND_1_CHAR( (char)0 );
      i++;
      gdb_string_index++;
    }
    while ( i%4 != 0 ) {
      FRAG_APPEND_1_CHAR( (char)0 );
      i++;
      gdb_string_index++;
    }
    subseg_new((char *) save_seg->name,save_subseg);
  }

  return old_gdb_string_index;
}

unsigned int
elf_stab_symbol(symbolP,stab_type)
     symbolS *symbolP;
     int stab_type;
{
  unsigned int length;
  int i;
  char c;
  char *toP;

  /* the string index portion of the stab */

  toP = frag_more( sizeof(long) +
                   sizeof(S_GET_TYPE(symbolP)) +
                   sizeof(S_GET_OTHER(symbolP)) +
                   sizeof(S_GET_DESC(symbolP)));
  md_number_to_chars(toP,symbolP->sy_name_offset,sizeof(long));
  md_number_to_chars(toP,
                     S_GET_TYPE(symbolP),
                     sizeof(S_GET_TYPE(symbolP)));
  md_number_to_chars(toP + sizeof(S_GET_TYPE(symbolP)),
                     S_GET_OTHER(symbolP),
                     sizeof(S_GET_OTHER(symbolP)));
  md_number_to_chars(toP + sizeof(S_GET_TYPE(symbolP))
                         + sizeof(S_GET_OTHER(symbolP)),
                     S_GET_DESC(symbolP),
                     sizeof(S_GET_DESC(symbolP)));

  /* n_value has to be relocated */

  /* Don't bother relocating if we're only adding in a constant. */

  if ((stab_type == 's' || stab_type == 'n') && symbolP->sy_forward == 0)
          S_SET_VALUE(symbolP,S_GET_VALUE(symbolP->sy_forward));

  toP = frag_more(4);
  md_number_to_chars(toP, S_GET_VALUE(symbolP),
                     sizeof(S_GET_VALUE(symbolP)));

#if 0
  if ( (stab_type == 's' || stab_type == 'n') && symbolP->sy_forward )
    {
      i = S_GET_TYPE(symbolP) & N_TYPE;
      fix_new_hppa(frag_now,    /* which frag */
                   toP-frag_now->fr_literal, /* where */
                   4,           /* size */
                   symbolP->sy_forward, /* addr of symbol for this stab */
                   (asymbol *)NULL,
                   0,
                   i == N_UNDF || i == N_ABS,   /* 1 if internal relocation */
                   R_HPPA,      /* reloc type */
                   e_fsel,      /* fixup field = F% */
                   32,
                   0,           /* arg_reloc descriptor */
                   (char *)0
                   );
    }
  else if ( stab_type == 'd' )
    {
      fix_new_hppa (frag_now,   /* which frag */
                    toP-frag_now->fr_literal, /* where */
                    4,          /* size */
                    symbolP,    /* addr of symbol for this stab */
                    (asymbol *)NULL,
                    0,
                    0,
                    R_HPPA,     /* reloc type */
                    e_fsel,     /* fixup field = F% */
                    32,
                    0,          /* arg_reloc descriptor */
                    (char *)0
                    );
    }
#else
  /* What needs to replace the above code?  */
  abort ();
#endif
}

static void obj_elf_stab(what)
     int what;
{
  extern int listing;

  symbolS *     symbolP = 0;
  char *        string;
  int saved_type = 0;
  int length;
  int goof = 0;
  long longint;
  asection *saved_seg = now_seg;
  asection *seg;
  subsegT subseg = now_subseg;

  seg = bfd_get_section_by_name(stdoutput,".stab");
  if ( seg == 0 )
    {
      seg = bfd_make_section_old_way(stdoutput,".stab");
      bfd_set_section_flags (stdoutput,
                             seg,
                             SEC_READONLY | SEC_ALLOC | SEC_LOAD | SEC_RELOC);
    }

  /*
   * Enter with input_line_pointer pointing past .stabX and any following
   * whitespace.
   */
  if (what == 's') {
      string = demand_copy_C_string(& length);
      SKIP_WHITESPACE();
      if (* input_line_pointer == ',')
       input_line_pointer ++;
      else
        {
          as_bad("I need a comma after symbol's name");
          goof = 1;
        }
    }
  else
    string = "";

  /*
   * Input_line_pointer->after ','.  String->symbol name.
   */
  if (! goof)
    {
      symbolP = symbol_new(string, &bfd_und_section, 0, (struct frag *)0);

      /* enter the string in the .stab string table (section .stabstr) */
      symbolP->sy_name_offset = elf_stab_symbol_string(string);

      switch (what)
        {
        case 'd':
          S_SET_NAME(symbolP, NULL); /* .stabd feature. */
          S_SET_VALUE(symbolP, obstack_next_free(&frags) - frag_now->fr_literal);
          S_SET_SEGMENT(symbolP, now_seg);
          symbolP->sy_frag = frag_now;
          break;

        case 'n':
          symbolP->sy_frag = &zero_address_frag;
          break;

        case 's':
          symbolP->sy_frag = & zero_address_frag;
          break;

        default:
          BAD_CASE(what);
          break;
        }

      if (get_absolute_expression_and_terminator(&longint) == ',')
        {
          saved_type = longint;
          S_SET_TYPE (symbolP, saved_type);
        }
      else
        {
          as_bad("I want a comma after the n_type expression");
          goof = 1;
          input_line_pointer --; /* Backup over a non-',' char. */
        }
    }

  if (!goof)
    {
      if (get_absolute_expression_and_terminator(&longint) == ',')
        S_SET_OTHER(symbolP, longint);
      else
        {
          as_bad("I want a comma after the n_other expression");
          goof = 1;
          input_line_pointer--; /* Backup over a non-',' char. */
        }
    }

  if (!goof)
    {
      S_SET_DESC(symbolP, get_absolute_expression());
      if (what == 's' || what == 'n')
        {
          if (*input_line_pointer != ',')
            {
              as_bad("I want a comma after the n_desc expression");
              goof = 1;
            }
          else
            {
              input_line_pointer++;
            }
        }
    }

  if ( !goof ) {
          if ( what=='s' || what=='n' ) {
                  pseudo_set(symbolP);
                  S_SET_TYPE (symbolP, saved_type);
          }
          /* Emit the stab symbol. */
          subseg_new((char *) seg->name,subseg);
          elf_stab_symbol(symbolP, what);
          subseg_new((char *) saved_seg->name,subseg);

          if ( what=='s' || what=='n' && symbolP->sy_forward == NULL ) {
                  /* symbol is not needed in the regular symbol table */
                  symbol_remove(symbolP,&symbol_rootP,&symbol_lastP);
          }

  }

#ifndef NO_LISTING
  if (listing && !goof)
    switch (S_GET_TYPE (symbolP))
      {
      case N_SLINE:
        listing_source_line (S_GET_DESC (symbolP));
        break;
      case N_SO:
      case N_SOL:
        listing_source_file (string);
        break;
      }
#endif

  if (goof)
    ignore_rest_of_line();
  else
    demand_empty_rest_of_line ();
} /* obj_elf_stab() */

static void obj_elf_desc() {
        char *name;
        char c;
        char *p;
        symbolS *symbolP;
        int temp;
        
        /*
         * Frob invented at RMS' request. Set the n_desc of a symbol.
         */
        name = input_line_pointer;
        c = get_symbol_end();
        p = input_line_pointer;
        * p = c;
        SKIP_WHITESPACE();
        if (*input_line_pointer != ',') {
                *p = 0;
                as_bad("Expected comma after name \"%s\"", name);
                *p = c;
                ignore_rest_of_line();
        } else {
                input_line_pointer ++;
                temp = get_absolute_expression();
                *p = 0;
                symbolP = symbol_find_or_make(name);
                *p = c;
                S_SET_DESC(symbolP,temp);
        }
        demand_empty_rest_of_line();
} /* obj_elf_desc() */

void obj_read_begin_hook()
{
}

void obj_symbol_new_hook(symbolP)
symbolS *symbolP;
{
  elf_symbol_type *esym = (elf_symbol_type *)symbolP;

  /* There is an Elf_Internal_Sym and an Elf_External_Sym.  For now,
     just zero them out.  */

  bzero((char *) &esym->internal_elf_sym,sizeof(Elf_Internal_Sym));
  bzero((char *) &esym->native_elf_sym,sizeof(Elf_External_Sym));
}

static void obj_elf_version()
{
    char *name;
    unsigned int c;
    char ch;
    char *p;
    int temp;
    symbolS *   symbolP;
    asection *seg = now_seg;
    subsegT subseg = now_subseg;
    Elf_Internal_Note i_note;
    Elf_External_Note e_note;
    asection *note_secp = (asection *)NULL;
    int i, len;

    SKIP_WHITESPACE();
    if (* input_line_pointer == '\"') {
      ++input_line_pointer; /* -> 1st char of string. */
      name = input_line_pointer;

      while ( is_a_char(c = next_char_of_string()) )
              ;
      c = *input_line_pointer;
      *input_line_pointer = '\0';
      *(input_line_pointer-1) = '\0';
      *input_line_pointer = c;

      /* create the .note section if this is the first version string */

      note_secp = bfd_get_section_by_name(stdoutput,".note");
      if ( note_secp == (asection *)NULL ) {
              note_secp = bfd_make_section_old_way(stdoutput,".note");
              bfd_set_section_flags(stdoutput,
                                    note_secp,
                                    SEC_LOAD | SEC_ALLOC | SEC_HAS_CONTENTS);
      }

      /* process the version string */

      subseg_new((char *)note_secp->name, 0);
      len = strlen(name);

      i_note.namesz     = ((len + 1) + 3) & ~3; /* round this to word boundary  */
      i_note.descsz     = 0;                    /* no description       */
      i_note.type       = NT_VERSION;
      p = frag_more(sizeof(e_note.namesz));
      md_number_to_chars(p, i_note.namesz, 4);
      p = frag_more(sizeof(e_note.descsz));
      md_number_to_chars(p, i_note.descsz, 4);
      p = frag_more(sizeof(e_note.type));
      md_number_to_chars(p, i_note.type,   4);

      for ( i = 0; i < len; i++ ) {
              ch = *(name + i);
              {
                      FRAG_APPEND_1_CHAR( ch );
              }
      }
      frag_align(2,0);

      subseg_new((char *)seg->name,subseg);
    }
    else {
      as_bad( "Expected \"-ed string" );
    }
    demand_empty_rest_of_line();
}

static void
obj_elf_size ()
{
  char *name = input_line_pointer;
  char c = get_symbol_end ();
  char *p;
  expressionS exp;
  segT sec;
  symbolS *sym;

  p = input_line_pointer;
  *p = c;
  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      *p = 0;
      as_bad ("expected comma after name `%s' in .size directive", name);
      *p = c;
      ignore_rest_of_line ();
      return;
    }
  input_line_pointer++;
  sec = expression (&exp);
  if (sec == absent_section)
    {
      as_bad ("missing expression in .size directive");
      exp.X_seg = absolute_section;
      exp.X_add_number = 0;
    }
  *p = 0;
  sym = symbol_find_or_make (name);
  *p = c;
  if (sec == absolute_section)
    S_SET_SIZE (sym, exp.X_add_number);
  else
    as_tsktsk (".size not yet supported, ignored");
  demand_empty_rest_of_line ();
}

static void
obj_elf_type ()
{
  char *name = input_line_pointer;
  char c = get_symbol_end ();
  char *p;
  int type;
  symbolS *sym;

  p = input_line_pointer;
  *p = c;
  SKIP_WHITESPACE ();
  if (*input_line_pointer != ',')
    {
      as_bad ("expected comma after name in .type directive");
    egress:
      ignore_rest_of_line ();
      return;
    }
  input_line_pointer++;
  SKIP_WHITESPACE ();
  if (*input_line_pointer != '#')
    {
      as_bad ("expected `#' after comma in .type directive");
      goto egress;
    }
  input_line_pointer++;
  if (!strncmp ("function", input_line_pointer, sizeof ("function") - 1))
    {
      type = BSF_FUNCTION;
      input_line_pointer += sizeof ("function") - 1;
    }
  else
    {
      as_bad ("unrecognized symbol type, ignored");
      goto egress;
    }
  demand_empty_rest_of_line ();
  *p = 0;
  sym = symbol_find_or_make (name);
  sym->bsym->flags = type;
}

static void
obj_elf_ident ()
{
  int xxx;
  char * string;

  string = demand_copy_C_string (&xxx);
  as_tsktsk (".ident not supported, ignoring");
}