#include "target.h"
#include "osabi.h"
#include "gdb_wait.h"
+#include "valprint.h"
\f
make_cleanup (xfree, arg);
buffer = xstrprintf ("#include \"%s\"\n", arg);
make_cleanup (xfree, buffer);
- eval_compile_command (NULL, buffer, scope);
+ eval_compile_command (NULL, buffer, scope, NULL);
do_cleanups (cleanup);
}
}
if (arg && *arg)
- eval_compile_command (NULL, arg, scope);
+ eval_compile_command (NULL, arg, scope, NULL);
else
{
struct command_line *l = get_command_line (compile_control, "");
do_cleanups (cleanup);
}
+/* Callback for compile_print_command. */
+
+void
+compile_print_value (struct value *val, void *data_voidp)
+{
+ const struct format_data *fmtp = data_voidp;
+
+ print_value (val, fmtp);
+}
+
+/* Handle the input from the 'compile print' command. The "compile
+ print" command is used to evaluate and print an expression that may
+ contain calls to the GCC compiler. The language expected in this
+ compile command is the language currently set in GDB. */
+
+static void
+compile_print_command (char *arg_param, int from_tty)
+{
+ const char *arg = arg_param;
+ struct cleanup *cleanup;
+ enum compile_i_scope_types scope = COMPILE_I_PRINT_ADDRESS_SCOPE;
+ struct format_data fmt;
+
+ cleanup = make_cleanup_restore_integer (&interpreter_async);
+ interpreter_async = 0;
+
+ /* Passing &FMT as SCOPE_DATA is safe as do_module_cleanup will not
+ touch the stale pointer if compile_object_run has already quit. */
+ print_command_parse_format (&arg, "compile print", &fmt);
+
+ if (arg && *arg)
+ eval_compile_command (NULL, arg, scope, &fmt);
+ else
+ {
+ struct command_line *l = get_command_line (compile_control, "");
+
+ make_cleanup_free_command_lines (&l);
+ l->control_u.compile.scope = scope;
+ l->control_u.compile.scope_data = &fmt;
+ execute_control_command_untraced (l);
+ }
+
+ do_cleanups (cleanup);
+}
+
/* A cleanup function to remove a directory and all its contents. */
static void
char *zap;
int wstat;
- gdb_assert (strncmp (dir, TMP_PREFIX, strlen (TMP_PREFIX)) == 0);
+ gdb_assert (startswith (dir, TMP_PREFIX));
zap = concat ("rm -rf ", dir, (char *) NULL);
wstat = system (zap);
if (wstat == -1 || !WIFEXITED (wstat) || WEXITSTATUS (wstat) != 0)
{
int argi;
- *argvp = xrealloc (*argvp, (*argcp + argc + 1) * sizeof (**argvp));
+ *argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
for (argi = 0; argi < argc; argi++)
(*argvp)[(*argcp)++] = xstrdup (argv[argi]);
const char *cs;
if (symtab == NULL || symtab->producer == NULL
- || strncmp (symtab->producer, "GNU ", strlen ("GNU ")) != 0)
+ || !startswith (symtab->producer, "GNU "))
return NULL;
cs = symtab->producer;
return cs;
}
+/* Filter out unwanted options from *ARGCP and ARGV. */
+
+static void
+filter_args (int *argcp, char **argv)
+{
+ char **destv;
+
+ for (destv = argv; *argv != NULL; argv++)
+ {
+ /* -fpreprocessed may get in commonly from ccache. */
+ if (strcmp (*argv, "-fpreprocessed") == 0)
+ {
+ xfree (*argv);
+ (*argcp)--;
+ continue;
+ }
+ *destv++ = *argv;
+ }
+ *destv = NULL;
+}
+
/* Produce final vector of GCC compilation options. First element is target
size ("-m64", "-m32" etc.), optionally followed by DW_AT_producer options
and then compile-args string GDB variable. */
char **argv_producer;
build_argc_argv (cs_producer_options, &argc_producer, &argv_producer);
+ filter_args (&argc_producer, argv_producer);
append_args (argcp, argvp, argc_producer, argv_producer);
freeargv (argv_producer);
}
freeing both strings. */
static char *
-compile_to_object (struct command_line *cmd, char *cmd_string,
+compile_to_object (struct command_line *cmd, const char *cmd_string,
enum compile_i_scope_types scope,
char **source_filep)
{
char *code;
+ const char *input;
char *source_file, *object_file;
struct compile_instance *compiler;
struct cleanup *cleanup, *inner_cleanup;
/* Set up instance and context for the compiler. */
if (current_language->la_get_compile_instance == NULL)
- error (_("No compiler support for this language."));
+ error (_("No compiler support for language %s."),
+ current_language->la_name);
compiler = current_language->la_get_compile_instance ();
cleanup = make_cleanup (cleanup_compile_instance, compiler);
{
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)
fputs_unfiltered ("\n", stream);
}
- code = ui_file_xstrdup (stream, NULL);
- make_cleanup (xfree, code);
+ stream_buf = ui_file_xstrdup (stream, NULL);
+ make_cleanup (xfree, stream_buf);
+ input = stream_buf;
}
else if (cmd_string != NULL)
- code = cmd_string;
+ input = cmd_string;
else
error (_("Neither a simple expression, or a multi-line specified."));
- code = current_language->la_compute_program (compiler, code, gdbarch,
+ code = current_language->la_compute_program (compiler, input, gdbarch,
expr_block, expr_pc);
make_cleanup (xfree, code);
if (compile_debug)
- fprintf_unfiltered (gdb_stdout, "debug output:\n\n%s", code);
+ fprintf_unfiltered (gdb_stdlog, "debug output:\n\n%s", code);
os_rx = osabi_triplet_regexp (gdbarch_osabi (gdbarch));
arch_rx = gdbarch_gnu_triplet_regexp (gdbarch);
- triplet_rx = concat (arch_rx, "-[^-]*-", os_rx, (char *) NULL);
+
+ /* Allow triplets with or without vendor set. */
+ triplet_rx = concat (arch_rx, "(-[^-]*)?-", os_rx, (char *) NULL);
make_cleanup (xfree, triplet_rx);
/* Set compiler command-line arguments. */
{
int argi;
- fprintf_unfiltered (gdb_stdout, "Passing %d compiler options:\n", argc);
+ fprintf_unfiltered (gdb_stdlog, "Passing %d compiler options:\n", argc);
for (argi = 0; argi < argc; argi++)
- fprintf_unfiltered (gdb_stdout, "Compiler option %d: <%s>\n",
+ fprintf_unfiltered (gdb_stdlog, "Compiler option %d: <%s>\n",
argi, argv[argi]);
}
fclose (src);
if (compile_debug)
- fprintf_unfiltered (gdb_stdout, "source file produced: %s\n\n",
+ fprintf_unfiltered (gdb_stdlog, "source file produced: %s\n\n",
source_file);
/* Call the compiler and start the compilation process. */
error (_("Compilation failed."));
if (compile_debug)
- fprintf_unfiltered (gdb_stdout, "object file produced: %s\n\n",
+ fprintf_unfiltered (gdb_stdlog, "object file produced: %s\n\n",
object_file);
discard_cleanups (inner_cleanup);
/* See compile.h. */
void
-eval_compile_command (struct command_line *cmd, char *cmd_string,
- enum compile_i_scope_types scope)
+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;
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);
+ 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);
\n\
compile code printf(\"Hello world\\n\");\n\
\n\
-Alternatively, you can type the source code interactively.\n\
-You can invoke this mode when no argument is given to the command\n\
-(i.e.,\"compile code\" is typed with nothing after it). An\n\
-interactive prompt will be shown allowing you to enter multiple\n\
-lines of source code. Type a line containing \"end\" to indicate\n\
-the end of the source code."),
+Alternatively, you can type a multiline expression by invoking\n\
+this command with no argument. GDB will then prompt for the\n\
+expression interactively; type a line containing \"end\" to\n\
+indicate the end of the expression."),
&compile_command_list);
c = add_cmd ("file", class_obscure, compile_file_command,
&compile_command_list);
set_cmd_completer (c, filename_completer);
+ add_cmd ("print", class_obscure, compile_print_command,
+ _("\
+Evaluate EXPR by using the compiler and print result.\n\
+\n\
+Usage: compile print[/FMT] [EXPR]\n\
+\n\
+The expression may be specified on the same line as the command, e.g.:\n\
+\n\
+ compile print i\n\
+\n\
+Alternatively, you can type a multiline expression by invoking\n\
+this command with no argument. GDB will then prompt for the\n\
+expression interactively; type a line containing \"end\" to\n\
+indicate the end of the expression.\n\
+\n\
+EXPR may be preceded with /FMT, where FMT is a format letter\n\
+but no count or size letter (see \"x\" command)."),
+ &compile_command_list);
+
add_setshow_boolean_cmd ("compile", class_maintenance, &compile_debug, _("\
Set compile command debugging."), _("\
Show compile command debugging."), _("\
absolute target address.
-fPIC is not used at is would require from GDB to generate .got. */
" -fPIE"
- /* We don't want warnings. */
- " -w"
+ /* We want warnings, except for some commonly happening for GDB commands. */
+ " -Wall "
+ " -Wno-implicit-function-declaration"
+ " -Wno-unused-but-set-variable"
+ " -Wno-unused-variable"
/* Override CU's possible -fstack-protector-strong. */
" -fno-stack-protector"
);
projects / deliverable / binutils-gdb.git / blobdiff