Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

Use ui_file_as_string in gdb/compile/

Browse Source 
Using ui_file_as_string would imply changing a few prototypes to pass
around source and object file names as std::string.  Instead of that,
wrap those two in a new class.  This ends up eliminating a small
wrinkle: get_new_file_names and compile_object_load have swapped
parameters.  The former takes "source, objfile", while the latter
takes "objfile, source".

gdb/ChangeLog:
2016-11-08  Pedro Alves  <palves@redhat.com>

	* c-lang.h (c_compute_program): Now returns std::string.
	* compile/compile-internal.h (class compile_file_names): New
	class.
	* compile/compile-object-load.c (compile_object_load): Replace
	object_file and source_file parameters with a compile_file_names
	parameter.  Adjust.
	* compile-object-load.h: Include "compile-internal.h".
	(compile_object_load): Replace object_file and source_file
	parameters with a compile_file_names parameter.
	* compile/compile-c-support.c (c_compute_program): Now returns a
	std::string.  Use ui_file_as_string.
	* compile/compile.c (get_new_file_names): Remove parameters and
	return a compile_file_names instead.
	(compile_to_object): Now returns a compile_file_names.  Use
	ui_file_as_string.
	(eval_compile_command): Use compile_file_names.
	* language.h (struct language_defn) <la_compute_program>: Now
	returns std::string.
This commit is contained in:
Pedro Alves
2016-11-08 15:26:46 +00:00
parent 3d8b0d9483
commit aaee65aea2
8 changed files with 122 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
gdb/compile/compile.c
View File

@@ -248,18 +248,20 @@ get_compile_file_tempdir (void)
return tempdir_name;
}
/* Compute the names of source and object files to use. The names are
allocated by malloc and should be freed by the caller. */
/* Compute the names of source and object files to use. */
static void
get_new_file_names (char **source_file, char **object_file)
static compile_file_names
get_new_file_names ()
{
static int seq;
const char *dir = get_compile_file_tempdir ();
++seq;
*source_file = xstrprintf ("%s%sout%d.c", dir, SLASH_STRING, seq);
*object_file = xstrprintf ("%s%sout%d.o", dir, SLASH_STRING, seq);
return compile_file_names (string_printf ("%s%sout%d.c",
dir, SLASH_STRING, seq),
string_printf ("%s%sout%d.o",
dir, SLASH_STRING, seq));
}
/* Get the block and PC at which to evaluate an expression. */
@@ -449,18 +451,13 @@ print_callback (void *ignore, const char *message)
}
/* Process the compilation request. On success it returns the object
file name and *SOURCE_FILEP is set to source file name. On an
error condition, error () is called. The caller is responsible for
freeing both strings. */
and source file names. On an error condition, error () is
called. */
static char *
static compile_file_names
compile_to_object (struct command_line *cmd, const char *cmd_string,
enum compile_i_scope_types scope,
char **source_filep)
enum compile_i_scope_types scope)
{
char *code;
const char *input;
char *source_file, *object_file;
struct compile_instance *compiler;
struct cleanup *cleanup, *inner_cleanup;
const struct block *expr_block;
@@ -496,11 +493,14 @@ compile_to_object (struct command_line *cmd, const char *cmd_string,
/* From the provided expression, build a scope to pass to the
compiler. */
std::string input_buf;
const char *input;
if (cmd != NULL)
{
struct ui_file *stream = mem_fileopen ();
struct command_line *iter;
char *stream_buf;
make_cleanup_ui_file_delete (stream);
for (iter = cmd->body_list[0]; iter; iter = iter->next)
@@ -509,20 +509,19 @@ compile_to_object (struct command_line *cmd, const char *cmd_string,
fputs_unfiltered ("\n", stream);
}
stream_buf = ui_file_xstrdup (stream, NULL);
make_cleanup (xfree, stream_buf);
input = stream_buf;
input_buf = ui_file_as_string (stream);
input = input_buf.c_str ();
}
else if (cmd_string != NULL)
input = cmd_string;
else
error (_("Neither a simple expression, or a multi-line specified."));
code = current_language->la_compute_program (compiler, input, gdbarch,
expr_block, expr_pc);
make_cleanup (xfree, code);
std::string code
= current_language->la_compute_program (compiler, input, gdbarch,
expr_block, expr_pc);
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code);
fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code.c_str ());
os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
@@ -553,37 +552,36 @@ compile_to_object (struct command_line *cmd, const char *cmd_string,
argi, argv[argi]);
}
get_new_file_names (&source_file, &object_file);
inner_cleanup = make_cleanup (xfree, source_file);
make_cleanup (xfree, object_file);
compile_file_names fnames = get_new_file_names ();
src = gdb_fopen_cloexec (source_file, "w");
src = gdb_fopen_cloexec (fnames.source_file (), "w");
if (src == NULL)
perror_with_name (_("Could not open source file for writing"));
make_cleanup (cleanup_unlink_file, source_file);
if (fputs (code, src) == EOF)
inner_cleanup = make_cleanup (cleanup_unlink_file,
(void *) fnames.source_file ());
if (fputs (code.c_str (), src) == EOF)
perror_with_name (_("Could not write to source file"));
fclose (src);
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
source_file);
fnames.source_file ());
/* Call the compiler and start the compilation process. */
compiler->fe->ops->set_source_file (compiler->fe, source_file);
compiler->fe->ops->set_source_file (compiler->fe, fnames.source_file ());
if (!compiler->fe->ops->compile (compiler->fe, object_file,
if (!compiler->fe->ops->compile (compiler->fe, fnames.object_file (),
compile_debug))
error (_("Compilation failed."));
if (compile_debug)
fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
object_file);
fnames.object_file ());
discard_cleanups (inner_cleanup);
do_cleanups (cleanup);
*source_filep = source_file;
return object_file;
return fnames;
}
/* The "compile" prefix command. */
@@ -602,32 +600,24 @@ void
eval_compile_command (struct command_line *cmd, const char *cmd_string,
enum compile_i_scope_types scope, void *scope_data)
{
char *object_file, *source_file;
struct cleanup *cleanup_unlink;
struct compile_module *compile_module;
object_file = compile_to_object (cmd, cmd_string, scope, &source_file);
if (object_file != NULL)
compile_file_names fnames = compile_to_object (cmd, cmd_string, scope);
cleanup_unlink = make_cleanup (cleanup_unlink_file,
(void *) fnames.object_file ());
make_cleanup (cleanup_unlink_file, (void *) fnames.source_file ());
compile_module = compile_object_load (fnames, scope, scope_data);
if (compile_module == NULL)
{
struct cleanup *cleanup_xfree, *cleanup_unlink;
struct compile_module *compile_module;
cleanup_xfree = make_cleanup (xfree, object_file);
make_cleanup (xfree, source_file);
cleanup_unlink = make_cleanup (cleanup_unlink_file, object_file);
make_cleanup (cleanup_unlink_file, source_file);
compile_module = compile_object_load (object_file, source_file,
scope, scope_data);
if (compile_module == NULL)
{
gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
do_cleanups (cleanup_xfree);
eval_compile_command (cmd, cmd_string,
COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
return;
}
discard_cleanups (cleanup_unlink);
do_cleanups (cleanup_xfree);
compile_object_run (compile_module);
gdb_assert (scope == COMPILE_I_PRINT_ADDRESS_SCOPE);
eval_compile_command (cmd, cmd_string,
COMPILE_I_PRINT_VALUE_SCOPE, scope_data);
return;
}
discard_cleanups (cleanup_unlink);
compile_object_run (compile_module);
}
/* See compile/compile-internal.h. */