/* Generic stabs parsing for gas.
- Copyright 1989, 1990, 1991, 1993, 1995, 1996, 1997, 1998, 2000, 2001
- Free Software Foundation, Inc.
+ Copyright (C) 1989-2019 Free Software Foundation, Inc.
-This file is part of GAS, the GNU Assembler.
+ 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 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 3,
+ 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.
+ 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. */
+ 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, 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#include "as.h"
+#include "filenames.h"
#include "obstack.h"
#include "subsegs.h"
#include "ecoff.h"
int outputting_stabs_line_debug = 0;
-static void s_stab_generic (int, char *, char *);
-static void generate_asm_file (int, char *);
+static void generate_asm_file (int, const char *);
/* Allow backends to override the names used for the stab sections. */
#ifndef STAB_SECTION_NAME
#define STAB_STRING_SECTION_NAME ".stabstr"
#endif
-/* Non-zero if we're in the middle of a .func function, in which case
+/* True 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;
+static bfd_boolean in_dot_func_p = FALSE;
-/* Label at start of current function if in_dot_func_p != 0. */
+/* Label at start of current function if in_dot_func_p != FALSE. */
static const char *current_function_label;
/*
#endif
unsigned int
-get_stab_string_offset (const char *string, const char *stabstr_secname)
+get_stab_string_offset (const char *string, const char *stabstr_secname,
+ bfd_boolean free_stabstr_secname)
{
unsigned int length;
unsigned int retval;
save_seg = now_seg;
save_subseg = now_subseg;
- /* Create the stab string section. */
+ /* Create the stab string section, if it doesn't already exist. */
seg = subseg_new (stabstr_secname, 0);
+ if (free_stabstr_secname && seg->name != stabstr_secname)
+ free ((char *) stabstr_secname);
retval = seg_info (seg)->stabu.stab_string_size;
if (retval <= 0)
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
+ bfd_set_section_flags (seg, SEC_READONLY | SEC_DEBUGGING);
}
if (length > 0)
/* 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;
+aout_process_stab (int what, const char *string, int type, int other, int desc)
{
/* Put the stab information in the symbol table. */
symbolS *symbol;
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);
+ &zero_address_frag);
if (what == 's' || what == 'n')
{
/* Pick up the value from the input line. */
- symbol_set_frag (symbol, &zero_address_frag);
pseudo_set (symbol);
}
else
symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);
+ symbol_get_bfdsym (symbol)->flags |= BSF_DEBUGGING;
+
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. */
+ kinds of stab sections. If STAB_SECNAME_OBSTACK_END is non-NULL,
+ then STAB_SECNAME and STABSTR_SECNAME will be freed if possible
+ before this function returns (the former by obstack_free). */
static void
-s_stab_generic (int what, char *stab_secname, char *stabstr_secname)
+s_stab_generic (int what,
+ const char *stab_secname,
+ const char *stabstr_secname,
+ const char *stab_secname_obstack_end)
{
long longint;
- char *string, *saved_string_obstack_end;
+ const char *string;
+ char *saved_string_obstack_end;
int type;
int other;
int desc;
int length;
string = demand_copy_C_string (&length);
+ if (string == NULL)
+ {
+ as_warn (_(".stab%c: missing string"), what);
+ ignore_rest_of_line ();
+ return;
+ }
/* FIXME: We should probably find some other temporary storage
for string, rather than leaking memory if someone else
happens to use the notes obstack. */
- saved_string_obstack_end = notes.next_free;
+ saved_string_obstack_end = obstack_next_free (¬es);
SKIP_WHITESPACE ();
if (*input_line_pointer == ',')
input_line_pointer++;
char *p;
static segT cached_sec;
- static char *cached_secname;
dot = frag_now_fix ();
md_flush_pending_output ();
#endif
- if (cached_secname && !strcmp (cached_secname, stab_secname))
+ if (cached_sec && strcmp (cached_sec->name, stab_secname) == 0)
{
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,
+ bfd_set_section_flags (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, if nobody else has used the obstack. */
- if (saved_string_obstack_end == notes.next_free)
- obstack_free (¬es, string);
- }
+ stroff = get_stab_string_offset (string, stabstr_secname,
+ stab_secname_obstack_end != NULL);
+
+ /* Release the string, if nobody else has used the obstack. */
+ if (saved_string_obstack_end != NULL
+ && saved_string_obstack_end == obstack_next_free (¬es))
+ obstack_free (¬es, string);
+ /* Similarly for the section name. This must be done before
+ creating symbols below, which uses the notes obstack. */
+ if (seg->name != stab_secname
+ && stab_secname_obstack_end != NULL
+ && stab_secname_obstack_end == obstack_next_free (¬es))
+ obstack_free (¬es, stab_secname);
/* At least for now, stabs in a special stab section are always
output as 12 byte blocks of information. */
}
else
{
+ if (stab_secname_obstack_end != NULL)
+ {
+ free ((char *) stabstr_secname);
+ if (stab_secname_obstack_end == obstack_next_free (¬es))
+ obstack_free (¬es, stab_secname);
+ }
#ifdef OBJ_PROCESS_STAB
OBJ_PROCESS_STAB (0, what, string, type, other, desc);
#else
void
s_stab (int what)
{
- s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
+ s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME, NULL);
}
/* "Extended stabs", used in Solaris only now. */
s_xstab (int what)
{
int length;
- char *stab_secname, *stabstr_secname;
- static char *saved_secname, *saved_strsecname;
+ char *stab_secname, *stabstr_secname, *stab_secname_obstack_end;
- /* @@ 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);
+ stab_secname_obstack_end = obstack_next_free (¬es);
SKIP_WHITESPACE ();
if (*input_line_pointer == ',')
input_line_pointer++;
/* 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);
+ stabstr_secname = concat (stab_secname, "str", (char *) NULL);
+ s_stab_generic (what, stab_secname, stabstr_secname,
+ stab_secname_obstack_end);
}
#ifdef S_SET_DESC
/* Frob invented at RMS' request. Set the n_desc of a symbol. */
void
-s_desc (ignore)
- int ignore ATTRIBUTE_UNUSED;
+s_desc (int ignore ATTRIBUTE_UNUSED)
{
char *name;
char c;
symbolS *symbolP;
int temp;
- name = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (&name);
p = input_line_pointer;
*p = c;
- SKIP_WHITESPACE ();
+ SKIP_WHITESPACE_AFTER_NAME ();
if (*input_line_pointer != ',')
{
*p = 0;
void
stabs_generate_asm_file (void)
{
- char *file;
+ const char *file;
unsigned int lineno;
- as_where (&file, &lineno);
+ file = as_where (&lineno);
if (use_gnu_debug_info_extensions)
{
- char *dir, *dir2;
+ const char *dir;
+ char *dir2;
- dir = getpwd ();
- dir2 = alloca (strlen (dir) + 2);
- sprintf (dir2, "%s%s", dir, "/");
+ dir = remap_debug_filename (getpwd ());
+ dir2 = concat (dir, "/", NULL);
generate_asm_file (N_SO, dir2);
+ free (dir2);
+ xfree ((char *) dir);
}
generate_asm_file (N_SO, file);
}
TYPE is one of N_SO, N_SOL. */
static void
-generate_asm_file (int type, char *file)
+generate_asm_file (int type, const 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;
+ const char *tmp = file;
+ const char *file_endp = file + strlen (file);
+ char *bufp;
if (last_file != NULL
- && strcmp (last_file, file) == 0)
+ && filename_cmp (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 = buf = XNEWVEC (char, 2 * strlen (file) + strlen (sym) + 12);
*bufp++ = '"';
- while (tmp < endp)
+ while (tmp < file_endp)
{
- char *bslash = strchr (tmp, '\\');
- size_t len = (bslash) ? (size_t) (bslash - tmp + 1) : strlen (tmp);
+ const char *bslash = strchr (tmp, '\\');
+ size_t len = bslash != NULL ? bslash - tmp + 1 : file_endp - 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);
+ memcpy (bufp, tmp, len);
tmp += len;
bufp += len;
sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
- input_line_pointer = buf;
+ temp_ilp (buf);
s_stab ('s');
+ restore_ilp ();
+
colon (sym);
if (last_file != NULL)
last_file = xstrdup (file);
free (buf);
-
- input_line_pointer = hold;
}
/* Generate stabs debugging information for the current line. This is
stabs_generate_asm_lineno (void)
{
static int label_count;
- char *hold;
- char *file;
+ const char *file;
unsigned int lineno;
char *buf;
char sym[30];
existing stabs hook, which expect to see a string, rather than
inventing new ones. */
- hold = input_line_pointer;
-
- as_where (&file, &lineno);
+ file = as_where (&lineno);
/* Don't emit sequences of stabs for the same line. */
if (prev_file == NULL)
{
- /* First time thru. */
+ /* First time through. */
prev_file = xstrdup (file);
prev_lineno = lineno;
}
else if (lineno == prev_lineno
- && strcmp (file, prev_file) == 0)
+ && filename_cmp (file, prev_file) == 0)
{
/* Same file/line as last time. */
return;
{
/* Remember file/line for next time. */
prev_lineno = lineno;
- if (strcmp (file, prev_file) != 0)
+ if (filename_cmp (file, prev_file) != 0)
{
free (prev_file);
prev_file = xstrdup (file);
if (in_dot_func_p)
{
- buf = (char *) alloca (100 + strlen (current_function_label));
+ buf = XNEWVEC (char, 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);
+ buf = XNEWVEC (char, 100);
sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
}
- input_line_pointer = buf;
+
+ temp_ilp (buf);
s_stab ('n');
+ restore_ilp ();
+
colon (sym);
- input_line_pointer = hold;
outputting_stabs_line_debug = 0;
+ free (buf);
}
/* Emit a function stab.
void
stabs_generate_asm_func (const char *funcname, const char *startlabname)
{
- static int void_emitted_p;
- char *hold = input_line_pointer;
+ static bfd_boolean void_emitted_p = FALSE;
char *buf;
- char *file;
unsigned int lineno;
if (! void_emitted_p)
{
- input_line_pointer = "\"void:t1=1\",128,0,0,0";
+ temp_ilp ((char *) "\"void:t1=1\",128,0,0,0");
s_stab ('s');
- void_emitted_p = 1;
+ restore_ilp ();
+ void_emitted_p = TRUE;
}
- as_where (&file, &lineno);
- asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
- funcname, N_FUN, lineno + 1, startlabname);
- input_line_pointer = buf;
+ as_where (&lineno);
+ if (asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
+ funcname, N_FUN, lineno + 1, startlabname) == -1)
+ as_fatal ("%s", xstrerror (errno));
+
+ temp_ilp (buf);
s_stab ('s');
+ restore_ilp ();
free (buf);
- input_line_pointer = hold;
current_function_label = xstrdup (startlabname);
- in_dot_func_p = 1;
+ in_dot_func_p = TRUE;
}
/* Emit a stab to record the end of a function. */
const char *startlabname)
{
static int label_count;
- char *hold = input_line_pointer;
char *buf;
char sym[30];
++label_count;
colon (sym);
- asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname);
- input_line_pointer = buf;
+ if (asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname) == -1)
+ as_fatal ("%s", xstrerror (errno));
+
+ temp_ilp (buf);
s_stab ('s');
+ restore_ilp ();
free (buf);
- input_line_pointer = hold;
- in_dot_func_p = 0;
+ in_dot_func_p = FALSE;
current_function_label = NULL;
}