[RFA 3/9] Return unique_xmalloc_ptr from macro scope functions

Tom Tromey
2018-02-07T22:04:44Z

This changes the macro scope functions (sal_macro_scope,
user_macro_scope, and default_macro_scope) to return a
unique_xmalloc_ptr, then fixes up the users. This allowed for the
removal of several cleanups.

2018-02-07 Tom Tromey <tom@tromey.com>

* symtab.c (default_collect_symbol_completion_matches_break_on):
Use unique_xmalloc_ptr.
* macroscope.h: (sal_macro_scope, user_macro_scope)
(default_macro_scope): Return unique_xmalloc_ptr.
* macroscope.c (sal_macro_scope, user_macro_scope)
(default_macro_scope): Return unique_xmalloc_ptr.
* macroexp.h (macro_expand, macro_expand_once): Return
unique_xmalloc_ptr.
* macroexp.c (macro_expand, macro_expand_once): Return
unique_xmalloc_ptr.
* macrocmd.c (macro_expand_command, macro_expand_once_command)
(info_macro_command, info_macros_command): Use
unique_xmalloc_ptr.
* compile/compile-c-support.c (write_macro_definitions): Use
unique_xmalloc_ptr.
* c-exp.y (c_parse): Use unique_xmalloc_ptr.
---
gdb/ChangeLog | 19 +++++++++++++++++++
gdb/c-exp.y | 24 +++++++++++-------------
gdb/compile/compile-c-support.c | 2 +-
gdb/macrocmd.c | 38 ++++++++++----------------------------
gdb/macroexp.c | 6 +++---
gdb/macroexp.h | 12 ++++++------
gdb/macroscope.c | 15 ++++++---------
gdb/macroscope.h | 15 ++++++---------
gdb/symtab.c | 9 +++------
9 files changed, 65 insertions(+), 75 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 00ed7e78c2..abb6126864 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,22 @@
+2018-02-07 Tom Tromey <tom@tromey.com>
+
+ * symtab.c (default_collect_symbol_completion_matches_break_on):
+ Use unique_xmalloc_ptr.
+ * macroscope.h: (sal_macro_scope, user_macro_scope)
+ (default_macro_scope): Return unique_xmalloc_ptr.
+ * macroscope.c (sal_macro_scope, user_macro_scope)
+ (default_macro_scope): Return unique_xmalloc_ptr.
+ * macroexp.h (macro_expand, macro_expand_once): Return
+ unique_xmalloc_ptr.
+ * macroexp.c (macro_expand, macro_expand_once): Return
+ unique_xmalloc_ptr.
+ * macrocmd.c (macro_expand_command, macro_expand_once_command)
+ (info_macro_command, info_macros_command): Use
+ unique_xmalloc_ptr.
+ * compile/compile-c-support.c (write_macro_definitions): Use
+ unique_xmalloc_ptr.
+ * c-exp.y (c_parse): Use unique_xmalloc_ptr.
+
2018-02-07 Simon Marchi <simon.marchi@ericsson.com>

* value.c (value_static_field): Assign field type instead of
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 8f0aa00f52..8dc3c068a5 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -3220,26 +3220,24 @@ c_parse (struct parser_state *par_state)
gdb_assert (par_state != NULL);
pstate = par_state;

- /* Note that parsing (within yyparse) freely installs cleanups
- assuming they'll be run here (below). */
-
- back_to = make_cleanup (free_current_contents, &expression_macro_scope);
-
- /* Set up the scope for macro expansion. */
- expression_macro_scope = NULL;
+ gdb::unique_xmalloc_ptr<struct macro_scope> macro_scope;

if (expression_context_block)
- expression_macro_scope
- = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+ macro_scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
else
- expression_macro_scope = default_macro_scope ();
- if (! expression_macro_scope)
- expression_macro_scope = user_macro_scope ();
+ macro_scope = default_macro_scope ();
+ if (! macro_scope)
+ macro_scope = user_macro_scope ();
+
+ scoped_restore restore_macro_scope
+ = make_scoped_restore (&expression_macro_scope, macro_scope.get ());

/* Initialize macro expansion code. */
obstack_init (&expansion_obstack);
gdb_assert (! macro_original_text);
- make_cleanup (scan_macro_cleanup, 0);
+ /* Note that parsing (within yyparse) freely installs cleanups
+ assuming they'll be run here (below). */
+ back_to = make_cleanup (scan_macro_cleanup, 0);

scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
parser_debug);
diff --git a/gdb/compile/compile-c-support.c b/gdb/compile/compile-c-support.c
index 006d3f811c..e694648288 100644
--- a/gdb/compile/compile-c-support.c
+++ b/gdb/compile/compile-c-support.c
@@ -157,7 +157,7 @@ static void
write_macro_definitions (const struct block *block, CORE_ADDR pc,
struct ui_file *file)
{
- struct macro_scope *scope;
+ gdb::unique_xmalloc_ptr<struct macro_scope> scope;

if (block != NULL)
scope = sal_macro_scope (find_pc_line (pc, 0));
diff --git a/gdb/macrocmd.c b/gdb/macrocmd.c
index e90d78724d..13fd95d7da 100644
--- a/gdb/macrocmd.c
+++ b/gdb/macrocmd.c
@@ -55,11 +55,8 @@ macro_inform_no_debuginfo (void)
static void
macro_expand_command (const char *exp, int from_tty)
{
- struct macro_scope *ms = NULL;
- char *expanded = NULL;
- struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
-
- make_cleanup (free_current_contents, &expanded);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
+ gdb::unique_xmalloc_ptr<char> expanded;

/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
@@ -74,26 +71,21 @@ macro_expand_command (const char *exp, int from_tty)
ms = default_macro_scope ();
if (ms)
{
- expanded = macro_expand (exp, standard_macro_lookup, ms);
+ expanded = macro_expand (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
- fputs_filtered (expanded, gdb_stdout);
+ fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
-
- do_cleanups (cleanup_chain);
- return;
}

static void
macro_expand_once_command (const char *exp, int from_tty)
{
- struct macro_scope *ms = NULL;
- char *expanded = NULL;
- struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
- make_cleanup (free_current_contents, &expanded);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
+ gdb::unique_xmalloc_ptr<char> expanded;

/* You know, when the user doesn't specify any expression, it would be
really cool if this defaulted to the last expression evaluated.
@@ -108,16 +100,13 @@ macro_expand_once_command (const char *exp, int from_tty)
ms = default_macro_scope ();
if (ms)
{
- expanded = macro_expand_once (exp, standard_macro_lookup, ms);
+ expanded = macro_expand_once (exp, standard_macro_lookup, ms.get ());
fputs_filtered ("expands to: ", gdb_stdout);
- fputs_filtered (expanded, gdb_stdout);
+ fputs_filtered (expanded.get (), gdb_stdout);
fputs_filtered ("\n", gdb_stdout);
}
else
macro_inform_no_debuginfo ();
-
- do_cleanups (cleanup_chain);
- return;
}

/* Outputs the include path of a macro starting at FILE and LINE to STREAM.
@@ -190,8 +179,7 @@ print_macro_definition (const char *name,
static void
info_macro_command (const char *args, int from_tty)
{
- struct macro_scope *ms = NULL;
- struct cleanup *cleanup_chain;
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
const char *name;
int show_all_macros_named = 0;
const char *arg_start = args;
@@ -228,7 +216,6 @@ info_macro_command (const char *args, int from_tty)
"whose definition you want to see."));

ms = default_macro_scope ();
- cleanup_chain = make_cleanup (free_current_contents, &ms);

if (! ms)
macro_inform_no_debuginfo ();
@@ -263,16 +250,13 @@ info_macro_command (const char *args, int from_tty)
show_pp_source_pos (gdb_stdout, ms->file, ms->line);
}
}
-
- do_cleanups (cleanup_chain);
}

/* Implementation of the "info macros" command. */
static void
info_macros_command (const char *args, int from_tty)
{
- struct macro_scope *ms = NULL;
- struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;

if (args == NULL)
ms = default_macro_scope ();
@@ -289,8 +273,6 @@ info_macros_command (const char *args, int from_tty)
macro_inform_no_debuginfo ();
else
macro_for_each_in_scope (ms->file, ms->line, print_macro_definition);
-
- do_cleanups (cleanup_chain);
}

\f
diff --git a/gdb/macroexp.c b/gdb/macroexp.c
index 8a2df1edff..aefb13a9d6 100644
--- a/gdb/macroexp.c
+++ b/gdb/macroexp.c
@@ -1485,7 +1485,7 @@ scan (struct macro_buffer *dest,
}

-char *
+gdb::unique_xmalloc_ptr<char>
macro_expand (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton)
@@ -1504,11 +1504,11 @@ macro_expand (const char *source,
appendc (&dest, '\0');

discard_cleanups (back_to);
- return dest.text;
+ return gdb::unique_xmalloc_ptr<char> (dest.text);
}

-char *
+gdb::unique_xmalloc_ptr<char>
macro_expand_once (const char *source,
macro_lookup_ftype *lookup_func,
void *lookup_func_baton)
diff --git a/gdb/macroexp.h b/gdb/macroexp.h
index f7c74116ce..8d3e3f010f 100644
--- a/gdb/macroexp.h
+++ b/gdb/macroexp.h
@@ -37,9 +37,9 @@ typedef struct macro_definition *(macro_lookup_ftype) (const char *name,
preprocessor definitions. SOURCE is a null-terminated string. The
result is a null-terminated string, allocated using xmalloc; it is
the caller's responsibility to free it. */
-char *macro_expand (const char *source,
- macro_lookup_ftype *lookup_func,
- void *lookup_func_baton);
+gdb::unique_xmalloc_ptr<char> macro_expand (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);

/* Expand all preprocessor macro references that appear explicitly in
@@ -49,9 +49,9 @@ char *macro_expand (const char *source,
SOURCE is a null-terminated string. The result is a
null-terminated string, allocated using xmalloc; it is the caller's
responsibility to free it. */
-char *macro_expand_once (const char *source,
- macro_lookup_ftype *lookup_func,
- void *lookup_func_baton);
+gdb::unique_xmalloc_ptr<char> macro_expand_once (const char *source,
+ macro_lookup_ftype *lookup_func,
+ void *lookup_func_baton);

/* If the null-terminated string pointed to by *LEXPTR begins with a
diff --git a/gdb/macroscope.c b/gdb/macroscope.c
index a94492011d..23d2e50fdd 100644
--- a/gdb/macroscope.c
+++ b/gdb/macroscope.c
@@ -35,11 +35,10 @@
struct macro_table *macro_user_macros;

-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
sal_macro_scope (struct symtab_and_line sal)
{
struct macro_source_file *main_file, *inclusion;
- struct macro_scope *ms;
struct compunit_symtab *cust;

if (sal.symtab == NULL)
@@ -48,7 +47,7 @@ sal_macro_scope (struct symtab_and_line sal)
if (COMPUNIT_MACRO_TABLE (cust) == NULL)
return NULL;

- ms = XNEW (struct macro_scope);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms (XNEW (struct macro_scope));

main_file = macro_main (COMPUNIT_MACRO_TABLE (cust));
inclusion = macro_lookup_inclusion (main_file, sal.symtab->filename);
@@ -87,22 +86,20 @@ sal_macro_scope (struct symtab_and_line sal)
}

-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
user_macro_scope (void)
{
- struct macro_scope *ms;
-
- ms = XNEW (struct macro_scope);
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms (XNEW (struct macro_scope));
ms->file = macro_main (macro_user_macros);
ms->line = -1;
return ms;
}

-struct macro_scope *
+gdb::unique_xmalloc_ptr<struct macro_scope>
default_macro_scope (void)
{
struct symtab_and_line sal;
- struct macro_scope *ms;
+ gdb::unique_xmalloc_ptr<struct macro_scope> ms;
struct frame_info *frame;
CORE_ADDR pc;

diff --git a/gdb/macroscope.h b/gdb/macroscope.h
index 3bd1c9e817..00fa98ab6e 100644
--- a/gdb/macroscope.h
+++ b/gdb/macroscope.h
@@ -39,13 +39,13 @@ struct macro_scope {
/* Return a `struct macro_scope' object corresponding to the symtab
and line given in SAL. If we have no macro information for that
location, or if SAL's pc is zero, return zero. */
-struct macro_scope *sal_macro_scope (struct symtab_and_line sal);
+gdb::unique_xmalloc_ptr<struct macro_scope> sal_macro_scope
+ (struct symtab_and_line sal);

/* Return a `struct macro_scope' object representing just the
- user-defined macros. The result is allocated using xmalloc; the
- caller is responsible for freeing it. */
-struct macro_scope *user_macro_scope (void);
+ user-defined macros. */
+gdb::unique_xmalloc_ptr<struct macro_scope> user_macro_scope (void);

/* Return a `struct macro_scope' object describing the scope the `macro
expand' and `macro expand-once' commands should use for looking up
@@ -53,11 +53,8 @@ struct macro_scope *user_macro_scope (void);
its PC; otherwise, this is the last listing position.

If we have no macro information for the current location, return
- the user macro scope.
-
- The object returned is allocated using xmalloc; the caller is
- responsible for freeing it. */
-struct macro_scope *default_macro_scope (void);
+ the user macro scope. */
+gdb::unique_xmalloc_ptr<struct macro_scope> default_macro_scope (void);

/* Look up the definition of the macro named NAME in scope at the source
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 81f4fc9ec5..0fd3f3a30f 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -5154,7 +5154,7 @@ default_collect_symbol_completion_matches_break_on
if (current_language->la_macro_expansion == macro_expansion_c
&& code == TYPE_CODE_UNDEF)
{
- struct macro_scope *scope;
+ gdb::unique_xmalloc_ptr<struct macro_scope> scope;

/* This adds a macro's name to the current completion list. */
auto add_macro_name = [&] (const char *macro_name,
@@ -5175,11 +5175,8 @@ default_collect_symbol_completion_matches_break_on
completion time. */
scope = default_macro_scope ();
if (scope)
- {
- macro_for_each_in_scope (scope->file, scope->line,
- add_macro_name);
- xfree (scope);
- }
+ macro_for_each_in_scope (scope->file, scope->line,
+ add_macro_name);

/* User-defined macros are always visible. */
macro_for_each (macro_user_macros, add_macro_name);
--
2.13.6