[deliverable/binutils-gdb.git] / gas / stabs.c

/* Generic stabs parsing for gas.
   Copyright (C) 1989, 90, 91, 93, 94, 95, 96, 97, 98, 99, 2000
   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, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

#include "as.h"
#include "obstack.h"
#include "subsegs.h"
#include "ecoff.h"

/* We need this, despite the apparent object format dependency, since
   it defines stab types, which all object formats can use now.  */

#include "aout/stab_gnu.h"

/* Holds whether the assembler is generating stabs line debugging
   information or not.  Potentially used by md_cleanup function.  */

int outputting_stabs_line_debug = 0;

static void s_stab_generic PARAMS ((int, char *, char *));
static void generate_asm_file PARAMS ((int, char *));

/* Allow backends to override the names used for the stab sections.  */
#ifndef STAB_SECTION_NAME
#define STAB_SECTION_NAME ".stab"
#endif

#ifndef STAB_STRING_SECTION_NAME
#define STAB_STRING_SECTION_NAME ".stabstr"
#endif

/* Non-zero if we're in the middle of a .func function, in which case
   stabs_generate_asm_lineno emits function relative line number stabs.
   Otherwise it emits line number stabs with absolute addresses.  Note that
   both cases only apply to assembler code assembled with -gstabs.  */
static int in_dot_func_p;

/* Label at start of current function if in_dot_func_p != 0.  */
static const char *current_function_label;

/*
 * 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.
 */

/*
 * Build a string dictionary entry for a .stabX symbol.
 * The symbol is added to the .<secname>str section.
 */

#ifndef SEPARATE_STAB_SECTIONS
#define SEPARATE_STAB_SECTIONS 0
#endif

unsigned int
get_stab_string_offset (string, stabstr_secname)
     const char *string;
     const char *stabstr_secname;
{
  unsigned int length;
  unsigned int retval;
  segT save_seg;
  subsegT save_subseg;
  segT seg;
  char *p;

  if (! SEPARATE_STAB_SECTIONS)
    abort ();

  length = strlen (string);

  save_seg = now_seg;
  save_subseg = now_subseg;

  /* Create the stab string section.  */
  seg = subseg_new (stabstr_secname, 0);

  retval = seg_info (seg)->stabu.stab_string_size;
  if (retval <= 0)
    {
      /* Make sure the first string is empty.  */
      p = frag_more (1);
      *p = 0;
      retval = seg_info (seg)->stabu.stab_string_size = 1;
#ifdef BFD_ASSEMBLER
      bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING);
      if (seg->name == stabstr_secname)
	seg->name = xstrdup (stabstr_secname);
#endif
    }

  if (length > 0)
    {				/* Ordinary case.  */
      p = frag_more (length + 1);
      strcpy (p, string);

      seg_info (seg)->stabu.stab_string_size += length + 1;
    }
  else
    retval = 0;

  subseg_set (save_seg, save_subseg);

  return retval;
}

#ifdef AOUT_STABS
#ifndef OBJ_PROCESS_STAB
#define OBJ_PROCESS_STAB(SEG,W,S,T,O,D)	aout_process_stab(W,S,T,O,D)
#endif

/* Here instead of obj-aout.c because other formats use it too.  */
void
aout_process_stab (what, string, type, other, desc)
     int what;
     const char *string;
     int type, other, desc;
{
  /* Put the stab information in the symbol table.  */
  symbolS *symbol;

  /* Create the symbol now, but only insert it into the symbol chain
     after any symbols mentioned in the value expression get into the
     symbol chain.  This is to avoid "continuation symbols" (where one
     ends in "\" and the debug info is continued in the next .stabs
     directive) from being separated by other random symbols.  */
  symbol = symbol_create (string, undefined_section, 0,
			  (struct frag *) NULL);
  if (what == 's' || what == 'n')
    {
      /* Pick up the value from the input line.  */
      symbol_set_frag (symbol, &zero_address_frag);
      pseudo_set (symbol);
    }
  else
    {
      /* .stabd sets the name to NULL.  Why?  */
      S_SET_NAME (symbol, NULL);
      symbol_set_frag (symbol, frag_now);
      S_SET_VALUE (symbol, (valueT) frag_now_fix ());
    }

  symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);

  S_SET_TYPE (symbol, type);
  S_SET_OTHER (symbol, other);
  S_SET_DESC (symbol, desc);
}
#endif

/* This can handle different kinds of stabs (s,n,d) and different
   kinds of stab sections.  */

static void
s_stab_generic (what, stab_secname, stabstr_secname)
     int what;
     char *stab_secname;
     char *stabstr_secname;
{
  long longint;
  char *string;
  int type;
  int other;
  int desc;

  /* The general format is:
     .stabs "STRING",TYPE,OTHER,DESC,VALUE
     .stabn TYPE,OTHER,DESC,VALUE
     .stabd TYPE,OTHER,DESC
     At this point input_line_pointer points after the pseudo-op and
     any trailing whitespace.  The argument what is one of 's', 'n' or
     'd' indicating which type of .stab this is.  */

  if (what != 's')
    string = "";
  else
    {
      int length;

      string = demand_copy_C_string (&length);
      SKIP_WHITESPACE ();
      if (*input_line_pointer == ',')
	input_line_pointer++;
      else
	{
	  as_warn (_(".stabs: Missing comma"));
	  ignore_rest_of_line ();
	  return;
	}
    }

  if (get_absolute_expression_and_terminator (&longint) != ',')
    {
      as_warn (_(".stab%c: Missing comma"), what);
      ignore_rest_of_line ();
      return;
    }
  type = longint;

  if (get_absolute_expression_and_terminator (&longint) != ',')
    {
      as_warn (_(".stab%c: Missing comma"), what);
      ignore_rest_of_line ();
      return;
    }
  other = longint;

  desc = get_absolute_expression ();
  if (what == 's' || what == 'n')
    {
      if (*input_line_pointer != ',')
	{
	  as_warn (_(".stab%c: Missing comma"), what);
	  ignore_rest_of_line ();
	  return;
	}
      input_line_pointer++;
      SKIP_WHITESPACE ();
    }

#ifdef TC_PPC
#ifdef OBJ_ELF
  /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
     given 4 arguments, make it a .stabn */
  else if (what == 'd')
    {
      char *save_location = input_line_pointer;

      SKIP_WHITESPACE ();
      if (*input_line_pointer == ',')
	{
	  input_line_pointer++;
	  what = 'n';
	}
      else
	input_line_pointer = save_location;
    }
#endif /* OBJ_ELF */
#endif /* TC_PPC */

#ifndef NO_LISTING
  if (listing)
    {
      switch (type)
	{
	case N_SLINE:
	  listing_source_line ((unsigned int) desc);
	  break;
	case N_SO:
	case N_SOL:
	  listing_source_file (string);
	  break;
	}
    }
#endif /* ! NO_LISTING */

  /* We have now gathered the type, other, and desc information.  For
     .stabs or .stabn, input_line_pointer is now pointing at the
     value.  */

  if (SEPARATE_STAB_SECTIONS)
    /* Output the stab information in a separate section.  This is used
       at least for COFF and ELF.  */
    {
      segT saved_seg = now_seg;
      subsegT saved_subseg = now_subseg;
      fragS *saved_frag = frag_now;
      valueT dot;
      segT seg;
      unsigned int stroff;
      char *p;

      static segT cached_sec;
      static char *cached_secname;

      dot = frag_now_fix ();

#ifdef md_flush_pending_output
      md_flush_pending_output ();
#endif

      if (cached_secname && !strcmp (cached_secname, stab_secname))
	{
	  seg = cached_sec;
	  subseg_set (seg, 0);
	}
      else
	{
	  seg = subseg_new (stab_secname, 0);
	  if (cached_secname)
	    free (cached_secname);
	  cached_secname = xstrdup (stab_secname);
	  cached_sec = seg;
	}

      if (! seg_info (seg)->hadone)
	{
#ifdef BFD_ASSEMBLER
	  bfd_set_section_flags (stdoutput, seg,
				 SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
#endif
#ifdef INIT_STAB_SECTION
	  INIT_STAB_SECTION (seg);
#endif
	  seg_info (seg)->hadone = 1;
	}

      stroff = get_stab_string_offset (string, stabstr_secname);
      if (what == 's')
	{
	  /* release the string */
	  obstack_free (&notes, string);
	}

      /* At least for now, stabs in a special stab section are always
	 output as 12 byte blocks of information.  */
      p = frag_more (8);
      md_number_to_chars (p, (valueT) stroff, 4);
      md_number_to_chars (p + 4, (valueT) type, 1);
      md_number_to_chars (p + 5, (valueT) other, 1);
      md_number_to_chars (p + 6, (valueT) desc, 2);

      if (what == 's' || what == 'n')
	{
	  /* Pick up the value from the input line.  */
	  cons (4);
	  input_line_pointer--;
	}
      else
	{
	  const char *fake;
	  symbolS *symbol;
	  expressionS exp;

	  /* Arrange for a value representing the current location.  */
	  fake = FAKE_LABEL_NAME;
	  symbol = symbol_new (fake, saved_seg, dot, saved_frag);

	  exp.X_op = O_symbol;
	  exp.X_add_symbol = symbol;
	  exp.X_add_number = 0;

	  emit_expr (&exp, 4);
	}

#ifdef OBJ_PROCESS_STAB
      OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
#endif

      subseg_set (saved_seg, saved_subseg);
    }
  else
    {
#ifdef OBJ_PROCESS_STAB
      OBJ_PROCESS_STAB (0, what, string, type, other, desc);
#else
      abort ();
#endif
    }

  demand_empty_rest_of_line ();
}

/* Regular stab directive.  */

void
s_stab (what)
     int what;
{
  s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
}

/* "Extended stabs", used in Solaris only now.  */

void
s_xstab (what)
     int what;
{
  int length;
  char *stab_secname, *stabstr_secname;
  static char *saved_secname, *saved_strsecname;

  /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
     cases it will be the same string, so we could release the storage
     back to the obstack it came from.  */
  stab_secname = demand_copy_C_string (&length);
  SKIP_WHITESPACE ();
  if (*input_line_pointer == ',')
    input_line_pointer++;
  else
    {
      as_bad (_("comma missing in .xstabs"));
      ignore_rest_of_line ();
      return;
    }

  /* To get the name of the stab string section, simply add "str" to
     the stab section name.  */
  if (saved_secname == 0 || strcmp (saved_secname, stab_secname))
    {
      stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
      strcpy (stabstr_secname, stab_secname);
      strcat (stabstr_secname, "str");
      if (saved_secname)
	{
	  free (saved_secname);
	  free (saved_strsecname);
	}
      saved_secname = stab_secname;
      saved_strsecname = stabstr_secname;
    }
  s_stab_generic (what, saved_secname, saved_strsecname);
}

#ifdef S_SET_DESC

/* Frob invented at RMS' request. Set the n_desc of a symbol.  */

void
s_desc (ignore)
     int ignore ATTRIBUTE_UNUSED;
{
  char *name;
  char c;
  char *p;
  symbolS *symbolP;
  int temp;

  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 ();
}				/* s_desc() */

#endif /* defined (S_SET_DESC) */

/* Generate stabs debugging information to denote the main source file.  */

void
stabs_generate_asm_file ()
{
  char *file;
  unsigned int lineno;

  as_where (&file, &lineno);
  generate_asm_file (N_SO, file);
}

/* Generate stabs debugging information to denote the source file.
   TYPE is one of N_SO, N_SOL.  */

static void
generate_asm_file (type, file)
     int type;
     char *file;
{
  static char *last_file;
  static int label_count;
  char *hold;
  char sym[30];
  char *buf;
  char *tmp = file;
  char *endp = file + strlen (file);
  char *bufp = buf;

  if (last_file != NULL
      && strcmp (last_file, file) == 0)
    return;

  /* Rather than try to do this in some efficient fashion, we just
     generate a string and then parse it again.  That lets us use the
     existing stabs hook, which expect to see a string, rather than
     inventing new ones.  */
  hold = input_line_pointer;

  sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
  ++label_count;

  /* Allocate enough space for the file name (possibly extended with
     doubled up backslashes), the symbol name, and the other characters
     that make up a stabs file directive.  */
  bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12);

  *bufp++ = '"';

  while (tmp < endp)
    {
      char *bslash = strchr (tmp, '\\');
      int len = (bslash ? (bslash - tmp + 1) : strlen (tmp));

      /* Double all backslashes, since demand_copy_C_string (used by
	 s_stab to extract the part in quotes) will try to replace them as
	 escape sequences.  backslash may appear in a filespec.  */
      strncpy (bufp, tmp, len);

      tmp += len;
      bufp += len;

      if (bslash != NULL)
	*bufp++ = '\\';
    }

  sprintf (bufp, "\",%d,0,0,%s\n", type, sym);

  input_line_pointer = buf;
  s_stab ('s');
  colon (sym);

  if (last_file != NULL)
    free (last_file);
  last_file = xstrdup (file);

  free (buf);

  input_line_pointer = hold;
}

/* Generate stabs debugging information for the current line.  This is
   used to produce debugging information for an assembler file.  */

void
stabs_generate_asm_lineno ()
{
  static int label_count;
  char *hold;
  char *file;
  unsigned int lineno;
  char *buf;
  char sym[30];

  /* Let the world know that we are in the middle of generating a
     piece of stabs line debugging information.  */
  outputting_stabs_line_debug = 1;

  /* Rather than try to do this in some efficient fashion, we just
     generate a string and then parse it again.  That lets us use the
     existing stabs hook, which expect to see a string, rather than
     inventing new ones.  */

  hold = input_line_pointer;

  as_where (&file, &lineno);

  generate_asm_file (N_SOL, file);

  sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
  ++label_count;

  if (in_dot_func_p)
    {
      buf = (char *) alloca (100 + strlen (current_function_label));
      sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
	       sym, current_function_label);
    }
  else
    {
      buf = (char *) alloca (100);
      sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
    }
  input_line_pointer = buf;
  s_stab ('n');
  colon (sym);

  input_line_pointer = hold;
  outputting_stabs_line_debug = 0;
}

/* Emit a function stab.
   All assembler functions are assumed to have return type `void'.  */

void
stabs_generate_asm_func (funcname, startlabname)
     const char *funcname;
     const char *startlabname;
{
  static int void_emitted_p;
  char *hold = input_line_pointer;
  char *buf;
  char *file;
  unsigned int lineno;

  if (! void_emitted_p)
    {
      input_line_pointer = "\"void:t1=1\",128,0,0,0";
      s_stab ('s');
      void_emitted_p = 1;
    }

  as_where (&file, &lineno);
  asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
	    funcname, N_FUN, lineno + 1, startlabname);
  input_line_pointer = buf;
  s_stab ('s');
  free (buf);

  input_line_pointer = hold;
  current_function_label = xstrdup (startlabname);
  in_dot_func_p = 1;
}

/* Emit a stab to record the end of a function.  */

void
stabs_generate_asm_endfunc (funcname, startlabname)
     const char *funcname ATTRIBUTE_UNUSED;
     const char *startlabname;
{
  static int label_count;
  char *hold = input_line_pointer;
  char *buf;
  char sym[30];

  sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
  ++label_count;
  colon (sym);

  asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname);
  input_line_pointer = buf;
  s_stab ('s');
  free (buf);

  input_line_pointer = hold;
  in_dot_func_p = 0;
  current_function_label = NULL;
}
Commit	Line	Data
252b5132	1	/* Generic stabs parsing for gas.
f0e652b4	2	Copyright (C) 1989, 90, 91, 93, 94, 95, 96, 97, 98, 99, 2000
252b5132 RH	3	Free Software Foundation, Inc.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as
	9	published by the Free Software Foundation; either version 2,
	10	or (at your option) any later version.
	11
	12	GAS is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	the GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
f0e652b4	20	02111-1307, USA. */
252b5132 RH	21
	22	#include "as.h"
	23	#include "obstack.h"
	24	#include "subsegs.h"
	25	#include "ecoff.h"
	26
	27	/* We need this, despite the apparent object format dependency, since
f0e652b4	28	it defines stab types, which all object formats can use now. */
252b5132 RH	29
	30	#include "aout/stab_gnu.h"
	31
bccba5f0 NC	32	/* Holds whether the assembler is generating stabs line debugging
	33	information or not. Potentially used by md_cleanup function. */
	34
92eb7b32	35	int outputting_stabs_line_debug = 0;
bccba5f0	36
252b5132 RH	37	static void s_stab_generic PARAMS ((int, char , char ));
	38	static void generate_asm_file PARAMS ((int, char *));
	39
	40	/* Allow backends to override the names used for the stab sections. */
	41	#ifndef STAB_SECTION_NAME
	42	#define STAB_SECTION_NAME ".stab"
	43	#endif
	44
	45	#ifndef STAB_STRING_SECTION_NAME
	46	#define STAB_STRING_SECTION_NAME ".stabstr"
	47	#endif
	48
	49	/* Non-zero if we're in the middle of a .func function, in which case
	50	stabs_generate_asm_lineno emits function relative line number stabs.
	51	Otherwise it emits line number stabs with absolute addresses. Note that
	52	both cases only apply to assembler code assembled with -gstabs. */
	53	static int in_dot_func_p;
	54
	55	/* Label at start of current function if in_dot_func_p != 0. */
	56	static const char *current_function_label;
	57
	58	/*
	59	* Handle .stabX directives, which used to be open-coded.
	60	* So much creeping featurism overloaded the semantics that we decided
	61	* to put all .stabX thinking in one place. Here.
	62	*
	63	* We try to make any .stabX directive legal. Other people's AS will often
	64	* do assembly-time consistency checks: eg assigning meaning to n_type bits
	65	* and "protecting" you from setting them to certain values. (They also zero
	66	* certain bits before emitting symbols. Tut tut.)
	67	*
	68	* If an expression is not absolute we either gripe or use the relocation
	69	* information. Other people's assemblers silently forget information they
	70	* don't need and invent information they need that you didn't supply.
	71	*/
	72
	73	/*
	74	* Build a string dictionary entry for a .stabX symbol.
	75	* The symbol is added to the .<secname>str section.
	76	*/
	77
	78	#ifndef SEPARATE_STAB_SECTIONS
	79	#define SEPARATE_STAB_SECTIONS 0
	80	#endif
	81
	82	unsigned int
	83	get_stab_string_offset (string, stabstr_secname)
	84	const char *string;
	85	const char *stabstr_secname;
	86	{
	87	unsigned int length;
	88	unsigned int retval;
	89	segT save_seg;
	90	subsegT save_subseg;
	91	segT seg;
	92	char *p;
	93
	94	if (! SEPARATE_STAB_SECTIONS)
	95	abort ();
	96
	97	length = strlen (string);
	98
	99	save_seg = now_seg;
	100	save_subseg = now_subseg;
101
102	/* Create the stab string section. */
103	seg = subseg_new (stabstr_secname, 0);
104
105	retval = seg_info (seg)->stabu.stab_string_size;
106	if (retval <= 0)
107	{
108	/* Make sure the first string is empty. */
109	p = frag_more (1);
110	*p = 0;
111	retval = seg_info (seg)->stabu.stab_string_size = 1;
112	#ifdef BFD_ASSEMBLER
113	bfd_set_section_flags (stdoutput, seg, SEC_READONLY \| SEC_DEBUGGING);
114	if (seg->name == stabstr_secname)
115	seg->name = xstrdup (stabstr_secname);
116	#endif
117	}
118
119	if (length > 0)
f0e652b4	120	{ /* Ordinary case. */
252b5132 RH	121	p = frag_more (length + 1);
	122	strcpy (p, string);
	123
	124	seg_info (seg)->stabu.stab_string_size += length + 1;
	125	}
	126	else
	127	retval = 0;
	128
	129	subseg_set (save_seg, save_subseg);
	130
	131	return retval;
	132	}
	133
	134	#ifdef AOUT_STABS
	135	#ifndef OBJ_PROCESS_STAB
	136	#define OBJ_PROCESS_STAB(SEG,W,S,T,O,D) aout_process_stab(W,S,T,O,D)
	137	#endif
	138
0aa5d426 HPN	139	/* Here instead of obj-aout.c because other formats use it too. */
0aa5d426 HPN	140	void
252b5132 RH	141	aout_process_stab (what, string, type, other, desc)
	142	int what;
	143	const char *string;
	144	int type, other, desc;
	145	{
	146	/* Put the stab information in the symbol table. */
	147	symbolS *symbol;
	148
	149	/* Create the symbol now, but only insert it into the symbol chain
	150	after any symbols mentioned in the value expression get into the
	151	symbol chain. This is to avoid "continuation symbols" (where one
	152	ends in "\" and the debug info is continued in the next .stabs
	153	directive) from being separated by other random symbols. */
	154	symbol = symbol_create (string, undefined_section, 0,
	155	(struct frag *) NULL);
	156	if (what == 's' \|\| what == 'n')
	157	{
	158	/* Pick up the value from the input line. */
49309057	159	symbol_set_frag (symbol, &zero_address_frag);
252b5132 RH	160	pseudo_set (symbol);
	161	}
	162	else
	163	{
	164	/* .stabd sets the name to NULL. Why? */
	165	S_SET_NAME (symbol, NULL);
49309057	166	symbol_set_frag (symbol, frag_now);
252b5132 RH	167	S_SET_VALUE (symbol, (valueT) frag_now_fix ());
	168	}
	169
	170	symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);
	171
	172	S_SET_TYPE (symbol, type);
	173	S_SET_OTHER (symbol, other);
	174	S_SET_DESC (symbol, desc);
	175	}
	176	#endif
	177
	178	/* This can handle different kinds of stabs (s,n,d) and different
f0e652b4	179	kinds of stab sections. */
252b5132	180
f0e652b4	181	static void
252b5132 RH	182	s_stab_generic (what, stab_secname, stabstr_secname)
	183	int what;
	184	char *stab_secname;
	185	char *stabstr_secname;
	186	{
	187	long longint;
	188	char *string;
	189	int type;
	190	int other;
	191	int desc;
	192
	193	/* The general format is:
	194	.stabs "STRING",TYPE,OTHER,DESC,VALUE
	195	.stabn TYPE,OTHER,DESC,VALUE
	196	.stabd TYPE,OTHER,DESC
	197	At this point input_line_pointer points after the pseudo-op and
	198	any trailing whitespace. The argument what is one of 's', 'n' or
	199	'd' indicating which type of .stab this is. */
	200
	201	if (what != 's')
	202	string = "";
	203	else
	204	{
	205	int length;
	206
	207	string = demand_copy_C_string (&length);
	208	SKIP_WHITESPACE ();
	209	if (*input_line_pointer == ',')
	210	input_line_pointer++;
	211	else
	212	{
	213	as_warn (_(".stabs: Missing comma"));
	214	ignore_rest_of_line ();
	215	return;
	216	}
	217	}
	218
	219	if (get_absolute_expression_and_terminator (&longint) != ',')
	220	{
	221	as_warn (_(".stab%c: Missing comma"), what);
	222	ignore_rest_of_line ();
	223	return;
	224	}
	225	type = longint;
	226
	227	if (get_absolute_expression_and_terminator (&longint) != ',')
	228	{
	229	as_warn (_(".stab%c: Missing comma"), what);
	230	ignore_rest_of_line ();
	231	return;
	232	}
	233	other = longint;
	234
	235	desc = get_absolute_expression ();
	236	if (what == 's' \|\| what == 'n')
	237	{
	238	if (*input_line_pointer != ',')
	239	{
	240	as_warn (_(".stab%c: Missing comma"), what);
	241	ignore_rest_of_line ();
	242	return;
	243	}
	244	input_line_pointer++;
	245	SKIP_WHITESPACE ();
246	}
247
248	#ifdef TC_PPC
249	#ifdef OBJ_ELF
250	/* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
251	given 4 arguments, make it a .stabn */
252	else if (what == 'd')
253	{
254	char *save_location = input_line_pointer;
255
256	SKIP_WHITESPACE ();
257	if (*input_line_pointer == ',')
258	{
259	input_line_pointer++;
260	what = 'n';
261	}
262	else
263	input_line_pointer = save_location;
264	}
265	#endif /* OBJ_ELF */
266	#endif /* TC_PPC */
267
268	#ifndef NO_LISTING
269	if (listing)
270	{
271	switch (type)
272	{
273	case N_SLINE:
274	listing_source_line ((unsigned int) desc);
275	break;
276	case N_SO:
277	case N_SOL:
278	listing_source_file (string);
279	break;
280	}
281	}
282	#endif /* ! NO_LISTING */
283
284	/* We have now gathered the type, other, and desc information. For
285	.stabs or .stabn, input_line_pointer is now pointing at the
286	value. */
287
288	if (SEPARATE_STAB_SECTIONS)
289	/* Output the stab information in a separate section. This is used
290	at least for COFF and ELF. */
291	{
292	segT saved_seg = now_seg;
293	subsegT saved_subseg = now_subseg;
294	fragS *saved_frag = frag_now;
295	valueT dot;
296	segT seg;
297	unsigned int stroff;
298	char *p;
299
300	static segT cached_sec;
301	static char *cached_secname;
302
303	dot = frag_now_fix ();
304
305	#ifdef md_flush_pending_output
306	md_flush_pending_output ();
307	#endif
308
309	if (cached_secname && !strcmp (cached_secname, stab_secname))
310	{
311	seg = cached_sec;
312	subseg_set (seg, 0);
313	}
314	else
315	{
316	seg = subseg_new (stab_secname, 0);
317	if (cached_secname)
318	free (cached_secname);
319	cached_secname = xstrdup (stab_secname);
320	cached_sec = seg;
321	}
322
323	if (! seg_info (seg)->hadone)
324	{
325	#ifdef BFD_ASSEMBLER
326	bfd_set_section_flags (stdoutput, seg,
327	SEC_READONLY \| SEC_RELOC \| SEC_DEBUGGING);
328	#endif
329	#ifdef INIT_STAB_SECTION
330	INIT_STAB_SECTION (seg);
331	#endif
332	seg_info (seg)->hadone = 1;
333	}
334
335	stroff = get_stab_string_offset (string, stabstr_secname);
336	if (what == 's')
337	{
338	/* release the string */
339	obstack_free (&notes, string);
340	}
341
342	/* At least for now, stabs in a special stab section are always
343	output as 12 byte blocks of information. */
344	p = frag_more (8);
345	md_number_to_chars (p, (valueT) stroff, 4);
346	md_number_to_chars (p + 4, (valueT) type, 1);
347	md_number_to_chars (p + 5, (valueT) other, 1);
348	md_number_to_chars (p + 6, (valueT) desc, 2);
349
350	if (what == 's' \|\| what == 'n')
351	{
352	/* Pick up the value from the input line. */
353	cons (4);
354	input_line_pointer--;
355	}
356	else
357	{
358	const char *fake;
359	symbolS *symbol;
360	expressionS exp;
361
362	/* Arrange for a value representing the current location. */
363	fake = FAKE_LABEL_NAME;
364	symbol = symbol_new (fake, saved_seg, dot, saved_frag);
365
366	exp.X_op = O_symbol;
367	exp.X_add_symbol = symbol;
368	exp.X_add_number = 0;
369
370	emit_expr (&exp, 4);
371	}
372
373	#ifdef OBJ_PROCESS_STAB
374	OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
375	#endif
376
377	subseg_set (saved_seg, saved_subseg);
378	}
379	else
380	{
381	#ifdef OBJ_PROCESS_STAB
382	OBJ_PROCESS_STAB (0, what, string, type, other, desc);
383	#else
384	abort ();
385	#endif
386	}
387
388	demand_empty_rest_of_line ();
389	}
390
f0e652b4	391	/* Regular stab directive. */
252b5132 RH	392
	393	void
	394	s_stab (what)
	395	int what;
	396	{
	397	s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
	398	}
	399
f0e652b4	400	/* "Extended stabs", used in Solaris only now. */
252b5132 RH	401
	402	void
	403	s_xstab (what)
	404	int what;
	405	{
	406	int length;
	407	char stab_secname, stabstr_secname;
	408	static char saved_secname, saved_strsecname;
	409
	410	/* @@ MEMORY LEAK: This allocates a copy of the string, but in most
	411	cases it will be the same string, so we could release the storage
	412	back to the obstack it came from. */
	413	stab_secname = demand_copy_C_string (&length);
	414	SKIP_WHITESPACE ();
	415	if (*input_line_pointer == ',')
	416	input_line_pointer++;
	417	else
	418	{
	419	as_bad (_("comma missing in .xstabs"));
	420	ignore_rest_of_line ();
	421	return;
	422	}
	423
	424	/* To get the name of the stab string section, simply add "str" to
	425	the stab section name. */
	426	if (saved_secname == 0 \|\| strcmp (saved_secname, stab_secname))
	427	{
	428	stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
	429	strcpy (stabstr_secname, stab_secname);
	430	strcat (stabstr_secname, "str");
	431	if (saved_secname)
	432	{
	433	free (saved_secname);
	434	free (saved_strsecname);
	435	}
	436	saved_secname = stab_secname;
	437	saved_strsecname = stabstr_secname;
	438	}
	439	s_stab_generic (what, saved_secname, saved_strsecname);
	440	}
	441
	442	#ifdef S_SET_DESC
	443
	444	/* Frob invented at RMS' request. Set the n_desc of a symbol. */
	445
f0e652b4	446	void
252b5132	447	s_desc (ignore)
0aa5d426	448	int ignore ATTRIBUTE_UNUSED;
252b5132 RH	449	{
	450	char *name;
	451	char c;
	452	char *p;
	453	symbolS *symbolP;
	454	int temp;
	455
	456	name = input_line_pointer;
	457	c = get_symbol_end ();
	458	p = input_line_pointer;
	459	*p = c;
	460	SKIP_WHITESPACE ();
	461	if (*input_line_pointer != ',')
	462	{
	463	*p = 0;
	464	as_bad (_("Expected comma after name \"%s\""), name);
	465	*p = c;
	466	ignore_rest_of_line ();
	467	}
	468	else
	469	{
	470	input_line_pointer++;
	471	temp = get_absolute_expression ();
	472	*p = 0;
	473	symbolP = symbol_find_or_make (name);
	474	*p = c;
	475	S_SET_DESC (symbolP, temp);
	476	}
	477	demand_empty_rest_of_line ();
	478	} /* s_desc() */
	479
	480	#endif /* defined (S_SET_DESC) */
	481
	482	/* Generate stabs debugging information to denote the main source file. */
	483
	484	void
	485	stabs_generate_asm_file ()
	486	{
	487	char *file;
	488	unsigned int lineno;
	489
	490	as_where (&file, &lineno);
	491	generate_asm_file (N_SO, file);
	492	}
	493
	494	/* Generate stabs debugging information to denote the source file.
	495	TYPE is one of N_SO, N_SOL. */
	496
	497	static void
	498	generate_asm_file (type, file)
	499	int type;
	500	char *file;
	501	{
	502	static char *last_file;
	503	static int label_count;
	504	char *hold;
252b5132	505	char sym[30];
604d524f NC	506	char *buf;
	507	char *tmp = file;
	508	char *endp = file + strlen (file);
	509	char *bufp = buf;
43ad3147	510
604d524f NC	511	if (last_file != NULL
	512	&& strcmp (last_file, file) == 0)
	513	return;
43ad3147	514
252b5132 RH	515	/* Rather than try to do this in some efficient fashion, we just
	516	generate a string and then parse it again. That lets us use the
	517	existing stabs hook, which expect to see a string, rather than
	518	inventing new ones. */
252b5132 RH	519	hold = input_line_pointer;
252b5132 RH	520
604d524f NC	521	sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
	522	++label_count;
	523
	524	/* Allocate enough space for the file name (possibly extended with
	525	doubled up backslashes), the symbol name, and the other characters
	526	that make up a stabs file directive. */
	527	bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12);
43ad3147	528
604d524f NC	529	*bufp++ = '"';
	530
	531	while (tmp < endp)
252b5132	532	{
604d524f NC	533	char *bslash = strchr (tmp, '\\');
604d524f NC	534	int len = (bslash ? (bslash - tmp + 1) : strlen (tmp));
43ad3147	535
604d524f NC	536	/* Double all backslashes, since demand_copy_C_string (used by
	537	s_stab to extract the part in quotes) will try to replace them as
	538	escape sequences. backslash may appear in a filespec. */
	539	strncpy (bufp, tmp, len);
43ad3147	540
604d524f NC	541	tmp += len;
	542	bufp += len;
	543
	544	if (bslash != NULL)
	545	*bufp++ = '\\';
252b5132 RH	546	}
252b5132 RH	547
604d524f NC	548	sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
	549
	550	input_line_pointer = buf;
	551	s_stab ('s');
	552	colon (sym);
	553
	554	if (last_file != NULL)
	555	free (last_file);
	556	last_file = xstrdup (file);
43ad3147	557
210dcc61	558	free (buf);
604d524f NC	559
604d524f NC	560	input_line_pointer = hold;
252b5132 RH	561	}
	562
	563	/* Generate stabs debugging information for the current line. This is
	564	used to produce debugging information for an assembler file. */
	565
	566	void
	567	stabs_generate_asm_lineno ()
	568	{
	569	static int label_count;
	570	char *hold;
	571	char *file;
	572	unsigned int lineno;
	573	char *buf;
	574	char sym[30];
	575
bccba5f0 NC	576	/* Let the world know that we are in the middle of generating a
	577	piece of stabs line debugging information. */
	578	outputting_stabs_line_debug = 1;
	579
252b5132 RH	580	/* Rather than try to do this in some efficient fashion, we just
	581	generate a string and then parse it again. That lets us use the
	582	existing stabs hook, which expect to see a string, rather than
	583	inventing new ones. */
	584
	585	hold = input_line_pointer;
	586
	587	as_where (&file, &lineno);
	588
	589	generate_asm_file (N_SOL, file);
	590
	591	sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
	592	++label_count;
	593
	594	if (in_dot_func_p)
	595	{
	596	buf = (char *) alloca (100 + strlen (current_function_label));
	597	sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
	598	sym, current_function_label);
	599	}
	600	else
	601	{
	602	buf = (char *) alloca (100);
	603	sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
	604	}
	605	input_line_pointer = buf;
	606	s_stab ('n');
	607	colon (sym);
	608
	609	input_line_pointer = hold;
bccba5f0	610	outputting_stabs_line_debug = 0;
252b5132 RH	611	}
	612
	613	/* Emit a function stab.
	614	All assembler functions are assumed to have return type `void'. */
	615
	616	void
	617	stabs_generate_asm_func (funcname, startlabname)
	618	const char *funcname;
	619	const char *startlabname;
	620	{
	621	static int void_emitted_p;
	622	char *hold = input_line_pointer;
	623	char *buf;
	624	char *file;
	625	unsigned int lineno;
	626
	627	if (! void_emitted_p)
	628	{
	629	input_line_pointer = "\"void:t1=1\",128,0,0,0";
	630	s_stab ('s');
	631	void_emitted_p = 1;
	632	}
	633
	634	as_where (&file, &lineno);
	635	asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
	636	funcname, N_FUN, lineno + 1, startlabname);
	637	input_line_pointer = buf;
	638	s_stab ('s');
	639	free (buf);
	640
	641	input_line_pointer = hold;
	642	current_function_label = xstrdup (startlabname);
	643	in_dot_func_p = 1;
	644	}
	645
	646	/* Emit a stab to record the end of a function. */
	647
	648	void
	649	stabs_generate_asm_endfunc (funcname, startlabname)
ab9da554	650	const char *funcname ATTRIBUTE_UNUSED;
252b5132 RH	651	const char *startlabname;
	652	{
	653	static int label_count;
	654	char *hold = input_line_pointer;
	655	char *buf;
	656	char sym[30];
	657
	658	sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
	659	++label_count;
	660	colon (sym);
	661
	662	asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname);
	663	input_line_pointer = buf;
	664	s_stab ('s');
	665	free (buf);
	666
	667	input_line_pointer = hold;
	668	in_dot_func_p = 0;
	669	current_function_label = NULL;
	670	}