[binutils.git] / gas / stabs.c

/* Generic stabs parsing for gas.
   Copyright (C) 1989, 1990, 1991, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */

#include "as.h"
#include "libiberty.h"
#include "obstack.h"
#include "subsegs.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"

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

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

  if (! SEPARATE_STAB_SECTIONS)
    abort ();

  retval = 0;
  length = strlen (string);
  if (length > 0)
    {				/* Ordinary case. */
      segT save_seg;
      subsegT save_subseg;
      segT seg;
      char *p;

      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
	}

      p = frag_more (length + 1);
      strcpy (p, string);

      seg_info (seg)->stabu.stab_string_size += length + 1;

      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

static 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->sy_frag = &zero_address_frag;
      pseudo_set (symbol);
    }
  else
    {
      /* .stabd sets the name to NULL.  Why?  */
      S_SET_NAME (symbol, NULL);
      symbol->sy_frag = 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 takes 4 arguments, so emulate it.  */
  else if (what == 'd')
    {
      char *save_location = input_line_pointer;

      SKIP_WHITESPACE ();
      if (*input_line_pointer == ',')
	{
	  int dummy;

	  input_line_pointer++;
	  SKIP_WHITESPACE ();

	  dummy = get_absolute_expression ();
	  if (dummy != 0)
	    {
	      as_warn (".stabd: Fourth field must be 0");
	      ignore_rest_of_line ();
	      return;
	    }
	  SKIP_WHITESPACE ();
	}
      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 ();

      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;
{
  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) */
Commit	Line	Data
625f4e48 KR	1	/* Generic stabs parsing for gas.
	2	Copyright (C) 1989, 1990, 1991, 1993 Free Software Foundation, Inc.
	3
	4	This file is part of GAS, the GNU Assembler.
	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
	8	published by the Free Software Foundation; either version 2,
	9	or (at your option) any later version.
	10
	11	GAS is distributed in the hope that it will be useful, but
	12	WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	14	the GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public
	17	License along with GAS; see the file COPYING. If not, write
	18	to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "as.h"
c7a89bde	21	#include "libiberty.h"
625f4e48 KR	22	#include "obstack.h"
	23	#include "subsegs.h"
	24
	25	/* We need this, despite the apparent object format dependency, since
	26	it defines stab types, which all object formats can use now. */
	27
	28	#include "aout/stab_gnu.h"
	29
	30	/* Allow backends to override the names used for the stab sections. */
	31	#ifndef STAB_SECTION_NAME
	32	#define STAB_SECTION_NAME ".stab"
	33	#endif
	34
	35	#ifndef STAB_STRING_SECTION_NAME
	36	#define STAB_STRING_SECTION_NAME ".stabstr"
	37	#endif
	38
	39	/*
	40	* Handle .stabX directives, which used to be open-coded.
	41	* So much creeping featurism overloaded the semantics that we decided
	42	* to put all .stabX thinking in one place. Here.
	43	*
	44	* We try to make any .stabX directive legal. Other people's AS will often
	45	* do assembly-time consistency checks: eg assigning meaning to n_type bits
	46	* and "protecting" you from setting them to certain values. (They also zero
	47	* certain bits before emitting symbols. Tut tut.)
	48	*
	49	* If an expression is not absolute we either gripe or use the relocation
	50	* information. Other people's assemblers silently forget information they
	51	* don't need and invent information they need that you didn't supply.
	52	*/
	53
	54	/*
	55	* Build a string dictionary entry for a .stabX symbol.
	56	* The symbol is added to the .<secname>str section.
	57	*/
	58
	59	#ifndef SEPARATE_STAB_SECTIONS
	60	#define SEPARATE_STAB_SECTIONS 0
	61	#endif
	62
	63	unsigned int
	64	get_stab_string_offset (string, stabstr_secname)
	65	const char *string;
	66	const char *stabstr_secname;
	67	{
	68	unsigned int length;
	69	unsigned int retval;
	70
	71	if (! SEPARATE_STAB_SECTIONS)
	72	abort ();
	73
	74	retval = 0;
	75	length = strlen (string);
	76	if (length > 0)
	77	{ /* Ordinary case. */
	78	segT save_seg;
	79	subsegT save_subseg;
625f4e48 KR	80	segT seg;
	81	char *p;
	82
	83	save_seg = now_seg;
	84	save_subseg = now_subseg;
	85
	86	/* Create the stab string section. */
c7a89bde	87	seg = subseg_new (stabstr_secname, 0);
625f4e48 KR	88
625f4e48 KR	89	retval = seg_info (seg)->stabu.stab_string_size;
c7a89bde	90	if (retval <= 0)
625f4e48 KR	91	{
	92	/* Make sure the first string is empty. */
	93	p = frag_more (1);
	94	*p = 0;
	95	retval = seg_info (seg)->stabu.stab_string_size = 1;
	96	#ifdef BFD_ASSEMBLER
	97	bfd_set_section_flags (stdoutput, seg, SEC_READONLY \| SEC_DEBUGGING);
c7a89bde ILT	98	if (seg->name == stabstr_secname)
c7a89bde ILT	99	seg->name = xstrdup (stabstr_secname);
625f4e48 KR	100	#endif
	101	}
	102
	103	p = frag_more (length + 1);
	104	strcpy (p, string);
	105
	106	seg_info (seg)->stabu.stab_string_size += length + 1;
	107
	108	subseg_set (save_seg, save_subseg);
	109	}
	110
	111	return retval;
	112	}
	113
	114	#ifdef AOUT_STABS
	115	#ifndef OBJ_PROCESS_STAB
	116	#define OBJ_PROCESS_STAB(SEG,W,S,T,O,D) aout_process_stab(W,S,T,O,D)
	117	#endif
	118
	119	static void
	120	aout_process_stab (what, string, type, other, desc)
	121	int what;
	122	const char *string;
	123	int type, other, desc;
	124	{
	125	/* Put the stab information in the symbol table. */
	126	symbolS *symbol;
	127
	128	/* Create the symbol now, but only insert it into the symbol chain
	129	after any symbols mentioned in the value expression get into the
	130	symbol chain. This is to avoid "continuation symbols" (where one
	131	ends in "\" and the debug info is continued in the next .stabs
	132	directive) from being separated by other random symbols. */
	133	symbol = symbol_create (string, undefined_section, 0,
	134	(struct frag *) NULL);
	135	if (what == 's' \|\| what == 'n')
	136	{
	137	/* Pick up the value from the input line. */
	138	symbol->sy_frag = &zero_address_frag;
	139	pseudo_set (symbol);
	140	}
	141	else
	142	{
	143	/* .stabd sets the name to NULL. Why? */
	144	S_SET_NAME (symbol, NULL);
	145	symbol->sy_frag = frag_now;
	146	S_SET_VALUE (symbol, (valueT) frag_now_fix ());
	147	}
	148
	149	symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);
	150
	151	S_SET_TYPE (symbol, type);
	152	S_SET_OTHER (symbol, other);
	153	S_SET_DESC (symbol, desc);
	154	}
	155	#endif
	156
	157	/* This can handle different kinds of stabs (s,n,d) and different
	158	kinds of stab sections. */
	159
	160	static void
	161	s_stab_generic (what, stab_secname, stabstr_secname)
	162	int what;
	163	char *stab_secname;
164	char *stabstr_secname;
165	{
166	long longint;
167	char *string;
168	int type;
169	int other;
170	int desc;
171
172	/* The general format is:
173	.stabs "STRING",TYPE,OTHER,DESC,VALUE
174	.stabn TYPE,OTHER,DESC,VALUE
175	.stabd TYPE,OTHER,DESC
176	At this point input_line_pointer points after the pseudo-op and
177	any trailing whitespace. The argument what is one of 's', 'n' or
178	'd' indicating which type of .stab this is. */
179
180	if (what != 's')
181	string = "";
182	else
183	{
184	int length;
185
186	string = demand_copy_C_string (&length);
187	SKIP_WHITESPACE ();
188	if (*input_line_pointer == ',')
189	input_line_pointer++;
190	else
191	{
192	as_warn (".stabs: Missing comma");
193	ignore_rest_of_line ();
194	return;
195	}
196	}
197
198	if (get_absolute_expression_and_terminator (&longint) != ',')
199	{
200	as_warn (".stab%c: Missing comma", what);
201	ignore_rest_of_line ();
202	return;
203	}
204	type = longint;
205
206	if (get_absolute_expression_and_terminator (&longint) != ',')
207	{
208	as_warn (".stab%c: Missing comma", what);
209	ignore_rest_of_line ();
210	return;
211	}
212	other = longint;
213
214	desc = get_absolute_expression ();
215	if (what == 's' \|\| what == 'n')
216	{
217	if (*input_line_pointer != ',')
218	{
219	as_warn (".stab%c: Missing comma", what);
220	ignore_rest_of_line ();
221	return;
222	}
223	input_line_pointer++;
224	SKIP_WHITESPACE ();
225	}
226
63cafcef MM	227	#ifdef TC_PPC
	228	#ifdef OBJ_ELF
	229	/* Solaris on PowerPC has decided that .stabd takes 4 arguments, so emulate it. */
	230	else if (what == 'd')
	231	{
	232	char *save_location = input_line_pointer;
	233
	234	SKIP_WHITESPACE ();
	235	if (*input_line_pointer == ',')
	236	{
	237	int dummy;
	238
	239	input_line_pointer++;
	240	SKIP_WHITESPACE ();
	241
	242	dummy = get_absolute_expression ();
	243	if (dummy != 0)
	244	{
	245	as_warn (".stabd: Fourth field must be 0");
	246	ignore_rest_of_line ();
	247	return;
	248	}
	249	SKIP_WHITESPACE ();
	250	}
	251	else
	252	input_line_pointer = save_location;
	253	}
	254	#endif /* OBJ_ELF */
	255	#endif /* TC_PPC */
	256
	257	#ifndef NO_LISTING
	258	if (listing)
	259	{
	260	switch (type)
	261	{
	262	case N_SLINE:
	263	listing_source_line ((unsigned int) desc);
	264	break;
	265	case N_SO:
	266	case N_SOL:
	267	listing_source_file (string);
	268	break;
	269	}
	270	}
	271	#endif /* ! NO_LISTING */
	272
625f4e48 KR	273	/* We have now gathered the type, other, and desc information. For
	274	.stabs or .stabn, input_line_pointer is now pointing at the
	275	value. */
	276
	277	if (SEPARATE_STAB_SECTIONS)
	278	/* Output the stab information in a separate section. This is used
	279	at least for COFF and ELF. */
	280	{
	281	segT saved_seg = now_seg;
	282	subsegT saved_subseg = now_subseg;
	283	fragS *saved_frag = frag_now;
	284	valueT dot;
	285	segT seg;
	286	unsigned int stroff;
	287	char *p;
	288
c7a89bde ILT	289	static segT cached_sec;
	290	static char *cached_secname;
	291
625f4e48 KR	292	dot = frag_now_fix ();
625f4e48 KR	293
c7a89bde ILT	294	if (cached_secname && !strcmp (cached_secname, stab_secname))
	295	{
	296	seg = cached_sec;
	297	subseg_set (seg, 0);
	298	}
	299	else
	300	{
	301	seg = subseg_new (stab_secname, 0);
	302	if (cached_secname)
	303	free (cached_secname);
	304	cached_secname = xstrdup (stab_secname);
	305	cached_sec = seg;
	306	}
625f4e48 KR	307
	308	if (! seg_info (seg)->hadone)
	309	{
	310	#ifdef BFD_ASSEMBLER
	311	bfd_set_section_flags (stdoutput, seg,
	312	SEC_READONLY \| SEC_RELOC \| SEC_DEBUGGING);
	313	#endif
	314	#ifdef INIT_STAB_SECTION
	315	INIT_STAB_SECTION (seg);
	316	#endif
	317	seg_info (seg)->hadone = 1;
	318	}
	319
	320	stroff = get_stab_string_offset (string, stabstr_secname);
c7a89bde ILT	321	if (what == 's')
	322	{
	323	/* release the string */
	324	obstack_free (&notes, string);
	325	}
625f4e48 KR	326
	327	/* At least for now, stabs in a special stab section are always
	328	output as 12 byte blocks of information. */
	329	p = frag_more (8);
	330	md_number_to_chars (p, (valueT) stroff, 4);
	331	md_number_to_chars (p + 4, (valueT) type, 1);
	332	md_number_to_chars (p + 5, (valueT) other, 1);
	333	md_number_to_chars (p + 6, (valueT) desc, 2);
	334
	335	if (what == 's' \|\| what == 'n')
	336	{
	337	/* Pick up the value from the input line. */
	338	cons (4);
	339	input_line_pointer--;
	340	}
	341	else
	342	{
	343	const char *fake;
	344	symbolS *symbol;
	345	expressionS exp;
	346
	347	/* Arrange for a value representing the current location. */
	348	fake = FAKE_LABEL_NAME;
	349	symbol = symbol_new (fake, saved_seg, dot, saved_frag);
	350
	351	exp.X_op = O_symbol;
	352	exp.X_add_symbol = symbol;
	353	exp.X_add_number = 0;
	354
	355	emit_expr (&exp, 4);
	356	}
	357
	358	#ifdef OBJ_PROCESS_STAB
63cafcef	359	OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
625f4e48 KR	360	#endif
	361
	362	subseg_set (saved_seg, saved_subseg);
	363	}
	364	else
	365	{
	366	#ifdef OBJ_PROCESS_STAB
	367	OBJ_PROCESS_STAB (0, what, string, type, other, desc);
	368	#else
	369	abort ();
	370	#endif
	371	}
	372
625f4e48 KR	373	demand_empty_rest_of_line ();
	374	}
	375
	376	/* Regular stab directive. */
	377
	378	void
	379	s_stab (what)
	380	int what;
	381	{
	382	s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
	383	}
	384
	385	/* "Extended stabs", used in Solaris only now. */
	386
	387	void
	388	s_xstab (what)
	389	int what;
	390	{
	391	int length;
	392	char stab_secname, stabstr_secname;
c7a89bde	393	static char saved_secname, saved_strsecname;
625f4e48	394
c7a89bde ILT	395	/* @@ MEMORY LEAK: This allocates a copy of the string, but in most
	396	cases it will be the same string, so we could release the storage
	397	back to the obstack it came from. */
625f4e48 KR	398	stab_secname = demand_copy_C_string (&length);
	399	SKIP_WHITESPACE ();
	400	if (*input_line_pointer == ',')
	401	input_line_pointer++;
	402	else
	403	{
	404	as_bad ("comma missing in .xstabs");
	405	ignore_rest_of_line ();
	406	return;
	407	}
	408
	409	/* To get the name of the stab string section, simply add "str" to
	410	the stab section name. */
c7a89bde ILT	411	if (saved_secname == 0 \|\| strcmp (saved_secname, stab_secname))
	412	{
	413	stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
	414	strcpy (stabstr_secname, stab_secname);
	415	strcat (stabstr_secname, "str");
	416	if (saved_secname)
	417	{
	418	free (saved_secname);
	419	free (saved_strsecname);
	420	}
	421	saved_secname = stab_secname;
	422	saved_strsecname = stabstr_secname;
	423	}
	424	s_stab_generic (what, saved_secname, saved_strsecname);
625f4e48 KR	425	}
	426
	427	#ifdef S_SET_DESC
	428
	429	/* Frob invented at RMS' request. Set the n_desc of a symbol. */
	430
	431	void
	432	s_desc (ignore)
	433	int ignore;
	434	{
	435	char *name;
	436	char c;
	437	char *p;
	438	symbolS *symbolP;
	439	int temp;
	440
	441	name = input_line_pointer;
	442	c = get_symbol_end ();
	443	p = input_line_pointer;
	444	*p = c;
	445	SKIP_WHITESPACE ();
	446	if (*input_line_pointer != ',')
	447	{
	448	*p = 0;
	449	as_bad ("Expected comma after name \"%s\"", name);
	450	*p = c;
	451	ignore_rest_of_line ();
	452	}
	453	else
	454	{
	455	input_line_pointer++;
	456	temp = get_absolute_expression ();
	457	*p = 0;
	458	symbolP = symbol_find_or_make (name);
	459	*p = c;
	460	S_SET_DESC (symbolP, temp);
	461	}
	462	demand_empty_rest_of_line ();
	463	} /* s_desc() */
	464
	465	#endif /* defined (S_SET_DESC) */